Merge branch 'master' into mueller/enhanced-controller

ipc/MessageQueueIF.h

@@ -1,61 +1,77 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
-// COULDDO: We could support blocking calls
-
 #include "messageQueueDefinitions.h"
-#include "MessageQueueMessage.h"
+#include "MessageQueueMessageIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
+#include <cstdint>
+
+
+// COULDDO: We could support blocking calls
+// semaphores are being implemented, which makes this idea even more iteresting.
+
+/**
+ * @defgroup message_queue Message Queue
+ * @brief Message Queue related software components
+ */
 class MessageQueueIF {
 public:
 	static const MessageQueueId_t NO_QUEUE = 0;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
-	/**
+	//! No new messages on the queue
-	 * No new messages on the queue
-	 */
 	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
-	/**
+	//! No space left for more messages
-	 * No space left for more messages
-	 */
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	/**
+	//! Returned if a reply method was called without partner
-	 * Returned if a reply method was called without partner
-	 */
 	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
+	//! Returned if the target destination is invalid.
+	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
 
 	virtual ~MessageQueueIF() {}
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * @details
-	 * 			lastParnter information as destination. If there was no message received yet
+	 * This operation simplifies answering an incoming message by using the
-	 * 			(i.e. lastPartner is zero), an error code is returned.
+	 * stored lastParnter information as destination. If there was no message
-	 * @param message	A pointer to a previously created message, which is sent.
+	 * received yet (i.e. lastPartner is zero), an error code is returned.
-	 * \return RETURN_OK if ok
+	 * @param message
-	 * \return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
+	 * A pointer to a previously created message, which is sent.
+	 * @return
+	 * -@c RETURN_OK if ok
+	 * -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
 	 */
-	virtual ReturnValue_t reply( MessageQueueMessage* message ) = 0;
+	virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
 
 	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
+	 * @brief	This function reads available messages from the message queue
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
+	 *          and returns the sender.
-	 * 			sender's queue id.
+	 * @details
-	 * @param message	A pointer to a message in which the received data is stored.
+	 * It works identically to the other receiveMessage call, but in addition
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 * returns the sender's queue id.
+	 * @param message
+	 * A pointer to a message in which the received data is stored.
+	 * @param receivedFrom
+	 * A pointer to a queue id in which the sender's id is stored.
 	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) = 0;
 
 	/**
 	 * @brief	This function reads available messages from the message queue.
-	 * @details	If data is available it is stored in the passed message pointer. The message's
+	 * @details
-	 * 			original content is overwritten and the sendFrom information is stored in the
+	 * If data is available it is stored in the passed message pointer.
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
+	 * The message's original content is overwritten and the sendFrom
-	 * 			message's content is cleared and the function returns immediately.
+	 * information is stored in theblastPartner attribute. Else, the lastPartner
-	 * @param message	A pointer to a message in which the received data is stored.
+	 * information remains untouched, the message's content is cleared and the
+	 * function returns immediately.
+	 * @param message
+	 * A pointer to a message in which the received data is stored.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::EMPTY if queue is empty
 	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) = 0;
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -63,57 +79,89 @@ public:
 	 */
 	virtual ReturnValue_t flush(uint32_t* count) = 0;
 	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
+	 * @brief	This method returns the message queue
+	 *          id of the last communication partner.
 	 */
 	virtual MessageQueueId_t getLastPartner() const = 0;
 	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
+	 * @brief	This method returns the message queue
+	 *          id of this class's message queue.
 	 */
 	virtual MessageQueueId_t getId() const = 0;
 
 	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * @brief	With the sendMessage call, a queue message
-	 * \details	This method takes the message provided, adds the sentFrom information and passes
+	 *          is sent to a receiving queue.
-	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * @details
-	 * 			value is returned.
+	 * This method takes the message provided, adds the sentFrom information
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * and passes it on to the destination provided with an operating system
-	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * call. The OS's returnvalue is returned.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * @param sendTo
-	 * 					This variable is set to zero by default.
+	 * This parameter specifies the message queue id to send the message to.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full (if implemented).
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id
+	 * into the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter is not incremented
+	 * if queue is full (if implemented).
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-	/**
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		 * @brief	This operation sends a message to the given destination.
+			bool ignoreFault = false ) = 0;
-		 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-		 * 			queue id as "sentFrom" parameter.
-		 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-		 * @param message	A pointer to a previously created message, which is sent.
-		 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-		 */
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo, MessageQueueMessage* message, bool ignoreFault = false ) = 0;
 
 	/**
-	 * \brief	The sendToDefaultFrom method sends a queue message to the default destination.
+	 * @brief	This operation sends a message to the given destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
+	 * @details
-	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * It directly uses the sendMessage call of the MessageQueueSender parent,
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * but passes its queue id as "sentFrom" parameter.
-	 * 					This variable is set to zero by default.
+	 * @param sendTo
+	 * This parameter specifies the message queue id of the destination
+	 * message queue.
+	 * @param message
+	 * A pointer to a previously created message, which is sent.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter is not incremented
+	 * if queue is full.
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
+
+	/**
+	 * @brief	The sendToDefaultFrom method sends a queue message
+	 *          to the default destination.
+	 * @details
+	 * In all other aspects, it works identical to the sendMessage method.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id
+	 * into the message. This variable is set to zero by default.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
 	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+	 * @details
-	 * 			Implementation class and adds its queue id as "sentFrom" information.
+	 * As in the sendMessage method, this function uses the sendToDefault
+	 * call of the Implementation class and adds its queue id as
+	 * "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message )  = 0;
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
 	/**
-	 * \brief	This method is a simple setter for the default destination.
+	 * @brief	This method is a simple setter for the default destination.
 	 */
 	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
 	/**
-	 * \brief	This method is a simple getter for the default destination.
+	 * @brief	This method is a simple getter for the default destination.
 	 */
 	virtual MessageQueueId_t getDefaultDestination() const = 0;
 
@@ -122,4 +170,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */

ipc/MessageQueueSenderIF.h

@@ -1,8 +1,8 @@
 #ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 #define FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 
-#include "../ipc/MessageQueueIF.h"
+#include "MessageQueueIF.h"
-#include "../ipc/MessageQueueMessageIF.h"
+#include "MessageQueueMessageIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
 class MessageQueueSenderIF {
@@ -15,7 +15,7 @@ public:
 	 * Not sure whether this is actually a good idea.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message,
+			MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = MessageQueueIF::NO_QUEUE,
 			bool ignoreFault = false);
 private:

ipc/QueueFactory.h

