diff --git a/container/ArrayList.h b/container/ArrayList.h
index be89761e..19454777 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -97,8 +97,7 @@ public:
 		bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
 			return !(*this == other);
 		}
-	}
-	;
+	};
 
 	/**
 	 * Number of Elements stored in this List
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index b744706d..edd66d37 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -19,32 +19,46 @@ public:
 	/**
 	 * Insert value into FIFO
 	 * @param value
-	 * @return
+	 * @return RETURN_OK on success, FULL if full
 	 */
 	ReturnValue_t insert(T value);
 	/**
 	 * Retrieve item from FIFO. This removes the item from the FIFO.
-	 * @param value
-	 * @return
+	 * @param value Must point to a valid T
+	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
 	 */
 	ReturnValue_t retrieve(T *value);
 	/**
 	 * Retrieve item from FIFO without removing it from FIFO.
-	 * @param value
-	 * @return
+	 * @param value Must point to a valid T
+	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
 	 */
 	ReturnValue_t peek(T * value);
 	/**
 	 * Remove item from FIFO.
-	 * @return
+	 * @return RETURN_OK on success, EMPTY if empty
 	 */
 	ReturnValue_t pop();
 
+	/***
+	 * Check if FIFO is empty
+	 * @return True if empty, False if not
+	 */
 	bool empty();
+	/***
+	 * Check if FIFO is Full
+	 * @return True if full, False if not
+	 */
 	bool full();
+	/***
+	 *  Current used size (elements) used
+	 * @return size_t in elements
+	 */
 	size_t size();
-
-
+	/***
+	 * Get maximal capacity of fifo
+	 * @return size_t with max capacity of this fifo
+	 */
 	size_t getMaxCapacity() const;
 
 protected:
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index d54b3f8f..763004b6 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -26,6 +26,9 @@ inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
 	if (empty()) {
 		return EMPTY;
 	} else {
+		if (value == nullptr){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
 		*value = values[readIndex];
 		readIndex = next(readIndex);
 		--currentSize;
@@ -38,6 +41,9 @@ inline ReturnValue_t FIFOBase<T>::peek(T* value) {
 	if(empty()) {
 		return EMPTY;
 	} else {
+		if (value == nullptr){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
 		*value = values[readIndex];
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 42b59177..e9e127cf 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -2,11 +2,13 @@
 #define FIXEDARRAYLIST_H_
 
 #include "ArrayList.h"
+#include <cmath>
 /**
  * \ingroup container
  */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
+template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
+	static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
 private:
 	T data[MAX_SIZE];
 public:
@@ -18,11 +20,13 @@ public:
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, other.data, sizeof(this->data));
 		this->entries = data;
+		this->size = other.size;
 	}
 
 	FixedArrayList& operator=(FixedArrayList other) {
 		memcpy(this->data, other.data, sizeof(this->data));
 		this->entries = data;
+		this->size = other.size;
 		return *this;
 	}
 
diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 31282f80..717575d7 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -10,10 +10,9 @@
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
 
 private:
 	typedef KEY_COMPARE compare;
@@ -99,7 +98,7 @@ public:
 	}
 
 	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.fist, pair.second);
+		return insert(pair.first, pair.second);
 	}
 
 	ReturnValue_t exists(key_t key) const {
diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index 05538478..a0aebb7d 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -3,26 +3,62 @@
 
 #include "../storagemanager/StorageManagerIF.h"
 #include <utility>
-
+/**
+ * The Placement Factory is used to create objects at runtime in a specific pool.
+ * In general, this should be avoided and it should only be used if you know what you are doing.
+ * You are not allowed to use this container with a type that allocates memory internally like ArrayList.
+ *
+ * Also, you have to check the returned pointer in generate against nullptr!
+ *
+ * A backend of Type StorageManagerIF must be given as a place to store the new objects.
+ * Therefore ThreadSafety is only provided by your StorageManager Implementation.
+ *
+ * Objects must be destroyed by the user with "destroy"! Otherwise the pool will not be cleared.
+ *
+ * The concept is based on the placement new operator.
+ *
+ * @warning Do not use with any Type that allocates memory internally!
+ * @ingroup container
+ */
 class PlacementFactory {
 public:
 	PlacementFactory(StorageManagerIF* backend) :
 			dataBackend(backend) {
 	}
+
+	/***
+	 * Generates an object of type T in the backend storage.
+	 *
+	 * @warning Do not use with any Type that allocates memory internally!
+	 *
+	 * @tparam T Type of Object
+	 * @param args Constructor Arguments to be passed
+	 * @return A pointer to the new object or a nullptr in case of failure
+	 */
 	template<typename T, typename ... Args>
 	T* generate(Args&&... args) {
 		store_address_t tempId;
-		uint8_t* pData = NULL;
+		uint8_t* pData = nullptr;
 		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
 				&pData);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return NULL;
+			return nullptr;
 		}
 		T* temp = new (pData) T(std::forward<Args>(args)...);
 		return temp;
 	}
