trying to fuse header / inc

src/fsfw/parameters/CMakeLists.txt

@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ParameterHelper.cpp
+		ParameterMessage.cpp
+		ParameterWrapper.cpp
+)

src/fsfw/parameters/HasParametersIF.h

@@ -0,0 +1,81 @@
+#ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
+#define FSFW_PARAMETERS_HASPARAMETERSIF_H_
+
+#include "ParameterWrapper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+
+/**
+ * Each parameter is identified with a unique parameter ID
+ * The first byte of the parameter ID will denote the domain ID.
+ * The second and third byte will be the unique identifier number.
+ */
+using ParameterId_t = uint32_t;
+
+/**
+ * @brief	This interface is used by components which have modifiable
+ * 			parameters, e.g. atittude controllers
+ * @details
+ * Each parameter has a unique parameter ID. The first byte of the parameter
+ * ID is the domain ID which can be used to identify unqiue spacecraft domains
+ * (e.g. control and sensor domain in the AOCS controller).
+ *
+ * The second byte is a unique identfier ID.
+ *
+ * The third and  fourth byte can be used as a linear index for matrix or array
+ * parameter entries.
+ */
+class HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
+	static const ReturnValue_t INVALID_IDENTIFIER_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
+
+	static uint8_t getDomain(ParameterId_t id) {
+		return id >> 24;
+	}
+
+	static uint8_t getUniqueIdentifierId(ParameterId_t id) {
+		return id >> 16;
+	}
+
+	/**
+	 * Get the index of a parameter. Please note that the index is always a
+	 * linear index. For a vector, this is straightforward.
+	 * For a matrix, the linear indexing run from left to right, top to bottom.
+	 * @param id
+	 * @return
+	 */
+	static uint16_t getIndex(ParameterId_t id) {
+		return id;
+	}
+
+	static uint32_t getFullParameterId(uint8_t domainId, uint8_t uniqueId, uint16_t linearIndex) {
+		return (domainId << 24) + (uniqueId << 16) + linearIndex;
+	}
+
+	virtual ~HasParametersIF() {}
+
+	/**
+	 * This is the generic function overriden by child classes to set
+	 * parameters. To set a parameter, the parameter wrapper is used with
+	 * a variety of set functions. The provided values can be checked with
+	 * newValues.
+	 * Always set parameter before checking newValues!
+	 *
+	 * @param domainId
+	 * @param parameterId
+	 * @param parameterWrapper
+	 * @param newValues
+	 * @param startAtIndex Linear index, runs left to right, top to bottom for
+	 * matrix indexes.
+	 * @return
+	 */
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+	        ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+	        uint16_t startAtIndex) = 0;
+};
+
+#endif /* FSFW_PARAMETERS_HASPARAMETERSIF_H_ */

src/fsfw/parameters/ParameterHelper.cpp