@@ -1,8 +1,10 @@
-#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
+#ifndef FSFW_IPC_QUEUEFACTORY_H_
-#define FRAMEWORK_IPC_QUEUEFACTORY_H_
+#define FSFW_IPC_QUEUEFACTORY_H_
 
 #include "MessageQueueIF.h"
-#include <stdint.h>
+#include "MessageQueueMessage.h"
+#include <cstdint>
+
 /**
  * Creates message queues.
  * This class is a "singleton" interface, i.e. it provides an
@@ -30,4 +32,4 @@ private:
 	static QueueFactory* factoryInstance;
 };
 
-#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
+#endif /* FSFW_IPC_QUEUEFACTORY_H_ */

osal/FreeRTOS/MessageQueue.cpp

@@ -1,42 +1,76 @@
 #include "MessageQueue.h"
-
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-// TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls
+// TODO I guess we should have a way of checking if we are in an ISR and then
-
+// use the "fromISR" versions of all calls
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+// As a first step towards this, introduces system context variable which needs
-defaultDestination(0),lastPartner(0)  {
+// to be switched manually
-	handle = xQueueCreate(message_depth, max_message_size);
+// Haven't found function to find system context.
-	if (handle == NULL) {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
-		sif::error << "MessageQueue creation failed" << std::endl;
+		maxMessageSize(maxMessageSize) {
+	handle = xQueueCreate(messageDepth, maxMessageSize);
+	if (handle == nullptr) {
+		sif::error << "MessageQueue::MessageQueue Creation failed" << std::endl;
 	}
 }
 
 MessageQueue::~MessageQueue() {
-	if (handle != NULL) {
+	if (handle != nullptr) {
 		vQueueDelete(handle);
 	}
 }
 
+void MessageQueue::switchSystemContext(CallContext callContext) {
+	this->callContext = callContext;
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-	if (this->lastPartner != 0) {
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return NO_REPLY_PARTNER;
 	}
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault,
+	        callContext);
+}
+
+
+ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
+	if (result != pdPASS) {
+		if (not ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter = objectManager->
+					get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != nullptr) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	if(status == HasReturnvaluesIF::RETURN_OK) {
@@ -45,8 +79,9 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(message->getBuffer()), 0);
+	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
+			message->getBuffer()), 0);
 	if (result == pdPASS){
 		this->lastPartner = message->getSender();
 		return HasReturnvaluesIF::RETURN_OK;
@@ -67,51 +102,55 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 }
 
 MessageQueueId_t MessageQueue::getId() const {
-	return (MessageQueueId_t) handle;
+	return reinterpret_cast<MessageQueueId_t>(handle);
 }
 
 void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	defaultDestinationSet = true;
 	this->defaultDestination = defaultDestination;
 }
 
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
-}
-
 MessageQueueId_t MessageQueue::getDefaultDestination() const {
 	return defaultDestination;
 }
 
 bool MessageQueue::isDefaultDestinationSet() const {
-	return 0;
+	return defaultDestinationSet;
 }
 
+
+// static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
+        bool ignoreFault, CallContext callContext) {
-	message->setSender(sentFrom);
+	BaseType_t result = pdFALSE;
+	QueueHandle_t destination = nullptr;
 
-	BaseType_t result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
+	if(sendTo == MessageQueueIF::NO_QUEUE or sendTo == 0x00) {
-			reinterpret_cast<const void*>(message->getBuffer()), 0);
+		return MessageQueueIF::DESTINVATION_INVALID;
-	if (result != pdPASS) {
+	}
-		if (!ignoreFault) {
+	else  {
-			InternalErrorReporterIF* internalErrorReporter =
+		destination = reinterpret_cast<QueueHandle_t>(sendTo);
-					objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		return MessageQueueIF::FULL;
 	}
-	return HasReturnvaluesIF::RETURN_OK;
 
+    message->setSender(sentFrom);
+
+
+    if(callContext == CallContext::TASK) {
+        result = xQueueSendToBack(destination,
+                static_cast<const void*>(message->getBuffer()), 0);
+    }
+    else {
+        /* If the call context is from an interrupt,
+         * request a context switch if a higher priority task
+         * was blocked by the interrupt. */
+        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
+                static_cast<const void*>(message->getBuffer()),
+                &xHigherPriorityTaskWoken);
+        if(xHigherPriorityTaskWoken == pdTRUE) {
+            TaskManagement::requestContextSwitch(callContext);
+        }
+    }
+    return handleSendResult(result, ignoreFault);
 }
-

osal/FreeRTOS/MessageQueue.h

@@ -1,159 +1,150 @@
-#ifndef MESSAGEQUEUE_H_
+#ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
+#define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/MessageQueueMessage.h"
+#include "../../ipc/MessageQueueMessageIF.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
 
-#include <FreeRTOS.h>
+#include <freertos/FreeRTOS.h>
-#include <queue.h>
+#include <freertos/queue.h>
+#include <fsfw/ipc/MessageQueueMessage.h>
 
