diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 18e46fba9..bcb302cda 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 ceb97d3b9..70ffbbdeb 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;
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 0b84bf4ea..ac170bd2a 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -148,47 +148,47 @@ public:
 		return theMap.maxSize();
 	}
 
-	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,
-				buffer, size, max_size, bigEndian);
+	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<key_t>::serialize(&theMap[i].first, buffer,
-					size, max_size, bigEndian);
-			result = SerializeAdapter<T>::serialize(&theMap[i].second, buffer, size,
-					max_size, bigEndian);
+			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
+					size, maxSize, streamEndianness);
+			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		uint32_t printSize = sizeof(_size);
 		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;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
-				buffer, size, bigEndian);
+	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<key_t>::deSerialize(&theMap[i].first, buffer,
-					size, bigEndian);
-			result = SerializeAdapter<T>::deSerialize(&theMap[i].second, buffer, size,
-					bigEndian);
+			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/HybridIterator.h b/container/HybridIterator.h
index b34fdfd01..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>
@@ -8,34 +8,32 @@ 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) {
 
 	}
 
 	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;
 		}
@@ -44,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;
@@ -66,11 +64,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(HybridIterator other) {
-		return value == other->value;
+	bool operator==(const HybridIterator& other) const {
+		return value == other.value;
 	}
 
-	bool operator!=(HybridIterator other) {
+	bool operator!=(const HybridIterator& other) const {
 		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_ */
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 992b7489a..6e7f330cb 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -68,50 +68,50 @@ public:
 		return this->storedPackets;
 	}
 
-	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 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 = AutoSerializeAdapter::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 = AutoSerializeAdapter::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 = AutoSerializeAdapter::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 = AutoSerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::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 {
-		uint32_t size = AutoSerializeAdapter::getSerializedSize(&blockStartAddress);
+	size_t getSerializedSize() const {
+		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;
 	}
 
@@ -485,37 +485,37 @@ 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 = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		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<Index<T> >::serialize(&this->entries[i], buffer, size,
-					max_size, bigEndian);
+			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 = AutoSerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
@@ -524,17 +524,17 @@ 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){
 			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;
 	}
 	/**
@@ -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 = AutoSerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -572,9 +572,9 @@ 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);
+					streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
index 70a2a3fb5..f44da64ed 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 99d2b51b2..3ea266ea8 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;
 	}
@@ -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 = ::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
 	DataSet 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 = ::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = ::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;
@@ -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/DataPoolAdmin.h b/datapool/DataPoolAdmin.h
index 448d78fbc..1be920b54 100644
--- a/datapool/DataPoolAdmin.h
+++ b/datapool/DataPoolAdmin.h
@@ -29,12 +29,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/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 0ff2121d6..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<Type>::serialize(&type, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+	result = SerializeAdapter::serialize(&columns, buffer, size,
+			maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::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 b43026af7..f49f2ee57 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/PIDReader.h b/datapool/PIDReader.h
index 63a62cf64..464b15495 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/PoolEntry.cpp b/datapool/PoolEntry.cpp
index de024c812..d535a72b6 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,13 +1,34 @@
 #include <framework/datapool/PoolEntry.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/globalfunctions/arrayprinter.h>
+#include <cstring>
 
 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 setLength,
+		bool setValid ) : length(setLength), valid(setValid) {
 	this->address = new T[this->length];
-	if (initValue != NULL) {
-		memcpy(this->address, initValue, this->getByteSize() );
+	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 {
-		memset(this->address, 0, this->getByteSize() );
+		std::memset(this->address, 0, this->getByteSize() );
 	}
 }
 
@@ -34,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;
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
 	sif::debug << std::dec << std::endl;
 }
 
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index ce41a9917..1a22bb638 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,81 +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.
+ * @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.
  *
- * \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.
+ * 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.
  *
- *	\ingroup data_pool
+ * 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
+	 * @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.
+	 * @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( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
+			bool setValid = false);
 	/**
-	 * \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	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.
+	 * @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 514e67ef9..a075436e2 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,62 +1,57 @@
-/**
- * \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_
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#define FRAMEWORK_DATAPOOL_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.
+ * @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.
  *
- * \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
+ * @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 required for C++ interfaces.
 	 */
 	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;
+	virtual void setValid(bool 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;
+	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.
+	 * @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;
 	/**
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index ba68bcd25..eca354a90 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -2,12 +2,15 @@
 #include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/Endiness.h>
+#include <framework/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) {
+		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);
@@ -19,7 +22,7 @@ PoolRawAccess::~PoolRawAccess() {
 }
 
 ReturnValue_t PoolRawAccess::read() {
-	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
+	PoolEntryIF *read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
 		valid = read_out->getValid();
 		if (read_out->getSize() > arrayEntry) {
@@ -29,7 +32,7 @@ ReturnValue_t PoolRawAccess::read() {
 			if (typeSize <= sizeof(value)) {
 				uint16_t arrayPosition = arrayEntry * typeSize;
 				sizeTillEnd = read_out->getByteSize() - arrayPosition;
-				uint8_t* ptr =
+				uint8_t *ptr =
 						&((uint8_t*) read_out->getRawData())[arrayPosition];
 				memcpy(value, ptr, typeSize);
 				return HasReturnvaluesIF::RETURN_OK;
@@ -42,8 +45,8 @@ ReturnValue_t PoolRawAccess::read() {
 	} else {
 		//Error entry does not exist.
 	}
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed." << std::endl;
+	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex
+			<< dataPoolId << std::dec << " failed." << std::endl;
 	valid = INVALID;
 	typeSize = 0;
 	sizeTillEnd = 0;
@@ -52,11 +55,11 @@ ReturnValue_t PoolRawAccess::read() {
 }
 
 ReturnValue_t PoolRawAccess::commit() {
-	PoolEntryIF* write_back = ::dataPool.getRawData(dataPoolId);
+	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];
+		uint8_t *ptr = &((uint8_t*) write_back->getRawData())[array_position];
 		memcpy(ptr, value, typeSize);
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
@@ -68,23 +71,17 @@ uint8_t* PoolRawAccess::getEntry() {
 	return value;
 }
 
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		uint32_t* writtenBytes, uint32_t max_size) {
-	uint8_t* data_ptr = getEntry();
+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)
+	if (typeSize == 0) {
 		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
+	if (typeSize > maxSize) {
+		return INCORRECT_SIZE;
+	}
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
 	*writtenBytes = typeSize;
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -93,11 +90,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;
 }
 
@@ -109,21 +106,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"
+		sif::error
+				<< "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal"
 				<< (uint32_t) typeSize << ", Requested: " << setSize
 				<< std::endl;
 		return INCORRECT_SIZE;
@@ -141,25 +131,24 @@ void PoolRawAccess::setValid(uint8_t valid) {
 	this->valid = valid;
 }
 
-uint16_t PoolRawAccess::getSizeTillEnd() const {
+size_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 {
+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;
@@ -169,28 +158,27 @@ 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) {
-#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 {
+	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 {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 3e2bd7ae3..09d19afd6 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -32,15 +32,15 @@ private:
 	/**
 	 * \brief	This value contains the size of the data pool entry 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.
 	 */
@@ -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
@@ -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);
+	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
@@ -106,8 +106,8 @@ public:
 	 * @return	- \c RETURN_OK on success
 	 * 			- \c RETURN_FAILED on failure
 	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			uint32_t setSize);
+	ReturnValue_t setEntryFromBigEndian(const uint8_t *buffer,
+			size_t setSize);
 	/**
 	 *  \brief This operation returns the type of the entry currently stored.
 	 */
@@ -115,12 +115,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.
 	 */
@@ -138,15 +138,15 @@ public:
 	/**
 	 * Getter for the remaining size.
 	 */
-	uint16_t getSizeTillEnd() const;
+	size_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 d395d4092..a06935c37 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 maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize<T>(&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/PoolVector.h b/datapool/PoolVector.h
index 929f2d315..777ec7238 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<T>::serialize(&(value[i]), buffer, size,
-					max_size, bigEndian);
+			result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+					maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -211,17 +211,17 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
-		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
+	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<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/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 50a5c07e5..34e45b684 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,
-		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) {
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * comCookie,
+		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId, uint32_t parent,
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		DeviceHandlerBase(setObjectId, deviceCommunication, comCookie,
+				setDeviceSwitch, thermalStatePoolId,thermalRequestPoolId,
+				(customFdir == nullptr? &childHandlerFdir : customFdir),
+				cmdQueueSize),
+		parentId(parent), childHandlerFdir(setObjectId) {
 }
 
 ChildHandlerBase::~ChildHandlerBase() {
@@ -34,7 +35,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 		parent->registerChild(getObjectId());
 	}
 
-	healthHelper.setParentQeueue(parentQueue);
+	healthHelper.setParentQueue(parentQueue);
 
 	modeHelper.setParentQueue(parentQueue);
 
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 3879f66fe..59cf26b1b 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,
+	ChildHandlerBase(object_id_t setObjectId,
+			object_id_t deviceCommunication, CookieIF * comCookie,
 			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId, uint32_t parent,
-			FailureIsolationBase* customFdir = NULL,
-			uint32_t cmdQueueSize = 20);
+			FailureIsolationBase* customFdir = nullptr,
+			size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();
diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
deleted file mode 100644
index 495c8c403..000000000
--- a/devicehandlers/Cookie.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef COOKIE_H_
-#define COOKIE_H_
-
-class Cookie{
-public:
-	virtual ~Cookie(){}
-};
-
-
-#endif /* COOKIE_H_ */
diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
new file mode 100644
index 000000000..496cf0d2f
--- /dev/null
+++ b/devicehandlers/CookieIF.h
@@ -0,0 +1,34 @@
+#ifndef COOKIE_H_
+#define COOKIE_H_
+#include <cstdint>
+
+/**
+ * @brief Physical address type
+ */
+typedef std::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 @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.
+ *
+ * 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 e0aca5731..9ca31a9bc 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,63 +1,131 @@
 #ifndef DEVICECOMMUNICATIONIF_H_
 #define DEVICECOMMUNICATIONIF_H_
 
-#include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
+/**
+ * @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;
 
-	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);
+	//! Standard Error Codes
+	//! General protocol error. Define more concrete errors in child handler
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x01);
+	//! 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);
+	// 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);
 
-	virtual ~DeviceCommunicationIF() {
+	//! Can be used in readReceivedMessage() if no reply was received.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0xA1);
 
-	}
+	virtual ~DeviceCommunicationIF() {}
 
-	virtual ReturnValue_t open(Cookie **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
+	 * @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) = 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 address
-	 * @param maxReplyLen
-	 * @return
+	 * @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 reOpen(Cookie *cookie, uint32_t address,
-			uint32_t maxReplyLen) = 0;
-
-	virtual void close(Cookie *cookie) = 0;
-
-	//SHOULDDO can data be const?
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
-			uint32_t len) = 0;
-
-	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
-
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
-
-	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
-			uint32_t *size) = 0;
-
-	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address) = 0;
-
-	virtual uint32_t getAddress(Cookie *cookie) = 0;
-
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter) = 0;
-
-	virtual uint32_t getParameter(Cookie *cookie) = 0;
+	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 90875838e..872310a1a 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,52 +1,60 @@
-#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>
 
+#include <iomanip>
+
 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) :
-		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) {
+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),
+		deviceThermalStatePoolId(thermalStatePoolId),
+		deviceThermalRequestPoolId(thermalRequestPoolId),
+		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
+		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
+		switchOffWasReported(false), actionHelper(this, nullptr),
+		childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
+		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			CommandMessage::MAX_MESSAGE_SIZE);
-	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
-	if (this->fdirInstance == NULL) {
+	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);
 	}
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	communicationInterface->close(cookie);
+	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -56,7 +64,7 @@ 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();
@@ -64,11 +72,12 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
+		performOperationHook();
 	}
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
-	switch (getRmapAction()) {
+	switch (getComAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
 			buildInternalCommand();
@@ -91,13 +100,91 @@ 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->initializeInterface(comCookie);
+	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++) {
 		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);
@@ -256,55 +343,49 @@ 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, 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, 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, bool 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) {
+	auto resultPair = deviceReplyMap.emplace(replyId, info);
+	if (resultPair.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;
 	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) {
+	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, uint8_t periodic) {
+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()) {
@@ -429,7 +510,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) {
@@ -450,12 +531,14 @@ 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);
 		}
-		//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
@@ -471,7 +554,17 @@ void DeviceHandlerBase::doGetWrite() {
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
 
-	result = communicationInterface->requestReceiveMessage(cookie);
+	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 {
@@ -485,10 +578,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) {
@@ -498,8 +591,8 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(cookie, &receivedData,
-			&receivedDataLen);
+	result = communicationInterface->readReceivedMessage(comCookie,
+			&receivedData, &receivedDataLen);
 
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -508,7 +601,7 @@ void DeviceHandlerBase::doGetRead() {
 		return;
 	}
 
-	if (receivedDataLen == 0)
+	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
 		return;
 
 	if (wiretappingMode == RAW) {
@@ -539,6 +632,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);
@@ -560,8 +655,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;
 	}
@@ -572,90 +667,10 @@ 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;
 	}
-
-}
-
-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, ioBoardAddress,
-			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,
@@ -687,8 +702,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 }
 
 //Default child implementations
-
-DeviceHandlerBase::RmapAction_t DeviceHandlerBase::getRmapAction() {
+DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
@@ -727,7 +741,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 
 	if (info->delayCycles != 0) {
 
-		if (info->periodic != 0) {
+		if (info->periodic) {
 			info->delayCycles = info->maxDelayCycles;
 		} else {
 			info->delayCycles = 0;
@@ -748,20 +762,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, ioBoardAddress,
-				maxDeviceReplyLen);
-		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, ioBoardAddress,
+//				maxDeviceReplyLen);
+//		if (result != RETURN_OK) {
+//			return result;
+//		}
+//		return RETURN_OK;
+//	}
+//	return RETURN_FAILED;
+//}
 
 void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
@@ -1022,7 +1036,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)) {
@@ -1044,19 +1057,19 @@ 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_IOBOARD);
-			}
-		}
-		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);
@@ -1072,7 +1085,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 
 void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
 	modeHelper.setParentQueue(parentQueueId);
-	healthHelper.setParentQeueue(parentQueueId);
+	healthHelper.setParentQueue(parentQueueId);
 }
 
 bool DeviceHandlerBase::isAwaitingReply() {
@@ -1270,3 +1283,9 @@ 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() {}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 756ad530d..435f8e066 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,26 +1,24 @@
 #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/serialize/SerialFixedArrayListAdapter.h>
-#include <map>
 #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{
 void setStaticFrameworkObjectIds();
@@ -29,29 +27,53 @@ void setStaticFrameworkObjectIds();
 class StorageManagerIF;
 
 /**
- * \defgroup devices Devices
+ * @defgroup devices Devices
  * Contains all devices and the DeviceHandlerBase class.
  */
 
 /**
- * \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
- * 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 @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 (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. 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()
  *
- * \ingroup devices
+ * 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,
@@ -68,59 +90,402 @@ 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 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 ioBoardAddress, 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, object_id_t deviceCommunication,
+			CookieIF * comCookie, uint8_t setDeviceSwitch,
+			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;
-
+			FailureIsolationBase* fdirInstance = nullptr,
+			size_t cmdQueueSize = 20);
 
 	/**
-		 * This function is a 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()
-		 *     	 Calls abstract funtions buildNomalDeviceCommand()
-		 *     	 or buildTransitionDeviceCommand()
-		 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite().
-		 *       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()
-		 * @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 (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();
 
-	/**
-	 *
-	 * @param parentQueueId
-	 */
-	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 	/**
 	 * 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_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
+	 *    - @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
+	 *	 	  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 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);
+
+	/**
+	 * @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, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data,
+			uint32_t size) override;
+
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -136,24 +501,27 @@ 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
+	 * 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);
-	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);
-	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);
+	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;
@@ -162,11 +530,11 @@ protected:
 	/**
 	 * Pointer to the raw packet that will be sent.
 	 */
-	uint8_t *rawPacket;
+	uint8_t *rawPacket = nullptr;
 	/**
 	 * Size of the #rawPacket.
 	 */
-	uint32_t rawPacketLen;
+	uint32_t rawPacketLen = 0;
 
 	/**
 	 * The mode the device handler is currently in.
@@ -185,12 +553,7 @@ protected:
 	/**
 	 * This is the counter value from performOperation().
 	 */
-	uint8_t pstStep;
-
-	/**
-	 * 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;
+	uint8_t pstStep = 0;
 
 	/**
 	 * wiretapping flag:
@@ -208,7 +571,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;
 
@@ -217,19 +580,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
@@ -239,17 +602,40 @@ protected:
 	/**
 	 * Communication object used for device communication
 	 */
-	DeviceCommunicationIF *communicationInterface;
+	DeviceCommunicationIF * communicationInterface = nullptr;
 
 	/**
 	 * Cookie used for communication
 	 */
-	Cookie *cookie;
+	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.
+	};
+	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
+
+	/**
+	 * @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.
+		bool periodic; //!< if this is !=0, the delayCycles will not be reset to 0 but to maxDelayCycles
+		DeviceCommandMap::iterator command; //!< The command that expects this reply.
+	};
+
+	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
+	using DeviceReplyIter = DeviceReplyMap::iterator;
 
 	/**
 	 * 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
@@ -280,7 +666,7 @@ protected:
 	 */
 	ReturnValue_t childTransitionFailure;
 
-	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.
 
@@ -290,7 +676,7 @@ 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.
 
@@ -317,11 +703,6 @@ protected:
 	void replyReturnvalueToCommand(ReturnValue_t status,
 			uint32_t parameter = 0);
 
-	/**
-	 *
-
-	 * @param parameter2 additional parameter
-	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
 	/**
@@ -329,7 +710,8 @@ protected:
 	 *
 	 * Sets #timeoutStart with every call.
 	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
+	 * 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.
@@ -345,41 +727,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).
 	 *
@@ -409,24 +756,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?
 	 *
@@ -446,41 +775,8 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
-	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;
+	virtual CommunicationAction_t getComAction();
 
 	/**
 	 * Build the device command to send for raw mode.
@@ -502,80 +798,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;
-
-	/**
-	 * fill the #deviceCommandMap
-	 *
-	 * called by the initialize() of the base class
-	 *
-	 * 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;
-
-	/**
-	 * 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	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,
-			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, 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.
@@ -583,48 +805,6 @@ 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.
-	 *
-	 * 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 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
-	 * @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 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
-	 * @param commander the one who initiated the command, is 0 if not external commanded
-	 * @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.
@@ -649,33 +829,11 @@ 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
 	 */
 	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.
-		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
 	 *
@@ -686,16 +844,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,
@@ -794,22 +952,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.
 	 *
@@ -861,17 +1003,12 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
-	/**
-	 * cached from ctor for initialize()
-	 */
-	const uint32_t ioBoardAddress;
-
 	/**
 	 * Used for timing out mode transitions.
 	 *
 	 * Set when setMode() is called.
 	 */
-	uint32_t timeoutStart;
+	uint32_t timeoutStart = 0;
 
 	/**
 	 * Delay for the current mode transition, used for time out
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index fe0ee8e8b..666d9efc3 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -8,7 +8,8 @@
 #include <framework/ipc/MessageQueueSenderIF.h>
 
 /**
- * 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 {
@@ -22,93 +23,127 @@ 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
 	 */
-//		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;
-		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);
+	// 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.
+	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 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 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);
 
