Merge remote-tracking branch 'upstream/development' into development

FSFWVersion.h

@@ -0,0 +1,11 @@
+#ifndef FSFW_DEFAULTCFG_VERSION_H_
+#define FSFW_DEFAULTCFG_VERSION_H_
+
+const char* const FSFW_VERSION_NAME = "fsfw";
+
+#define FSFW_VERSION 		0
+#define	FSFW_SUBVERSION 	0
+
+
+
+#endif /* FSFW_DEFAULTCFG_VERSION_H_ */

README.md

@@ -0,0 +1,4 @@
+Flight Software Framework (FSFW)
+======
+
+I want to be written!

action/ActionHelper.cpp

@@ -3,8 +3,9 @@
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
+ActionHelper::ActionHelper(HasActionsIF* setOwner,
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
+        MessageQueueIF* useThisQueue) :
+		owner(setOwner), queueToUse(useThisQueue) {
 }
 
 ActionHelper::~ActionHelper() {
@@ -33,13 +34,15 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
+        ActionId_t commandId, ReturnValue_t result) {
 	CommandMessage reply;
 	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
 	queueToUse->sendMessage(reportTo, &reply);
 }
 
-void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
+        ReturnValue_t result) {
 	CommandMessage reply;
 	ActionMessage::setCompletionReply(&reply, commandId, result);
 	queueToUse->sendMessage(reportTo, &reply);
@@ -49,8 +52,8 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
 	queueToUse = queue;
 }
 
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-		store_address_t dataAddress) {
+        ActionId_t actionId, store_address_t dataAddress) {
 	const uint8_t* dataPtr = NULL;
 	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
@@ -62,6 +65,11 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	}
 	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
 	ipcStore->deleteData(dataAddress);
+	if(result == HasActionsIF::EXECUTION_FINISHED) {
+		CommandMessage reply;
+		ActionMessage::setCompletionReply(&reply, actionId, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+	}
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		CommandMessage reply;
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
@@ -86,22 +94,28 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
+	result = data->serialize(&dataPtr, &size, maxSize,
+	        SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ipcStore->deleteData(storeAddress);
 		return result;
 	}
-	//We don't need to report the objectId, as we receive REQUESTED data before the completion success message.
+	// We don't need to report the objectId, as we receive REQUESTED data
-	//True aperiodic replies need to be reported with another dedicated message.
+	// before the completion success message.
+	// True aperiodic replies need to be reported with
+	// another dedicated message.
 	ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-	//TODO Service Implementation sucks at the moment
+    // If the sender needs to be hidden, for example to handle packet
-	if (hideSender){
+    // as unrequested reply, this will be done here.
+	if (hideSender) {
 		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	} else {
+	}
+	else {
 		result = queueToUse->sendMessage(reportTo, &reply);
 	}
-	if ( result != HasReturnvaluesIF::RETURN_OK){
+
+	if (result != HasReturnvaluesIF::RETURN_OK){
 		ipcStore->deleteData(storeAddress);
 	}
 	return result;
@@ -109,3 +123,39 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 
 void ActionHelper::resetHelper() {
 }
+
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+        ActionId_t replyId, const uint8_t *data, size_t dataSize,
+        bool hideSender) {
+    CommandMessage reply;
+    store_address_t storeAddress;
+    ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+        return result;
+    }
+
+    // We don't need to report the objectId, as we receive REQUESTED data
+    // before the completion success message.
+    // True aperiodic replies need to be reported with
+    // another dedicated message.
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+    // If the sender needs to be hidden, for example to handle packet
+    // as unrequested reply, this will be done here.
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
+}

action/ActionHelper.h

@@ -1,15 +1,18 @@
-#ifndef ACTIONHELPER_H_
+#ifndef FSFW_ACTION_ACTIONHELPER_H_
-#define ACTIONHELPER_H_
+#define FSFW_ACTION_ACTIONHELPER_H_
 
 #include "ActionMessage.h"
 #include "../serialize/SerializeIF.h"
 #include "../ipc/MessageQueueIF.h"
 /**
- * \brief Action Helper is a helper class which handles action messages
+ * @brief Action Helper is a helper class which handles action messages
  *
- * Components which use the HasActionIF this helper can be used to handle the action messages.
+ * Components which use the HasActionIF this helper can be used to handle
- * It does handle step messages as well as other answers to action calls. It uses the executeAction function
+ * the action messages.
- * of its owner as callback. The call of the initialize function is mandatory and it needs a valid messageQueueIF pointer!
+ * It does handle step messages as well as other answers to action calls.
+ * It uses the executeAction function of its owner as callback.
+ * The call of the initialize function is mandatory and needs a
+ * valid MessageQueueIF pointer!
  */
 class HasActionsIF;
 
@@ -18,7 +21,8 @@ public:
 	/**
 	 * Constructor of the action helper
 	 * @param setOwner Pointer to the owner of the interface
-	 * @param useThisQueue messageQueue to be used, can be set during initialize function as well.
+	 * @param useThisQueue  messageQueue to be used, can be set during
+	 *                      initialize function as well.
 	 */
 	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
 
@@ -26,28 +30,36 @@ public:
 	/**
 	 * Function to be called from the owner with a new command message
 	 *
-	 * If the message is a valid action message the helper will use the executeAction function from HasActionsIF.
+	 * If the message is a valid action message the helper will use the
-	 * If the message is invalid or the callback fails a message reply will be send to the sender of the message automatically.
+	 * executeAction function from HasActionsIF.
+	 * If the message is invalid or the callback fails a message reply will be
+	 * send to the sender of the message automatically.
 	 *
 	 * @param command Pointer to a command message received by the owner
-	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message, CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
+	 *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
 	 */
 	ReturnValue_t handleActionMessage(CommandMessage* command);
 	/**
-	 * Helper initialize function. Must be called before use of any other helper function
+	 * Helper initialize function. Must be called before use of any other
-	 * @param queueToUse_ Pointer to the messageQueue to be used, optional if queue was set in constructor
+	 * helper function
+	 * @param queueToUse_   Pointer to the messageQueue to be used, optional
+	 *                      if queue was set in constructor
 	 * @return Returns RETURN_OK if successful
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
 	/**
-	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
+	 * Function to be called from the owner to send a step message.
+	 * Success or failure will be determined by the result value.
 	 *
 	 * @param step Number of steps already done
 	 * @param reportTo The messageQueueId to report the step message to
 	 * @param commandId ID of the executed command
 	 * @param result Result of the execution
 	 */
-	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void step(uint8_t step, MessageQueueId_t reportTo,
+			ActionId_t commandId,
+			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 	/**
 	 * Function to be called by the owner to send a action completion message
 	 *
@@ -55,39 +67,59 @@ public:
 	 * @param commandId ID of the executed command
 	 * @param result Result of the execution
 	 */
-	void finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void finish(MessageQueueId_t reportTo, ActionId_t commandId,
+	        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 	/**
-	 * Function to be called by the owner if an action does report data
+	 * Function to be called by the owner if an action does report data.
-	 *
+	 * Takes a SerializeIF* pointer and serializes it into the IPC store.
-	 * @param reportTo MessageQueueId_t to report the action completion message to
+	 * @param reportTo  MessageQueueId_t to report the action completion
+	 *                  message to
 	 * @param replyId ID of the executed command
 	 * @param data Pointer to the data
 	 * @return Returns RETURN_OK if successful, otherwise failure code
 	 */
-	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender = false);
+	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+	        SerializeIF* data, bool hideSender = false);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes the raw data and writes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            const uint8_t* data, size_t dataSize, bool hideSender = false);
 	/**
-	 * Function to setup the MessageQueueIF* of the helper. Can be used to set the messageQueueIF* if
+	 * Function to setup the MessageQueueIF* of the helper. Can be used to
-	 * message queue is unavailable at construction and initialize but must be setup before first call of other functions.
+	 * set the MessageQueueIF* if message queue is unavailable at construction
+	 * and initialize but must be setup before first call of other functions.
 	 * @param queue Queue to be used by the helper
 	 */
 	void setQueueToUse(MessageQueueIF *queue);
 protected:
-	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
+	//!< Increase of value of this per step
+	static const uint8_t STEP_OFFSET = 1;
 	HasActionsIF* owner;//!< Pointer to the owner
-	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
+	//! Queue to be used as response sender, has to be set in ctor or with
-	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
+	//! setQueueToUse
+	MessageQueueIF* queueToUse;
+	//! Pointer to an IPC Store, initialized during construction or
+	StorageManagerIF* ipcStore = nullptr;
+
 	/**
-	 *Internal function called by handleActionMessage(CommandMessage* command)
+	 * Internal function called by handleActionMessage
-	 *
 	 * @param commandedBy MessageQueueID of Commander
 	 * @param actionId ID of action to be done
 	 * @param dataAddress Address of additional data in IPC Store
 	 */
-	virtual void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+	virtual void prepareExecution(MessageQueueId_t commandedBy,
+	        ActionId_t actionId, store_address_t dataAddress);
 	/**
-	 *
+	 * @brief Default implementation is empty.
 	 */
 	virtual void resetHelper();
 };
 
-#endif /* ACTIONHELPER_H_ */
+#endif /* FSFW_ACTION_ACTIONHELPER_H_ */

action/HasActionsIF.h

@@ -1,11 +1,12 @@
-#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
+#ifndef FSFW_ACTION_HASACTIONSIF_H_
-#define FRAMEWORK_ACTION_HASACTIONSIF_H_
+#define FSFW_ACTION_HASACTIONSIF_H_
 
 #include "ActionHelper.h"
 #include "ActionMessage.h"
 #include "SimpleActionHelper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MessageQueueIF.h"
+
 /**
  * @brief
  * Interface for component which uses actions
@@ -47,14 +48,16 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	/**
 	 * Execute or initialize the execution of a certain function.
-	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
+	 * The ActionHelpers will execute this function and behave differently
-	 * be done. When needing more steps, return RETURN_OK and issue steps and
+	 * depending on the returnvalue.
-	 * completion manually.
+	 *
-	 * One "step failed" or completion report must be issued!
+	 * @return
+	 * -@c EXECUTION_FINISHED Finish reply will be generated
+	 * -@c Not RETURN_OK Step failure reply will be generated
 	 */
 	virtual ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
 };
 
 
-#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
+#endif /* FSFW_ACTION_HASACTIONSIF_H_ */

action/SimpleActionHelper.cpp

@@ -1,16 +1,17 @@
 #include "HasActionsIF.h"
 #include "SimpleActionHelper.h"
+
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
 		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
+		ActionHelper(setOwner, useThisQueue), isExecuting(false) {
-				0), lastAction(0), stepCount(0) {
 }
 
 SimpleActionHelper::~SimpleActionHelper() {
 }
 
 void SimpleActionHelper::step(ReturnValue_t result) {
-	//STEP_OFFESET is subtracted to compensate for adding offset in base method, which is not necessary here.
+	// STEP_OFFESET is subtracted to compensate for adding offset in base
+	// method, which is not necessary here.
 	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
 			result);
 	if (result != HasReturnvaluesIF::RETURN_OK) {

action/SimpleActionHelper.h

@@ -1,8 +1,13 @@
-#ifndef SIMPLEACTIONHELPER_H_
+#ifndef FSFW_ACTION_SIMPLEACTIONHELPER_H_
-#define SIMPLEACTIONHELPER_H_
+#define FSFW_ACTION_SIMPLEACTIONHELPER_H_
 
 #include "ActionHelper.h"
 
+/**
+ * @brief	This is an action helper which is only able to service one action
+ * 			at a time but remembers last commander and last action which
+ * 			simplifies usage
+ */
 class SimpleActionHelper: public ActionHelper {
 public:
 	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
@@ -12,13 +17,14 @@ public:
 	ReturnValue_t reportData(SerializeIF* data);
 
 protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-	virtual  void resetHelper();
+			store_address_t dataAddress);
+	virtual void resetHelper();
 private:
 	bool isExecuting;
-	MessageQueueId_t lastCommander;
+	MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
-	ActionId_t lastAction;
+	ActionId_t lastAction = 0;
-	uint8_t stepCount;
+	uint8_t stepCount = 0;
 };
 
 #endif /* SIMPLEACTIONHELPER_H_ */

container/SharedRingBuffer.cpp

@@ -9,6 +9,7 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
 	mutex = MutexFactory::instance()->createMutex();
 }
 
+
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 		const size_t size, bool overwriteOld, size_t maxExcessBytes):
 		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
@@ -16,6 +17,11 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 	mutex = MutexFactory::instance()->createMutex();
 }
 
+
+void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
+	this->fifoDepth = fifoDepth;
+}
+
 ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
         MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
     return mutex->lockMutex(timeoutType, timeout);
@@ -25,6 +31,25 @@ ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
     return mutex->unlockMutex();
 }
 
+
+
 MutexIF* SharedRingBuffer::getMutexHandle() const {
     return mutex;
 }
+
+ReturnValue_t SharedRingBuffer::initialize() {
+	if(fifoDepth > 0) {
+		receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
+	}
+	return SystemObject::initialize();
+}
+
+DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
+	if(receiveSizesFIFO == nullptr) {
+		// Configuration error.
+		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
+				<< " was not configured to have sizes FIFO, returning nullptr!"
+				<< std::endl;
+	}
+	return receiveSizesFIFO;
+}

container/SharedRingBuffer.h

@@ -2,6 +2,7 @@
 #define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 
 #include "SimpleRingBuffer.h"