+	/***
+	 * Function to destroy the object allocated with generate and free space in backend.
+	 * This must be called by the user.
+	 *
+	 * @param thisElement Element to be destroyed
+	 * @return RETURN_OK if the element was destroyed, different errors on failure
+	 */
 	template<typename T>
 	ReturnValue_t destroy(T* thisElement) {
+		if (thisElement == nullptr){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
 		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
 		thisElement->~T();
 		uint8_t* pointer = (uint8_t*) (thisElement);
diff --git a/container/RingBufferTest.cpp.ignore b/container/RingBufferTest.cpp.ignore
deleted file mode 100644
index d660e29c..00000000
--- a/container/RingBufferTest.cpp.ignore
+++ /dev/null
@@ -1,79 +0,0 @@
-
-#include <iostream>
-#include "SimpleRingBuffer.h"
-
-
-int main() {
-	using namespace std;
-	SimpleRingBuffer buffer(64, false);
-	uint8_t data[8] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-	ReturnValue_t result = buffer.writeData(data, 8);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(data, 8);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	uint8_t buffer2[47] = {0};
-	for (uint8_t count = 0; count<sizeof(buffer2); count++) {
-		buffer2[count] = count;
-	}
-	result = buffer.writeData(buffer2, sizeof(buffer2));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(buffer2, sizeof(buffer2));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	uint8_t readBuffer[64] = {0};
-	uint32_t writtenData = 0;
-	result = buffer.readData(readBuffer, 12, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-
-	result = buffer.readData(readBuffer, 60, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-	result = buffer.writeData(data, sizeof(data));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.readData(readBuffer, 60, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-	result = buffer.writeData(readBuffer, sizeof(readBuffer));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(readBuffer, sizeof(readBuffer)-1);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	} else {
-		cout << "write done." << endl;
-	}
-}
-
-
diff --git a/container/listTest.cpp.ignore b/container/listTest.cpp.ignore
deleted file mode 100644
index 257b733f..00000000
--- a/container/listTest.cpp.ignore
+++ /dev/null
@@ -1,365 +0,0 @@
-#include "FixedArrayList.h"
-#include "SinglyLinkedList.h"
-#include "HybridIterator.h"
-
-#include "FixedMap.h"
-
-#include <stdio.h>
-
-/*
-
-class Packet: public SinglyLinkedList {
-public:
-	SinglyLinkedList::Element<uint32_t> element1;
-	SinglyLinkedList::Element<uint32_t> element2;
-
-	Packet() {
-		this->start = &element1;
-		element1.next = &element2;
-	}
-};
-
-class Packet2: public SinglyLinkedList {
-public:
-	SinglyLinkedList::Element<uint32_t> element1;
-	SinglyLinkedList::Element<FixedArrayList<FixedArrayList<uint8_t, 5>, 2>> element2;
-	SinglyLinkedList::Element<uint32_t> element3;
-
-	Packet2() {
-		this->start = &element1;
-		element1.next = &element2;
-		element2.next = &element3;
-	}
-};
-
-class Packet3: public SinglyLinkedList {
-public:
-	SinglyLinkedList::TypedElement<uint32_t> element1;
-	SinglyLinkedList::TypedElement<uint32_t> element2;
-
-	Packet3() {
-		this->start = &element1;
-		element1.next = &element2;
-	}
-};
-
-void arrayList() {
-	puts("** Array List **");
-	FixedArrayList<uint32_t, 10, uint32_t> list;
-	FixedArrayList<uint32_t, 10, uint32_t> list2;
-
-	list.size = 2;
-
-	list[0] = 0xcafecafe;
-
-	list[1] = 0x12345678;
-
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	printf("printsize: %i\n", list.getPrintSize());
-
-	list.print(&pointer, &size, 100, true);
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	pointer = buffer;
-
-	size2 = size;
-
-	printf("list2 read: %x\n", list2.read(&pointer, &size2, true));
-
-	printf("list2(%i):", list2.size);
-	for (ArrayList<uint32_t, uint32_t>::Iterator iter = list2.begin();
-			iter != list2.end(); iter++) {
-		printf("0x%04x ", *iter);
-	}
-	printf("\n");
-
-	HybridIterator<uint32_t, uint32_t> hiter(list.begin(),list.end());
-
-	printf("hybrid1: 0x%04x\n", *(hiter++));
-	printf("hybrid2: 0x%04x\n", *hiter);
-
-}
-
-void allocatingList() {
-	puts("** Allocating List **");
-	ArrayList<uint8_t> myList(3), myList2(2);
-	myList[0] = 0xab;
-	myList[1] = 0xcd;
-	myList.size = 2;
-
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	myList.print(&pointer, &size, 100, true);
-
-	pointer = buffer;
-	size2 = size;
-
-	printf("Read %x\n", myList2.read(&pointer, &size2, true));
-
-	printf("%x,%x\n", myList2[0], myList2[1]);
-
-}
-
-void linkedList() {
-	puts("** Linked List **");
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	Packet myPacket;
-	myPacket.element1.entry = 0x12345678;
-	myPacket.element2.entry = 0x9abcdef0;
-
-	pointer = buffer;
-	size = 0;
-	ReturnValue_t result = myPacket.print(&pointer, &size, 100, true);
-
-	printf("result %02x\n", result);
-
-	printf("printsize: %i\n", myPacket.getPrintSize());
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	Packet3 myPacket3;
-
-	myPacket3.element1.entry = 0x12345678;
-	myPacket3.element2.entry = 0xabcdeff;
-
-	SinglyLinkedList::TypedIterator<uint32_t> titer(&myPacket3.element1);
-
-	printf("0x%04x\n", *titer);
-
-	HybridIterator<uint32_t, uint32_t> hiter(&myPacket3.element1);
-
-	printf("hybrid1: 0x%04x\n", *hiter);
-	hiter++;
-	printf("hybrid2: 0x%04x\n", *hiter);
-}
-
-void complex() {
-	puts("** complex **");
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2 = size;
-
-	Packet myPacket2;
-
-	size2 = size;
-	pointer = buffer;
-
-	myPacket2.read(&pointer, &size2, true);
-
-	printf("packet: 0x%04x, 0x%04x\n", myPacket2.element1.entry,
-			myPacket2.element2.entry);
-
-	buffer[0] = 0x12;
-	buffer[1] = 0x34;
-	buffer[2] = 0x56;
-	buffer[3] = 0x78;
-	buffer[4] = 0x2;
-	buffer[5] = 0x3;
-	buffer[6] = 0xab;
-	buffer[7] = 0xcd;
-	buffer[8] = 0xef;
-	buffer[9] = 0x2;
-	buffer[10] = 0x11;
-	buffer[11] = 0x22;
-	buffer[12] = 0xca;
-	buffer[13] = 0xfe;
-	buffer[14] = 0x5a;
-	buffer[15] = 0xfe;
-
-	pointer = buffer;
-	size2 = 23;
-
-	Packet2 p2;
-
-	ReturnValue_t result = p2.read(&pointer, &size2, true);
-	printf("result is %02x\n", result);
-
-	printf("%04x; %i: %i: %x %x %x; %i: %x %x;; %04x\n", p2.element1.entry,
-			p2.element2.entry.size, p2.element2.entry[0].size,
-			p2.element2.entry[0][0], p2.element2.entry[0][1],
-			p2.element2.entry[0][2], p2.element2.entry[1].size,
-			p2.element2.entry[1][0], p2.element2.entry[1][1],
-			p2.element3.entry);
-
-}
-*/
-struct Test {
-	uint32_t a;
-	uint32_t b;
-};
-
-template<typename key_t, typename T>
-void printMap(FixedMap<key_t, T> *map) {
-	typename FixedMap<key_t, T>::Iterator iter;
-	printf("Map (%i): ", map->getSize());
-	for (iter = map->begin(); iter != map->end(); ++iter) {
-		printf("%x:%08x,%08x ", iter.value->first, (*iter).a, (*iter).b);
-	}
-	printf("\n");
-}
-
-template<typename T>
-void map() {
-	puts("** Map **");
-	typename FixedMap<T, Test>::Iterator iter;
-	ReturnValue_t result;
-	FixedMap<T, Test> myMap(5);
-
-	printMap<T, Test>(&myMap);
-
-	Test a;
-	a.a = 0x01234567;
-	a.b = 0xabcdef89;
-
-	myMap.insert(1, a);
-	printMap<T, Test>(&myMap);
-
-	a.a = 0;
-
-	myMap.insert(2, a);
-	printMap<T, Test>(&myMap);
-
-	printf("2 exists: %x\n", myMap.exists(0x02));
-
-	printf("ff exists: %x\n", myMap.exists(0xff));
-
-	a.a = 1;
-	printf("insert 0x2: %x\n", myMap.insert(2, a));
-
-	result = myMap.insert(0xff, a);
-	a.a = 0x44;
-	result = myMap.insert(0xab, a);
-	result = myMap.insert(0xa, a);
-
-	printMap<T, Test>(&myMap);
-
-	printf("insert 0x5: %x\n", myMap.insert(5, a));
-
-	printf("erase 0xfe: %x\n", myMap.erase(0xfe));
-
-	printf("erase 0x2: %x\n", myMap.erase(0x2));
-
-	printMap<T, Test>(&myMap);
-
-	printf("erase 0xab: %x\n", myMap.erase(0xab));
-	printMap<T, Test>(&myMap);
-
-	printf("insert 0x5: %x\n", myMap.insert(5, a));
-	printMap<T, Test>(&myMap);
-
-	iter = myMap.begin();
-	++iter;
-	++iter;
-	++iter;
-
-	printf("iter: %i: %x,%x\n",iter.value->first, iter->a, iter->b);
-
-	myMap.erase(&iter);
-
-	printf("iter: %i: %x,%x\n",iter.value->first, iter->a, iter->b);
-	printMap<T, Test>(&myMap);
-
-}
-
-/*
-void mapPrint() {
-	puts("** Map Print **");
-	FixedMap<uint16_t, Packet2> myMap(5);
-	Packet2 myPacket;
-	myPacket.element1.entry = 0x12345678;
-
-	myPacket.element2.entry[0][0] = 0xab;
-	myPacket.element2.entry[0][1] = 0xcd;
-	myPacket.element2.entry[0].size = 2;
-	myPacket.element2.entry.size = 1;
-
-	myPacket.element3.entry = 0xabcdef90;
-
-	myMap.insert(0x1234, myPacket);
-
-	uint8_t buffer[100];
-	uint32_t size = 0, i;
-	uint8_t *pointer = buffer;
-
-	printf("printsize: %i\n", myMap.getPrintSize());
-
-	SerializeAdapter<FixedMap<uint16_t, Packet2>>::print(&myMap, &pointer,
-			&size, 100, false);
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	int32_t size2 = size;
-	pointer = buffer;
-
-	FixedMap<uint16_t, Packet2> myMap2(5);
-
-	ReturnValue_t result = SerializeAdapter<FixedMap<uint16_t, Packet2>>::read(
-			&myMap2, &pointer, &size2, false);
-
-	Packet2 *myPacket2 = myMap2.find(0x1234);
-
-	printf("Map (%i): Packet2: %x, Array (%i): Array (%i): %x, %x; %x\n",
-			myMap2.getSize(), myPacket2->element1.entry,
-			myPacket2->element2.entry.size, myPacket2->element2.entry[0].size,
-			myPacket2->element2.entry[0][0], myPacket2->element2.entry[0][1],
-			myPacket2->element3.entry);
-
-}
-
-void empty() {
-	puts("** Empty **");
-	ArrayList<uint32_t> list(0);
-	printf("%p %p\n", list.front(), list.back());
-}
-*/
-
-int main(void) {
-
-//	arrayList();
-//	linkedList();
-//	allocatingList();
-//	complex();
-
-	map<uint32_t>();
-//
-//	mapPrint();
-
-//	empty();
-
-
-
-	return 0;
-}
diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index a1cbddf8..7491f47d 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -1,12 +1,5 @@
-/**
- * @file	AcceptsMemoryMessagesIF.h
- * @brief	This file defines the AcceptsMemoryMessagesIF class.
- * @date	11.07.2013
- * @author	baetz
- */
-
-#ifndef ACCEPTSMEMORYMESSAGESIF_H_
-#define ACCEPTSMEMORYMESSAGESIF_H_
+#ifndef FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
+#define FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
 
 #include "HasMemoryIF.h"
 #include "MemoryMessage.h"
@@ -18,4 +11,4 @@ public:
 };
 
 
-#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
+#endif /* FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 48a605be..6b11882f 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -1,14 +1,15 @@
-#include "../globalfunctions/CRC.h"
 #include "MemoryHelper.h"
 #include "MemoryMessage.h"
+
+#include "../globalfunctions/CRC.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/EndianConverter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
-MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue) :
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(NULL), ipcAddress(), lastCommand(
-				CommandMessage::CMD_NONE), lastSender(0), reservedSpaceInIPC(
-				NULL), busy(false) {
+MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
+		MessageQueueIF* useThisQueue):
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcAddress(),
+		lastCommand(CommandMessage::CMD_NONE), busy(false) {
 }
 
 ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
@@ -33,17 +34,8 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 	}
 }
 