-		//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 uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
-		//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 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 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 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 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.
+	};
 
-		/**
-		 * 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
 	 */
-	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;
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 2c9e820fe..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 {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
-			buffer, size, max_size, bigEndian);
+		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<ActionId_t>::serialize(&actionId, buffer,
-			size, max_size, bigEndian);
+	result = SerializeAdapter::serialize(&actionId, buffer,
+			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) {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
-			buffer, size, bigEndian);
+		size_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::deSerialize(&actionId, buffer,
-			size, bigEndian);
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
+			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/devicehandlers/FixedSequenceSlot.cpp b/devicehandlers/FixedSequenceSlot.cpp
index 29e7ee6ab..bb97a8e5c 100644
--- a/devicehandlers/FixedSequenceSlot.cpp
+++ b/devicehandlers/FixedSequenceSlot.cpp
@@ -16,6 +16,5 @@ FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 	handler->setTaskIF(executingTask);
 }
 
-FixedSequenceSlot::~FixedSequenceSlot() {
-}
+FixedSequenceSlot::~FixedSequenceSlot() {}
 
diff --git a/devicehandlers/FixedSequenceSlot.h b/devicehandlers/FixedSequenceSlot.h
index 5aff0f4f3..7868cce30 100644
--- a/devicehandlers/FixedSequenceSlot.h
+++ b/devicehandlers/FixedSequenceSlot.h
@@ -13,35 +13,47 @@
 class PeriodicTaskIF;
 
 /**
- * \brief	This 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.
+ * @details	The PollingSlot class is the representation of a single polling
+ * 			sequence table entry.
  */
 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, what 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.