+#include "DynamicFIFO.h"
 #include "../ipc/MutexIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../timemanager/Clock.h"
@@ -26,6 +27,16 @@ public:
 	SharedRingBuffer(object_id_t objectId, const size_t size,
 			bool overwriteOld, size_t maxExcessBytes);
 
+	/**
+	 * @brief	This function can be used to add an optional FIFO to the class
+	 * @details 
+	 * This FIFO will be allocated in the initialize function (and will
+	 * have a fixed maximum size after that). It can be used to store
+	 * values like packet sizes, for example for a shared ring buffer
+	 * used by producer/consumer tasks.
+	 */
+	void setToUseReceiveSizeFIFO(size_t fifoDepth);
+
 	/**
 	 * This constructor takes an external buffer with the specified size.
 	 * @param buffer
@@ -59,8 +70,21 @@ public:
 	 * @return
 	 */
 	MutexIF* getMutexHandle() const;
+
+	ReturnValue_t initialize() override;
+
+	/**
+	 * If the shared ring buffer was configured to have a sizes FIFO, a handle
+	 * to that FIFO can be retrieved with this function.
+	 * Do not forget to protect access with a lock if required!
+	 * @return
+	 */
+	DynamicFIFO<size_t>* getReceiveSizesFIFO();
 private:
 	MutexIF* mutex = nullptr;
+
+	size_t fifoDepth = 0;
+	DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
 };
 
 

defaultcfg/README.md

@@ -0,0 +1,6 @@
+# How to setup configuration folder for FSFW
+
+It is recommended to copy the content of the defaultcfg folder
+into a config folder which is in the same directory as the Flight
+Software Framework submodule. After that, the config.mk folder should be
+included by the primary Makefile with CURRENTPATH set correctly.

defaultcfg/config/FSFWConfig.h

@@ -0,0 +1,54 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include <FSFWVersion.h>
+#include <cstddef>
+
+//! Used to determine whether C++ ostreams are used
+//! Those can lead to code bloat.
+#define FSFW_CPP_OSTREAM_ENABLED 	1
+
+//! Reduced printout to further decrese code size
+//! Be careful, this also turns off most diagnostic prinouts!
+#define FSFW_REDUCED_PRINTOUT		0
+
+//! Can be used to enable debugging printouts for developing the FSFW
+#define FSFW_DEBUGGING              0
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+#define FSFW_CSB_FIFO_DEPTH			6
+
+//! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiled source files)
+#define FSFW_OBJ_EVENT_TRANSLATION	0
+
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
+#define FSFW_DEBUG_OUTPUT 			1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO				1
+#include <translateObjects.h>
+#include <translateEvents.h>
+#else
+#define FSFW_DEBUG_OUTPUT			0
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NO_C99_IO 	1
+
+namespace fsfwconfig {
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
+
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
+
+#endif /* CONFIG_FSFWCONFIG_H_ */

defaultcfg/config/OBSWConfig.h

@@ -0,0 +1,16 @@
+#ifndef CONFIG_OBSWCONFIG_H_
+#define CONFIG_OBSWCONFIG_H_
+
+#include "OBSWVersion.h"
+
+#ifdef __cplusplus
+namespace config {
+#endif
+
+/* Add mission configuration flags here */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CONFIG_OBSWCONFIG_H_ */

defaultcfg/config/OBSWVersion.h

@@ -0,0 +1,9 @@
+#ifndef CONFIG_VERSION_H_
+#define CONFIG_VERSION_H_
+
+/* OBSW versioning can be specified in this file */
+
+#define OBSW_VERSION      0
+#define OBSW_SUBVERSION   0
+
+#endif /* CONFIG_VERSION_H_ */

defaultcfg/config/config.mk

@@ -0,0 +1,15 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/tmtc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/devices/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
+INCLUDES += $(CURRENTPATH)/objects
+INCLUDES += $(CURRENTPATH)/returnvalues
+INCLUDES += $(CURRENTPATH)/tmtc
+INCLUDES += $(CURRENTPATH)/events
+INCLUDES += $(CURRENTPATH)/devices
+INCLUDES += $(CURRENTPATH)/pollingsequence
+INCLUDES += $(CURRENTPATH)/ipc

defaultcfg/config/devices/logicalAddresses.cpp

@@ -0,0 +1,5 @@
+#include "logicalAddresses.h"
+
+
+
+

defaultcfg/config/devices/logicalAddresses.h

@@ -0,0 +1,18 @@
+#ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
+#define CONFIG_DEVICES_LOGICALADDRESSES_H_
+
+#include <config/objects/systemObjectList.h>
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <cstdint>
+
+/**
+ * Can be used for addresses for physical devices like I2C adresses.
+ */
+namespace addresses {
+	/* Logical addresses have uint32_t datatype */
+	enum logicalAddresses: address_t {
+	};
+}
+
+
+#endif /* CONFIG_DEVICES_LOGICALADDRESSES_H_ */

defaultcfg/config/devices/powerSwitcherList.cpp

@@ -0,0 +1,4 @@
+#include "powerSwitcherList.h"
+
+
+

defaultcfg/config/devices/powerSwitcherList.h

@@ -0,0 +1,12 @@
+#ifndef CONFIG_DEVICES_POWERSWITCHERLIST_H_
+#define CONFIG_DEVICES_POWERSWITCHERLIST_H_
+
+namespace switches {
+	/* Switches are uint8_t datatype and go from 0 to 255 */
+	enum switcherList {
+	};
+
+}
+
+
+#endif /* CONFIG_DEVICES_POWERSWITCHERLIST_H_ */

defaultcfg/config/events/subsystemIdRanges.h

@@ -0,0 +1,18 @@
+#ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+#define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+
+#include <cstdint>
+#include <fsfw/events/fwSubsystemIdRanges.h>
+
+/**
+ * @brief	Custom subsystem IDs can be added here
+ * @details
+ * Subsystem IDs are used to create unique events.
+ */
+namespace SUBSYSTEM_ID {
+enum: uint8_t {
+	SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
+};
+}
+
+#endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */

defaultcfg/config/ipc/missionMessageTypes.cpp

@@ -0,0 +1,11 @@
+#include <config/ipc/MissionMessageTypes.h>
+#include <fsfw/ipc/CommandMessageIF.h>
+
+void messagetypes::clearMissionMessage(CommandMessage* message) {
+	switch(message->getMessageType()) {
+	default:
+		break;
+	}
+}
+
+

defaultcfg/config/ipc/missionMessageTypes.h

@@ -0,0 +1,21 @@
+#ifndef CONFIG_IPC_MISSIONMESSAGETYPES_H_
+#define CONFIG_IPC_MISSIONMESSAGETYPES_H_
+
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/ipc/FwMessageTypes.h>
+
+/**
+ * Custom command messages are specified here.
+ * Most messages needed to use FSFW are already located in
+ * <fsfw/ipc/FwMessageTypes.h>
+ * @param message Generic Command Message
+ */
+namespace messagetypes {
+enum CustomMessageTypes {
+	MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT
+};
+
+void clearMissionMessage(CommandMessage* message);
+}
+
+#endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */

defaultcfg/config/objects/Factory.cpp

@@ -0,0 +1,54 @@
+#include "Factory.h"
+#include "../tmtc/apid.h"
+#include "../tmtc/pusIds.h"
+#include "../objects/systemObjectList.h"
+#include "../devices/logicalAddresses.h"
+#include "../devices/powerSwitcherList.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+
+#include <cstdint>
+
+/**
+ * This class should be used to create all system objects required for
+ * the on-board software, using the object ID list from the configuration
+ * folder.
+ *
+ * The objects are registered in the internal object manager automatically.
+ * This is used later to add objects to tasks.
+ *
+ * This file also sets static framework IDs.
+ *
+ * Framework objects are created first.
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+	PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+	CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+	CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
+
+	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
+
+	TmPacketStored::timeStamperId = objects::PUS_TIME;
+	//TmFunnel::downlinkDestination = objects::NO_OBJECT;
+}
+

defaultcfg/config/objects/Factory.h

@@ -0,0 +1,17 @@
+#ifndef FACTORY_H_
+#define FACTORY_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <cstddef>
+
+namespace Factory {
+	/**
+	 * @brief   Creates all SystemObject elements which are persistent
+	 *          during execution.
+	 */
+	void produce();
+	void setStaticFrameworkObjectIds();
+}
+
+
+#endif /* FACTORY_H_ */

defaultcfg/config/objects/systemObjectList.h

@@ -0,0 +1,16 @@
+#ifndef CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <cstdint>
+#include <fsfw/objectmanager/frameworkObjects.h>
+
+// The objects will be instantiated in the ID order
+namespace objects {
+	enum sourceObjects: uint32_t {
+		/* All addresses between start and end are reserved for the FSFW */
+		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
+		FSFW_CONFIG_RESERVED_END = TM_STORE
+	};
+}
+
+#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */

defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp

@@ -0,0 +1,23 @@
+#include "PollingSequenceFactory.h"
+
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+
+ReturnValue_t pst::pollingSequenceInitDefault(
+        FixedTimeslotTaskIF *thisSequence) {
+	/* Length of a communication cycle */
+	uint32_t length = thisSequence->getPeriodMs();
+
+	/* Add polling sequence table here */
+
+	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
+		        << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+

defaultcfg/config/pollingsequence/PollingSequenceFactory.h

@@ -0,0 +1,32 @@
+#ifndef POLLINGSEQUENCEFACTORY_H_
+#define POLLINGSEQUENCEFACTORY_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+class FixedTimeslotTaskIF;
+
+/**
+ * All device handlers are scheduled by adding them into  Polling Sequence Tables (PST)
+ * to satisfy stricter timing requirements of device communication,
+ * A device handler has four different communication steps:
+ *   1. DeviceHandlerIF::SEND_WRITE -> Send write via interface
+ *   2. DeviceHandlerIF::GET_WRITE -> Get confirmation for write
+ *   3. DeviceHandlerIF::SEND_READ -> Send read request
+ *   4. DeviceHandlerIF::GET_READ -> Read from interface
+ * The PST specifies precisely when the respective ComIF functions are called
+ * during the communication cycle time.
+ * The task is created using the FixedTimeslotTaskIF,
+ * which utilises the underlying Operating System Abstraction Layer (OSAL)
+ *
+ * @param thisSequence FixedTimeslotTaskIF * object is passed inside the Factory class when creating the PST
+ * @return
+ */
+namespace pst {
+
+/* Default PST */
+ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
+
+
+}
+
+#endif /* POLLINGSEQUENCEINIT_H_ */

defaultcfg/config/returnvalues/classIds.h

@@ -0,0 +1,16 @@
+#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
+#define CONFIG_RETURNVALUES_CLASSIDS_H_
+
+#include <fsfw/returnvalues/FwClassIds.h>
+
+/**
+ * @brief   CLASS_ID defintions which are required for custom returnvalues.
+ */
+namespace CLASS_ID {
+enum {
+	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
+};
+}
+
+
+#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */

defaultcfg/config/tmtc/apid.h

@@ -0,0 +1,18 @@
+#ifndef CONFIG_TMTC_APID_H_
+#define CONFIG_TMTC_APID_H_
+
+#include <cstdint>
+
+/**
+ * Application Process Definition: entity, uniquely identified by an
+ * application process ID (APID), capable of generating telemetry source
+ * packets and receiving telecommand packets.
+ *
+ * Chose APID(s) for mission and define it here.
+ */
+namespace apid {
+	static const uint16_t DEFAULT_APID = 0x00;
+}
+
+
+#endif /* CONFIG_TMTC_APID_H_ */

defaultcfg/config/tmtc/pusIds.h

@@ -0,0 +1,23 @@
+#ifndef CONFIG_TMTC_PUSIDS_HPP_
+#define CONFIG_TMTC_PUSIDS_HPP_
+
+namespace pus {
+enum Ids: uint8_t {
+	PUS_SERVICE_1 = 1,
+	PUS_SERVICE_2 = 2,
+	PUS_SERVICE_3 = 3,
+	PUS_SERVICE_5 = 5,
+	PUS_SERVICE_6 = 6,
+	PUS_SERVICE_8 = 8,
+	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_11 = 11,
+	PUS_SERVICE_17 = 17,
+	PUS_SERVICE_19 = 19,
+	PUS_SERVICE_20 = 20,
+	PUS_SERVICE_23 = 23,
+	PUS_SERVICE_200 = 200,
+	PUS_SERVICE_201 = 201,
+};
+};
+
+#endif /* CONFIG_TMTC_PUSIDS_HPP_ */

devicehandlers/DeviceHandlerBase.cpp

@@ -1224,7 +1224,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (result == BUSY) {
 		    //so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::endl;
+					<< ": DHB::buildInternalCommand: Busy" << std::dec << std::endl;
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}

devicehandlers/DeviceHandlerIF.h

@@ -18,6 +18,8 @@ public:
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
+	static constexpr Command_t NO_COMMAND = 0xffffffff;
+
 	/**
 	 * @brief This is the mode the <strong>device handler</strong> is in.
 	 *

events/Event.h

@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
 //could be move to more suitable location
-#include <config/tmtc/subsystemIdRanges.h>
+#include <subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;

events/EventManager.cpp

@@ -1,5 +1,7 @@
 #include "EventManager.h"
 #include "EventMessage.h"
+#include <FSFWConfig.h>
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
@@ -12,8 +14,10 @@ const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
 // objects registering for certain events.
 // Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
 // So a good guess is 75 to a max of 100 pools required for each, which fits well.
-// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
+const uint16_t EventManager::N_ELEMENTS[N_POOLS] = {
-const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
+		fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES ,
+		fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS,
+		fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS };
 
 EventManager::EventManager(object_id_t setObjectId) :
 		SystemObject(setObjectId),

fsfw.mk

@@ -28,12 +28,25 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/*.cpp)
 # select the OS
 ifeq ($(OS_FSFW),rtems)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/rtems/*.cpp)
+
 else ifeq ($(OS_FSFW),linux)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
+
 else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
+
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
+ifeq ($(OS),Windows_NT)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/windows/*.cpp)
+else
+# For now, the linux UDP bridge sources needs to be included manually by upper makefile
+# for host OS because we can't be sure the OS is linux.
+# Following lines can be used to do this:
+# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TcUnixUdpPollingTask.cpp
+# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TmTcUnixUdpBridge.cpp
+endif
+
 else
 $(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host)
 endif
@@ -57,3 +70,5 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
+
+INCLUDES += $(CURRENTPATH)

health/HasHealthIF.h

@@ -1,5 +1,5 @@
-#ifndef HASHEALTHIF_H_
+#ifndef FSFW_HEALTH_HASHEALTHIF_H_
-#define HASHEALTHIF_H_
+#define FSFW_HEALTH_HASHEALTHIF_H_
 
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -8,9 +8,13 @@
 class HasHealthIF {
 public:
 
-	typedef enum {
+	enum HealthState: uint8_t {
-		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
+		HEALTHY = 1,
-	} HealthState;
+		FAULTY = 0,
+		EXTERNAL_CONTROL = 2,
+		NEEDS_RECOVERY = 3,
+		PERMANENT_FAULTY = 4
+	};
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
 	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
@@ -31,20 +35,17 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
 	/**
-	 * set the Health State
+	 * @brief   Set the Health State
-	 *
 	 * The parent will be informed, if the Health changes
-	 *
 	 * @param health
 	 */
 	virtual ReturnValue_t setHealth(HealthState health) = 0;
 
 	/**
-	 * get Health State
+	 * @brief   Get Health State
-	 *
+	 * @return  Health State of the object
-	 * @return Health State of the object
 	 */
 	virtual HasHealthIF::HealthState getHealth() = 0;
 };
 
-#endif /* HASHEALTHIF_H_ */
+#endif /* FSFW_HEALTH_HASHEALTHIF_H_ */

health/HealthHelper.h

@@ -12,13 +12,15 @@
 #include "../returnvalues/HasReturnvaluesIF.h"
 
 /**
- * Helper class for Objects that implement HasHealthIF
+ * @brief   Helper class for Objects that implement HasHealthIF
+ * @details
+ * It takes care of registering with the Health Table as well as handling
+ * health commands (including replying to the sender) and updating
+ * the Health Table.
  *
- * It takes care of registering with the Health Table as well as handling health commands
+ * If a parent is set in the ctor, the parent will be informed with a
- * (including replying to the sender) and updating the Health Table.
+ * @c HEALTH_INFO message about changes in the health state.
- *
+ * Note that a @c HEALTH_INFO is only generated if the Health
- * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
- * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
  * changes, not for all @c HEALTH_SET commands received.
  *
  * It does NOT handle @c HEALTH_INFO messages
@@ -27,10 +29,9 @@ class HealthHelper {
 public:
 
 	/**
-	 * ctor
-	 *
 	 * @param owner
-	 * @param objectId the object Id to use when communication with the HealthTable
+	 * @param objectId      The object Id to use when communication with
+	 *                      the HealthTable
 	 */
 	HealthHelper(HasHealthIF* owner, object_id_t objectId);
 
@@ -56,8 +57,9 @@ public:
 	 *
 	 * @param message
 	 * @return
-	 * 			-@c RETURN_OK if the message was handled
+	 * -@c RETURN_OK if the message was handled
-	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
+	 * -@c RETURN_FAILED if the message could not be handled
+	 *     (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
 	 */
 	ReturnValue_t handleHealthCommand(CommandMessage *message);
 
@@ -78,16 +80,19 @@ public:
 	HasHealthIF::HealthState getHealth();
 
 	/**
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue   The queue ID of the parent object.
+	 *                      Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueue);
 
 	/**
 	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue   The queue ID of the parent object.
+	 *                      Set to 0 if no parent present
 	 * @return
-	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
+	 * -@c RETURN_OK if the Health Table was found and the object
-	 * 			-@c RETURN_FAILED else
+	 * could be registered
+	 * -@c RETURN_FAILED else
 	 */
 	ReturnValue_t initialize(MessageQueueId_t parentQueue );
 
@@ -110,11 +115,15 @@ private:
 	HasHealthIF* owner;
 
 	/**
-	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
+	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message
-	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
+	 * will be sent to this queue
+	 * @param health
+	 * The health is passed as parameter so that the number of
+	 * calls to the health table can be minimized
 	 * @param oldHealth information of the previous health state.
 	 */
-	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
+	void informParent(HasHealthIF::HealthState health,
+	        HasHealthIF::HealthState oldHealth);
 
 	void handleSetHealthCommand(CommandMessage *message);
 };

health/HealthMessage.cpp

@@ -7,11 +7,13 @@ void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
 	message->setParameter2(oldHealth);
 }
 
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
+void HealthMessage::setHealthMessage(CommandMessage* message,
+        Command_t command) {
 	message->setCommand(command);
 }
 
-HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
+HasHealthIF::HealthState HealthMessage::getHealth(
+        const CommandMessage* message) {
 	return (HasHealthIF::HealthState) message->getParameter();
 }
 

health/HealthMessage.h

@@ -1,5 +1,5 @@
-#ifndef HEALTHMESSAGE_H_
+#ifndef FSFW_HEALTH_HEALTHMESSAGE_H_
-#define HEALTHMESSAGE_H_
+#define FSFW_HEALTH_HEALTHMESSAGE_H_
 
 #include "HasHealthIF.h"
 #include "../ipc/CommandMessage.h"
@@ -7,14 +7,20 @@
 class HealthMessage {
 public:
 	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
-	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);//REPLY_COMMAND_OK/REPLY_REJECTED
+
-	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);	//NO REPLY!
+	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);
+	// No reply expected, health will be announced as event!
+	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(2);
+	// Same as before, but all objects in health table will
+	// announce their health as events.
+	static const Command_t HEALTH_ANNOUNCE_ALL = MAKE_COMMAND_ID(3);
+
 	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
 	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
 
 	static void setHealthMessage(CommandMessage *message, Command_t command,
-			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
+			HasHealthIF::HealthState health,
-
+			HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
 	static void setHealthMessage(CommandMessage *message, Command_t command);
 
 	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
@@ -27,4 +33,4 @@ private:
 	HealthMessage();
 };
 
-#endif /* HEALTHMESSAGE_H_ */
+#endif /* FSFW_HEALTH_HEALTHMESSAGE_H_ */

health/HealthTable.cpp

@@ -1,6 +1,7 @@
 #include "HealthTable.h"
-#include "../serialize/SerializeAdapter.h"
+#include "../ipc/MutexHelper.h"
 #include "../ipc/MutexFactory.h"
+#include "../serialize/SerializeAdapter.h"
 
 HealthTable::HealthTable(object_id_t objectid) :
 		SystemObject(objectid) {
@@ -9,6 +10,12 @@ HealthTable::HealthTable(object_id_t objectid) :
 	mapIterator = healthMap.begin();
 }
 
+void HealthTable::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->mutexTimeoutMs = timeoutMs;
+}
+
 HealthTable::~HealthTable() {
 	MutexFactory::instance()->deleteMutex(mutex);
 }
@@ -18,74 +25,63 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 	if (healthMap.count(object) != 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	healthMap.insert(
+	healthMap.emplace(object, initilialState);
-			std::pair<object_id_t, HasHealthIF::HealthState>(object,
-					initilialState));
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::BLOCKING);
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
 	}
-	mutex->unlockMutex();
 }
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
 	}
-	mutex->unlockMutex();
 	return state;
 }
 
-uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	uint32_t size = healthMap.size() * 5 + 2;
-	mutex->unlockMutex();
-	return size;
-}
-
 bool HealthTable::hasHealth(object_id_t object) {
-	bool exits = false;
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
-	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
-		exits = true;
+		return true;
 	}
-	mutex->unlockMutex();
+	return false;
-	return exits;
+}
+
+size_t HealthTable::getPrintSize() {
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
+    uint32_t size = healthMap.size() * sizeof(object_id_t) +
+            sizeof(HasHealthIF::HealthState) + sizeof(uint16_t);
+    return size;
 }
 
 void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-	mutex->lockMutex(MutexIF::BLOCKING);
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter::serialize(&count,
+	SerializeAdapter::serialize(&count,
 			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-	HealthMap::iterator iter;
+	for (const auto& health: healthMap) {
-	for (iter = healthMap.begin();
+		SerializeAdapter::serialize(&health.first,
-			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
-			++iter) {
-		result = SerializeAdapter::serialize(&iter->first,
 				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-		uint8_t health = iter->second;
+		uint8_t healthValue = health.second;
-		result = SerializeAdapter::serialize(&health, &pointer, &size,
+		SerializeAdapter::serialize(&healthValue, &pointer, &size,
 				maxSize, SerializeIF::Endianness::BIG);
 	}
-	mutex->unlockMutex();
 }
 
-ReturnValue_t HealthTable::iterate(
+ReturnValue_t HealthTable::iterate(HealthEntry *value, bool reset) {
-		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
@@ -94,7 +90,5 @@ ReturnValue_t HealthTable::iterate(
 	}
 	*value = *mapIterator;
 	mapIterator++;
-	mutex->unlockMutex();
-
 	return result;
 }

health/HealthTable.h

@@ -1,35 +1,47 @@
-#ifndef HEALTHTABLE_H_
+#ifndef FSFW_HEALTH_HEALTHTABLE_H_
-#define HEALTHTABLE_H_
+#define FSFW_HEALTH_HEALTHTABLE_H_
 
 #include "HealthTableIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../ipc/MutexIF.h"
 #include <map>
 
-typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
 
 class HealthTable: public HealthTableIF, public SystemObject {
 public:
 	HealthTable(object_id_t objectid);
 	virtual ~HealthTable();
 
-	virtual ReturnValue_t registerObject(object_id_t object,
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
 
-	virtual bool hasHealth(object_id_t object);
+    /** HealthTableIF overrides */
-	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
+    virtual ReturnValue_t registerObject(object_id_t object,
-	virtual HasHealthIF::HealthState getHealth(object_id_t);
+            HasHealthIF::HealthState initilialState =
+            HasHealthIF::HEALTHY) override;
+    virtual size_t getPrintSize() override;
+    virtual void printAll(uint8_t *pointer, size_t maxSize) override;
 
-	virtual uint32_t getPrintSize();
+	/** ManagesHealthIF overrides */
-	virtual void printAll(uint8_t *pointer, size_t maxSize);
+	virtual bool hasHealth(object_id_t object) override;
+	virtual void setHealth(object_id_t object,
+	        HasHealthIF::HealthState newState) override;
+	virtual HasHealthIF::HealthState getHealth(object_id_t) override;
 
 protected:
+	using HealthMap = std::map<object_id_t, HasHealthIF::HealthState>;
+	using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
+
 	MutexIF* mutex;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t mutexTimeoutMs = 20;
+
 	HealthMap healthMap;
 
 	HealthMap::iterator mapIterator;
 
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
+	virtual ReturnValue_t iterate(
+	        HealthEntry* value,
+	        bool reset = false) override;
 };
 
-#endif /* HEALTHTABLE_H_ */
+#endif /* FSFW_HEALTH_HEALTHTABLE_H_ */

health/HealthTableIF.h

@@ -1,26 +1,24 @@
-#ifndef HEALTHTABLEIF_H_
+#ifndef FSFW_HEALTH_HEALTHTABLEIF_H_
-#define HEALTHTABLEIF_H_
+#define FSFW_HEALTH_HEALTHTABLEIF_H_
 
 #include "ManagesHealthIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <map>
-
 
 class HealthTableIF: public ManagesHealthIF {
-	friend class HealthCommandingService;
 public:
-	virtual ~HealthTableIF() {
+	virtual ~HealthTableIF() {}
-	}
 
 	virtual ReturnValue_t registerObject(object_id_t object,
 			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
 
-	virtual uint32_t getPrintSize() = 0;
+	virtual size_t getPrintSize() = 0;
 	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
 
 protected:
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
+	virtual ReturnValue_t iterate(
+	        std::pair<object_id_t,HasHealthIF::HealthState> *value,
+	        bool reset = false) = 0;
 };
 
-#endif /* HEALTHTABLEIF_H_ */
+#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */

health/ManagesHealthIF.h

@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+#ifndef FSFW_HEALTH_MANAGESHEALTHIF_H_
-#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+#define FSFW_HEALTH_MANAGESHEALTHIF_H_
 
 #include "HasHealthIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
+
 class ManagesHealthIF {
 public:
 	virtual ~ManagesHealthIF() {
@@ -49,4 +50,4 @@ public:
 	}
 };
 
-#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
+#endif /* FSFW_HEALTH_MANAGESHEALTHIF_H_ */

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/host/QueueFactory.cpp

@@ -1,6 +1,11 @@
+
+#include "MessageQueue.h"
+
+#include "../../ipc/MessageQueueSenderIF.h"
+#include "../../ipc/MessageQueueMessageIF.h"
 #include "../../ipc/QueueFactory.h"
-#include "../../osal/host/MessageQueue.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
+
 #include <cstring>
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;

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);

osal/windows/TcWinUdpPollingTask.cpp

@@ -0,0 +1,148 @@
+#include "TcWinUdpPollingTask.h"
+#include "../../globalfunctions/arrayprinter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+#include <winsock2.h>
+#include <windows.h>
+
+TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
+		object_id_t tmtcUnixUdpBridge, size_t frameSize,
+		double timeoutSeconds): SystemObject(objectId),
+		tmtcBridgeId(tmtcUnixUdpBridge) {
+	if(frameSize > 0) {
+		this->frameSize = frameSize;
+	}
+	else {
+		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
+	}
+
+	// Set up reception buffer with specified frame size.
+	// For now, it is assumed that only one frame is held in the buffer!
+	receptionBuffer.reserve(this->frameSize);
+	receptionBuffer.resize(this->frameSize);
+
+	if(timeoutSeconds == -1) {
+		receptionTimeout = DEFAULT_TIMEOUT;
+	}
+	else {
+		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
+	}
+}
+
+TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
+
+ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new UDP datagrams in permanent loop.
+	while(true) {
+		//! Sender Address is cached here.
+		struct sockaddr_in senderAddress;
+		int senderAddressSize = sizeof(senderAddress);
+		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+				reinterpret_cast<char*>(receptionBuffer.data()), frameSize,
+				receptionFlags, reinterpret_cast<sockaddr*>(&senderAddress),
+				&senderAddressSize);
+		if(bytesReceived == SOCKET_ERROR) {
+			// handle error
+			sif::error << "TcWinUdpPollingTask::performOperation: Reception"
+					" error." << std::endl;
+			handleReadError();
+			continue;
+		}
+		//sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived
+		//		<< " bytes received" << std::endl;
+
+		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+
+		}
+		tmtcBridge->registerCommConnect();
+		tmtcBridge->checkAndSetClientAddress(senderAddress);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::error << "Packet size: " << bytesRead << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	TmTcMessage message(storeId);
+
+	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Serial Polling: Sending message to queue failed"
+				<< std::endl;
+		tcStore->deleteData(storeId);
+	}
+	return result;
+}
+
+ReturnValue_t TcWinUdpPollingTask::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	if (tcStore == nullptr) {
+		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	tmtcBridge = objectManager->get<TmTcWinUdpBridge>(tmtcBridgeId);
+	if(tmtcBridge == nullptr) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+				" TMTC bridge object!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	serverUdpSocket = tmtcBridge->serverSocket;
+	//sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket "
+	//        << serverUdpSocket << std::endl;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcWinUdpPollingTask::initializeAfterTaskCreation() {
+	// Initialize the destination after task creation. This ensures
+	// that the destination has already been set in the TMTC bridge.
+	targetTcDestination = tmtcBridge->getRequestQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
+	DWORD timeoutMs = timeoutSeconds * 1000.0;
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+				"receive timeout failed with " << strerror(errno) << std::endl;
+	}
+}
+
+void TcWinUdpPollingTask::handleReadError() {
+    int error = WSAGetLastError();
+    switch(error) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    case(WSAEFAULT): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSADEFAULT: "
+                << "Bad address " << std::endl;
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleReadError: Error code: "
+                << error << std::endl;
+        break;
+    }
+    }
+    // to prevent spam.
+    Sleep(1000);
+}