-ReturnValue_t MemoryHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore != NULL) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
 void MemoryHelper::completeLoad(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
+		const uint8_t* dataToCopy, const size_t size, uint8_t* copyHere) {
 	busy = false;
 	switch (errorCode) {
 	case HasMemoryIF::DO_IT_MYSELF:
@@ -67,13 +59,13 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		return;
 	}
 	//Only reached on success
-	CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
 	queueToUse->sendMessage(lastSender, &reply);
 	ipcStore->deleteData(ipcAddress);
 }
 
 void MemoryHelper::completeDump(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size) {
+		const uint8_t* dataToCopy, const size_t size) {
 	busy = false;
 	CommandMessage reply;
 	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
@@ -125,12 +117,12 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 		break;
 	}
 	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
-		reply.clearCommandMessage();
+		reply.clear();
 	}
 }
 
 void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
-		uint32_t totalSize, uint8_t datatypeSize) {
+		size_t totalSize, uint8_t datatypeSize) {
 	if (totalSize % datatypeSize != 0){
 		return;
 	}
@@ -185,11 +177,18 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
 }
 
 ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
-	if(queueToUse_!=NULL){
-		this->queueToUse = queueToUse_;
-	}else{
-		return MessageQueueIF::NO_QUEUE;
+	if(queueToUse_ == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
+	this->queueToUse = queueToUse_;
 	return initialize();
 }
+
+ReturnValue_t MemoryHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore != nullptr) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index 5e1a99b6..a651861c 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,11 +1,16 @@
-#ifndef MEMORYHELPER_H_
-#define MEMORYHELPER_H_
-#include "../ipc/CommandMessage.h"
+#ifndef FSFW_MEMORY_MEMORYHELPER_H_
+#define FSFW_MEMORY_MEMORYHELPER_H_
+
 #include "AcceptsMemoryMessagesIF.h"