-//TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
+// TODO: this class assumes that MessageQueueId_t is the same size as void*
+// (the FreeRTOS handle type), compiler will catch this but it might be nice
+// to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
 
 /**
- *	@brief		This class manages sending and receiving of message queue messages.
+ * @brief		This class manages sending and receiving of
+ * 				message queue messages.
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
  *
- *	@details	Message queues are used to pass asynchronous messages between processes.
+ * The MessageQueue should be used as "post box" for a single owning object.
- *				They work like post boxes, where all incoming messages are stored in FIFO
+ * So all message queue communication is "n-to-one".
- *				order. This class creates a new receiving queue and provides methods to fetch
+ * For creating the queue, as well as sending and receiving messages, the class
- *				received messages. Being a child of MessageQueueSender, this class also provides
+ * makes use of the operating system calls provided.
- *				methods to send a message to a user-defined or a default destination. In addition
+ *
- *				it also provides a reply method to answer to the queue it received its last message
+ * Please keep in mind that FreeRTOS offers different calls for message queue
- *				from.
+ * operations if called from an ISR.
- *				The MessageQueue should be used as "post box" for a single owning object. So all
+ * For now, the system context needs to be switched manually.
- *				message queue communication is "n-to-one".
+ * @ingroup osal
- *				For creating the queue, as well as sending and receiving messages, the class makes
+ * @ingroup message_queue
- *				use of the operating system calls provided.
- *	\ingroup message_queue
  */
 class MessageQueue : public MessageQueueIF {
 	friend class MessageQueueSenderIF;
 public:
 	/**
 	 * @brief	The constructor initializes and configures the message queue.
-	 * @details	By making use of the according operating system call, a message queue is created
+	 * @details
-	 * 			and initialized. The message depth - the maximum number of messages to be
+	 * By making use of the according operating system call, a message queue
-	 * 			buffered - may be set with the help of a parameter, whereas the message size is
+	 * is created and initialized. The message depth - the maximum number of
-	 * 			automatically set to the maximum message queue message size. The operating system
+	 * messages to be buffered - may be set with the help of a parameter,
-	 * 			sets the message queue id, or i case of failure, it is set to zero.
+	 * whereas the message size is automatically set to the maximum message
-	 * @param message_depth	The number of messages to be buffered before passing an error to the
+	 * queue message size. The operating system sets the message queue id, or
-	 * 						sender. Default is three.
+	 * in case of failure, it is set to zero.
-	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
+	 * @param message_depth
-	 * 							This should be left default.
+	 * The number of messages to be buffered before passing an error to the
+	 * sender. Default is three.
+	 * @param max_message_size
+	 * With this parameter, the maximum message size can be adjusted.
+	 * This should be left default.
 	 */
-	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	MessageQueue( size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
+
+	/** Copying message queues forbidden */
+	MessageQueue(const MessageQueue&) = delete;
+	MessageQueue& operator=(const MessageQueue&) = delete;
+
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided by the operating system.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
 	 */
 	virtual ~MessageQueue();
+
 	/**
-	 * @brief	This operation sends a message to the given destination.
+	 * This function is used to switch the call context. This has to be called
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
+	 * if a message is sent or received from an ISR!
-	 * 			queue id as "sentFrom" parameter.
+	 * @param callContext
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
+	void switchSystemContext(CallContext callContext);
+
+	/** MessageQueueIF implementation */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t sendToDefault( MessageQueueMessage* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply( MessageQueueMessage* message );
 
-	/**
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message,
-			MessageQueueId_t *receivedFrom);
 
-	/**
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
-	 * @brief	This function reads available messages from the message queue.
+	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
-	 * @details	If data is available it is stored in the passed message pointer. The message's
+			MessageQueueMessageIF* message,
-	 * 			original content is overwritten and the sendFrom information is stored in the
+			MessageQueueId_t sentFrom = NO_QUEUE,
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
+			bool ignoreFault = false) override;
-	 * 			message's content is cleared and the function returns immediately.
+
-	 * @param message	A pointer to a message in which the received data is stored.
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-	 */
+			MessageQueueId_t sentFrom = NO_QUEUE,
-	ReturnValue_t receiveMessage(MessageQueueMessage* message);
+			bool ignoreFault = false) override;
-	/**
+
-	 * Deletes all pending messages in the queue.
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-	 * @param count The number of flushed messages.
+			MessageQueueId_t *receivedFrom) override;
-	 * @return RETURN_OK on success.
+
-	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-	ReturnValue_t flush(uint32_t* count);
+
-	/**
+	ReturnValue_t flush(uint32_t* count) override;
-	 * @brief	This method returns the message queue id of the last communication partner.
+
-	 */
+	MessageQueueId_t getLastPartner() const override;
-	MessageQueueId_t getLastPartner() const;
+
-	/**
+	MessageQueueId_t getId() const override;
-	 * @brief	This method returns the message queue id of this class's message queue.
+
-	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-	MessageQueueId_t getId() const;
+
-	/**
+	MessageQueueId_t getDefaultDestination() const override;
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+
-	 * \details	This method takes the message provided, adds the sentFrom information and passes
+	bool isDefaultDestinationSet() const override;
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	The sendToDefault method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
 
-	bool isDefaultDestinationSet() const;
 protected:
 	/**
-	 * Implementation to be called from any send Call within MessageQueue and MessageQueueSenderIF
+	 * @brief 	Implementation to be called from any send Call within
-	 * 	 \details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			MessageQueue and MessageQueueSenderIF.
-	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * @details
-	 * 			value is returned.
+	 * This method takes the message provided, adds the sentFrom information and
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * passes it on to the destination provided with an operating system call.
-	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * The OS's return value is returned.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * @param sendTo
-	 * 					This variable is set to zero by default.
+	 * This parameter specifies the message queue id to send the message to.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id into
+	 * the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter  is not incremented
+	 * if queue is full.
+	 * @param context Specify whether call is made from task or from an ISR.
 	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,bool ignoreFault=false);
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
 private:
+	bool defaultDestinationSet = false;
 	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination;
+	MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
-	MessageQueueId_t lastPartner;
+	MessageQueueId_t lastPartner = MessageQueueIF::NO_QUEUE;
+	const size_t maxMessageSize;
+	//! Stores the current system context
+	CallContext callContext =  CallContext::TASK;
 };
 
-#endif /* MESSAGEQUEUE_H_ */
+#endif /* FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_ */

osal/FreeRTOS/QueueFactory.cpp

@@ -1,14 +1,14 @@
+#include "MessageQueue.h"
+
 #include "../../ipc/MessageQueueSenderIF.h"
 #include "../../ipc/QueueFactory.h"
 
-#include "MessageQueue.h"
-
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);

osal/linux/MessageQueue.cpp

@@ -9,9 +9,11 @@
 #include <errno.h>
 
 
+
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
-		defaultDestination(MessageQueueIF::NO_QUEUE) {
+		defaultDestination(MessageQueueIF::NO_QUEUE),
+		maxMessageSize(maxMessageSize) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;
@@ -46,7 +48,7 @@ MessageQueue::~MessageQueue() {
 	status = mq_unlink(name);
 	if(status != 0){
 		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
-				   << strerror(errno) <<std::endl;
+				   << strerror(errno) << std::endl;
 	}
 }
 
@@ -61,22 +63,27 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		// Just an additional helpful printout :-)
 		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
 				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			/*
-			// This happens if the msg_max value is not large enough
+			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			// It is ignored if the executable is run in privileged mode.
+			This happens if the msg_max value is not large enough
-			// Run the unlockRealtime script or grant the mode manually by using:
+			It is ignored if the executable is run in privileged mode.
-			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+		    Run the unlockRealtime script or grant the mode manually by using:
+			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
 
-			// Persistent solution for session:
+			Persistent solution for session:
-			// echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
 
-			// Permanent solution:
+			Permanent solution:
-			// sudo nano /etc/sysctl.conf
+			sudo nano /etc/sysctl.conf
-			// Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			// Apply changes with: sudo sysctl -p
+			Apply changes with: sudo sysctl -p
+			*/
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
+			sif::error << "This error can be fixed by setting the maximum "
+					"allowed message size higher!" << std::endl;
+
 		}
 		break;
 	}