osal/windows/TcWinUdpPollingTask.h

@@ -0,0 +1,67 @@
+#ifndef FSFW_OSAL_WINDOWS_TCSOCKETPOLLINGTASK_H_
+#define FSFW_OSAL_WINDOWS_TCSOCKETPOLLINGTASK_H_
+
+#include "TmTcWinUdpBridge.h"
+#include "../../objectmanager/SystemObject.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+
+#include <vector>
+
+/**
+ * @brief 	This class can be used to implement the polling of a Unix socket,
+ * 			using UDP for now.
+ * @details
+ * The task will be blocked while the specified number of bytes has not been
+ * received, so TC reception is handled inside a separate task.
+ * This class caches the IP address of the sender. It is assumed there
+ * is only one sender for now.
+ */
+class TcWinUdpPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+	friend class TmTcWinUdpBridge;
+public:
+	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
+	//! 0.5  default milliseconds timeout for now.
+	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
+
+	TcWinUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
+	virtual~ TcWinUdpPollingTask();
+
+	/**
+	 * Turn on optional timeout for UDP polling. In the default mode,
+	 * the receive function will block until a packet is received.
+	 * @param timeoutSeconds
+	 */
+	void setTimeout(double timeoutSeconds);
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t initialize() override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+	StorageManagerIF* tcStore = nullptr;
+
+private:
+	//! TMTC bridge is cached.
+	object_id_t tmtcBridgeId = objects::NO_OBJECT;
+	TmTcWinUdpBridge* tmtcBridge = nullptr;
+	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
+	//! Reception flags: https://linux.die.net/man/2/recvfrom.
+	int receptionFlags = 0;
+
+	//! Server socket, which is member of TMTC bridge and is assigned in
+	//! constructor
+	SOCKET serverUdpSocket = 0;
+
+	std::vector<uint8_t> receptionBuffer;
+
+	size_t frameSize = 0;
+	timeval receptionTimeout;
+
+	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
+	void handleReadError();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */

osal/windows/TmTcWinUdpBridge.cpp

@@ -0,0 +1,176 @@
+#include <fsfw/ipc/MutexHelper.h>
+#include "TmTcWinUdpBridge.h"
+
+TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
+        object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
+        uint16_t serverPort, uint16_t clientPort):
+        TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
+    mutex = MutexFactory::instance()->createMutex();
+
+    // Initiates Winsock DLL.
+    WSAData wsaData;
+    WORD wVersionRequested = MAKEWORD(2, 2);
+    int err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0) {
+        /* Tell the user that we could not find a usable */
+        /* Winsock DLL.                                  */
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
+                "WSAStartup failed with error: " << err << std::endl;
+        return;
+    }
+
+    uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
+    if(serverPort != 0xFFFF) {
+        setServerPort = serverPort;
+    }
+
+    uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+    if(clientPort != 0xFFFF) {
+        setClientPort = clientPort;
+    }
+
+    // Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
+    //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
+    serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if(serverSocket == INVALID_SOCKET) {
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
+                " UDP socket!" << std::endl;
+        handleSocketError();
+        return;
+    }
+
+    serverAddress.sin_family = AF_INET;
+
+    // Accept packets from any interface. (potentially insecure).
+    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+    serverAddress.sin_port = htons(setServerPort);
+    serverAddressLen = sizeof(serverAddress);
+    setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
+            reinterpret_cast<const char*>(&serverSocketOptions),
+            sizeof(serverSocketOptions));
+
+    clientAddress.sin_family = AF_INET;
+    clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+    clientAddress.sin_port = htons(setClientPort);
+    clientAddressLen = sizeof(clientAddress);
+
+    int result = bind(serverSocket,
+            reinterpret_cast<struct sockaddr*>(&serverAddress),
+            serverAddressLen);
+    if(result != 0) {
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
+                "local port " << setServerPort << " to server socket!"
+                << std::endl;
+        handleBindError();
+    }
+}
+
+TmTcWinUdpBridge::~TmTcWinUdpBridge() {
+    WSACleanup();
+}
+
+ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+    int flags = 0;
+
+    //clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+    //clientAddressLen = sizeof(serverAddress);
+
+//  char ipAddress [15];
+//  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//                  &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+    ssize_t bytesSent = sendto(serverSocket,
+            reinterpret_cast<const char*>(data), dataLen, flags,
+            reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+    if(bytesSent == SOCKET_ERROR) {
+        sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
+                << std::endl;
+        handleSendError();
+    }
+//  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//          " sent." << std::endl;
+    return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+    MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+
+//  char ipAddress [15];
+//  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//          &newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//  sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
+//          &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+    // Set new IP address if it has changed.
+    if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+        clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+        clientAddressLen = sizeof(clientAddress);
+    }
+}
+
+void TmTcWinUdpBridge::handleSocketError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+         */
+        sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
+}
+
+void TmTcWinUdpBridge::handleBindError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+        */
+        sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
+}
+
+void TmTcWinUdpBridge::handleSendError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    case(WSAEADDRNOTAVAIL): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSAEADDRNOTAVAIL: "
+                << "Check target address. " << std::endl;
+        break;
+    }
+    default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+        */
+        sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
+}
+

osal/windows/TmTcWinUdpBridge.h

@@ -0,0 +1,49 @@
+#ifndef FSFW_OSAL_WINDOWS_TMTCWINUDPBRIDGE_H_
+#define FSFW_OSAL_WINDOWS_TMTCWINUDPBRIDGE_H_
+
+#include "../../tmtcservices/TmTcBridge.h"
+
+#include <winsock2.h>
+#include <windows.h>
+
+class TmTcWinUdpBridge: public TmTcBridge {
+    friend class TcWinUdpPollingTask;
+public:
+    // The ports chosen here should not be used by any other process.
+    static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
+    static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
+
+    TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
+            object_id_t tmStoreId, object_id_t tcStoreId,
+            uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+    virtual~ TmTcWinUdpBridge();
+
+    void checkAndSetClientAddress(sockaddr_in clientAddress);
+
+protected:
+    virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+
+private:
+    SOCKET serverSocket = 0;
+
+    const int serverSocketOptions = 0;
+
+    struct sockaddr_in clientAddress;
+    int clientAddressLen = 0;
+
+    struct sockaddr_in serverAddress;
+    int serverAddressLen = 0;
+
+    //! Access to the client address is mutex protected as it is set
+    //! by another task.
+    MutexIF* mutex;
+
+    void handleSocketError();
+    void handleBindError();
+    void handleSendError();
+};
+
+
+
+#endif /* FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_ */
+

returnvalues/HasReturnvaluesIF.h

@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#ifndef FSFW_RETURNVALUES_HASRETURNVALUESIF_H_
-#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FSFW_RETURNVALUES_HASRETURNVALUESIF_H_
 
 #include "FwClassIds.h"
-#include <config/returnvalues/classIds.h>
+#include <returnvalues/classIds.h>
 #include <cstdint>
 
 #define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
@@ -15,9 +15,17 @@ public:
 	static const ReturnValue_t RETURN_FAILED = 1;
 	virtual ~HasReturnvaluesIF() {}
 
-	static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
+	/**
-	    return (interfaceId << 8) + number;
+	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
+	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
+	 * @param interfaceId
+	 * @param number
+	 * @return
+	 */
+	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
+			uint8_t number) {
+	    return (static_cast<ReturnValue_t>(interfaceId) << 8) + number;
 	}
 };
 
-#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
+#endif /* FSFW_RETURNVALUES_HASRETURNVALUESIF_H_ */

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_ */

timemanager/CCSDSTime.cpp

@@ -1,8 +1,9 @@
-#include "../timemanager/CCSDSTime.h"
+#include "CCSDSTime.h"
+
 #include <cstdio>
 #include <cinttypes>
 #include <cmath>
-
+#include <FSFWConfig.h>
 
 CCSDSTime::CCSDSTime() {
 }
@@ -158,15 +159,16 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 // Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
 // Suggestion: use uint16 all the time. This should work on all systems.
-#ifdef NEWLIB_NANO_NO_C99_IO
+#if FSFW_NO_C99_IO == 1
 	uint16_t year;
 	uint16_t month;
 	uint16_t day;
 	uint16_t hour;
 	uint16_t minute;
 	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%"
-				&month, &day, &hour, &minute, &second);
+	        "2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &month, &day, &hour,
+	        &minute, &second);
 	if (count == 6) {
 		to->year = year;
 		to->month = month;
@@ -179,12 +181,13 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 
 	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%"
-			&hour, &minute, &second);
+	        "2" SCNu16 ":%fZ", &year, &day, &hour, &minute, &second);
 	if (count == 5) {
 		uint8_t tempDay;
 		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
+				reinterpret_cast<uint8_t *>(&month),
+				reinterpret_cast<uint8_t *>(&tempDay));
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
 		}

timemanager/TimeStamperIF.h

@@ -14,8 +14,12 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
 	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
 
-	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
+	//! This is a mission-specific constant and determines the total
-	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
+	//! size reserved for timestamps.
+	//! TODO: Default define in FSFWConfig ?
+	static const uint8_t MISSION_TIMESTAMP_SIZE = 8;
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer,
+	        const uint8_t maxSize) = 0;
 	virtual ~TimeStamperIF() {}
 };
 

tmtcpacket/SpacePacketBase.cpp

@@ -1,6 +1,6 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "SpacePacketBase.h"
-#include <string.h>
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
 
 SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
 	this->data = (SpacePacketPointer*) set_address;
@@ -14,7 +14,8 @@ uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
 	return (this->data->header.packet_id_h & 0b11100000) >> 5;
 }
 
-void SpacePacketBase::initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
+void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
+		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
 	//reset header to zero:
 	memset(data,0, sizeof(this->data->header) );
 	//Set TC/TM bit.
@@ -81,7 +82,7 @@ void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
 	this->data->header.packet_length_l = ( new_length & 0x00FF );
 }
 