+
+#include "../ipc/CommandMessage.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../ipc/MessageQueueIF.h"
 
+/**
+ * @brief   TODO: documentation.
+ */
 class MemoryHelper : public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
@@ -13,25 +18,32 @@ public:
 	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
 	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
+
+    MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue);
+    ~MemoryHelper();
+
+    ReturnValue_t handleMemoryCommand(CommandMessage* message);
+    void completeLoad(ReturnValue_t errorCode,
+            const uint8_t* dataToCopy = nullptr, const size_t size = 0,
+            uint8_t* copyHere = nullptr);
+    void completeDump(ReturnValue_t errorCode,
+            const uint8_t* dataToCopy = nullptr, const size_t size = 0);
+    void swapMatrixCopy(uint8_t *out, const uint8_t *in, size_t totalSize,
+            uint8_t datatypeSize);
+    ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+
 private:
 	HasMemoryIF* workOnThis;
 	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
+	StorageManagerIF* ipcStore = nullptr;
 	store_address_t ipcAddress;
 	Command_t lastCommand;
-	MessageQueueId_t lastSender;
-	uint8_t* reservedSpaceInIPC;
+	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
+	uint8_t* reservedSpaceInIPC = nullptr;
 	bool busy;
 	void handleMemoryLoad(CommandMessage* message);
 	void handleMemoryCheckOrDump(CommandMessage* message);
 	ReturnValue_t initialize();