+	 * @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;
+
+	/**
+	 * @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;
+	}
 };
 
 
diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 2fa13faef..9a0dc3724 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -7,17 +7,12 @@ FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
 }
 
 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++;
-	}
+	// Call the destructor on each list entry.
+	slotList.clear();
 }
 
 void FixedSlotSequence::executeAndAdvance() {
-	(*this->current)->handler->performOperation((*this->current)->opcode);
+	current->handler->performOperation(current->opcode);
 //	if (returnValue != RETURN_OK) {
 //		this->sendErrorMessage( returnValue );
 //	}
@@ -31,53 +26,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 lengthMs - 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 lengthMs - (--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;
@@ -93,26 +85,30 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		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 == NULL) {
+		if (slotIt->handler == nullptr) {
 			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
 					<< std::endl;
 			count++;
-		} else if ((*slotIt)->pollingTimeMs < time) {
+		} else if (slotIt->pollingTimeMs < time) {
 			sif::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.
+			//info << "Current slot polling time: " << std::endl;
+			//info << std::dec << slotIt->pollingTimeMs << std::endl;
 		}
-		time = (*slotIt)->pollingTimeMs;
+		time = slotIt->pollingTimeMs;
 		slotIt++;
 	}
+	//info << "Number of elements in slot list: "
+	//	   << slotList.size() << std::endl;
 	if (count > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -121,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 64c68aeae..32b61f56d 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -1,9 +1,9 @@
-#ifndef FIXEDSLOTSEQUENCE_H_
-#define FIXEDSLOTSEQUENCE_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_FIXEDSLOTSEQUENCE_H_
+#define FRAMEWORK_DEVICEHANDLERS_FIXEDSLOTSEQUENCE_H_
 
 #include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObject.h>
-#include <list>
+#include <set>
 
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
@@ -24,30 +24,39 @@
  */
 class FixedSlotSequence {
 public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 	/**
-	 * \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);
@@ -61,47 +70,59 @@ public:
 	bool slotFollowsImmediately();
 
 	/**
-	 * \brief	This method returns the time until the next software component is invoked.
+	 * @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();
 
 	/**
-	 * \brief	This method returns the time difference between the current slot and the previous slot
+	 * @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 prevous 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.
+	 * @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.
+	 * @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
-	 * 			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.
+	 * @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.
+	 * @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;
 
 	/**
 	 * Iterate through slotList and check successful creation.
@@ -109,18 +130,21 @@ public:
 	 * @return
 	 */
 	ReturnValue_t checkSequence() const;
+
 protected:
 
 	/**
-	 * \brief	This list contains all OPUSPollingSlot objects, defining order and execution time of the
-	 * 			device handler objects.
+	 * @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 OPUSPollingSlot 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.
+	 * @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.
 	 */
-	std::list<FixedSequenceSlot*> slotList;
+	SlotList slotList;
 
 	uint32_t lengthMs;
 };
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index ea0b99ffa..61a824215 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/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 814d26f4e..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<uint8_t>::serialize(&ptc, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::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<uint8_t>::getSerializedSize(&dontcare);
+	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<uint8_t>::deSerialize(&ptc, buffer,
-			size, bigEndian);
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&pfc, buffer, size,
-			bigEndian);
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
+			streamEndianness);
 	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/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 398cf3f0b..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<uint8_t>::serialize(&count,
-				buffer, size, max_size, bigEndian);
+		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, 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 10e07173b..6fee1f522 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 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<T>::serialize(&upperBound, buffer, size, max_size, bigEndian);
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
+				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_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/HealthHelper.cpp b/health/HealthHelper.cpp
index ed97f3d3d..7b8b3a53f 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -29,11 +29,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 a1ca2c525..471bc7e9f 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -78,7 +78,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);
 
 	/**
 	 *
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index a575b2828..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<uint16_t>::serialize(&count,
-			&pointer, &size, maxSize, true);
+	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<object_id_t>::serialize(&iter->first,
-				&pointer, &size, maxSize, true);
+		result = SerializeAdapter::serialize(&iter->first,
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 		uint8_t health = iter->second;
-		result = SerializeAdapter<uint8_t>::serialize(&health, &pointer, &size,
-				maxSize, true);
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
+				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/health/HealthTableIF.h b/health/HealthTableIF.h
index 6fdfc2c04..a850a8048 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -17,7 +17,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/ipc/QueueFactory.h b/ipc/QueueFactory.h
index c385b15df..6e7c4a269 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -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(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
 
 	void deleteMessageQueue(MessageQueueIF* queue);
 private:
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 2a830c5a5..af56f2b83 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, MessageQueueIF* useThisQueue) :
@@ -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/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/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)() ):
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index cffc2125e..dce202657 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,16 +1,18 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/globalfunctions/timevalOperations.h>
-#include <stdlib.h>
-#include "Timekeeper.h"
+#include <framework/osal/FreeRTOS/Timekeeper.h>
 
-#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
 
 uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
+MutexIF* Clock::timeMutex = nullptr;
 
 uint32_t Clock::getTicksPerSecond(void) {
 	return 1000;
@@ -56,7 +58,6 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
 
 timeval Clock::getUptime() {
 	TickType_t ticksSinceStart = xTaskGetTickCount();
-
 	return Timekeeper::ticksToTimeval(ticksSinceStart);
 }
 
@@ -128,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/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index fb3c3b03e..c062101d9 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);
 	}
 
@@ -58,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;
 	}
@@ -81,43 +80,79 @@ 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;
+	// A local iterator for the Polling Sequence Table is created to find the
+    // start time for the first entry.
+	FixedSlotSequence::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;
 	/* 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
-	vTaskDelayUntil(&xLastWakeTime, interval);
+	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 (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()) {
+	        // 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;
+    // 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 bed130511..66af0311b 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,24 +1,27 @@
-#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:
+
 	/**
-	 * @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 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,
@@ -26,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();
 	/**
@@ -44,13 +49,14 @@ 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) override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
 protected:
 	bool started;
 	TaskHandle_t handle;
@@ -58,32 +64,35 @@ 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);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
 };
 
-#endif /* POLLINGTASK_H_ */
+#endif /* FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index eaf245d37..a01289189 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -25,8 +25,8 @@ QueueFactory::~QueueFactory() {
 }
 
 MessageQueueIF* QueueFactory::createMessageQueue(uint32_t message_depth,
-		uint32_t max_message_size) {
-	return new MessageQueue(message_depth, max_message_size);
+		size_t maxMessageSize) {
+	return new MessageQueue(message_depth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 81f7f9979..643b27479 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,20 +1,19 @@
-#include "Timekeeper.h"
-#include <FreeRTOSConfig.h>
+#include <framework/osal/FreeRTOS/Timekeeper.h>
 
-Timekeeper::Timekeeper() :
-		offset( { 0, 0 }) {
-	// TODO Auto-generated constructor stub
+#include "FreeRTOSConfig.h"
 
-}
+Timekeeper * Timekeeper::myinstance = nullptr;
 
-Timekeeper * Timekeeper::myinstance = NULL;
+Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
+
+Timekeeper::~Timekeeper() {}
 
 const timeval& Timekeeper::getOffset() const {
 	return offset;
 }
 
 Timekeeper* Timekeeper::instance() {
-	if (myinstance == NULL) {
+	if (myinstance == nullptr) {
 		myinstance = new Timekeeper();
 	}
 	return myinstance;
@@ -24,10 +23,6 @@ void Timekeeper::setOffset(const timeval& offset) {
 	this->offset = offset;
 }
 
-Timekeeper::~Timekeeper() {
-	// TODO Auto-generated destructor stub
-}
-
 timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 	timeval uptime;
 	uptime.tv_sec = ticks / configTICK_RATE_HZ;
@@ -40,3 +35,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..7d3ca22b7 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -3,7 +3,9 @@
 
 #include <framework/timemanager/Clock.h>
 
-#include <FreeRTOS.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.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/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index e24a4fe4b..630b2cf4c 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,10 +1,10 @@
-#include <sys/time.h>
-#include <time.h>
+#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>
@@ -65,6 +65,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/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 6350f3472..916e6d6cc 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -8,7 +8,20 @@
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
 public:
-	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
+	/**
+	 * 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();
@@ -17,7 +30,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 +49,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 +60,13 @@ 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.
+	 *
+	 * 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/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index edabe9467..a0749ded3 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,56 +1,37 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.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>
 
+#include <fstream>
 
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE) {
+#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) {
 	//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++);
+	//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)
-	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);
+	// 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) {
-		//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 {
+		handleError(&attributes, messageDepth);
+	}
+	else {
 		//Successful mq_open call
 		this->id = tempId;
 	}
@@ -69,6 +50,73 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
+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;
+		}
+		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,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), false);
@@ -108,12 +156,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.
@@ -123,9 +172,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;
@@ -133,8 +185,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;
@@ -182,9 +238,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;
@@ -233,7 +290,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();
@@ -241,10 +299,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;
@@ -254,18 +315,22 @@ 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*/
 		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..2808d36e1 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -4,21 +4,26 @@
 #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.
+ * @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 +40,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(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.
@@ -168,6 +174,8 @@ private:
 	char name[5];
 
 	static uint16_t queueCounter;
+
+	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index b754c3f44..df5bbf930 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() {
@@ -37,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;
 }
 
@@ -56,9 +58,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();
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.
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 899700f0d..bc3e62ed7 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,8 +1,13 @@
 #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_) {
+    name[0] = '\0';
+    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
+}
 
 PosixThread::~PosixThread() {
 	//No deletion and no free of Stack Pointer
@@ -55,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;
@@ -113,12 +114,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 +130,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 << "Posix Thread stack init failed with: " <<
+		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, sp, stackSize);
+	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
 		sif::error << "Posix Thread attribute setStack failed with: " <<
 				strerror(status) << std::endl;
@@ -154,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: " <<
@@ -188,8 +193,18 @@ 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 d96c4156e..e9d317289 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -1,15 +1,15 @@
 #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:
+	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
 	PosixThread(const char* name_, int priority_, size_t stackSize_);
 	virtual ~PosixThread();
 	/**
@@ -54,21 +54,24 @@ 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_);
 
 private:
-	char name[10];
+	char name[PTHREAD_MAX_NAMELEN];
 	int priority;
-	size_t stackSize;
+	size_t stackSize = 0;
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index fc4c90261..268d0b995 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(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
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) {
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 9fc34ff18..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 result = SerializeAdapter<float>::serialize(
-			&timeSinceLastReset, buffer, size, max_size, bigEndian);
+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, 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 result = SerializeAdapter<float>::deSerialize(
-			&timeSinceLastReset, buffer, size, bigEndian);
+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, bigEndian);
+			size, streamEndianness);
 }
 
-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,
-			size, max_size, bigEndian);
+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 > 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<float>::serialize(&timeRunning,
-			buffer, size, max_size, bigEndian);
+	result = SerializeAdapter::serialize(&timeRunning,
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::serialize(&percentUsage,
-			buffer, size, max_size, bigEndian);
+	result = SerializeAdapter::serialize(&percentUsage,
+			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) {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&id, buffer,
-			size, bigEndian);
+		int32_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -169,13 +169,13 @@ 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,
-			buffer, size, bigEndian);
+	result = SerializeAdapter::deSerialize(&timeRunning,
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::deSerialize(&percentUsage,
-			buffer, size, bigEndian);
+	result = SerializeAdapter::deSerialize(&percentUsage,
+			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/osal/rtems/QueueFactory.cpp b/osal/rtems/QueueFactory.cpp
index 0f2e0ea9b..8cc9905cb 100644
--- a/osal/rtems/QueueFactory.cpp
+++ b/osal/rtems/QueueFactory.cpp
@@ -49,9 +49,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(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 9e4fc4938..f896f00fd 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 1dac70757..bbf1e8a36 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<Type>::serialize(&type, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::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 = HasReturnvaluesIF::RETURN_OK;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
-		result = SerializeAdapter<T>::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<T>::deSerialize(
+			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 result = SerializeAdapter<Type>::deSerialize(&type, &stream,
-			&streamSize, true);
+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<uint8_t>::deSerialize(&columns, &stream,
-			&streamSize, true);
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::deSerialize(&rows, &stream, &streamSize,
-			true);
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
+			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 f61786b8a..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 {
@@ -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;
@@ -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 6a87d88b8..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 result = SerializeAdapter<float>::serialize(&min, buffer,
-			size, max_size, bigEndian);
+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<float>::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 result = SerializeAdapter<float>::deSerialize(&min, buffer,
-			size, bigEndian);
+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<float>::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/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 120d8b8c9..ddee539e3 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -55,12 +55,15 @@ 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
+	LOCAL_POOL_OWNER_IF, //LPIF 58
+	POOL_VARIABLE_IF, //PVA 59
+	HOUSEKEEPING_MANAGER, //HKM 60
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 5adbca3fc..d231f4ee9 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,27 +1,23 @@
-#ifndef HASRETURNVALUESIF_H_
-#define HASRETURNVALUESIF_H_
+#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FRAMEWORK_RETURNVALUES_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;
 
 
-
-
-
-
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
 	static const ReturnValue_t RETURN_FAILED = 1;
-	virtual ~HasReturnvaluesIF() {
-	}
+	virtual ~HasReturnvaluesIF() {}
 
+	static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
+	    return (interfaceId << 8) + number;
+	}
 };
 
-
-
-#endif /* HASRETURNVALUESIF_H_ */
+#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index c091ba182..4890c516a 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,12 +1,12 @@
 #ifndef RMAPCOOKIE_H_
 #define RMAPCOOKIE_H_
 
-#include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/rmap/rmapStructs.h>
 
 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();
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 4958b3ed7..674d050db 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -5,43 +5,43 @@
 RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF* cookie,
 		uint8_t* data, uint32_t len) {
 	return RMAP::sendWriteCommand((RMAPCookie *) cookie, data, len);
 }
 
-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) {
 	return RMAP::sendReadCommand((RMAPCookie *) cookie,
 				((RMAPCookie *) cookie)->getMaxReplyLen());
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
 		uint8_t** buffer, uint32_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 12ae67e4a..9d756ea2a 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -25,7 +25,7 @@ public:
 	 * @param maxReplyLen Maximum length of expected reply
 	 * @return
 	 */
-	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
+	virtual ReturnValue_t open(CookieIF **cookie, uint32_t address,
 			uint32_t maxReplyLen) = 0;
 
 	/**
@@ -39,7 +39,7 @@ public:
 	 * @param maxReplyLen
 	 * @return
 	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
+	virtual ReturnValue_t reOpen(CookieIF *cookie, uint32_t address,
 			uint32_t maxReplyLen) = 0;
 
 
@@ -47,7 +47,7 @@ public:
 	 * Closing call of connection and memory free of cookie. Mission dependent call
 	 * @param cookie
 	 */
-	virtual void close(Cookie *cookie) = 0;
+	virtual void close(CookieIF *cookie) = 0;
 
 	//SHOULDDO can data be const?
 	/**
@@ -58,23 +58,23 @@ public:
 	 * @param len Length of the data to be send
 	 * @return - Return codes of RMAP::sendWriteCommand()
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, uint8_t *data,
 			uint32_t len);
 
-	virtual ReturnValue_t getSendSuccess(Cookie *cookie);
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
 
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie);
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie);
 
-	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 			uint32_t *size);
 
-	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address);
+	virtual ReturnValue_t setAddress(CookieIF *cookie, uint32_t address);
 
-	virtual uint32_t getAddress(Cookie *cookie);
+	virtual uint32_t getAddress(CookieIF *cookie);
 
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter);
+	virtual ReturnValue_t setParameter(CookieIF *cookie, uint32_t parameter);
 
-	virtual uint32_t getParameter(Cookie *cookie);
+	virtual uint32_t getParameter(CookieIF *cookie);
 };
 
 #endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
new file mode 100644
index 000000000..cd5d5497b
--- /dev/null
+++ b/serialize/EndianConverter.h
@@ -0,0 +1,126 @@
+#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_ */
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
deleted file mode 100644
index 6ff544447..000000000
--- a/serialize/EndianSwapper.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
-
-#include <framework/osal/Endiness.h>
-#include <cstring>
-#include <iostream>
-
-class EndianSwapper {
-private:
-	EndianSwapper() {
-	}
-	;
-public:
-	template<typename T>
-	static T swap(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 (uint8_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
-	}
-	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
-		for (uint8_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
-	}
-};
-
-#endif /* ENDIANSWAPPER_H_ */
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 5ffbc3757..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) {
-		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
-				buffer, size, max_size, 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, maxSize, streamEndianness);
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::serialize(&list->entries[i], buffer, size,
-					max_size, bigEndian);
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return getSerializedSize(adaptee);
 	}
 
@@ -47,31 +47,31 @@ 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;
 	}
 
-	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<count_t>::deSerialize(&tempSize,
-				buffer, size, bigEndian);
+		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<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&list->front()[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 3ed083bf5..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 += AutoSerializeAdapter::getSerializedSize(
+		serializedLength += SerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
-	if (*size + serializedLength > max_size) {
+	if (*size + serializedLength > maxSize) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
-					max_size, bigEndian);
+			SerializeAdapter::serialize(&bufferLength, buffer, size,
+					maxSize, streamEndianness);
 		}
 		if (this->constBuffer != NULL) {
 			memcpy(*buffer, this->constBuffer, bufferLength);
@@ -50,20 +50,20 @@ 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 + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
 		return bufferLength;
 	}
 }
 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){
-			T serializedSize = AutoSerializeAdapter::getSerializedSize(
+			T serializedSize = SerializeAdapter::getSerializedSize(
 					&bufferLength);
 			if((*size - bufferLength - serializedSize) >= 0){
 				*buffer +=  serializedSize;
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/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..ec7275157 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -3,123 +3,121 @@
 
 #include <framework/container/IsDerivedFrom.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianSwapper.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serialize/SerializeIF.h>
 #include <string.h>
 
 /**
  * \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..3941e9fbb 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);
+	size_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..14244a7a7 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 maxSize, 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/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 58065994a..5c80862c2 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,11 +1,58 @@
 #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*);
+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()) {
@@ -20,52 +67,70 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 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);
-		// Write log_message and time
-		this->putChars(preamble, preamble + sizeof(preamble));
-		// Handle output
-		this->putChars(pbase(), pptr());
+	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;
+	auto 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;
 }
 
-#ifndef UT699
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
-	this->log_message = set_message;
-	this->isActive = true;
-	setp( buf, buf + BUF_SIZE );
+bool ServiceInterfaceBuffer::isBuffered() const {
+	return buffered;
 }
 
-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);
+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;
 	}
-	memcpy(array, begin, length);
-
-	for( ; begin != end; begin++){
-		printChar(begin);
+	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 "";
 	}
-
+	if(charCount > MAX_PREAMBLE_SIZE) {
+		printf("ServiceInterfaceBuffer: Char count too large for maximum "
+				"preamble size");
+		return "";
+	}
+	currentSize += charCount;
+	if(preambleSize != nullptr) {
+		*preambleSize = currentSize;
+	}
+	return preamble;
 }
-#endif
+
+
 
 #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 b42c8a197..39ea25c2d 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -1,51 +1,71 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <iostream>
-#include <iosfwd>
 #include <sstream>
-#include <cstdio>
+#include <iomanip>
 
 #ifndef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
+
+/**
+ * @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:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+	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.
-	virtual int overflow(int c = Traits::eof());
+	//! 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.
-	virtual int sync(void);
+	//! 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 log_message;
+	//! For additional message information
+	std::string logMessage;
+	std::string preamble;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
 
-	// Work in buffer mode. It is also possible to work without buffer.
+	//! 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.
+	//! 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> > {
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index c2979f369..76481ed12 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,11 +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->buf.isActive = myActive;
+	this->streambuf.isActive = myActive;
 }
 
-ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
-		uint16_t port) :
-		std::basic_ostream<char, std::char_traits<char> >(&buf), buf(
-				set_message, port) {
+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 df736a1b6..9e19c228c 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -3,28 +3,56 @@
 
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <iostream>
-#include <iosfwd>
-#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.
-namespace sif {
-extern std::ostream debug;
-extern std::ostream info;
-extern std::ostream warning;
-extern std::ostream error;
-}
-
-
-class ServiceInterfaceStream : public std::basic_ostream< char, std::char_traits< char > > {
-protected:
-    ServiceInterfaceBuffer buf;
+/**
+ * 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:
-    ServiceInterfaceStream( std::string set_message, 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 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/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 2d7d9c443..fcf2e1891 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<Mode_t>::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 8e7531f3d..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<uint32_t>::serialize(&value1, buffer, size,
-				max_size, bigEndian);
+		result = SerializeAdapter::serialize(&value1, buffer, size,
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::serialize(&value2, buffer, size,
-				max_size, bigEndian);
+		result = SerializeAdapter::serialize(&value2, buffer, size,
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::serialize(&value3, buffer, size,
-				max_size, bigEndian);
+		result = SerializeAdapter::serialize(&value3, buffer, size,
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 
-		result = SerializeAdapter<uint8_t>::serialize(&value4, buffer, size,
-				max_size, bigEndian);
+		result = SerializeAdapter::serialize(&value4, buffer, size,
+				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<uint32_t>::deSerialize(&value1, buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::deSerialize(&value2, buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value3, buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value4, buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
+				streamEndianness);
 
 		return result;
 	}
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index 5c5955c1c..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:
@@ -37,13 +28,26 @@ 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_) {
+	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 /* EXECUTABLEOBJECTIF_H_ */
+#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index bf6f73986..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;
-	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
-			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
-			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&parameters.upperOpLimit, &data,
-			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&nopParameters.upperNopLimit, &data,
-			&readSize, true);
+	size_t readSize = size;
+	SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
+			&readSize, SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
+			&readSize, SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
+			&readSize, SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
+			&readSize, SerializeIF::Endianness::BIG);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index af6572472..121c63df9 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -2,12 +2,15 @@
 #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>
 
+//! 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:
@@ -21,7 +24,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.
@@ -33,22 +36,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);
 