-uint32_t SpacePacketBase::getFullSize() {
+size_t SpacePacketBase::getFullSize() {
 	//+1 is done because size in packet data length field is: size of data field -1
 	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
 }

tmtcpacket/SpacePacketBase.h

@@ -1,10 +1,11 @@
-#ifndef SPACEPACKETBASE_H_
+#ifndef FSFW_TMTCPACKET_SPACEPACKETBASE_H_
-#define SPACEPACKETBASE_H_
+#define FSFW_TMTCPACKET_SPACEPACKETBASE_H_
 
 #include "ccsds_header.h"
+#include <cstddef>
 
 /**
- * \defgroup tmtcpackets Space Packets
+ * @defgroup tmtcpackets Space Packets
  * This is the group, where all classes associated with Telecommand and
  * Telemetry packets belong to.
  * The class hierarchy resembles the dependency between the different standards
@@ -81,7 +82,8 @@ public:
 	 */
 	bool isTelecommand( void );
 
-	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
+	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader,
+	        uint16_t apid, uint16_t sequenceCount = 0);
 	/**
 	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
 	 *  which is checked with this method.
@@ -167,10 +169,10 @@ public:
 	 * This method returns the full raw packet size.
 	 * @return	The full size of the packet in bytes.
 	 */
-	uint32_t getFullSize();
+	size_t getFullSize();
 
 	uint32_t getApidAndSequenceCount() const;
 
 };
 
-#endif /* SPACEPACKETBASE_H_ */
+#endif /* FSFW_TMTCPACKET_SPACEPACKETBASE_H_ */

tmtcpacket/pus/PacketTimestampInterpreterIF.h

@@ -7,7 +7,8 @@ class TmPacketMinimal;
 class PacketTimestampInterpreterIF {
 public:
 	virtual ~PacketTimestampInterpreterIF() {}
-	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
+	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet,
+	        timeval* timestamp) const = 0;
 	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
 };
 

tmtcpacket/pus/TcPacketBase.cpp

@@ -1,11 +1,14 @@
-#include "../../globalfunctions/CRC.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "TcPacketBase.h"
-#include <string.h>
 
-TcPacketBase::TcPacketBase(const uint8_t* set_data) :
+#include "../../globalfunctions/CRC.h"
-		SpacePacketBase(set_data) {
+#include "../../globalfunctions/arrayprinter.h"
-	tcData = (TcPacketPointer*) set_data;
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+#include <cstring>
+
+TcPacketBase::TcPacketBase(const uint8_t* setData) :
+		SpacePacketBase(setData) {
+	tcData = reinterpret_cast<TcPacketPointer*>(const_cast<uint8_t*>(setData));
 }
 
 TcPacketBase::~TcPacketBase() {
@@ -13,28 +16,28 @@ TcPacketBase::~TcPacketBase() {
 }
 
 uint8_t TcPacketBase::getService() {
-	return tcData->data_field.service_type;
+	return tcData->dataField.service_type;
 }
 
 uint8_t TcPacketBase::getSubService() {
-	return tcData->data_field.service_subtype;
+	return tcData->dataField.service_subtype;
 }
 
 uint8_t TcPacketBase::getAcknowledgeFlags() {
-	return tcData->data_field.version_type_ack & 0b00001111;
+	return tcData->dataField.version_type_ack & 0b00001111;
 }
 
 const uint8_t* TcPacketBase::getApplicationData() const {
-	return &tcData->data;
+	return &tcData->appData;
 }
 
 uint16_t TcPacketBase::getApplicationDataSize() {
-	return getPacketDataLength() - sizeof(tcData->data_field) - CRC_SIZE + 1;
+	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
 }
 
 uint16_t TcPacketBase::getErrorControl() {
 	uint16_t size = getApplicationDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tcData->data;
+	uint8_t* p_to_buffer = &tcData->appData;
 	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
 }
 
@@ -42,41 +45,42 @@ void TcPacketBase::setErrorControl() {
 	uint32_t full_size = getFullSize();
 	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
 	uint32_t size = getApplicationDataSize();
-	(&tcData->data)[size] = (crc & 0XFF00) >> 8;	// CRCH
+	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
-	(&tcData->data)[size + 1] = (crc) & 0X00FF; 		// CRCL
+	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
 }
 
-void TcPacketBase::setData(const uint8_t* p_Data) {
+void TcPacketBase::setData(const uint8_t* pData) {
-	SpacePacketBase::setData(p_Data);
+	SpacePacketBase::setData(pData);
-	tcData = (TcPacketPointer*) p_Data;
+	tcData = (TcPacketPointer*) pData;
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
-	return (tcData->data_field.version_type_ack & 0b10000000) >> 7;
+	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
 }
 
 uint8_t TcPacketBase::getPusVersionNumber() {
-	return (tcData->data_field.version_type_ack & 0b01110000) >> 4;
+	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
 }
 
 void TcPacketBase::print() {
-	uint8_t * wholeData = getWholeData();
+    sif::debug << "TcPacketBase::print: " << std::endl;
-	sif::debug << "TcPacket contains: " << std::endl;
+	arrayprinter::print(getWholeData(), getFullSize());
-	for (uint8_t count = 0; count < getFullSize(); ++count) {
-		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
 }
 
 void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
-		uint8_t ack, uint8_t service, uint8_t subservice) {
+        uint8_t ack, uint8_t service, uint8_t subservice) {
 	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->data_field, 0, sizeof(tcData->data_field));
+	std::memset(&tcData->dataField, 0, sizeof(tcData->dataField));
-	setPacketDataLength(sizeof(tcData->data_field) + CRC_SIZE);
+	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	//Data Field Header:
-	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	//Set CCSDS_secondary_header_flag to 0 and version number to 001
-	tcData->data_field.version_type_ack = 0b00010000;
+	tcData->dataField.version_type_ack = 0b00010000;
-	tcData->data_field.version_type_ack |= (ack & 0x0F);
+	tcData->dataField.version_type_ack |= (ack & 0x0F);
-	tcData->data_field.service_type = service;
+	tcData->dataField.service_type = service;
-	tcData->data_field.service_subtype = subservice;
+	tcData->dataField.service_subtype = subservice;
+}
+
+size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
+	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
+			appDataLen + TcPacketBase::CRC_SIZE;
 }

tmtcpacket/pus/TcPacketBase.h

@@ -1,7 +1,9 @@
-#ifndef TCPACKETBASE_H_
+#ifndef TMTCPACKET_PUS_TCPACKETBASE_H_
-#define TCPACKETBASE_H_
+#define TMTCPACKET_PUS_TCPACKETBASE_H_
 
 #include "../../tmtcpacket/SpacePacketBase.h"
+#include <cstddef>
+
 
 /**
  * This struct defines a byte-wise structured PUS TC Data Field Header.
@@ -23,14 +25,14 @@ struct PUSTcDataFieldHeader {
  */
 struct TcPacketPointer {
 	CCSDSPrimaryHeader primary;
-	PUSTcDataFieldHeader data_field;
+	PUSTcDataFieldHeader dataField;
-	uint8_t data;
+	uint8_t appData;
 };
 
 /**
  * This class is the basic data handler for any ECSS PUS Telecommand packet.
  *
- * In addition to \SpacePacketBase, the class provides methods to handle
+ * In addition to #SpacePacketBase, the class provides methods to handle
  * the standardized entries of the PUS TC Packet Data Field Header.
  * It does not contain the packet data itself but a pointer to the
  * data must be set on instantiation. An invalid pointer may cause
@@ -39,67 +41,38 @@ struct TcPacketPointer {
  * @ingroup tmtcpackets
  */
 class TcPacketBase : public SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TcPacketPointer* tcData;
 public:
-	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
+	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) +
-	/**
+	        sizeof(PUSTcDataFieldHeader) + 2);
-	 * With this constant for the acknowledge field responses on all levels are expected.
+
-	 */
+	enum AckField {
-	static const uint8_t ACK_ALL = 0b1111;
+		//! No acknowledgements are expected.
-	/**
+		ACK_NONE = 0b0000,
-	 * With this constant for the acknowledge field a response on acceptance is expected.
+		//! Acknowledgements on acceptance are expected.
-	 */
+		ACK_ACCEPTANCE = 0b0001,
-	static const uint8_t ACK_ACCEPTANCE = 0b0001;
+		//! Acknowledgements on start are expected.
-	/**
+		ACK_START = 0b0010,
-	 * With this constant for the acknowledge field a response on start of execution is expected.
+		//! Acknowledgements on step are expected.
-	 */
+		ACK_STEP = 0b0100,
-	static const uint8_t ACK_START = 0b0010;
+		//! Acknowledfgement on completion are expected.
-	/**
+		ACK_COMPLETION = 0b1000
-	 * With this constant for the acknowledge field responses on execution steps are expected.
+	};
-	 */
+
-	static const uint8_t ACK_STEP = 0b0100;
+	static constexpr uint8_t ACK_ALL = ACK_ACCEPTANCE | ACK_START | ACK_STEP |
-	/**
+			ACK_COMPLETION;
-	 * With this constant for the acknowledge field a response on completion is expected.
+
-	 */
-	static const uint8_t ACK_COMPLETION = 0b1000;
-	/**
-	 * With this constant for the acknowledge field no responses are expected.
-	 */
-	static const uint8_t ACK_NONE = 0b000;
 	/**
 	 * This is the default constructor.
 	 * It sets its internal data pointer to the address passed and also
 	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
+	 * @param setData	The position where the packet data lies.
 	 */
-	TcPacketBase( const uint8_t* set_data );
+	TcPacketBase( const uint8_t* setData );
 	/**
 	 * This is the empty default destructor.
 	 */
 	virtual ~TcPacketBase();
-	/**
+
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param sequenceCount Sequence Count in the primary header.
-	 * @param ack Which acknowledeges are expected from the receiver.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack, uint8_t service, uint8_t subservice);
 	/**
 	 * This command returns the CCSDS Secondary Header Flag.
 	 * It shall always be zero for PUS Packets. This is the
@@ -166,22 +139,49 @@ public:
 	 * current content of the packet.
 	 */
 	void setErrorControl();
-	/**
+
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telecommand Packet.
-	 */
-	void setData( const uint8_t* p_data );
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.
 	 */
 	void print();
+	/**
+	 * Calculate full packet length from application data length.
+	 * @param appDataLen
+	 * @return
+	 */
+	static size_t calculateFullPacketLength(size_t appDataLen);
+
+protected:
+    /**
+     * A pointer to a structure which defines the data structure of
+     * the packet's data.
+     *
+     * To be hardware-safe, all elements are of byte size.
+     */
+    TcPacketPointer* tcData;
+
+    /**
+     * Initializes the Tc Packet header.
+     * @param apid APID used.
+     * @param sequenceCount Sequence Count in the primary header.
+     * @param ack Which acknowledeges are expected from the receiver.
+     * @param service   PUS Service
+     * @param subservice PUS Subservice
+     */
+    void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+            uint8_t service, uint8_t subservice);
+
+    /**
+     * With this method, the packet data pointer can be redirected to another
+     * location.
+     * This call overwrites the parent's setData method to set both its
+     * @c tc_data pointer and the parent's @c data pointer.
+     *
+     * @param p_data    A pointer to another PUS Telecommand Packet.
+     */
+    void setData( const uint8_t* pData );
 };
 
 
-#endif /* TCPACKETBASE_H_ */
+#endif /* TMTCPACKET_PUS_TCPACKETBASE_H_ */

tmtcpacket/pus/TcPacketStored.cpp

@@ -1,37 +1,50 @@
+#include "TcPacketStored.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "TcPacketStored.h"
+
-#include <string.h>
+#include <cstring>
+
+StorageManagerIF* TcPacketStored::store = nullptr;
 
 TcPacketStored::TcPacketStored(store_address_t setAddress) :
-		TcPacketBase(NULL), storeAddress(setAddress) {
+		TcPacketBase(nullptr), storeAddress(setAddress) {
-	this->setStoreAddress(this->storeAddress);
+	setStoreAddress(storeAddress);
 }
 
-TcPacketStored::TcPacketStored(uint16_t apid, uint8_t ack, uint8_t service,
+TcPacketStored::TcPacketStored(uint16_t apid,  uint8_t service,
-		uint8_t subservice, uint8_t sequence_count, const uint8_t* data,
+        uint8_t subservice, uint8_t sequenceCount, const uint8_t* data,
-		uint32_t size) :
+		size_t size, uint8_t ack) :
-		TcPacketBase(NULL) {
+		TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!this->checkAndSetStore()) {
+	if (not this->checkAndSetStore()) {
 		return;
 	}
-	uint8_t* p_data = NULL;
+	uint8_t* pData = nullptr;
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
-			(TC_PACKET_MIN_SIZE + size), &p_data);
+			(TC_PACKET_MIN_SIZE + size), &pData);
 	if (returnValue != this->store->RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get free element from store!"
+				<< std::endl;
 		return;
 	}
-	this->setData(p_data);
+	this->setData(pData);
-	initializeTcPacket(apid, sequence_count, ack, service, subservice);
+	initializeTcPacket(apid, sequenceCount, ack, service, subservice);
-	memcpy(&tcData->data, data, size);
+	memcpy(&tcData->appData, data, size);
 	this->setPacketDataLength(
 			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	this->setErrorControl();
 }
 
-TcPacketStored::TcPacketStored() :
+ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
-		TcPacketBase(NULL) {
+		size_t* dataSize) {
+	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+	}
+	return result;
+}
+
+TcPacketStored::TcPacketStored(): TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	this->checkAndSetStore();
 