-public:
-	ReturnValue_t handleMemoryCommand(CommandMessage* message);
-	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
-	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
-	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
-	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
-	~MemoryHelper();
+
 };
-#endif /* MEMORYHELPER_H_ */
+#endif /* FSFW_MEMORY_MEMORYHELPER_H_ */
diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index 741565fc..94fa4691 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -1,7 +1,6 @@
 #include "MemoryMessage.h"
+
 #include "../objectmanager/ObjectManagerIF.h"
-MemoryMessage::MemoryMessage() {
-}
 
 uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
 	return message->getParameter();
@@ -17,26 +16,24 @@ uint32_t MemoryMessage::getLength(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
+void MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
 		uint32_t address, uint32_t length) {
 	message->setCommand(CMD_MEMORY_DUMP);
 	message->setParameter( address );
 	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
+void MemoryMessage::setMemoryDumpReply(CommandMessage* message,
+        store_address_t storageID) {
 	message->setCommand(REPLY_MEMORY_DUMP);
 	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
+void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
 		uint32_t address, store_address_t storageID) {
 	message->setCommand(CMD_MEMORY_LOAD);
 	message->setParameter( address );
 	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
@@ -65,22 +62,21 @@ void MemoryMessage::clear(CommandMessage* message) {
 		}
 }
 
-ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
+void MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
 		uint32_t address, uint32_t length) {
 	message->setCommand(CMD_MEMORY_CHECK);
 	message->setParameter( address );
 	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
+void MemoryMessage::setMemoryCheckReply(CommandMessage* message,
 		uint16_t crc) {
 	message->setCommand(REPLY_MEMORY_CHECK);
 	message->setParameter( crc );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
+void MemoryMessage::setCrcReturnValue(CommandMessage* message,
+        ReturnValue_t returnValue){
 	message->setParameter(returnValue<<16);
 };
 
@@ -96,18 +92,16 @@ Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
+void MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
 		ReturnValue_t errorCode, Command_t initialCommand) {
 	message->setCommand(REPLY_MEMORY_FAILED);
 	message->setParameter(errorCode);
 	message->setParameter2(initialCommand);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
+void MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
 	message->setCommand(END_OF_MEMORY_COPY);
 	message->setParameter(0);
 	message->setParameter2(0);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index a4c2de63..05b9926d 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -1,14 +1,15 @@
-#ifndef MEMORYMESSAGE_H_
-#define MEMORYMESSAGE_H_
+#ifndef FSFW_MEMORY_MEMORYMESSAGE_H_
+#define FSFW_MEMORY_MEMORYMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
 
 
 class MemoryMessage {
-private:
-	MemoryMessage(); //A private ctor inhibits instantiation
 public:
+    // Instantiation forbidden.
+	MemoryMessage() = delete;
+
 	static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
 	static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
@@ -19,21 +20,29 @@ public:
 	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
 
 	static uint32_t getAddress( const CommandMessage* message );
-	static store_address_t getStoreID( const CommandMessage* message );
+	static store_address_t getStoreID(const CommandMessage* message);
 	static uint32_t getLength( const CommandMessage* message );
-	static ReturnValue_t getErrorCode( const CommandMessage* message );
-	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static ReturnValue_t setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
-	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
-	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
-	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
+	static ReturnValue_t getErrorCode(const CommandMessage* message);
+    static uint16_t getCrc(const CommandMessage* message );
+    static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
+    static Command_t getInitialCommand(const CommandMessage* message);
+
+	static void setMemoryDumpCommand(CommandMessage* message,
+	        uint32_t address, uint32_t length );
+	static void setMemoryDumpReply(CommandMessage* message,
+	        store_address_t storageID);
+	static void setMemoryLoadCommand(CommandMessage* message,
+	        uint32_t address, store_address_t storageID );
+	static void setMemoryCheckCommand(CommandMessage* message,
+	        uint32_t address, uint32_t length);
+	static void setMemoryCheckReply(CommandMessage* message,
+	        uint16_t crc);
+	static void setMemoryReplyFailed(CommandMessage* message,
+	        ReturnValue_t errorCode, Command_t initialCommand);
+	static void setMemoryCopyEnd(CommandMessage* message);
 	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
-	static uint16_t getCrc( const CommandMessage* message );
-	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
-	static Command_t getInitialCommand( const CommandMessage* message );
+
 	static void clear(CommandMessage* message);
 };
 
-#endif /* MEMORYMESSAGE_H_ */
+#endif /* FSFW_MEMORY_MEMORYMESSAGE_H_ */
diff --git a/memory/MemoryProxyIF.h b/memory/MemoryProxyIF.h
deleted file mode 100644
index 1494d523..00000000
--- a/memory/MemoryProxyIF.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-
-#include "AcceptsMemoryMessagesIF.h"
-
-/**
- * This was a nice idea to transparently forward incoming messages to another object.
- * But it doesn't work like that.
- */
-class MemoryProxyIF : public AcceptsMemoryMessagesIF {
-public:
-	virtual MessageQueueId_t getProxyQueue() const = 0;
-	MessageQueueId_t getCommandQueue() const {
-		return getProxyQueue();
-	}
-	virtual ~MemoryProxyIF() {}
-
-};
-
-
-
-#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index 4381046c..34a15937 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -1,18 +1,11 @@
-/**
- * @file	HasModesIF.h
- * @brief	This file defines the HasModesIF class.
- * @date	20.06.2013
- * @author	baetz
- */
+#ifndef FSFW_MODES_HASMODESIF_H_
+#define FSFW_MODES_HASMODESIF_H_
 
-#ifndef HASMODESIF_H_
-#define HASMODESIF_H_
-
-#include "../events/Event.h"
 #include "ModeHelper.h"
 #include "ModeMessage.h"
+#include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include <cstdint>
 
 
 class HasModesIF {
@@ -37,21 +30,22 @@ public:
 	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
 	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
-	virtual ~HasModesIF() {
-	}
+
+	virtual ~HasModesIF() {}
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
+
 protected:
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	virtual void startTransition(Mode_t mode, Submode_t submode) {
-	}
-	virtual void setToExternalControl() {
-	}
-	virtual void announceMode(bool recursive) {
-	}
+
+	virtual void startTransition(Mode_t mode, Submode_t submode) {}
+
+	virtual void setToExternalControl() {}
+
+	virtual void announceMode(bool recursive) {}
 };
 
-#endif /* HASMODESIF_H_ */
+#endif /*FSFW_MODES_HASMODESIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index f464a743..6be4f776 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,38 +1,39 @@
 #include "HasModesIF.h"
 #include "ModeHelper.h"
+
 #include "../ipc/MessageQueueSenderIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 ModeHelper::ModeHelper(HasModesIF *owner) :
-		theOneWhoCommandedAMode(0), commandedMode(HasModesIF::MODE_OFF), commandedSubmode(
-				HasModesIF::SUBMODE_NONE), owner(owner), parentQueueId(0), forced(
-				false) {
-}
+		commandedMode(HasModesIF::MODE_OFF),
+		commandedSubmode(HasModesIF::SUBMODE_NONE),
+		owner(owner), forced(false) {}
 
 ModeHelper::~ModeHelper() {
 
 }
 
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 	CommandMessage reply;
 	Mode_t mode;
 	Submode_t submode;
-	switch (message->getCommand()) {
+	switch (command->getCommand()) {
 	case ModeMessage::CMD_MODE_COMMAND_FORCED:
 		forced = true;
 		/* NO BREAK falls through*/
 	case ModeMessage::CMD_MODE_COMMAND: {
-		mode = ModeMessage::getMode(message);
-		submode = ModeMessage::getSubmode(message);
+		mode = ModeMessage::getMode(command);
+		submode = ModeMessage::getSubmode(command);
 		uint32_t timeout;
 		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			ModeMessage::cantReachMode(&reply, result);
-			MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
-					owner->getCommandQueue());
+			ModeMessage::setCantReachMode(&reply, result);
+			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+			        owner->getCommandQueue());
 			break;
 		}
 		//Free to start transition
-		theOneWhoCommandedAMode = message->getSender();
+		theOneWhoCommandedAMode = command->getSender();
 		commandedMode = mode;
 		commandedSubmode = submode;
 
@@ -42,7 +43,6 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
 		}
 
 		countdown.setTimeout(timeout);
-
 		owner->startTransition(mode, submode);
 	}
 		break;
