release 0.0.1 of fsfw added as a core

2021-06-21 15:04:15 +02:00
parent b4e5534407
commit caea75b0a8
587 changed files with 55346 additions and 0 deletions
--- a/fsfw/serialize/EndianConverter.h
+++ b/fsfw/serialize/EndianConverter.h
@ -0,0 +1,124 @@
+#ifndef FSFW_SERIALIZE_ENDIANCONVERTER_H_
+#define FSFW_SERIALIZE_ENDIANCONVERTER_H_
+
+#include "../osal/Endiness.h"
+#include <cstring>
+#include <iostream>
+
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
+class EndianConverter {
+private:
+	EndianConverter() {};
+public:
+	/**
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertBigEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		T tmp;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
+		for (size_t count = 0; count < sizeof(T); count++) {
+			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+		}
+		return tmp;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		return in;
+#else
+#error Unknown Byte Order
+#endif
+	}
+
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		for (size_t count = 0; count < size; count++) {
+			out[size - count - 1] = in[count];
+		}
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (size_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (size_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+};
+
+#endif /* FSFW_SERIALIZE_ENDIANCONVERTER_H_ */
--- a/fsfw/serialize/SerialArrayListAdapter.h
+++ b/fsfw/serialize/SerialArrayListAdapter.h
@ -0,0 +1,86 @@
+#ifndef FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
+
+#include "SerializeIF.h"
+#include "../container/ArrayList.h"
+#include <utility>
+
+/**
+ * Also serializes length field !
+ * @author 	baetz
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialArrayListAdapter : public SerializeIF {
+public:
+	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
+				buffer, size, maxSize, streamEndianness);
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const {
+		return getSerializedSize(adaptee);
+	}
+
+	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
+		uint32_t printSize = sizeof(count_t);
+		count_t i = 0;
+
+		for (i = 0; i < list->size; ++i) {
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
+		}
+
+		return printSize;
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return deSerialize(adaptee, buffer, size, streamEndianness);
+	}
+
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
+			const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		count_t tempSize = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
+				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (tempSize > list->maxSize()) {
+			return SerializeIF::TOO_MANY_ELEMENTS;
+		}
+
+		list->size = tempSize;
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			result = SerializeAdapter::deSerialize(
+					&list->front()[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+private:
+	ArrayList<T, count_t> *adaptee;
+};
+
+#endif /* FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_ */
--- a/fsfw/serialize/SerialBufferAdapter.cpp
+++ b/fsfw/serialize/SerialBufferAdapter.cpp
@ -0,0 +1,129 @@
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength),
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
+		bufferLength(bufferLength) {}
+
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	if (serializeLength) {
+		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
+				buffer, size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	if (*size + bufferLength > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+
+	if (this->constBuffer != nullptr) {
+		std::memcpy(*buffer, this->constBuffer, bufferLength);
+	}
+	else if (this->buffer != nullptr) {
+		// This will propably be never reached, constBuffer should always be
+		// set if non-const buffer is set.
+		std::memcpy(*buffer, this->buffer, bufferLength);
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*size += bufferLength;
+	(*buffer) += bufferLength;
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (serializeLength) {
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
+	} else {
+		return bufferLength;
+	}
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	if (this->buffer == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(serializeLength){
+		count_t lengthField = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
+				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if(lengthField > bufferLength) {
+			return TOO_MANY_ELEMENTS;
+		}
+		bufferLength = lengthField;
+	}
+
+	if (bufferLength <= *size) {
+		*size -= bufferLength;
+		std::memcpy(this->buffer, *buffer, bufferLength);
+		(*buffer) += bufferLength;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(buffer == nullptr) {
+		sif::error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()." << std::endl;
+		return nullptr;
+	}
+	return buffer;
+}
+
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(constBuffer == nullptr) {
+		sif::error << "SerialBufferAdapter::getConstBuffer:"
+				" Buffers are unitialized!" << std::endl;
+		return nullptr;
+	}
+	return constBuffer;
+}
+
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
+		count_t bufferLength) {
+	this->buffer = buffer;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
+}
+
+
+//forward Template declaration for linker
+template class SerialBufferAdapter<uint8_t>;
+template class SerialBufferAdapter<uint16_t>;
+template class SerialBufferAdapter<uint32_t>;
+template class SerialBufferAdapter<uint64_t>;
+
--- a/fsfw/serialize/SerialBufferAdapter.h
+++ b/fsfw/serialize/SerialBufferAdapter.h
@ -0,0 +1,78 @@
+#ifndef SERIALBUFFERADAPTER_H_
+#define SERIALBUFFERADAPTER_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * This adapter provides an interface for SerializeIF to serialize or deserialize
+ * buffers with no length header but a known size.
+ *
+ * Additionally, the buffer length can be serialized too and will be put in
+ * front of the serialized buffer.
+ *
+ * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
+ *
+ * \ingroup serialize
+ */
+template<typename count_t>
+class SerialBufferAdapter: public SerializeIF {
+public:
+
+    /**
+     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength
+     */
+    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    /**
+     * Constructor for non-constant uint8_t buffer.
+     * Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength Length field will be serialized with size count_t
+     */
+    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    virtual ~SerialBufferAdapter();
+
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const override;
+
+    virtual size_t getSerializedSize() const override;
+
+    /**
+     * @brief This function deserializes a buffer into the member buffer.
+     * @details
+     * If a length field is present, it is ignored, as the size should have
+     * been set in the constructor. If the size is not known beforehand,
+     * consider using SerialFixedArrayListAdapter instead.
+     * @param buffer [out] Resulting buffer
+     * @param size remaining size to deserialize, should be larger than buffer
+     *        + size field size
+     * @param bigEndian
+     * @return
+     */
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) override;
+
+    uint8_t * getBuffer();
+    const uint8_t * getConstBuffer();
+    void setBuffer(uint8_t* buffer, count_t bufferLength);
+private:
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
+	uint8_t *buffer = nullptr;
+	count_t bufferLength = 0;
+};
+
+#endif /* SERIALBUFFERADAPTER_H_ */
--- a/fsfw/serialize/SerialFixedArrayListAdapter.h
+++ b/fsfw/serialize/SerialFixedArrayListAdapter.h
@ -0,0 +1,57 @@
+#ifndef FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
+
+#include "SerialArrayListAdapter.h"
+#include "../container/FixedArrayList.h"
+
+/**
+ * @brief 	This adapter provides an interface for SerializeIF to serialize and
+ * 			deserialize buffers with a header containing the buffer length.
+ * @details
+ * Can be used by SerialLinkedListAdapter by declaring
+ * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
+ * The sequence of objects is defined in the constructor by
+ * using the setStart and setNext functions.
+ *
+ * @tparam BUFFER_TYPE: Specifies the data type of the buffer
+ * @tparam MAX_SIZE: Specifies the maximum allowed number of elements
+ * 					 (not bytes!)
+ * @tparam count_t: specifies the type/size of the length field which defaults
+ * 					to one byte.
+ * @ingroup serialize
+ */
+template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class SerialFixedArrayListAdapter :
+		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
+		public SerializeIF {
+public:
+	/**
+	 * Constructor arguments are forwarded to FixedArrayList constructor.
+	 * Refer to the fixed array list constructors for different options.
+	 * @param args
+	 */
+	template<typename... Args>
+	SerialFixedArrayListAdapter(Args... args) :
+	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
+	        std::forward<Args>(args)...){}
+
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
+                buffer, size, maxSize, streamEndianness);
+    }
+
+    size_t getSerializedSize() const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+        		getSerializedSize(this);
+    }
+
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
+                buffer, size, streamEndianness);
+    }
+
+};
+
+#endif /* FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_ */
--- a/fsfw/serialize/SerialLinkedListAdapter.h
+++ b/fsfw/serialize/SerialLinkedListAdapter.h
@ -0,0 +1,128 @@
+#ifndef FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "SerializeAdapter.h"
+#include "SerializeElement.h"
+#include "SerializeIF.h"
+
+ /**
+ * @brief  	Implement the conversion of object data to data streams
+ * 		   	or vice-versa, using linked lists.
+ * @details
+ * An alternative to the AutoSerializeAdapter functions
+ *   - All object members with a datatype are declared as
+ *     SerializeElement<element_type> members inside the class
+ *     implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to
+ *     de-/serialize buffers.
+ *   - The element type can also be a SerialFixedArrayListAdapter to
+ *     de-/serialize buffers with a size header, which is scanned automatically.
+ *
+ * The sequence of objects is defined in the constructor by using
+ * the setStart and setNext functions.
+ *
+ * 1. The serialization process is done by instantiating the class and
+ *    calling serialize after all SerializeElement entries have been set by
+ *    using the constructor or setter functions. An additional size variable
+ *    can be supplied which is calculated/incremented automatically.
+ * 2. The deserialization process is done by instantiating the class and
+ *    supplying a buffer with the data which is converted into an object.
+ *    The size of data to serialize can be supplied and is
+ *    decremented in the function. Range checking is done internally.
+ * @author baetz
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
+public:
+
+	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
+			bool printCount = false) :
+			SinglyLinkedList<T>(start), printCount(printCount) {
+	}
+
+	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
+			SinglyLinkedList<T>(first), printCount(printCount) {
+
+	}
+
+	SerialLinkedListAdapter(bool printCount = false) :
+			SinglyLinkedList<T>(), printCount(printCount) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		if (printCount) {
+			count_t mySize = SinglyLinkedList<T>::getSize();
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
+					buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const LinkedElement<T>* element,
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		while ((result == HasReturnvaluesIF::RETURN_OK) and (element != nullptr)) {
+			result = element->value->serialize(buffer, size, maxSize,
+					streamEndianness);
+			element = element->getNext();
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		if (printCount) {
+			return SerialLinkedListAdapter<T>::getSerializedSize()
+					+ sizeof(count_t);
+		} else {
+			return getSerializedSize(SinglyLinkedList<T>::start);
+		}
+	}
+
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
+		size_t size = 0;
+		while (element != nullptr) {
+			size += element->value->getSerializedSize();
+			element = element->getNext();
+		}
+		return size;
+	}
+
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override {
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size,
+				streamEndianness);
+	}
+
+	static ReturnValue_t deSerialize(LinkedElement<T>* element,
+			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		while ((result == HasReturnvaluesIF::RETURN_OK) and (element != nullptr)) {
+			result = element->value->deSerialize(buffer, size, streamEndianness);
+			element = element->getNext();
+		}
+		return result;
+	}
+
+	/**
+	 * Copying is forbidden by deleting the copy constructor and the copy
+	 * assignment operator because of the pointers to the linked list members.
+	 * Unless the child class implements an own copy constructor or
+	 * copy assignment operator, these operation will throw a compiler error.
+	 * @param
+	 */
+	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
+	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
+
+	bool printCount;
+};
+
+#endif /* FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_ */
--- a/fsfw/serialize/SerializeAdapter.h
+++ b/fsfw/serialize/SerializeAdapter.h
@ -0,0 +1,193 @@
+#ifndef _FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+#define _FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "EndianConverter.h"
+#include "SerializeIF.h"
+#include <cstddef>
+#include <type_traits>
+
+ /**
+ * @brief These adapters provides an interface to use the SerializeIF functions
+ * 		  with arbitrary template objects to facilitate and simplify the
+ * 		  serialization of classes with different multiple different data types
+ * 		  into buffers and vice-versa.
+ * @details
+ * The correct serialization or deserialization function is chosen at
+ * compile time with template type deduction.
+ *
+ * @ingroup serialize
+ */
+class SerializeAdapter {
+public:
+	/***
+	 * This function can be used to serialize a trivial copy-able type or a
+	 * child of SerializeIF.
+	 * The right template to be called is determined in the function itself.
+	 * For objects of non trivial copy-able type this function is almost never
+	 * called by the user directly. Instead helpers for specific types like
+	 * SerialArrayListAdapter or SerialLinkedListAdapter is the right choice here.
+	 *
+	 * @param[in] object Object to serialize, the used type is deduced from this pointer
+	 * @param[in/out] buffer Buffer to serialize into. Will be moved by the function.
+	 * @param[in/out] size Size of current written buffer. Will be incremented by the function.
+	 * @param[in] maxSize Max size of Buffer
+	 * @param[in] streamEndianness Endianness of serialized element as in according to SerializeIF::Endianness
+	 * @return
+	 * 		- @c BUFFER_TOO_SHORT The given buffer in is too short
+	 * 		- @c RETURN_FAILED Generic Error
+	 * 		- @c RETURN_OK Successful serialization
+	 */
+	template<typename T>
+	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+			size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
+	}
+	/**
+	 * Function to return the serialized size of the object in the pointer.
+	 * May be a trivially copy-able object or a Child of SerializeIF
+	 *
+	 * @param object Pointer to Object
+	 * @return Serialized size of object
+	 */
+	template<typename T>
+	static size_t getSerializedSize(const T *object){
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
+		return adapter.getSerializedSize(object);
+	}
+	/**
+	 * @brief
+	 * Deserializes a object from a given buffer of given size.
+	 * Object Must be trivially copy-able or a child of SerializeIF.
+	 *
+	 * @details
+	 * Buffer will be moved to the current read location. Size will be decreased by the function.
+	 *
+	 * @param[in/out] buffer Buffer to deSerialize from. Will be moved by the function.
+	 * @param[in/out] size Remaining size of the buffer to read from. Will be decreased by function.
+	 * @param[in] streamEndianness Endianness as in according to SerializeIF::Endianness
+	 * @return
+	 * 	- @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
+	 * 	- @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
+	 * 	- @c RETURN_FAILED Generic Error
+	 * 	- @c RETURN_OK Successful deserialization
+	 */
+	template<typename T>
+	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+			size_t *size, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
+	}
+private:
+	/**
+	 * Internal template to deduce the right function calls at compile time
+	 */
+	template<typename T, bool> class InternalSerializeAdapter;
+
+	/**
+	 * Template to be used if T is not a child of SerializeIF
+	 *
+	 * @tparam T T must be trivially_copyable
+	 */
+	template<typename T>
+	class InternalSerializeAdapter<T, false> {
+		static_assert (std::is_trivially_copyable<T>::value,
+				"If a type needs to be serialized it must be a child of "
+				"SerializeIF or trivially copy-able");
+	public:
+		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size,
+				SerializeIF::Endianness streamEndianness) {
+			size_t ignoredSize = 0;
+			if (size == nullptr) {
+				size = &ignoredSize;
+			}
+			// Check remaining size is large enough and check integer
+			// overflow of *size
+			size_t newSize = sizeof(T) + *size;
+			if ((newSize <= max_size) and (newSize > *size)) {
+				T tmp;
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					tmp = *object;
+					break;
+				}
+				std::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);
+				std::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 for objects that inherit from SerializeIF
+	 *
+	 * @tparam T A child of SerializeIF
+	 */
+	template<typename T>
+	class InternalSerializeAdapter<T, true> {
+	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 == nullptr) {
+				size = &ignoredSize;
+			}
+			return object->serialize(buffer, size, max_size, streamEndianness);
+		}
+		size_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 /* _FSFW_SERIALIZE_SERIALIZEADAPTER_H_ */
--- a/fsfw/serialize/SerializeElement.h
+++ b/fsfw/serialize/SerializeElement.h
@ -0,0 +1,63 @@
+#ifndef FSFW_SERIALIZE_SERIALIZEELEMENT_H_
+#define FSFW_SERIALIZE_SERIALIZEELEMENT_H_
+
+#include "SerializeAdapter.h"
+#include "../container/SinglyLinkedList.h"
+#include <utility>
+
+/**
+ * @brief This class is used to mark datatypes for serialization with the
+ *        SerialLinkedListAdapter
+ * @details
+ * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
+ * inside a SerialLinkedListAdapter implementation and setting the sequence
+ * of objects with setNext() and setStart().
+ * Serialization and Deserialization is then performed automatically in
+ * specified sequence order.
+ * @ingroup serialize
+ */
+template<typename T>
+class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
+public:
+	template<typename ... Args>
+	SerializeElement(Args ... args) :
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+
+	}
+	SerializeElement() :
+			LinkedElement<SerializeIF>(this) {
+	}
+
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&entry);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
+	}
+
+	operator T() {
+		return entry;
+	}
+
+	SerializeElement<T>& operator=(T newValue) {
+		entry = newValue;
+		return *this;
+	}
+
+	T* operator->() {
+		return &entry;
+	}
+
+	T entry;
+};
+
+#endif /* FSFW_SERIALIZE_SERIALIZEELEMENT_H_ */
--- a/fsfw/serialize/SerializeIF.h
+++ b/fsfw/serialize/SerializeIF.h
@ -0,0 +1,87 @@
+#ifndef FSFW_SERIALIZE_SERIALIZEIF_H_
+#define FSFW_SERIALIZE_SERIALIZEIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+/**
+ * @defgroup serialize Serialization
+ * Contains serialization services.
+ */
+
+/**
+ * @brief 	Translation of objects into data streams and from data streams.
+ * @details
+ * Also provides options to convert from/to data with different endianness.
+ * variables.
+ * @ingroup serialize
+ */
+class SerializeIF {
+public:
+	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); // !< The given buffer in serialize is too short
+	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2); // !< The input stream in deserialize is too short
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);// !< There are too many elements to be deserialized
+
+	virtual ~SerializeIF() {
+	}
+	/**
+	 * @brief
+	 * Function to serialize the object into a buffer with maxSize. Size represents the written amount.
+	 * If a part of the buffer has been used already, size must be set to the used amount of bytes.
+	 *
+	 * @details
+	 * Implementations of this function must increase the size variable and move the buffer pointer.
+	 * MaxSize must be checked by implementations of this function
+	 * and BUFFER_TOO_SHORT has to be returned if size would be larger than maxSize.
+	 *
+	 * Custom implementations might use additional return values.
+	 *
+	 * @param[in/out] buffer Buffer to serialize into, will be set to the current write location
+	 * @param[in/out] size Size that has been used in the buffer already, will be increased by the function
+	 * @param[in] maxSize The size of the buffer that is allowed to be used for serialize.
+	 * @param[in] streamEndianness Endianness of the serialized data according to SerializeIF::Endianness
+	 * @return
+	 * 		- @c BUFFER_TOO_SHORT The given buffer in is too short
+	 * 		- @c RETURN_FAILED Generic error
+	 * 		- @c RETURN_OK Successful serialization
+	 */
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const = 0;
+
+	/**
+	 * Gets the size of a object if it would be serialized in a buffer
+	 * @return Size of serialized object
+	 */
+	virtual size_t getSerializedSize() const = 0;
+
+	/**
+	 * @brief
+	 * Deserializes a object from a given buffer of given size.
+	 *
+	 * @details
+	 * Buffer must be moved to the current read location by the implementation
+	 * of this function. Size must be decreased by the implementation.
+	 * Implementations are not allowed to alter the buffer as indicated by const pointer.
+	 *
+	 * Custom implementations might use additional return values.
+	 *
+	 * @param[in/out] buffer Buffer to deSerialize from. Will be moved by the function.
+	 * @param[in/out] size Remaining size of the buffer to read from. Will be decreased by function.
+	 * @param[in] streamEndianness Endianness as in according to SerializeIF::Endianness
+	 * @return
+	 * 	- @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
+	 * 	- @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
+	 * 	- @c RETURN_FAILED Generic Error
+	 * 	- @c RETURN_OK Successful deserialization
+	 */
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) = 0;
+
+};
+
+#endif /* FSFW_SERIALIZE_SERIALIZEIF_H_ */