@@ -118,15 +125,15 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), false);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
@@ -134,21 +141,34 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	*receivedFrom = this->lastPartner;
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::receiveMessage: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() < maxMessageSize) {
+		sif::error << "MessageQueue::receiveMessage: Message size "
+				<< message->getMaximumMessageSize()
+				<< " too small to receive data!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	unsigned int messagePriority = 0;
 	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
-			message->MAX_MESSAGE_SIZE,&messagePriority);
+			message->getMaximumMessageSize(),&messagePriority);
 	if (status > 0) {
 		this->lastPartner = message->getSender();
 		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
@@ -158,7 +178,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 	} else {
 		//No message was received. Keep lastPartner anyway, I might send
 		//something later. But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+		memset(message->getData(), 0, message->getMaximumMessageSize());
 		switch(errno){
 		case EAGAIN:
 			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
@@ -258,18 +278,19 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 	this->defaultDestination = defaultDestination;
 }
 
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
-
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
 }
 
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
+
+}
+
 MessageQueueId_t MessageQueue::getDefaultDestination() const {
 	return this->defaultDestination;
 }
@@ -281,11 +302,18 @@ bool MessageQueue::isDefaultDestinationSet() const {
 uint16_t MessageQueue::queueCounter = 0;
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessage *message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	message->setSender(sentFrom);
 	int result = mq_send(sendTo,
-			reinterpret_cast<const char*>(message->getBuffer()), message->messageSize,0);
+			reinterpret_cast<const char*>(message->getBuffer()),
+			message->getMessageSize(),0);
 
 	//TODO: Check if we're in ISR.
 	if (result != 0) {
@@ -303,13 +331,16 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			//MQ_NONBLOCK flag was set in its attributes, and the
 			//specified queue is full.
 			return MessageQueueIF::FULL;
-		case EBADF:
+		case EBADF: {
 			//mq_des doesn't represent a valid message queue descriptor,
 			//or mq_des wasn't opened for writing.
-			sif::error << "MessageQueue::sendMessage: Configuration error "
+			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
-			           << strerror(errno) << " in mq_send mqSendTo: " << sendTo
+					<< " destination invalid."  << std::endl;
-					   << " sent from " << sentFrom << std::endl;
+			sif::error << strerror(errno) << " in "
-			/*NO BREAK*/
+					<<"mq_send to: " << sendTo << " sent from "
+					<< sentFrom << std::endl;
+			return DESTINVATION_INVALID;
+		}
 		case EINTR:
 			//The call was interrupted by a signal.
 		case EINVAL:

osal/linux/MessageQueue.h

@@ -1,5 +1,5 @@
-#ifndef MESSAGEQUEUE_H_
+#ifndef FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
+#define FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
 
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
@@ -56,14 +56,14 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false );
 	/**
 	 * @brief	This operation sends a message to the default destination.
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
 	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message );
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using the stored
@@ -71,7 +71,7 @@ public:
 	 * 			(i.e. lastPartner is zero), an error code is returned.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t reply( MessageQueueMessage* message );
+	ReturnValue_t reply( MessageQueueMessageIF* message );
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -80,7 +80,7 @@ public:
 	 * @param message	A pointer to a message in which the received data is stored.
 	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom);
 
 	/**
@@ -91,7 +91,7 @@ public:
 	 * 			message's content is cleared and the function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -114,7 +114,9 @@ public:
 	 * 					This variable is set to zero by default.
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false );
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false );
 	/**
 	 * \brief	The sendToDefault method sends a queue message to the default destination.
 	 * \details	In all other aspects, it works identical to the sendMessage method.
@@ -122,7 +124,8 @@ public:
 	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -145,7 +148,9 @@ protected:
 	 * 					This variable is set to zero by default.
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,bool ignoreFault=false);
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
 private:
 	/**
 	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
@@ -171,11 +176,12 @@ private:
 	/**
 	 * The name of the message queue, stored for unlinking
 	 */
-	char name[5];
+	char name[16];
 
 	static uint16_t queueCounter;
+	const size_t maxMessageSize;
 
 	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
 
-#endif /* MESSAGEQUEUE_H_ */
+#endif /* FSFW_OSAL_LINUX_MESSAGEQUEUE_H_ */

osal/linux/QueueFactory.cpp

@@ -15,7 +15,7 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);

tcdistribution/CCSDSDistributor.cpp

@@ -1,31 +1,39 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "CCSDSDistributor.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../tmtcpacket/SpacePacketBase.h"
 
-CCSDSDistributor::CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId ) :
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
-		TcDistributor( setObjectId ), default_apid( setDefaultApid ), tcStore(NULL) {
+		object_id_t setObjectId):
+		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
 }
 
-CCSDSDistributor::~CCSDSDistributor() {
+CCSDSDistributor::~CCSDSDistributor() {}
 
-}
+TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
-
+//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
-iterator_t CCSDSDistributor::selectDestination() {
+//			this->currentMessage.getStorageId().pool_index << ", " <<
-//	debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
+//			this->currentMessage.getStorageId().packet_index << std::endl;
-	const uint8_t* p_packet = NULL;
+	const uint8_t* packet = nullptr;
 	size_t size = 0;
-	//TODO check returncode?
+	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
-	this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
+			&packet, &size );
-	SpacePacketBase current_packet( p_packet );
+	if(result != HasReturnvaluesIF::RETURN_OK) {
-//	info << "CCSDSDistributor::selectDestination has packet with APID " << std::hex << current_packet.getAPID() << std::dec << std::endl;
+		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
-	iterator_t position = this->queueMap.find( current_packet.getAPID() );
+				" store failed!" << std::endl;
+	}
+	SpacePacketBase currentPacket(packet);
+
+//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
+//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
 	if ( position != this->queueMap.end() ) {
 		return position;
 	} else {
-		//The APID was not found. Forward packet to main SW-APID anyway to create acceptance failure report.
+		//The APID was not found. Forward packet to main SW-APID anyway to
-		return this->queueMap.find( this->default_apid );
+		// create acceptance failure report.
+		return this->queueMap.find( this->defaultApid );
 	}