@@ -56,7 +60,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
new file mode 100644
index 000000000..52118d580
--- /dev/null
+++ b/timemanager/Stopwatch.cpp
@@ -0,0 +1,57 @@
+#include <framework/timemanager/Stopwatch.h>
+#include <framework/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
new file mode 100644
index 000000000..630202cc1
--- /dev/null
+++ b/timemanager/Stopwatch.h
@@ -0,0 +1,71 @@
+#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#include <framework/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/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 6eea6f586..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 result = SerializeAdapter<uint16_t>::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;
 		}
-		return SerializeAdapter<uint16_t>::serialize(&ssc, buffer, size,
-				max_size, bigEndian);
+		return SerializeAdapter::serialize(&ssc, buffer, size,
+				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 result = SerializeAdapter<uint16_t>::deSerialize(&apid,
-				buffer, size, bigEndian);
+	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<uint16_t>::deSerialize(&ssc, buffer, size,
-				bigEndian);
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
+				streamEndianness);
 	}
 };
 
@@ -218,74 +218,74 @@ 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 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 = AutoSerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::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 += 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;
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
-				size, bigEndian);
+	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 = AutoSerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, bigEndian);
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceType, buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, bigEndian);
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&subCounter, buffer, size,
-				bigEndian);
+		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,bigEndian);
+		return adapter.deSerialize(buffer,size,streamEndianness);
 	}
 
 private:
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 1f1949682..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<uint16_t>::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 {
-		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
+	size_t getSerializedSize() const {
+		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);
+	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 1a6781b40..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<uint8_t>::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 {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
+	size_t getSerializedSize() const {
+		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);
+	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 1b589b201..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<uint8_t>::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 {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
+	size_t getSerializedSize() const {
+		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);
+	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 0add30a5c..7c3275818 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);
@@ -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 d70b90428..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;
-	SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
-			sizeof(object_id_t), true);
+	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(
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index 1bc53c2a8..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;
@@ -108,13 +108,13 @@ 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,
-			sizeof(reportBuffer), true);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
 }
 