@@ -50,8 +50,8 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
 		owner->getMode(&mode, &submode);
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
 				submode);
-		MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
-				owner->getCommandQueue());
+		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+		       owner->getCommandQueue());
 	}
 		break;
 	case ModeMessage::CMD_MODE_ANNOUNCE:
@@ -71,27 +71,45 @@ ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
 	return initialize();
 }
 
-void ModeHelper::modeChanged(Mode_t mode, Submode_t submode) {
+void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 	forced = false;
+	sendModeReplyMessage(ownerMode, ownerSubmode);
+	sendModeInfoMessage(ownerMode, ownerSubmode);
+	theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
+}
+
+void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
 	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueIF::NO_QUEUE) {
-		if ((mode != commandedMode) || (submode != commandedSubmode)) {
+	if (theOneWhoCommandedAMode != MessageQueueIF::NO_QUEUE)
+	{
+		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
+		{
 			ModeMessage::setModeMessage(&reply,
-					ModeMessage::REPLY_WRONG_MODE_REPLY, mode, submode);
-		} else {
+					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
+					ownerSubmode);
+		}
+		else
+		{
 			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
-					mode, submode);
+					ownerMode, ownerSubmode);
 		}
 		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-				owner->getCommandQueue());
+		        owner->getCommandQueue());
 	}