-
 }
 
 MessageQueueId_t CCSDSDistributor::getRequestQueue() {
@@ -35,9 +43,9 @@ MessageQueueId_t CCSDSDistributor::getRequestQueue() {
 ReturnValue_t CCSDSDistributor::registerApplication(
 		AcceptsTelecommandsIF* application) {
 	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
+	auto insertPair = this->queueMap.emplace(application->getIdentifier(),
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
+	        application->getRequestQueue());
-	if(  errorCode == false ) {
+	if(not insertPair.second) {
 		returnValue = RETURN_FAILED;
 	}
 	return returnValue;
@@ -46,9 +54,8 @@ ReturnValue_t CCSDSDistributor::registerApplication(
 ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
 		MessageQueueId_t id) {
 	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
+	auto insertPair = this->queueMap.emplace(apid, id);
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
+	if(not insertPair.second) {
-	if(  errorCode == false ) {
 		returnValue = RETURN_FAILED;
 	}
 	return returnValue;
@@ -62,7 +69,11 @@ uint16_t CCSDSDistributor::getIdentifier() {
 ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
 	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
-	if (this->tcStore == NULL) status = RETURN_FAILED;
+	if (this->tcStore == nullptr) {
+	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
+	            " TC store!" << std::endl;
+	    status = RETURN_FAILED;
+	}
 	return status;
 }
 

tcdistribution/CCSDSDistributor.h

@@ -1,58 +1,71 @@
-#ifndef CCSDSDISTRIBUTOR_H_
+#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-#define CCSDSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
 
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "CCSDSDistributorIF.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
-#include "TcDistributor.h"
+#include "../tcdistribution/TcDistributor.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
+
 /**
- * An instantiation of the CCSDSDistributorIF.
+ * @brief 	An instantiation of the CCSDSDistributorIF.
- * It receives Space Packets, and selects a destination depending on the APID of the telecommands.
+ * @details
+ * It receives Space Packets, and selects a destination depending on the
+ * APID of the telecommands.
  * The Secondary Header (with Service/Subservice) is ignored.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
-class CCSDSDistributor : public TcDistributor, public CCSDSDistributorIF, public AcceptsTelecommandsIF {
+class CCSDSDistributor : public TcDistributor,
-protected:
+		public CCSDSDistributorIF,
-	/**
+		public AcceptsTelecommandsIF {
-	 * This implementation checks if an Application with fitting APID has registered and forwards the
-	 * packet to the according message queue.
-	 * If the packet is not found, it returns the queue to \c default_apid, where a Acceptance Failure
-	 * message should be generated.
-	 * @return Iterator to map entry of found APID or iterator to default APID.
-	 */
-	iterator_t selectDestination();
-	/**
-	 * The default APID, where packets with unknown APID are sent to.
-	 */
-	uint16_t default_apid;
-	/**
-	 * A reference to the TC storage must be maintained, as this class handles pure Space Packets and there
-	 * exists no SpacePacketStored class.
-	 */
-	StorageManagerIF* tcStore;
-	/**
-	 * The callback here handles the generation of acceptance success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
 public:
 	/**
-	 * The constructor sets the default APID and calls the TcDistributor ctor with a certain object id.
+	 * @brief	The constructor sets the default APID and calls the
-	 * \c tcStore is set in the \c initialize method.
+	 * 			TcDistributor ctor with a certain object id.
-	 * @param set_default_apid The default APID, where packets with unknown destination are sent to.
+	 * @details
+	 * @c tcStore is set in the @c initialize method.
+	 * @param setDefaultApid The default APID, where packets with unknown
+	 * destination are sent to.
 	 */
-	CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId );
+	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
 	/**
 	 * The destructor is empty.
 	 */
-	~CCSDSDistributor();
+	virtual ~CCSDSDistributor();
-	MessageQueueId_t getRequestQueue();
+
-	ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id );
+	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t registerApplication( AcceptsTelecommandsIF* application );
+	ReturnValue_t registerApplication( uint16_t apid,
-	uint16_t getIdentifier();
+			MessageQueueId_t id) override;
-	ReturnValue_t initialize();
+	ReturnValue_t registerApplication(
+			AcceptsTelecommandsIF* application) override;
+	uint16_t getIdentifier() override;
+	ReturnValue_t initialize() override;
+
+protected:
+	/**
+	 * This implementation checks if an application with fitting APID has
+	 * registered and forwards the packet to the according message queue.
+	 * If the packet is not found, it returns the queue to @c defaultApid,
+	 * where a Acceptance Failure message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	TcMqMapIter selectDestination() override;
+    /**
+     * The callback here handles the generation of acceptance
+     * success/failure messages.
+     */
+    ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus ) override;
+
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t defaultApid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles
+	 * pure Space Packets and there exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore = nullptr;
+
 };
 
-
+#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
-
-#endif /* CCSDSDISTRIBUTOR_H_ */

tcdistribution/CCSDSDistributorIF.h

@@ -1,34 +1,38 @@
-#ifndef CCSDSDISTRIBUTORIF_H_
+#ifndef FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_
-#define CCSDSDISTRIBUTORIF_H_
+#define FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_
 
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 /**
  * This is the Interface to a CCSDS Distributor.
- * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
+ * On a CCSDS Distributor, Applications (in terms of CCSDS) may register
- * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
+ * themselves, either by passing a pointer to themselves (and implementing the
- * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
+ * CCSDSApplicationIF),  or by explicitly passing an APID and a MessageQueueId
- * \ingroup tc_distribution
+ * to route the TC's to.
+ * @ingroup tc_distribution
  */
 class CCSDSDistributorIF {
 public:
 	/**
-	 * With this call, a class implementing the CCSDSApplicationIF can register at the
+	 * With this call, a class implementing the CCSDSApplicationIF can register
-	 * distributor.
+	 * at the distributor.
 	 * @param application A pointer to the Application to register.
-	 * @return	- \c RETURN_OK on success,
+	 * @return	- @c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
+	 * 			- @c RETURN_FAILED on failure.
 	 */
-	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
+	virtual ReturnValue_t registerApplication(
+	        AcceptsTelecommandsIF* application) = 0;
 	/**
 	 * With this call, other Applications can register to the CCSDS distributor.
 	 * This is done by passing an APID and a MessageQueueId to the method.
 	 * @param apid	The APID to register.
-	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
+	 * @param id	The MessageQueueId of the message queue to send the
-	 * @return	- \c RETURN_OK on success,
+	 *              TC Packets to.
-	 * 			- \c RETURN_FAILED on failure.
+	 * @return	- @c RETURN_OK on success,
+	 * 			- @c RETURN_FAILED on failure.
 	 */
-	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
+	virtual ReturnValue_t registerApplication( uint16_t apid,
+	        MessageQueueId_t id) = 0;
 	/**
 	 * The empty virtual destructor.
 	 */
@@ -37,4 +41,4 @@ public:
 };
 
 
-#endif /* CCSDSDISTRIBUTORIF_H_ */
+#endif /* FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_ */

tcdistribution/PUSDistributor.cpp

@@ -1,61 +1,71 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "CCSDSDistributorIF.h"
 #include "PUSDistributor.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcservices/PusVerificationReport.h"
 
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource) :
+PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-		TcDistributor(setObjectId), checker(setApid), verifyChannel(), currentPacket(), tcStatus(
+		object_id_t setPacketSource) :
-				RETURN_FAILED), packetSource(setPacketSource) {
+		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+		tcStatus(RETURN_FAILED), packetSource(setPacketSource) {}
+
+PUSDistributor::~PUSDistributor() {}
+
+PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+    // sif:: debug << "PUSDistributor::handlePacket received: "
+    //          << this->current_packet_id.store_index << ", "
+    //          << this->current_packet_id.packet_index << std::endl;
+    TcMqMapIter queueMapIt = this->queueMap.end();
+    if(this->currentPacket == nullptr) {
+        return queueMapIt;
+    }
+    this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
+    if (currentPacket->getWholeData() != nullptr) {
+        tcStatus = checker.checkPacket(currentPacket);
+#ifdef DEBUG
+        if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
+            sif::debug << "PUSDistributor::handlePacket: Packet format "
+                    << "invalid, code "<< static_cast<int>(tcStatus)
+                    << std::endl;
+        }
+#endif
+        uint32_t queue_id = currentPacket->getService();
+        queueMapIt = this->queueMap.find(queue_id);
+    }
+    else {
+        tcStatus = PACKET_LOST;
+    }
+
+    if (queueMapIt == this->queueMap.end()) {
+        tcStatus = DESTINATION_NOT_FOUND;
+#ifdef DEBUG
+        sif::debug << "PUSDistributor::handlePacket: Destination not found, "
+                << "code "<< static_cast<int>(tcStatus) << std::endl;
+#endif
+    }
+
+    if (tcStatus != RETURN_OK) {
+        return this->queueMap.end();
+    }
+    else {
+        return queueMapIt;
+    }
 
 }
 