@@ -0,0 +1,140 @@
+#include "fsfw/parameters/ParameterHelper.h"
+#include "fsfw/parameters/ParameterMessage.h"
+
+#include "fsfw/objectmanager/ObjectManager.h"
+
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner):
+        owner(owner) {}
+
+ParameterHelper::~ParameterHelper() {
+}
+
+ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+    if(storage == nullptr) {
+        // ParameterHelper was not initialized
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    switch (message->getCommand()) {
+    case ParameterMessage::CMD_PARAMETER_DUMP: {
+        ParameterWrapper description;
+        uint8_t domain = HasParametersIF::getDomain(
+                ParameterMessage::getParameterId(message));
+        uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+                ParameterMessage::getParameterId(message));
+        result = owner->getParameter(domain, uniqueIdentifier,
+                &description, &description, 0);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+            result = sendParameter(message->getSender(),
+                    ParameterMessage::getParameterId(message), &description);
+        }
+    }
+    break;
+    case ParameterMessage::CMD_PARAMETER_LOAD: {
+        ParameterId_t parameterId = 0;
+        uint8_t ptc = 0;
+        uint8_t pfc = 0;
+        uint8_t rows = 0;
+        uint8_t columns = 0;
+        store_address_t storeId = ParameterMessage::getParameterLoadCommand(
+                message, &parameterId, &ptc, &pfc, &rows, &columns);
+        Type type(Type::getActualType(ptc, pfc));
+
+        uint8_t domain = HasParametersIF::getDomain(parameterId);
+        uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+                parameterId);
+        uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
+
+        ConstStorageAccessor accessor(storeId);
+        result = storage->getData(storeId, accessor);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "ParameterHelper::handleParameterMessage: Getting"
+                    << " store data failed for load command." << std::endl;
+#endif
+            break;
+        }
+
+        ParameterWrapper streamWrapper;
+        result = streamWrapper.set(type, rows, columns, accessor.data(),
+                accessor.size());
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+
+        ParameterWrapper ownerWrapper;
+        result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
+                &streamWrapper, linearIndex);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+
+        result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+
+        result = sendParameter(message->getSender(),
+                ParameterMessage::getParameterId(message), &ownerWrapper);
+        break;
+    }
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        rejectCommand(message->getSender(), result, message->getCommand());
+    }
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
+        const ParameterWrapper* description) {
+    size_t serializedSize = description->getSerializedSize();
+
+    uint8_t *storeElement = nullptr;
+    store_address_t address;
+
+    ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+            &storeElement);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    size_t storeElementSize = 0;
+
+    result = description->serialize(&storeElement, &storeElementSize,
+            serializedSize, SerializeIF::Endianness::BIG);
+
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        storage->deleteData(address);
+        return result;
+    }
+
+    CommandMessage reply;
+
+    ParameterMessage::setParameterDumpReply(&reply, id, address);
+
+    MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::initialize() {
+    ownerQueueId = owner->getCommandQueue();
+
+    storage = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+    if (storage == nullptr) {
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+        Command_t initialCommand) {
+    CommandMessage reply;
+    reply.setReplyRejected(reason, initialCommand);
+    MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+}

src/fsfw/parameters/ParameterHelper.h

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

src/fsfw/parameters/ParameterMessage.cpp

@@ -0,0 +1,65 @@
+#include "fsfw/parameters/ParameterMessage.h"
+
+#include "fsfw/objectmanager/ObjectManager.h"
+
+ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter2();
+	return address;
+}
+
+void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
+		ParameterId_t id) {
+	message->setCommand(CMD_PARAMETER_DUMP);
+	message->setParameter(id);
+}
+
+void ParameterMessage::setParameterDumpReply(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(REPLY_PARAMETER_DUMP);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
+		ParameterId_t id, store_address_t storeId, uint8_t ptc, uint8_t pfc,
+		uint8_t rows = 1, uint8_t columns = 1) {
+	message->setCommand(CMD_PARAMETER_LOAD);
+	message->setParameter(id);
+	message->setParameter2(storeId.raw);
+	uint32_t packedParameterSettings = (ptc << 24) | (pfc << 16) |
+	        (rows << 8) | columns;
+	message->setParameter3(packedParameterSettings);
+}
+
+store_address_t ParameterMessage::getParameterLoadCommand(
+        const CommandMessage *message, ParameterId_t* parameterId, uint8_t *ptc,
+        uint8_t *pfc, uint8_t *rows, uint8_t *columns) {
+    *parameterId = message->getParameter();
+    uint32_t packedParamSettings = message->getParameter3();
+    *ptc = packedParamSettings >> 24 & 0xff;
+    *pfc = packedParamSettings >> 16 & 0xff;
+    *rows = packedParamSettings >> 8 & 0xff;
+    *columns = packedParamSettings & 0xff;
+    return message->getParameter2();
+}
+
+void ParameterMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_PARAMETER_LOAD:
+	case REPLY_PARAMETER_DUMP: {
+		StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}

src/fsfw/parameters/ParameterMessage.h