+}
+
+void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
 	if (theOneWhoCommandedAMode != parentQueueId
-			&& parentQueueId != MessageQueueIF::NO_QUEUE) {
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO, mode,
-				submode);
-		MessageQueueSenderIF::sendMessage(parentQueueId, &reply, owner->getCommandQueue());
+			and parentQueueId != MessageQueueIF::NO_QUEUE)
+	{
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
+				ownerMode, ownerSubmode);
+		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
+		        owner->getCommandQueue());
 	}
-	theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
 }
 
 void ModeHelper::startTimer(uint32_t timeoutMs) {
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 542fe780..c2f089ec 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,7 +1,8 @@
-#ifndef MODEHELPER_H_
-#define MODEHELPER_H_
+#ifndef FSFW_MODES_MODEHELPER_H_
+#define FSFW_MODES_MODEHELPER_H_
 
 #include "ModeMessage.h"
+#include "../ipc/MessageQueueIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Countdown.h"
 
@@ -9,7 +10,7 @@ class HasModesIF;
 
 class ModeHelper {
 public:
-	MessageQueueId_t theOneWhoCommandedAMode;
+	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
 	Mode_t commandedMode;
 	Submode_t commandedSubmode;
 
@@ -19,14 +20,14 @@ public:
 	ReturnValue_t handleModeCommand(CommandMessage *message);
 
 	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue the Queue id of the parent object.
+	 * Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueueId);
 
 	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
 
-	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
+	ReturnValue_t initialize(void);
 
 	void modeChanged(Mode_t mode, Submode_t submode);
 
@@ -39,11 +40,14 @@ public:
 	void setForced(bool forced);
 protected:
 	HasModesIF *owner;
-	MessageQueueId_t parentQueueId;
+	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
 
 	Countdown countdown;
 
 	bool forced;
+private:
+	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
 };
 