-PUSDistributor::~PUSDistributor() {
-
-}
-
-iterator_t PUSDistributor::selectDestination() {
-//	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
-	iterator_t queueMapIt = this->queueMap.end();
-	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
-	if (currentPacket.getWholeData() != NULL) {
-		tcStatus = checker.checkPacket(&currentPacket);
-//		info << "PUSDistributor::handlePacket: packetCheck returned with " << (int)tc_status << std::endl;
-		uint32_t queue_id = currentPacket.getService();
-		queueMapIt = this->queueMap.find(queue_id);
-	} else {
-		tcStatus = PACKET_LOST;
-	}
-	if (queueMapIt == this->queueMap.end()) {
-		tcStatus = DESTINATION_NOT_FOUND;
-	}
-
-	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: error with " << (int) tcStatus
-				<< std::endl;
-		return this->queueMap.end();
-	} else {
-		return queueMapIt;
-	}
-
-}
-
-//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
-//	return ( service_id << 8 ) + subservice_id;
-//}
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
 	uint16_t serviceId = service->getIdentifier();
+	// sif::info << "Service ID: " << (int)serviceId << std::endl;
 	MessageQueueId_t queue = service->getRequestQueue();
-	errorCode = this->queueMap.insert(
+	auto returnPair = queueMap.emplace(serviceId, queue);
-			std::pair<uint32_t, MessageQueueId_t>(serviceId, queue)).second;
+	if (not returnPair.second) {
-	if (errorCode == false) {
+		sif::error << "PUSDistributor::registerService: Service ID already"
-		//TODO Return Code
+				" exists in map." << std::endl;
-		returnValue = MessageQueueIF::NO_QUEUE;
+		return SERVICE_ID_ALREADY_EXISTS;
 	}
-	return returnValue;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 MessageQueueId_t PUSDistributor::getRequestQueue() {
@@ -68,13 +78,14 @@ ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
 	}
 	if (tcStatus != RETURN_OK) {
 		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
-				&currentPacket, tcStatus);
+				currentPacket, tcStatus);
-		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
+		// A failed packet is deleted immediately after reporting,
-		currentPacket.deletePacket();
+		// otherwise it will block memory.
+		currentPacket->deletePacket();
 		return RETURN_FAILED;
 	} else {
 		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
-				&currentPacket);
+				currentPacket);
 		return RETURN_OK;
 	}
 }
@@ -84,11 +95,19 @@ uint16_t PUSDistributor::getIdentifier() {
 }
 
 ReturnValue_t PUSDistributor::initialize() {
+    currentPacket = new TcPacketStored();
+    if(currentPacket == nullptr) {
+        // Should not happen, memory allocation failed!
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
-	if (ccsdsDistributor == NULL) {
+	if (ccsdsDistributor == nullptr) {
-		return RETURN_FAILED;
+		sif::error << "PUSDistributor::initialize: Packet source invalid."
-	} else {
+		        << " Make sure it exists and implements CCSDSDistributorIF!"
-		return ccsdsDistributor->registerApplication(this);
+		        << std::endl;
+	    return RETURN_FAILED;
 	}
+	return ccsdsDistributor->registerApplication(this);
 }

tcdistribution/PUSDistributor.h

@@ -1,67 +1,79 @@
-#ifndef PUSDISTRIBUTOR_H_
+#ifndef FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-#define PUSDISTRIBUTOR_H_
+#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "PUSDistributorIF.h"
 #include "TcDistributor.h"
 #include "TcPacketCheck.h"
+
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/VerificationReporter.h"
 
 /**
- * This class accepts PUS Telecommands and forwards them to Application services.
+ * This class accepts PUS Telecommands and forwards them to Application
- * In addition, the class performs a formal packet check and sends acceptance success
+ * services. In addition, the class performs a formal packet check and
- * or failure messages.
+ * sends acceptance success or failure messages.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
 class PUSDistributor: public TcDistributor,
 		public PUSDistributorIF,
 		public AcceptsTelecommandsIF {
 public:
 	/**
-	 * The ctor passes \c set_apid to the checker class and calls the TcDistribution ctor with a certain object id.
+	 * The ctor passes @c set_apid to the checker class and calls the
+	 * TcDistribution ctor with a certain object id.
 	 * @param setApid The APID of this receiving Application.
 	 * @param setObjectId Object ID of the distributor itself
-	 * @param setPacketSource Object ID of the source of TC packets. Must implement CCSDSDistributorIF.
+	 * @param setPacketSource Object ID of the source of TC packets.
+	 * Must implement CCSDSDistributorIF.
 	 */
-	PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource);
+	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+			object_id_t setPacketSource);
 	/**
 	 * The destructor is empty.
 	 */
 	virtual ~PUSDistributor();