@@ -40,14 +53,14 @@ TcPacketStored::TcPacketStored() :
 ReturnValue_t TcPacketStored::deletePacket() {
 	ReturnValue_t result = this->store->deleteData(this->storeAddress);
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->setData( NULL);
+	this->setData(nullptr);
 	return result;
 }
 
 bool TcPacketStored::checkAndSetStore() {
-	if (this->store == NULL) {
+	if (this->store == nullptr) {
 		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-		if (this->store == NULL) {
+		if (this->store == nullptr) {
 			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
 					<< std::endl;
 			return false;
@@ -58,17 +71,17 @@ bool TcPacketStored::checkAndSetStore() {
 
 void TcPacketStored::setStoreAddress(store_address_t setAddress) {
 	this->storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
+	const uint8_t* tempData = nullptr;
 	size_t temp_size;
 	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
 	if (this->checkAndSetStore()) {
-		status = this->store->getData(this->storeAddress, &temp_data,
+		status = this->store->getData(this->storeAddress, &tempData,
 				&temp_size);
 	}
 	if (status == StorageManagerIF::RETURN_OK) {
-		this->setData(temp_data);
+		this->setData(tempData);
 	} else {
-		this->setData(NULL);
+		this->setData(nullptr);
 		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	}
 }
@@ -78,7 +91,7 @@ store_address_t TcPacketStored::getStoreAddress() {
 }
 
 bool TcPacketStored::isSizeCorrect() {
-	const uint8_t* temp_data = NULL;
+	const uint8_t* temp_data = nullptr;
 	size_t temp_size;
 	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
 			&temp_size);
@@ -90,8 +103,6 @@ bool TcPacketStored::isSizeCorrect() {
 	return false;
 }
 
-StorageManagerIF* TcPacketStored::store = NULL;
-
 TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
 		TcPacketBase(data) {
 	if (getFullSize() != size) {
@@ -100,7 +111,7 @@ TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
 	if (this->checkAndSetStore()) {
 		ReturnValue_t status = store->addData(&storeAddress, data, size);
 		if (status != HasReturnvaluesIF::RETURN_OK) {
-			this->setData(NULL);
+			this->setData(nullptr);
 		}
 	}
 }

tmtcpacket/pus/TcPacketStored.h

@@ -1,8 +1,8 @@
-#ifndef TCPACKETSTORED_H_
+#ifndef TMTCPACKET_PUS_TCPACKETSTORED_H_
-#define TCPACKETSTORED_H_
+#define TMTCPACKET_PUS_TCPACKETSTORED_H_
 
-#include "../../storagemanager/StorageManagerIF.h"
 #include "TcPacketBase.h"
+#include "../../storagemanager/StorageManagerIF.h"
 
 /**
  *	This class generates a ECSS PUS Telecommand packet within a given
@@ -15,26 +15,6 @@
  *	@ingroup tmtcpackets
  */
 class TcPacketStored : public TcPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TC_STORE.
-	 */
-	static StorageManagerIF* store;
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
 public:
 	/**
 	 * This is a default constructor which does not set the data pointer.
@@ -53,18 +33,20 @@ public:
 	 * a new PUS Telecommand Packet is created there.
 	 * Packet Application Data passed in data is copied into the packet.
 	 * @param apid			Sets the packet's APID field.
-	 * @param ack			Set's the packet's Ack field,
-	 * 		which specifies number and size of verification packets returned
-	 * 		for this command.
 	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the destination service.
+	 *                      This specifies the destination service.
 	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the destination sub-service.
+	 * 		                This specifies the destination sub-service.
-	 * @param sequence_count	Sets the packet's Source Sequence Count field.
+	 * @param sequence_count Sets the packet's Source Sequence Count field.
 	 * @param data		The data to be copied to the Application Data Field.
 	 * @param size		The amount of data to be copied.
+	 * @param ack           Set's the packet's Ack field, which specifies
+	 *                      number of verification packets returned
+     *                      for this command.
 	 */
-	TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service, uint8_t subservice, uint8_t sequence_count = 0, const uint8_t* data = NULL, uint32_t size = 0 );
+	TcPacketStored(uint16_t apid, uint8_t service, uint8_t subservice,
+			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL);
 	/**
 	 * Another constructor to create a TcPacket from a raw packet stream.
 	 * Takes the data and adds it unchecked to the TcStore.
@@ -72,10 +54,19 @@ public:
 	 * @param Size size of the packet.
 	 */
 	TcPacketStored( const uint8_t* data, uint32_t size);
+
+	/**
+	 * Getter function for the raw data.
+	 * @param dataPtr [out] Pointer to the data pointer to set
+	 * @param dataSize [out] Address of size to set.
+	 * @return -@c RETURN_OK if data was retrieved successfully.
+	 */
+	ReturnValue_t getData(const uint8_t ** dataPtr,
+			size_t* dataSize);
 	/**
 	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * @return	The current store address. The (raw) value is
-	 * 			the packet is not linked.
+	 * 			@c StorageManagerIF::INVALID_ADDRESS if the packet is not linked.
 	 */
 	store_address_t getStoreAddress();
 	/**
@@ -99,7 +90,28 @@ public:
 	 * 			store or size is incorrect.
 	 */
 	bool isSizeCorrect();
+
+private:
+    /**
+     * This is a pointer to the store all instances of the class use.
+     * If the store is not yet set (i.e. @c store is NULL), every constructor
+     * call tries to set it and throws an error message in case of failures.
+     * The default store is objects::TC_STORE.
+     */
+    static StorageManagerIF* store;
+    /**
+     * The address where the packet data of the object instance is stored.
+     */
+    store_address_t storeAddress;
+    /**
+     * A helper method to check if a store is assigned to the class.
+     * If not, the method tries to retrieve the store from the global
+     * ObjectManager.
+     * @return  @li @c true if the store is linked or could be created.
+     *          @li @c false otherwise.
+     */
+    bool checkAndSetStore();
 };
 
 
-#endif /* TCPACKETSTORED_H_ */
+#endif /* TMTCPACKET_PUS_TCPACKETSTORED_H_ */

tmtcpacket/pus/TmPacketBase.cpp

@@ -1,13 +1,19 @@
+#include "TmPacketBase.h"
+
 #include "../../globalfunctions/CRC.h"
+#include "../../globalfunctions/arrayprinter.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "TmPacketBase.h"
 #include "../../timemanager/CCSDSTime.h"
-#include <string.h>
 
-TmPacketBase::TmPacketBase(uint8_t* set_data) :
+#include <cstring>
-		SpacePacketBase(set_data) {
+
-	tm_data = (TmPacketPointer*) set_data;
+TimeStamperIF* TmPacketBase::timeStamper = nullptr;
+object_id_t TmPacketBase::timeStamperId = 0;
+
+TmPacketBase::TmPacketBase(uint8_t* setData) :
+		SpacePacketBase(setData) {
+	tmData = reinterpret_cast<TmPacketPointer*>(setData);
 }
 
 TmPacketBase::~TmPacketBase() {
@@ -15,25 +21,25 @@ TmPacketBase::~TmPacketBase() {
 }
 
 uint8_t TmPacketBase::getService() {
-	return tm_data->data_field.service_type;
+	return tmData->data_field.service_type;
 }
 
 uint8_t TmPacketBase::getSubService() {
-	return tm_data->data_field.service_subtype;
+	return tmData->data_field.service_subtype;
 }
 
 uint8_t* TmPacketBase::getSourceData() {
-	return &tm_data->data;
+	return &tmData->data;
 }
 
 uint16_t TmPacketBase::getSourceDataSize() {
-	return getPacketDataLength() - sizeof(tm_data->data_field)
+	return getPacketDataLength() - sizeof(tmData->data_field)
 			- CRC_SIZE + 1;
 }
 
 uint16_t TmPacketBase::getErrorControl() {
 	uint32_t size = getSourceDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tm_data->data;
+	uint8_t* p_to_buffer = &tmData->data;
 	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
 }
 
@@ -47,16 +53,12 @@ void TmPacketBase::setErrorControl() {
 
 void TmPacketBase::setData(const uint8_t* p_Data) {
 	SpacePacketBase::setData(p_Data);
-	tm_data = (TmPacketPointer*) p_Data;
+	tmData = (TmPacketPointer*) p_Data;
 }
 
 void TmPacketBase::print() {
-	/*uint8_t * wholeData = getWholeData();
+	 sif::debug << "TmPacketBase::print: " << std::endl;
-	 debug << "TmPacket contains: " << std::endl;
+	 arrayprinter::print(getWholeData(), getFullSize());
-	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
-	 debug << std::hex << (uint16_t)wholeData[count] << " ";
-	 }
-	 debug << std::dec << std::endl;*/
 }
 
 bool TmPacketBase::checkAndSetStamper() {
@@ -73,32 +75,36 @@ bool TmPacketBase::checkAndSetStamper() {
 
 ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
 	uint32_t tempSize = 0;
-	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
+	return CCSDSTime::convertFromCcsds(timestamp, tmData->data_field.time,
-			&tempSize, sizeof(tm_data->data_field.time));
+			&tempSize, sizeof(tmData->data_field.time));
 }
 
 uint8_t* TmPacketBase::getPacketTimeRaw() const{
-	return tm_data->data_field.time;
+	return tmData->data_field.time;
 
 }
 
-void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
+void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service,
+        uint8_t subservice, uint8_t packetSubcounter) {
 	//Set primary header:
 	initSpacePacketHeader(false, true, apid);
 	//Set data Field Header:
 	//First, set to zero.
-	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
+	memset(&tmData->data_field, 0, sizeof(tmData->data_field));
-	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
+
 	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
-	// The other 4 bits of the first byte are the spacecraft time reference status
+	// The other 4 bits of the first byte are the spacecraft time reference
-	// To change to PUS-C, set 0b00100000
+	// status. To change to PUS-C, set 0b00100000.
-	tm_data->data_field.version_type_ack = 0b00010000;
+    // Set CCSDS_secondary header flag to 0, version number to 001 and ack
-	tm_data->data_field.service_type = service;
+    // to 0000
-	tm_data->data_field.service_subtype = subservice;
+	tmData->data_field.version_type_ack = 0b00010000;
-	tm_data->data_field.subcounter = packetSubcounter;
+	tmData->data_field.service_type = service;
+	tmData->data_field.service_subtype = subservice;
+	tmData->data_field.subcounter = packetSubcounter;
 	//Timestamp packet
 	if (checkAndSetStamper()) {
-		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
+		timeStamper->addTimeStamp(tmData->data_field.time,
+		        sizeof(tmData->data_field.time));
 	}
 }
 
@@ -106,9 +112,6 @@ void TmPacketBase::setSourceDataSize(uint16_t size) {
 	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
 
-uint32_t TmPacketBase::getTimestampSize() const {
+size_t TmPacketBase::getTimestampSize() const {
-	return sizeof(tm_data->data_field.time);
+	return sizeof(tmData->data_field.time);
 }
-
-TimeStamperIF* TmPacketBase::timeStamper = NULL;
-object_id_t TmPacketBase::timeStamperId = 0;

tmtcpacket/pus/TmPacketBase.h

@@ -1,8 +1,8 @@
-#ifndef TMPACKETBASE_H_
+#ifndef TMTCPACKET_PUS_TMPACKETBASE_H_
-#define TMPACKETBASE_H_
+#define TMTCPACKET_PUS_TMPACKETBASE_H_
 
+#include "../SpacePacketBase.h"
 #include "../../timemanager/TimeStamperIF.h"
-#include "../../tmtcpacket/SpacePacketBase.h"
 #include "../../timemanager/Clock.h"
 #include "../../objectmanager/SystemObjectIF.h"
 
@@ -14,7 +14,7 @@ void setStaticFrameworkObjectIds();
  * This struct defines a byte-wise structured PUS TM Data Field Header.
  * Any optional fields in the header must be added or removed here.
  * Currently, no Destination field is present, but an eigth-byte representation
- * for a time tag [TBD].
+ * for a time tag.
  * @ingroup tmtcpackets
  */
 struct PUSTmDataFieldHeader {
@@ -40,7 +40,7 @@ struct TmPacketPointer {
 /**
  * This class is the basic data handler for any ECSS PUS Telemetry packet.
  *
- * In addition to \SpacePacketBase, the class provides methods to handle
+ * In addition to #SpacePacketBase, the class provides methods to handle
  * the standardized entries of the PUS TM Packet Data Field Header.
  * It does not contain the packet data itself but a pointer to the
  * data must be set on instantiation. An invalid pointer may cause
@@ -54,29 +54,27 @@ public:
 	/**
 	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
 	 */
-	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
+	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) +
-	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
+	        sizeof(PUSTmDataFieldHeader) + 2);
-	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
+	//! Maximum size of a TM Packet in this mission.
+	//! TODO: Make this dependant on a config variable.
+	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048;
+	//! First byte of secondary header for PUS-A packets.
+	//! TODO: Maybe also support PUS-C via config?
+	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000;
+
 	/**
 	 * This is the default constructor.
 	 * It sets its internal data pointer to the address passed and also
 	 * forwards the data pointer to the parent SpacePacketBase class.
 	 * @param set_address	The position where the packet data lies.
 	 */
-	TmPacketBase( uint8_t* set_data );
+	TmPacketBase( uint8_t* setData );
 	/**
 	 * This is the empty default destructor.
 	 */
 	virtual ~TmPacketBase();
-	/**
+
-	 * Initializes the Tm Packet header.
-	 * Does set the timestamp (to now), but not the error control field.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
 	/**
 	 * This is a getter for the packet's PUS Service ID, which is the second
 	 * byte of the Data Field Header.
@@ -106,11 +104,14 @@ public:
 	 */
 	uint16_t getSourceDataSize();
 
-	/**
+    /**
-	 * In case data was filled manually (almost never the case).
+     * With this method, the Error Control Field is updated to match the
-	 * @param size Size of source data (without CRC and data filed header!).
+     * current content of the packet. This method is not protected because
-	 */
+     * a recalculation by the user might be necessary when manipulating fields
-	void setSourceDataSize(uint16_t size);
+     * like the sequence count.
+     */
+    void setErrorControl();
+
 	/**
 	 * This getter returns the Error Control Field of the packet.
 	 *
@@ -120,28 +121,15 @@ public:
 	 * @return	The PUS Error Control
 	 */
 	uint16_t getErrorControl();
-	/**
+
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telemetry Packet.
-	 */
-	void setData( const uint8_t* p_Data );
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.
 	 */
 	void print();
 	/**
-	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
+	 * Interprets the "time"-field in the secondary header and returns it in
+	 * timeval format.
 	 * @return Converted timestamp of packet.
 	 */
 	ReturnValue_t getPacketTime(timeval* timestamp) const;
@@ -151,7 +139,7 @@ public:
 	 */
 	uint8_t* getPacketTimeRaw() const;
 
-	uint32_t getTimestampSize() const;
+	size_t getTimestampSize() const;
 
 protected:
 	/**
@@ -160,20 +148,49 @@ protected:
 	 *
 	 * To be hardware-safe, all elements are of byte size.
 	 */
-	TmPacketPointer* tm_data;
+	TmPacketPointer* tmData;
 	/**
 	 * The timeStamper is responsible for adding a timestamp to the packet.
 	 * It is initialized lazy.
 	 */
 	static TimeStamperIF* timeStamper;
+	//! The ID to use when looking for a time stamper.
+	static object_id_t timeStamperId;
 
-	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
+    /**
-	/**
+     * Initializes the Tm Packet header.
-	 * Checks if a time stamper is available and tries to set it if not.
+     * Does set the timestamp (to now), but not the error control field.
-	 * @return Returns false if setting failed.
+     * @param apid APID used.
-	 */
+     * @param service   PUS Service
-	bool checkAndSetStamper();
+     * @param subservice PUS Subservice
+     * @param packetSubcounter Additional subcounter used.
+     */
+    void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice,
+            uint8_t packetSubcounter);
+
+    /**
+     * With this method, the packet data pointer can be redirected to another
+     * location.
+     *
+     * This call overwrites the parent's setData method to set both its
+     * @c tc_data pointer and the parent's @c data pointer.
+     *
+     * @param p_data    A pointer to another PUS Telemetry Packet.
+     */
+    void setData( const uint8_t* pData );
+
+    /**
+     * In case data was filled manually (almost never the case).
+     * @param size Size of source data (without CRC and data filed header!).
+     */
+    void setSourceDataSize(uint16_t size);
+
+    /**
+     * Checks if a time stamper is available and tries to set it if not.
+     * @return Returns false if setting failed.
+     */
+    bool checkAndSetStamper();
 };
 
 
-#endif /* TMPACKETBASE_H_ */
+#endif /* TMTCPACKET_PUS_TMPACKETBASE_H_ */

tmtcpacket/pus/TmPacketStored.cpp

@@ -1,11 +1,16 @@
+#include "TmPacketStored.h"
+
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "TmPacketStored.h"
 #include "../../tmtcservices/TmTcMessage.h"
-#include <string.h>
+
+#include <cstring>
+
+StorageManagerIF *TmPacketStored::store = nullptr;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = nullptr;
 
 TmPacketStored::TmPacketStored(store_address_t setAddress) :
-		TmPacketBase(NULL), storeAddress(setAddress) {
+		TmPacketBase(nullptr), storeAddress(setAddress) {
 	setStoreAddress(storeAddress);
 }
 
@@ -14,10 +19,10 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
+	if (not checkAndSetStore()) {
 		return;
 	}
-	uint8_t *pData = NULL;
+	uint8_t *pData = nullptr;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
@@ -38,7 +43,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		SerializeIF *header) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
+	if (not checkAndSetStore()) {
 		return;
 	}
 	size_t sourceDataSize = 0;
@@ -77,29 +82,29 @@ store_address_t TmPacketStored::getStoreAddress() {
 void TmPacketStored::deletePacket() {
 	store->deleteData(storeAddress);
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	setData(NULL);
+	setData(nullptr);
 }
 
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
+	const uint8_t* tempData = nullptr;
-	size_t temp_size;
+	size_t tempSize;
-	if (!checkAndSetStore()) {
+	if (not checkAndSetStore()) {
 		return;
 	}
-	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
+	ReturnValue_t status = store->getData(storeAddress, &tempData, &tempSize);
 	if (status == StorageManagerIF::RETURN_OK) {
-		setData(temp_data);
+		setData(tempData);
 	} else {
-		setData(NULL);
+		setData(nullptr);
 		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	}
 }
 
 bool TmPacketStored::checkAndSetStore() {
-	if (store == NULL) {
+	if (store == nullptr) {
 		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-		if (store == NULL) {
+		if (store == nullptr) {
 			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
 					<< std::endl;
 			return false;
@@ -108,12 +113,9 @@ bool TmPacketStored::checkAndSetStore() {
 	return true;
 }
 
-StorageManagerIF *TmPacketStored::store = NULL;
-InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
-
 ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		MessageQueueId_t sentFrom, bool doErrorReporting) {
-	if (getWholeData() == NULL) {
+	if (getWholeData() == nullptr) {
 		//SHOULDDO: More decent code.
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -133,11 +135,11 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 }
 
 void TmPacketStored::checkAndReportLostTm() {
-	if (internalErrorReporter == NULL) {
+	if (internalErrorReporter == nullptr) {
 		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
 				objects::INTERNAL_ERROR_REPORTER);
 	}
-	if (internalErrorReporter != NULL) {
+	if (internalErrorReporter != nullptr) {
 		internalErrorReporter->lostTm();
 	}
 }

tmtcpacket/pus/TmPacketStored.h

@@ -1,9 +1,10 @@
-#ifndef TMPACKETSTORED_H_
+#ifndef TMTCPACKET_PUS_TMPACKETSTORED_H_
-#define TMPACKETSTORED_H_
+#define TMTCPACKET_PUS_TMPACKETSTORED_H_
+
+#include "TmPacketBase.h"
 
 #include "../../serialize/SerializeIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "TmPacketBase.h"
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueSenderIF.h"
 
@@ -18,31 +19,6 @@
  *	@ingroup tmtcpackets
  */
 class TmPacketStored : public TmPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TM_STORE.
-	 */
-	static StorageManagerIF* store;
-
-	static InternalErrorReporterIF *internalErrorReporter;
-
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-
-	void checkAndReportLostTm();
 public:
 	/**
 	 * This is a default constructor which does not set the data pointer.
@@ -52,28 +28,38 @@ public:
 	/**
 	 * With this constructor, new space is allocated in the packet store and
 	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet. The Application data is
+	 * Packet Application Data passed in data is copied into the packet.
-	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
+	 * The Application data is passed in two parts, first a header, then a
-	 * Packet from two separate data sources.
+	 * data field. This allows building a Telemetry Packet from two separate
+	 * data sources.
 	 * @param apid			Sets the packet's APID field.
 	 * @param service		Sets the packet's Service ID field.
 	 * 		This specifies the source service.
 	 * @param subservice	Sets the packet's Service Subtype field.
 	 * 		This specifies the source sub-service.
 	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application Data Field
+	 * @param data			The payload data to be copied to the
+	 * 						Application Data Field
 	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be copied in front of data
+	 * @param headerData 	The header Data of the Application field,
+	 * 						 will be copied in front of data
 	 * @param headerSize	The size of the headerDataF
 	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
+			uint32_t size = 0, const uint8_t* headerData = nullptr,
+			uint32_t headerSize = 0);
 	/**
-	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
+	 * Another ctor to directly pass structured content and header data to the
+	 * packet to avoid additional buffers.
 	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter, SerializeIF* content,
+			SerializeIF* header = nullptr);
 	/**
 	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * @return	The current store address. The (raw) value is
+	 * 			@c StorageManagerIF::INVALID_ADDRESS if
 	 * 			the packet is not linked.
 	 */
 	store_address_t getStoreAddress();
@@ -89,8 +75,34 @@ public:
 	 */
 	void setStoreAddress( store_address_t setAddress );
 
-	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
+	ReturnValue_t sendPacket( MessageQueueId_t destination,
+			MessageQueueId_t sentFrom, bool doErrorReporting = true );
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. @c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TM_STORE.
+	 */
+	static StorageManagerIF* store;
+
+	static InternalErrorReporterIF *internalErrorReporter;
+
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	@c true if the store is linked or could be created.
+	 * 			@li @c false otherwise.
+	 */
+	bool checkAndSetStore();
+
+	void checkAndReportLostTm();
 };
 
 
-#endif /* TMPACKETSTORED_H_ */
+#endif /* TMTCPACKET_PUS_TMPACKETSTORED_H_ */

unittest/README.md

@@ -0,0 +1,59 @@
+## FSFW Testing
+This repository contains testing and unit testing components.
+
+[Catch2](https://github.com/catchorg/Catch2) has been used as a framework,
+and these unit tests can only be run on a linux host machine.
+The makefile with default settings creates the unit test binary which can be
+run in the terminal or in eclipse.
+
+### Instructions
+
+To run the fsfw unittests in the project, perform following steps:
+
+1. Copy the testcfg folder  the project root (folder containing the FSFW).
+2. There is a makefile inside the testcfg folder which can be used to have 
+   a starting point to compile the unit tests. Copy that Makefile to the project
+   root
+3. Create a folder named catch2 (can have other name which requires Makefile 
+   adaption) and copy the Catch2 header files there (NOTE: CMake support
+   not enabled yet!)
+   
+### Eclipse CDT settings
+
+The default eclipse terminal has issues displaying the colors used
+when running the unit test binary by catch2. To fix this issue,
+install the ANSI Escape In Console package from the eclipse marketplace.
+
+### GCOV integration
+
+GCOV has been integrated as a code coverage tool.
+It can be enabled by adding `GCOV=1` to the build process as an additional argument.
+Coverage data will be provided in form of .gcno and .gcda files.
+These can be displayed in eclipse by looking
+for a .gcno or .gcda file in the \_obj folder, double-clicking it
+and picking the right source-binary. This will generate 
+information about which lines of a file have run, provided it is open in 
+eclipse.
+
+### LCOV integration
+
+The files generated by GCOV can also be processed by the tool LCOV.
+On ubuntu, the tool can be installed with the following command:
+
+```sh 
+sudo apt-get install lcov
+```` 
+
+After that, the tool can be run by building the unit tests with `GCOV=1`,
+running them at least one time and then executing the `lcov.sh` script.
+
+### Adding unit tests
+
+The catch unit tests are located in unittest/testfw. To add new unit tests,
+add them to the UnitTestCatch.cpp file or add a new source file which
+includes catch.hpp.
+
+For writing basics tests, the [assertion documentation](https://github.com/catchorg/Catch2/blob/master/docs/assertions.md#top)
+or the existing examples are a good guideliens.
+For more advanced tests, refer to the [catch2 documentation](https://github.com/catchorg/Catch2/blob/master/docs/Readme.md#top).
+

unittest/core/CatchDefinitions.cpp

@@ -0,0 +1,11 @@
+#include "CatchDefinitions.h"
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+
+StorageManagerIF* tglob::getIpcStoreHandle() {
+	if(objectManager != nullptr) {
+		return objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	} else {
+		sif::error << "Global object manager uninitialized" << std::endl;
+		return nullptr;
+	}
+}

unittest/core/CatchDefinitions.h

@@ -0,0 +1,21 @@
+#ifndef FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
+#define FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
+
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+
+namespace retval {
+static constexpr int CATCH_OK = static_cast<int>(HasReturnvaluesIF::RETURN_OK);
+static constexpr int CATCH_FAILED = static_cast<int>(HasReturnvaluesIF::RETURN_FAILED);
+}
+
+namespace tconst {
+	static constexpr MessageQueueId_t testQueueId = 42;
+}
+
+namespace tglob {
+	StorageManagerIF* getIpcStoreHandle();
+}
+
+#endif /* FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_ */

unittest/core/CatchRunner.cpp

@@ -0,0 +1,31 @@
+/**
+ * @file 	CatchSource.cpp
+ * @brief 	Source file to compile catch framework.
+ * @details	All tests should be written in other files.
+ * For eclipse console output, install ANSI Escape in Console
+ * from the eclipse market place to get colored characters.
+ */
+
+#ifndef NO_UNIT_TEST_FRAMEWORK
+
+#define CATCH_CONFIG_RUNNER
+#include <catch2/catch.hpp>
+
+#if CUSTOM_UNITTEST_RUNNER == 0
+
+extern int customSetup();
+
+int main( int argc, char* argv[] ) {
+    customSetup();
+
+    // Catch internal function call
+    int result = Catch::Session().run( argc, argv );
+
+    // global clean-up
+    return result;
+}
+
+#endif
+
+
+#endif

unittest/core/CatchSetup.cpp

@@ -0,0 +1,42 @@
+#include "CatchDefinitions.h"
+
+#include <testcfg/cdatapool/dataPoolInit.h>
+#include <testcfg/objects/Factory.h>
+
+
+#ifdef GCOV
+#include <gcov.h>
+#endif
+
+#include "../../objectmanager/ObjectManager.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../datapool/DataPool.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+
+/* Global instantiations normally done in main.cpp */
+/* Initialize Data Pool */
+//namespace glob {
+DataPool dataPool(datapool::dataPoolInit);
+//}
+
+
+namespace sif {
+/* Set up output streams */
+ServiceInterfaceStream debug("DEBUG");
+ServiceInterfaceStream info("INFO");
+ServiceInterfaceStream error("ERROR");
+ServiceInterfaceStream warning("WARNING");
+}
+
+/* Global object manager */
+ObjectManagerIF *objectManager;
+
+int customSetup() {
+    // global setup
+    objectManager = new ObjectManager(Factory::produce);
+    objectManager -> initialize();
+    return 0;
+}
+

unittest/core/core.mk

@@ -0,0 +1,3 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
+
+INCLUDES += $(CURRENTPATH)

unittest/core/printChar.cpp

@@ -0,0 +1,10 @@
+#include <fsfw/unittest/core/printChar.h>
+#include <cstdio>
+
+void printChar(const char* character, bool errStream) {
+	if(errStream) {
+		std::putc(*character, stderr);
+		return;
+	}
+	std::putc(*character, stdout);
+}

unittest/core/printChar.h

@@ -0,0 +1,8 @@
+#ifndef FSFW_UNITTEST_CORE_PRINTCHAR_H_
+#define FSFW_UNITTEST_CORE_PRINTCHAR_H_
+
+
+extern "C" void printChar(const char*, bool errStream);
+
+
+#endif /* FSFW_UNITTEST_CORE_PRINTCHAR_H_ */

unittest/internal/InternalUnitTester.cpp

@@ -0,0 +1,27 @@
+#include "InternalUnitTester.h"
+#include "UnittDefinitions.h"
+
+#include "osal/IntTestMq.h"
+#include "osal/IntTestSemaphore.h"
+#include "osal/IntTestMutex.h"
+#include "serialize/IntTestSerialization.h"
+
+#include <cstdlib>
+
+InternalUnitTester::InternalUnitTester() {}
+
+InternalUnitTester::~InternalUnitTester() {}
+
+ReturnValue_t InternalUnitTester::performTests() {
+	sif::info << "Running internal unit tests.." << std::endl;
+	testserialize::test_serialization();
+	testmq::testMq();
+	testsemaph::testBinSemaph();
+	testsemaph::testCountingSemaph();
+	testmutex::testMutex();
+	sif::info << "Internal unit tests finished." << std::endl;
+	return RETURN_OK;
+}
+
+
+

unittest/internal/InternalUnitTester.h

@@ -0,0 +1,29 @@
+#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
+#define FRAMEWORK_TEST_UNITTESTCLASS_H_
+
+#include "UnittDefinitions.h"
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief	Can be used for internal testing, for example for hardware specific
+ * 			tests which can not be run on a host-machine.
+ *
+ * TODO: A lot of ways to improve this class. A way for tests to subscribe
+ * 		 in this central class would be nice. Right now, this is the class
+ * 		 which simply calls all other tests from other files manually.
+ * 		 Maybe there is a better way..
+ */
+class InternalUnitTester: public HasReturnvaluesIF {
+public:
+	InternalUnitTester();
+	virtual~ InternalUnitTester();
+
+	/**
+	 * Some function which calls all other tests
+	 * @return
+	 */
+	virtual ReturnValue_t performTests();
+};
+
+
+#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */

unittest/internal/UnittDefinitions.cpp

@@ -0,0 +1,7 @@
+#include <fsfw/unittest/internal/UnittDefinitions.h>
+
+ ReturnValue_t unitt::put_error(std::string errorId) {
+	sif::error << "Unit Tester error: Failed at test ID "
+			<< errorId << "\n" << std::flush;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}

unittest/internal/UnittDefinitions.h

@@ -0,0 +1,33 @@
+#ifndef UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
+#define UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <cstdint>
+#include <cstddef>
+
+namespace tv {
+// POD test values
+static const bool tv_bool = true;
+static const uint8_t tv_uint8   {5};
+static const uint16_t tv_uint16 {283};
+static const uint32_t tv_uint32 {929221};
+static const uint64_t tv_uint64 {2929329429};
+
+static const int8_t tv_int8 {-16};
+static const int16_t tv_int16 {-829};
+static const int32_t tv_int32 {-2312};
+
+static const float tv_float {8.2149214};
+static const float tv_sfloat = {-922.2321321};
+static const double tv_double {9.2132142141e8};
+static const double tv_sdouble {-2.2421e19};
+}
+
+namespace unitt {
+ReturnValue_t put_error(std::string errorId);
+}
+
+
+
+#endif /* UNITTEST_INTERNAL_UNITTDEFINITIONS_H_ */

unittest/internal/internal.mk

@@ -0,0 +1,3 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/osal/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/serialize/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)

unittest/internal/osal/IntTestMq.cpp

@@ -0,0 +1,52 @@
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/unittest/internal/osal/IntTestMq.h>
+#include <fsfw/unittest/internal/UnittDefinitions.h>
+
+#include <array>
+
+using retval = HasReturnvaluesIF;
+
+void testmq::testMq() {
+	std::string id = "[testMq]";
+	MessageQueueIF* testSenderMq =
+			QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testSenderMqId = testSenderMq->getId();
+
+	MessageQueueIF* testReceiverMq =
+			QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testReceiverMqId = testReceiverMq->getId();
+	std::array<uint8_t, 20> testData { 0 };
+	testData[0] = 42;
+	MessageQueueMessage testMessage(testData.data(), 1);
+	testSenderMq->setDefaultDestination(testReceiverMqId);
+
+
+	auto result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+	if(result != retval::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	MessageQueueMessage recvMessage;
+	result = testReceiverMq->receiveMessage(&recvMessage);
+	if(result != retval::RETURN_OK or recvMessage.getData()[0] != 42) {
+		unitt::put_error(id);
+	}
+
+	result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+	if(result != retval::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	MessageQueueId_t senderId = 0;
+	result = testReceiverMq->receiveMessage(&recvMessage,&senderId);
+	if(result != retval::RETURN_OK or recvMessage.getData()[0] != 42) {
+		unitt::put_error(id);
+	}
+	if(senderId != testSenderMqId) {
+		unitt::put_error(id);
+	}
+	senderId = testReceiverMq->getLastPartner();
+	if(senderId != testSenderMqId) {
+		unitt::put_error(id);
+	}
+
+}

unittest/internal/osal/IntTestMq.h

@@ -0,0 +1,9 @@
+#ifndef UNITTEST_INTERNAL_INTESTMQ_H_
+#define UNITTEST_INTERNAL_INTESTMQ_H_
+
+namespace testmq {
+void testMq();
+}
+
+
+#endif /* UNITTEST_INTERNAL_INTESTMQ_H_ */

unittest/internal/osal/IntTestMutex.cpp

@@ -0,0 +1,42 @@
+#include "IntTestMutex.h"
+
+#include <fsfw/ipc/MutexFactory.h>
+#include <unittest/internal/UnittDefinitions.h>
+
+#if defined(hosted)
+#include <fsfw/osal/hosted/Mutex.h>
+#include <thread>
+#include <future>
+#endif
+
+
+void testmutex::testMutex() {
+	std::string id = "[testMutex]";
+	MutexIF* mutex = MutexFactory::instance()->createMutex();
+	auto result = mutex->lockMutex(MutexIF::POLLING);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	// timed_mutex from the C++ library specifies undefined behaviour if
+	// the timed mutex is locked twice from the same thread.
+#if defined(hosted)
+	// hold on, this actually worked ? :-D This calls the function from
+	// another thread and stores the returnvalue in a future.
+	auto future = std::async(&MutexIF::lockMutex, mutex, 1);
+	result = future.get();
+#else
+	result = mutex->lockMutex(MutexIF::TimeoutType::WAITING, 1);
+#endif
+	if(result != MutexIF::MUTEX_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	result = mutex->unlockMutex();
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	result = mutex->unlockMutex();
+	if(result != MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX) {
+		unitt::put_error(id);
+	}
+}

unittest/internal/osal/IntTestMutex.h

@@ -0,0 +1,10 @@
+#ifndef UNITTEST_INTERNAL_INTTESTMUTEX_H_
+#define UNITTEST_INTERNAL_INTTESTMUTEX_H_
+
+namespace testmutex {
+void testMutex();
+}
+
+
+
+#endif /* UNITTEST_INTERNAL_INTTESTMUTEX_H_ */

unittest/internal/osal/IntTestSemaphore.cpp

@@ -0,0 +1,160 @@
+#include "IntTestSemaphore.h"
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/timemanager/Stopwatch.h>
+
+
+void testsemaph::testBinSemaph() {
+	std::string id = "[BinSemaphore]";
+	SemaphoreIF* binSemaph =
+			SemaphoreFactory::instance()->createBinarySemaphore();
+	if(binSemaph == nullptr) {
+		return;
+	}
+	testBinSemaphoreImplementation(binSemaph, id);
+	SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+#if defined(freeRTOS)
+	SemaphoreIF* binSemaphUsingTask =
+			SemaphoreFactory::instance()->createBinarySemaphore(1);
+	testBinSemaphoreImplementation(binSemaphUsingTask, id);
+	SemaphoreFactory::instance()->deleteSemaphore(binSemaphUsingTask);
+#endif
+}
+
+
+void testsemaph::testCountingSemaph() {
+	std::string id = "[CountingSemaph]";
+	{
+		// First test: create a binary semaphore by using a counting semaphore.
+		SemaphoreIF* countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(1,1);
+		if(countingSemaph == nullptr) {
+			return;
+		}
+		testBinSemaphoreImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#if defined(freeRTOS)
+		countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(1, 1, 1);
+		testBinSemaphoreImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#endif
+	}
+
+	{
+		// Second test: counting semaphore with count 3 and init count of 3.
+		SemaphoreIF* countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(3,3);
+		testCountingSemaphImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#if defined(freeRTOS)
+		countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(3, 0, 1);
+		uint8_t semaphCount = countingSemaph->getSemaphoreCounter();
+		if(semaphCount != 0) {
+			unitt::put_error(id);
+		}
+		// release 3 times in a row
+		for(int i = 0; i < 3; i++) {
+			auto result = countingSemaph->release();
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				unitt::put_error(id);
+			}
+		}
+		testCountingSemaphImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#endif
+	}
+}
+
+
+void testsemaph::testBinSemaphoreImplementation(SemaphoreIF* binSemaph,
+		std::string id) {
+	uint8_t semaphCount = binSemaph->getSemaphoreCounter();
+	if(semaphCount != 1) {
+		unitt::put_error(id);
+	}
+
+	ReturnValue_t result = binSemaph->release();
+	if(result != SemaphoreIF::SEMAPHORE_NOT_OWNED) {
+		unitt::put_error(id);
+	}
+	result = binSemaph->acquire(SemaphoreIF::BLOCKING);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+
+	// There is not really a point in testing time related, the task
+	// might get interrupted..
+	{
+		//Stopwatch stopwatch(false);
+		result = binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
+		//dur_millis_t time = stopwatch.stop();
+//		if(abs(time - 10) > 2) {
+//		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
+//		            << std::endl;
+//			unitt::put_error(id);
+//		}
+	}
+
+	if(result != SemaphoreIF::SEMAPHORE_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	semaphCount = binSemaph->getSemaphoreCounter();
+	if(semaphCount != 0) {
+		unitt::put_error(id);
+	}
+
+	result = binSemaph->release();
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+}
+
+void testsemaph::testCountingSemaphImplementation(SemaphoreIF* countingSemaph,
+		std::string id) {
+	// check count getter function
+	uint8_t semaphCount = countingSemaph->getSemaphoreCounter();
+	if(semaphCount != 3) {
+		unitt::put_error(id);
+	}
+	ReturnValue_t result = countingSemaph->release();
+	if(result != SemaphoreIF::SEMAPHORE_NOT_OWNED) {
+		unitt::put_error(id);
+	}
+	// acquire 3 times in a row
+	for(int i = 0; i < 3; i++) {
+		result = countingSemaph->acquire(SemaphoreIF::BLOCKING);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			unitt::put_error(id);
+		}
+	}
+
+	{
+		Stopwatch stopwatch(false);
+		// attempt to take when count is 0, measure time
+		result = countingSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
+		dur_millis_t time = stopwatch.stop();
+		if(abs(time - 10) > 1) {
+			unitt::put_error(id);
+		}
+	}
+
+	if(result != SemaphoreIF::SEMAPHORE_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	// release 3 times in a row
+	for(int i = 0; i < 3; i++) {
+		result = countingSemaph->release();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			unitt::put_error(id);
+		}
+	}
+	// assert correct full count
+	if(countingSemaph->getSemaphoreCounter() != 3) {
+		unitt::put_error(id);
+	}
+}

unittest/internal/osal/IntTestSemaphore.h

@@ -0,0 +1,15 @@
+#ifndef UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_
+#define UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_
+class SemaphoreIF;
+#include <string>
+
+namespace testsemaph {
+void testBinSemaph();
+void testBinSemaphoreImplementation(SemaphoreIF* binSemaph, std::string id);
+void testCountingSemaph();
+void testCountingSemaphImplementation(SemaphoreIF* countingSemaph,
+		std::string id);
+}
+
+
+#endif /* UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_ */