@@ -0,0 +1,62 @@
+#ifndef FSFW_PARAMETERS_PARAMETERMESSAGE_H_
+#define FSFW_PARAMETERS_PARAMETERMESSAGE_H_
+
+#include "HasParametersIF.h"
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+/**
+ * @brief   ParameterMessage interface
+ * @details
+ * General structure of a parameter message:
+ *  1. 4-byte Object ID
+ *  2. 4-byte Parameter ID, first byte is Domain ID, second byte is unique
+ *     identifier, third and fourth byte is linear index to start from
+ *  3. 4-byte Parameter Settings. First byte and second byte are the PTC and PFC
+ *     ECSS type identifiers (see ECSS-E-ST-70-41C15 p.428 or Type class in
+ *     globalfunctions). Third byte is the number of rows and fourth byte
+ *     is the number of columns. For single variable parameters, this will
+ *     be [1, 1].
+ *
+ */
+class ParameterMessage {
+private:
+	ParameterMessage();
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
+	static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
+
+	static ParameterId_t getParameterId(const CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setParameterDumpCommand(CommandMessage* message,
+			ParameterId_t id);
+	static void setParameterDumpReply(CommandMessage* message,
+			ParameterId_t id,  store_address_t storageID);
+
+	/**
+	 * Command to set a load parameter message. The CCSDS / ECSS type in
+	 * form of a PTC and a PFC is expected. See ECSS-E-ST-70-41C15 p.428
+	 * for all types or the Type class in globalfunctions.
+	 * @param message
+	 * @param id
+	 * @param storeId
+	 * @param ptc Type information according to CCSDS/ECSS standards
+	 * @param pfc Type information according to CCSDS/ECSS standards
+	 * @param rows Set number of rows in parameter set, minimum one.
+	 * @param columns Set number of columns in parameter set, minimum one
+	 */
+	static void setParameterLoadCommand(CommandMessage* message,
+	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
+	        uint8_t pfc, uint8_t rows, uint8_t columns);
+
+	static store_address_t getParameterLoadCommand(
+	        const CommandMessage* message, ParameterId_t* parameterId,
+	        uint8_t* ptc, uint8_t* pfc, uint8_t* rows, uint8_t* columns) ;
+
+	static void clear(CommandMessage* message);
+
+};
+
+#endif /* FSFW_PARAMETERS_PARAMETERMESSAGE_H_ */

src/fsfw/parameters/ParameterWrapper.cpp

@@ -0,0 +1,351 @@
+#include "fsfw/FSFW.h"
+#include "fsfw/parameters/ParameterWrapper.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+ParameterWrapper::ParameterWrapper() :
+		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		void *data):
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(data), readonlyData(data) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		const void *data):
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(nullptr), readonlyData(data) {
+}
+
+ParameterWrapper::~ParameterWrapper() {
+}
+
+ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	/* serialize uses readonlyData, as it is always valid */
+	if (readonlyData == nullptr) {
+		return NOT_SET;
+	}
+	switch (type) {
+	case Type::UINT8_T:
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT8_T:
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::UINT16_T:
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT16_T:
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::UINT32_T:
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT32_T:
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::FLOAT:
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::DOUBLE:
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
+		break;
+	default:
+		result = UNKNOWN_DATATYPE;
+		break;
+	}
+	return result;
+}
+
+size_t ParameterWrapper::getSerializedSize() const {
+	uint32_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	const T *element = (const T*) readonlyData;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	uint16_t dataSize = columns * rows;
+	while (dataSize != 0) {
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		element++;
+		dataSize--;
+	}
+	return result;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void *from, uint8_t fromRows,
+		uint8_t fromColumns) {
+
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = reinterpret_cast<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
+	    uint16_t offset = (((startingRow + fromRow) *
+	    		static_cast<uint16_t>(columns)) + startingColumn);
+		T *dataWithDataType = static_cast<T*>(data) + offset;
+
+		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
+			result = SerializeAdapter::deSerialize(
+					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
+					SerializeIF::Endianness::BIG);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+	}
+
+	return result;
+
+}
+
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness) {
+	return deSerialize(buffer, size, streamEndianness, 0);
+}
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
+	ParameterWrapper streamDescription;
+
+	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return copyFrom(&streamDescription, startWritingAtIndex);
+}
+
+ReturnValue_t ParameterWrapper::set(Type type, uint8_t rows, uint8_t columns,
+        const void *data, size_t dataSize) {
+    this->type = type;
+    this->rows = rows;
+    this->columns = columns;
+
+    size_t expectedSize = type.getSize() * rows * columns;
+    if (expectedSize < dataSize) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
+
+    this->data = nullptr;
+    this->readonlyData = data;
+    pointsToStream = true;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
+			&streamSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t dataSize = type.getSize() * rows * columns;
+
+	if (streamSize < dataSize) {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
+
+	data = nullptr;
+	readonlyData = stream;
+	pointsToStream = true;
+
+	stream += dataSize;
+	if (remainingStream !=  nullptr) {
+		*remainingStream = stream;
+	}
+	streamSize -= dataSize;
+	if (remainingSize != nullptr) {
+		*remainingSize = streamSize;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
+		uint16_t startWritingAtIndex) {
+	if (data == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    sif::warning << "ParameterWrapper::copyFrom: Called on read-only variable!" << std::endl;
+#else
+	    sif::printWarning("ParameterWrapper::copyFrom: Called on read-only variable!\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+		return READONLY;
+	}
+
+	if (from->readonlyData == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ParameterWrapper::copyFrom: Source not set!" << std::endl;
+#else
+        sif::printWarning("ParameterWrapper::copyFrom: Source not set!\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+		return SOURCE_NOT_SET;
+	}
+
+	if (type != from->type) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ParameterWrapper::copyFrom: Datatype missmatch!" << std::endl;
+#else
+        sif::printWarning("ParameterWrapper::copyFrom: Datatype missmatch!\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+		return DATATYPE_MISSMATCH;
+	}
+
+	// The smallest allowed value for rows and columns is one.
+	if(rows == 0 or columns == 0) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ParameterWrapper::copyFrom: Columns or rows zero!" << std::endl;
+#else
+        sif::printWarning("ParameterWrapper::copyFrom: Columns or rows zero!\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+	    return COLUMN_OR_ROWS_ZERO;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = 0;
+	uint8_t startingColumn = 0;
+	ParameterWrapper::convertLinearIndexToRowAndColumn(startWritingAtIndex,
+	        &startingRow, &startingColumn);
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return TOO_BIG;
+	}
+
+	uint8_t typeSize = type.getSize();
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		default:
+			result = UNKNOWN_DATATYPE;
+			break;
+		}
+	}
+	else {
+		//need a type to do arithmetic
+		uint8_t* typedData = static_cast<uint8_t*>(data);
+		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
+			size_t offset = (((startingRow + fromRow) * static_cast<uint16_t>(
+					columns)) + startingColumn) * typeSize;
+			std::memcpy(typedData +  offset, from->readonlyData,
+					typeSize * from->columns);
+		}
+	}
+
+	return result;
+}
+
+void ParameterWrapper::convertLinearIndexToRowAndColumn(uint16_t index,
+        uint8_t *row, uint8_t *column) {
+    if(row == nullptr or column == nullptr) {
+        return;
+    }
+    // Integer division.
+    *row = index / columns;
+    *column = index % columns;
+}
+
+uint16_t ParameterWrapper::convertRowAndColumnToLinearIndex(uint8_t row,
+        uint8_t column) {
+    return row * columns + column;
+}

src/fsfw/parameters/ParameterWrapper.h

@@ -0,0 +1,199 @@
+#ifndef FSFW_PARAMETERS_PARAMETERWRAPPER_H_
+#define FSFW_PARAMETERS_PARAMETERWRAPPER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+#include "../globalfunctions/Type.h"
+#include <cstddef>
+
+/**
+ * @brief       This wrapper encapsulates the access to parameters provided by HasParametersIF.
+ * @details
+ * This wrapper is used by the ParameterHelper to interface with the on-board parameters
+ * exposed by the software via the HasParametersIF. A handle of this wrapper is passed
+ * to the user which then can be used to set or dump the parameters.
+ *
+ * The wrapper provides a set of setter functions. The user should call those setter functions,
+ * supplying an address to the local parameters. The user can also deserialize or
+ * serialize the parameter data. Please note that this will also serialize and deserialize
+ * the parameter information field (4 bytes) containing the ECSS PTC, PFC and rows and columns
+ * number.
+ */
+class ParameterWrapper: public SerializeIF {
+	friend class DataPoolParameterWrapper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
+	static const ReturnValue_t UNKNOWN_DATATYPE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t COLUMN_OR_ROWS_ZERO = MAKE_RETURN_CODE(0x08);
+
+	ParameterWrapper();
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, const void *data);
+	virtual ~ParameterWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
+
+	/**
+	 * Get a specific parameter value by supplying the row and the column.
+	 * @tparam T Type of target data
+	 * @param value [out] Pointer to storage location
+	 * @param row
+	 * @param column
+	 * @return
+	 * -@c RETURN_OK if element was retrieved successfully
+	 * -@c NOT_SET data has not been set yet
+	 * -@c DATATYPE_MISSMATCH Invalid supplied type
+	 * -@c OUT_OF_BOUNDS Invalid row and/or column.
+	 */
+	template<typename T>
+	ReturnValue_t getElement(T *value, uint8_t row = 0,
+			uint8_t column = 0) const;
+
+	template<typename T>
+	void set(T *data, uint8_t rows, uint8_t columns) {
+		this->data = data;
+		this->readonlyData = data;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
+		this->data = nullptr;
+		this->readonlyData = readonlyData;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	/**
+	 * Setter function for scalar non-const entries
+	 * @tparam T
+	 * @param member
+	 */
+	template<typename T>
+	void set(T& member) {
+		this->set(&member, 1, 1);
+	}
+
+	/**
+	 * Setter function for scalar const entries.
+	 * TODO: This is confusing, it should not be called set. Maybe we should call all functions
+	 * assign instead?
+	 * @tparam T
+	 * @param readonlyMember
+	 */
+	template<typename T>
+	void set(const T& readonlyMember) {
+		this->set(&readonlyMember, 1, 1);
+	}
+
+	template<typename T>
+	void setVector(T& member) {
+	    /* For a vector entry, the number of rows will be one
+	    (left to right, top to bottom indexing) */
+		this->set(member, 1, sizeof(member) / sizeof(member[0]));
+	}
+
+	template<typename T>
+	void setVector(const T& member) {
+        /* For a vector entry, the number of rows will be one
+        (left to right, top to bottom indexing) */
+		this->set(member, 1, sizeof(member) / sizeof(member[0]));
+	}
+	template<typename T>
+	void setMatrix(T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]),
+		        sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	template<typename T>
+	void setMatrix(const T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]),
+		        sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	ReturnValue_t set(Type type, uint8_t rows, uint8_t columns,
+	        const void *data, size_t dataSize);
+
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
+			const uint8_t **remainingStream = nullptr,
+			size_t *remainingSize = nullptr);
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+
+    void convertLinearIndexToRowAndColumn(uint16_t index,
+            uint8_t *row, uint8_t *column);
+
+    uint16_t convertRowAndColumnToLinearIndex(uint8_t row,
+            uint8_t column);
+
+	bool pointsToStream = false;
+
+	Type type;
+	uint8_t rows = 0;
+	uint8_t columns = 0;
+	void *data = nullptr;
+	const void *readonlyData = nullptr;
+
+	template<typename T>
+	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows, uint8_t fromColumns);
+};
+
+template <typename T>
+inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
+		uint8_t column) const {
+	if (readonlyData == nullptr){
+		return NOT_SET;
+	}
+
+	if (PodTypeConversion<T>::type != type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	if ((row >= rows) or (column >= columns)) {
+		return OUT_OF_BOUNDS;
+	}
+
+	if (pointsToStream) {
+		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
+		streamWithType += (row * columns + column) * type.getSize();
+		size_t size = type.getSize();
+		return SerializeAdapter::deSerialize(value, &streamWithType,
+				&size, SerializeIF::Endianness::BIG);
+	}
+	else {
+		const T *dataWithType = static_cast<const T*>(readonlyData);
+		*value = dataWithType[row * columns + column];
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+#endif /* FSFW_PARAMETERS_PARAMETERWRAPPER_H_ */

src/fsfw/parameters/ReceivesParameterMessagesIF.h

@@ -0,0 +1,19 @@
+#ifndef FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_
+#define FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_
+
+
+#include "HasParametersIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesParameterMessagesIF : public HasParametersIF {
+public:
+
+	static const uint8_t DOMAIN_ID_BASE = 0;
+	virtual ~ReceivesParameterMessagesIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_ */