-	ReturnValue_t registerService(AcceptsTelecommandsIF* service);
+	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
-	MessageQueueId_t getRequestQueue();
+	MessageQueueId_t getRequestQueue() override;
-	uint16_t getIdentifier();
+	ReturnValue_t initialize() override;
-	ReturnValue_t initialize();
+	uint16_t getIdentifier() override;
+
 protected:
 	/**
 	 * This attribute contains the class, that performs a formal packet check.
 	 */
 	TcPacketCheck checker;
 	/**
-	 * With this class, verification messages are sent to the TC Verification service.
+	 * With this class, verification messages are sent to the
+	 * TC Verification service.
 	 */
 	VerificationReporter verifyChannel;
 	/**
 	 * The currently handled packet is stored here.
 	 */
-	TcPacketStored currentPacket;
+	TcPacketStored* currentPacket = nullptr;
 	/**
-	 * With this variable, the current check status is stored to generate acceptance messages later.
+	 * With this variable, the current check status is stored to generate
+	 * acceptance messages later.
 	 */
 	ReturnValue_t tcStatus;
 
 	const object_id_t packetSource;
+
 	/**
-	 * This method reads the packet service, checks if such a service is registered and forwards the packet to the destination.
+	 * This method reads the packet service, checks if such a service is
-	 * It also initiates the formal packet check and sending of verification messages.
+	 * registered and forwards the packet to the destination.
-	 * @return Iterator to map entry of found service id or iterator to \c map.end().
+	 * It also initiates the formal packet check and sending of verification
+	 * messages.
+	 * @return Iterator to map entry of found service id
+	 * or iterator to @c map.end().
 	 */
-	iterator_t selectDestination();
+	TcMqMapIter selectDestination() override;
 	/**
-	 * The callback here handles the generation of acceptance success/failure messages.
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
 	 */
-	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
+	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus) override;
 };
 
-#endif /* PUSDISTRIBUTOR_H_ */
+#endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */

tcdistribution/PUSDistributorIF.h

@@ -1,11 +1,12 @@
-#ifndef PUSDISTRIBUTORIF_H_
+#ifndef FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_
-#define PUSDISTRIBUTORIF_H_
+#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_
 
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
+
 /**
  * This interface allows PUS Services to register themselves at a PUS Distributor.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
 class PUSDistributorIF {
 public:
@@ -17,10 +18,10 @@ public:
 /**
  * With this method, Services can register themselves at the PUS Distributor.
  * @param service A pointer to the registering Service.
- * @return	- \c RETURN_OK on success,
+ * @return	- @c RETURN_OK on success,
- * 			- \c RETURN_FAILED on failure.
+ * 			- @c RETURN_FAILED on failure.
  */
 	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
 };
 
-#endif /* PUSDISTRIBUTORIF_H_ */
+#endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_ */

tcdistribution/TcDistributor.cpp

@@ -1,12 +1,13 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "TcDistributor.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../tmtcservices/TmTcMessage.h"
 #include "../ipc/QueueFactory.h"
 
-TcDistributor::TcDistributor(object_id_t set_object_id) :
+TcDistributor::TcDistributor(object_id_t objectId) :
-		SystemObject(set_object_id), tcQueue(NULL) {
+		SystemObject(objectId) {
-	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
+	tcQueue = QueueFactory::instance()->
+	        createMessageQueue(DISTRIBUTER_MAX_PACKETS);
 }
 
 TcDistributor::~TcDistributor() {
@@ -15,7 +16,6 @@ TcDistributor::~TcDistributor() {
 
 ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 	ReturnValue_t status = RETURN_OK;
-//	debug << "TcDistributor: performing Operation." << std::endl;
 	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
 			status = tcQueue->receiveMessage(&currentMessage)) {
 		status = handlePacket();
@@ -29,7 +29,7 @@ ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 
 ReturnValue_t TcDistributor::handlePacket() {
 
-	iterator_t queueMapIt = this->selectDestination();
+	TcMqMapIter queueMapIt = this->selectDestination();
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if (queueMapIt != this->queueMap.end()) {
 		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
@@ -39,14 +39,14 @@ ReturnValue_t TcDistributor::handlePacket() {
 }
 
 void TcDistributor::print() {
-	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
+	sif::debug << "Distributor content is: " << std::endl
-			<< std::endl;
+	        << "ID\t| Message Queue ID" << std::endl;
-	for (iterator_t it = this->queueMap.begin(); it != this->queueMap.end();
+	sif::debug << std::setfill('0') << std::setw(8) << std::hex;
-			it++) {
+	for (const auto& queueMapIter: queueMap) {
-		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
+		sif::debug << queueMapIter.first << "\t| 0x"   << queueMapIter.second
-				<< std::endl;
+		         << std::endl;
 	}
-	sif::debug << std::dec;
+	sif::debug << std::setfill(' ') << std::dec;
 
 }
 

tcdistribution/TcDistributor.h

@@ -1,5 +1,6 @@
-#ifndef TCDISTRIBUTOR_H_
+#ifndef FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_
-#define TCDISTRIBUTOR_H_
+#define FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_
+
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -9,16 +10,12 @@
 #include "../ipc/MessageQueueIF.h"
 #include <map>
 
-
 /**
- * \defgroup tc_distribution Telecommand Distribution
+ * @defgroup tc_distribution Telecommand Distribution
- * All classes associated with Routing and Distribution of Telecommands belong to this group.
+ * All classes associated with Routing and Distribution of Telecommands
+ * belong to this group.
  */
 
-/**
- * This typedef simplifies writing down the \c map iterator.
- */
-typedef std::map<uint32_t, MessageQueueId_t>::iterator iterator_t;
 
 /**
  * This is the base class to implement distributors for Space Packets.
@@ -28,62 +25,19 @@ typedef std::map<uint32_t, MessageQueueId_t>::iterator iterator_t;
  * message queue ids to some identifier. The process of unpacking the
  * destination information from the packet is handled by the child class
  * implementations.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
-class TcDistributor : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
+class TcDistributor : public SystemObject,
-private:
+		public ExecutableObjectIF,
-	/**
+		public HasReturnvaluesIF {
-	 * This constant sets the maximum number of packets distributed per call.
-	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
-protected:
-	/**
-	 * This is the receiving queue for incoming Telecommands.
-	 * The child classes must make its queue id public.
-	 */
-	MessageQueueIF* tcQueue;
-	/**
-	 * The last received incoming packet information is stored in this
-	 * member.
-	 * As different child classes unpack the incoming packet differently
-	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
-	 * is not tried to unpack the packet information within this class.
-	 */
-	TmTcMessage currentMessage;
-	/**
-	 * The map that links certain packet information to a destination.
-	 * The packet information may be the APID of the packet or the service
-	 * identifier. Filling of the map is under control of the different child
-	 * classes.
-	 */
-	std::map<uint32_t, MessageQueueId_t> queueMap;
-	/**
-	 * This method shall unpack the routing information from the incoming
-	 * packet and select the map entry which represents the packet's target.
-	 * @return	An iterator to the map element to forward to or queuMap.end().
-	 */
-	virtual iterator_t selectDestination() = 0;
-	/**
-	 * The handlePacket method calls the child class's selectDestination method
-	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
-	 * 		destination was found.
-	 */
-	ReturnValue_t handlePacket();
-	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
-	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
-	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
-	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	static constexpr ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t SERVICE_ID_ALREADY_EXISTS = MAKE_RETURN_CODE(3);
 	/**
 	 * Within the default constructor, the SystemObject id is set and the
 	 * message queue is initialized.
@@ -91,7 +45,7 @@ public:
 	 * @param set_object_id	This id is assigned to the distributor
 	 * 		implementation.
 	 */
-	TcDistributor( object_id_t set_object_id );
+	TcDistributor(object_id_t objectId);
 	/**
 	 * The destructor is empty, the message queues are not in the vicinity of
 	 * this class.
@@ -110,7 +64,59 @@ public:
 	 * queueMap.
 	 */
 	void print();
+
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueueIF* tcQueue = nullptr;
+	/**
+	 * The last received incoming packet information is stored in this
+	 * member.
+	 * As different child classes unpack the incoming packet differently
+	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
+	 * is not tried to unpack the packet information within this class.
+	 */
+	TmTcMessage currentMessage;
+	/**
+	 * The map that links certain packet information to a destination.
+	 * The packet information may be the APID of the packet or the service
+	 * identifier. Filling of the map is under control of the different child
+	 * classes.
+	 */
+	TcMessageQueueMap queueMap;
+	/**
+	 * This method shall unpack the routing information from the incoming
+	 * packet and select the map entry which represents the packet's target.
+	 * @return	An iterator to the map element to forward to or queuMap.end().
+	 */
+	virtual TcMqMapIter selectDestination() = 0;
+	/**
+	 * The handlePacket method calls the child class's selectDestination method
+	 * and forwards the packet to its destination, if found.
+	 * @return The message queue return value or @c RETURN_FAILED, in case no
+	 * 		destination was found.
+	 */
+	ReturnValue_t handlePacket();
+	/**
+	 * This method gives the child class a chance to perform some kind of
+	 * operation after the parent tried to forward the message.
+	 * A typically application would be sending success/failure messages.
+	 * The default implementation just returns @c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt
+	 *                      to send the TC.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
+	 */
+	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static constexpr uint8_t DISTRIBUTER_MAX_PACKETS = 128;
 };
 
 
-#endif /* TCDISTRIBUTOR_H_ */
+#endif /* FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_ */

tcdistribution/TcPacketCheck.cpp

@@ -1,31 +1,33 @@
+#include "TcPacketCheck.h"
+
 #include "../globalfunctions/CRC.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "TcPacketCheck.h"
 #include "../tmtcservices/VerificationCodes.h"
 
-TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
+TcPacketCheck::TcPacketCheck( uint16_t setApid ) : apid(setApid) {
 }
 
-ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* currentPacket ) {
-	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
+	uint16_t calculated_crc = CRC::crc16ccitt( currentPacket->getWholeData(),
+	        currentPacket->getFullSize() );
 	if ( calculated_crc != 0 ) {
 		return INCORRECT_CHECKSUM;
 	}
-	bool condition = !(current_packet->hasSecondaryHeader()) ||
+	bool condition = (not currentPacket->hasSecondaryHeader()) or
-			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
+			(currentPacket->getPacketVersionNumber() != CCSDS_VERSION_NUMBER) or
-			!(current_packet->isTelecommand());
+			(not currentPacket->isTelecommand());
 	if ( condition ) {
 		return INCORRECT_PRIMARY_HEADER;
 	}
-	if ( current_packet->getAPID() != this->apid )
+	if ( currentPacket->getAPID() != this->apid )
 		return ILLEGAL_APID;
 
-	if ( !current_packet->isSizeCorrect() ) {
+	if ( not currentPacket->isSizeCorrect() ) {
 		return INCOMPLETE_PACKET;
 	}
-	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+	condition = (currentPacket->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
+			(currentPacket->getPusVersionNumber() != PUS_VERSION_NUMBER);
 	if ( condition ) {
 		return INCORRECT_SECONDARY_HEADER;
 	}

tcdistribution/TcPacketCheck.h

@@ -1,28 +1,29 @@
-#ifndef TCPACKETCHECK_H_
+#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_
-#define TCPACKETCHECK_H_
+#define FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcservices/PusVerificationReport.h"
+
 /**
  * This class performs a formal packet check for incoming PUS Telecommand Packets.
  * Currently, it only checks if the APID and CRC are correct.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
 class TcPacketCheck : public HasReturnvaluesIF {
 protected:
 	/**
 	 * Describes the version number a packet must have to pass.
 	 */
-	static const uint8_t CCSDS_VERSION_NUMBER = 0;
+	static constexpr uint8_t CCSDS_VERSION_NUMBER = 0;
 	/**
 	 * Describes the secondary header a packet must have to pass.
 	 */
-	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	static constexpr uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
 	/**
 	 * Describes the TC Packet PUS Version Number a packet must have to pass.
 	 */
-	static const uint8_t PUS_VERSION_NUMBER = 1;
+	static constexpr uint8_t PUS_VERSION_NUMBER = 1;
 	/**
 	 * The packet id each correct packet should have.
 	 * It is composed of the APID and some static fields.
@@ -41,19 +42,19 @@ public:
 	 * The constructor only sets the APID attribute.
 	 * @param set_apid The APID to set.
 	 */
-	TcPacketCheck( uint16_t set_apid );
+	TcPacketCheck( uint16_t setApid );
 	/**
 	 * This is the actual method to formally check a certain Telecommand Packet.
 	 * The packet's Application Data can not be checked here.
 	 * @param current_packet The packt to check
-	 * @return	- \c RETURN_OK on success.
+	 * @return	- @c RETURN_OK on success.
-	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
+	 * 			- @c INCORRECT_CHECKSUM if checksum is invalid.
-	 * 			- \c ILLEGAL_APID if APID does not match.
+	 * 			- @c ILLEGAL_APID if APID does not match.
 	 */
-	ReturnValue_t checkPacket( TcPacketStored* current_packet );
+	ReturnValue_t checkPacket( TcPacketStored* currentPacket );
 
 	uint16_t getApid() const;
 };
 
 
-#endif /* TCPACKETCHECK_H_ */
+#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_ */