-#endif /* MODEHELPER_H_ */
+#endif /* FSFW_MODES_MODEHELPER_H_ */
diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index 14dbbb31..b33bba60 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -8,12 +8,11 @@ Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
-		Mode_t mode, Submode_t submode) {
+void ModeMessage::setModeMessage(CommandMessage* message,
+        Command_t command, Mode_t mode, Submode_t submode) {
 	message->setCommand( command );
 	message->setParameter( mode );
 	message->setParameter2( submode );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
@@ -24,7 +23,8 @@ void ModeMessage::clear(CommandMessage* message) {
 	message->setCommand(CommandMessage::CMD_NONE);
 }
 
-void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
+void ModeMessage::setCantReachMode(CommandMessage* message,
+        ReturnValue_t reason) {
 	message->setCommand(REPLY_CANT_REACH_MODE);
 	message->setParameter(reason);
 	message->setParameter2(0);
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index 925f3fc1..856996cf 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -1,12 +1,5 @@
-/**
- * @file	ModeMessage.h
- * @brief	This file defines the ModeMessage class.
- * @date	17.07.2013
- * @author	baetz
- */
-
-#ifndef MODEMESSAGE_H_
-#define MODEMESSAGE_H_
+#ifndef FSFW_MODES_MODEMESSAGE_H_
+#define FSFW_MODES_MODEMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 
@@ -30,11 +23,12 @@ public:
 
 	static Mode_t getMode(const CommandMessage* message);
 	static Submode_t getSubmode(const CommandMessage* message);
-	static ReturnValue_t setModeMessage(CommandMessage* message,
+    static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+
+	static void setModeMessage(CommandMessage* message,
 			Command_t command, Mode_t mode, Submode_t submode);
-	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
-	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+	static void setCantReachMode(CommandMessage* message, ReturnValue_t reason);
 	static void clear(CommandMessage* message);
 };
 
-#endif /* MODEMESSAGE_H_ */
+#endif /* FSFW_MODES_MODEMESSAGE_H_ */
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index e5c61cae..cb5ffd04 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,8 +1,8 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../objectmanager/ObjectManagerIF.h"
 
 #include <fstream>
-
 #include <fcntl.h>           /* For O_* constants */
 #include <sys/stat.h>        /* For mode constants */
 #include <cstring>
diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index 32f7e5a7..c63b47a6 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -107,13 +107,23 @@ ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
 		const CommandMessage *reply, object_id_t objectId) {
 	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
 			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+	ReturnValue_t result = sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+	if(result == RETURN_OK){
+		// We want to produce an error here in any case because the mode was not correct
+		return RETURN_FAILED;
+	}
+	return result;
 }
 
 ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
 		const CommandMessage *reply, object_id_t objectId) {
 	CantReachModePacket cantReachModePacket(objectId,
 	        ModeMessage::getCantReachModeReason(reply));
-	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
+	ReturnValue_t result = sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
 	        &cantReachModePacket);
+	if(result == RETURN_OK){
+		// We want to produce an error here in any case because the mode was not reached
+		return RETURN_FAILED;
+	}
+	return result;
 }
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index b047576b..bfad9ec5 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -4,31 +4,6 @@
 PusVerificationMessage::PusVerificationMessage() {
 }
 
-//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
-//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
-//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
-//	uint16_t tcPacketId = current_packet->getPacketId();
-//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
-//	uint8_t* data = this->getBuffer();
-//	data[messageSize] = set_report_id;
-//	messageSize += sizeof(set_report_id);
-//	data[messageSize] = ackFlags;
-//	messageSize += sizeof(ackFlags);
-//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-//	messageSize += sizeof(tcPacketId);
-//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-//	messageSize += sizeof(tcSequenceControl);
-//	data[messageSize] = set_step;
-//	messageSize += sizeof(set_step);
-//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-//	messageSize += sizeof(set_error_code);
-//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-//	messageSize += sizeof(parameter1);
-//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-//	messageSize += sizeof(parameter2);
-//}
-
 PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index b4739577..88954cfd 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -1,9 +1,13 @@
-#ifndef PUSVERIFICATIONREPORT_H_
-#define PUSVERIFICATIONREPORT_H_
+#ifndef FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_
+#define FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_
+
+#include "VerificationCodes.h"
 
 #include "../ipc/MessageQueueMessage.h"
 #include "../tmtcpacket/pus/TcPacketBase.h"
-#include "VerificationCodes.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#include <cstdint>
 
 class PusVerificationMessage: public MessageQueueMessage {
 private:
@@ -30,7 +34,7 @@ private:
 public:
 	static const uint8_t VERIFICATION_MIN_SIZE = 6;
 	PusVerificationMessage();
-//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+
 	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
 			uint16_t tcPacketId, uint16_t tcSequenceControl,
 			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
@@ -74,4 +78,4 @@ public:
 	uint8_t* getReport();
 };
 
-#endif /* PUSVERIFICATIONREPORT_H_ */
+#endif /* FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_ */