@@ -135,26 +135,26 @@ 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,
-			sizeof(reportBuffer), true);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
-	SerializeAdapter<ReturnValue_t>::serialize(&setErrorCode, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
-	SerializeAdapter<uint32_t>::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
-	SerializeAdapter<uint32_t>::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+	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() {
 }
 
-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();
 };
 
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
new file mode 100644
index 000000000..b55803cbc
--- /dev/null
+++ b/tmtcservices/TmTcBridge.cpp
@@ -0,0 +1,211 @@
+#include <framework/tmtcservices/TmTcBridge.h>
+
+#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 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;
+	}
+
+	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 result = handleTmQueue();
+	if(result != RETURN_OK) {
+		sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl;
+		return RETURN_FAILED;
+	}
+
+	if(tmStored and communicationLinkUp) {
+		result = handleStoredTm();
+	}
+	return result;
+
+}
+
+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))
+	{
+		if(communicationLinkUp == false) {
+			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) {
+			sif::warning << "TmTcBridge: 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) {
+	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);
+	}
+	storeId = message->getStorageId();
+	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) {
+		//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);
+
+		if(result != RETURN_OK) {
+			sif::error << "TMTC Bridge: Could not send stored downlink data"
+			      << std::endl;
+			result = RETURN_FAILED;
+		}
+		counter ++;
+
+		if(tmFifo.empty()) {
+			tmStored = false;
+		}
+		tmStore->deleteData(storeId);
+	}
+	return result;
+}
+
+void TmTcBridge::registerCommConnect() {
+	if(not communicationLinkUp) {
+		//info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+		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, 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
new file mode 100644
index 000000000..993cd5b99
--- /dev/null
+++ b/tmtcservices/TmTcBridge.h
@@ -0,0 +1,154 @@
+#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 <framework/container/FIFO.h>
+#include <framework/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);
+
+	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;
+
+	/**
+	 * @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.
+	 */
+	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;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */