Merge remote-tracking branch 'upstream/master' into mueller_TmTcBridge_cherryPicked

devicehandlers/ChildHandlerBase.cpp

@@ -2,15 +2,16 @@
 #include <framework/devicehandlers/ChildHandlerBase.h>
 #include <framework/subsystem/SubsystemBase.h>
 
-ChildHandlerBase::ChildHandlerBase(uint32_t ioBoardAddress,
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
-		object_id_t setObjectId, object_id_t deviceCommunication,
+		object_id_t deviceCommunication, CookieIF * comCookie,
-		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		uint32_t thermalRequestPoolId, uint32_t parent,
-		uint32_t parent, FailureIsolationBase* customFdir, uint32_t cmdQueueSize) :
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
+		DeviceHandlerBase(setObjectId, deviceCommunication, comCookie,
-				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
+				setDeviceSwitch, thermalStatePoolId,thermalRequestPoolId,
-				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
+				(customFdir == nullptr? &childHandlerFdir : customFdir),
-				parent), childHandlerFdir(setObjectId) {
+				cmdQueueSize),
+		parentId(parent), childHandlerFdir(setObjectId) {
 }
 
 ChildHandlerBase::~ChildHandlerBase() {

devicehandlers/ChildHandlerBase.h

@@ -6,12 +6,12 @@
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
-	ChildHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
+	ChildHandlerBase(object_id_t setObjectId,
-			object_id_t deviceCommunication, uint32_t maxDeviceReplyLen,
+			object_id_t deviceCommunication, CookieIF * comCookie,
 			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId, uint32_t parent,
-			FailureIsolationBase* customFdir = NULL,
+			FailureIsolationBase* customFdir = nullptr,
-			uint32_t cmdQueueSize = 20);
+			size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();

devicehandlers/Cookie.h

@@ -1,10 +0,0 @@
-#ifndef COOKIE_H_
-#define COOKIE_H_
-
-class Cookie{
-public:
-	virtual ~Cookie(){}
-};
-
-
-#endif /* COOKIE_H_ */

devicehandlers/CookieIF.h

@@ -0,0 +1,34 @@
+#ifndef COOKIE_H_
+#define COOKIE_H_
+#include <cstdint>
+
+/**
+ * @brief Physical address type
+ */
+typedef std::uint32_t address_t;
+
+/**
+ * @brief 	This datatype is used to identify different connection over a
+ * 			single interface (like RMAP or I2C)
+ * @details
+ * To use this class, implement a communication specific child cookie which
+ * inherits Cookie. Cookie instances are created in config/Factory.cpp by
+ * calling @code{.cpp} CookieIF* childCookie = new ChildCookie(...)
+ * @endcode .
+ *
+ * [not implemented yet]
+ * This cookie is then passed to the child device handlers, which stores the
+ * pointer and passes it to the communication interface functions.
+ *
+ * The cookie can be used to store all kinds of information
+ * about the communication, like slave addresses, communication status,
+ * communication parameters etc.
+ *
+ * @ingroup comm
+ */
+class CookieIF {
+public:
+	virtual ~CookieIF() {};
+};
+
+#endif /* COOKIE_H_ */

devicehandlers/DeviceCommunicationIF.h

@@ -1,63 +1,131 @@
 #ifndef DEVICECOMMUNICATIONIF_H_
 #define DEVICECOMMUNICATIONIF_H_
 
-#include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
+/**
+ * @defgroup interfaces Interfaces
+ * @brief Interfaces for flight software objects
+ */
 
+/**
+ * @defgroup comm Communication
+ * @brief Communication software components.
+ */
+
+/**
+ * @brief This is an interface to decouple device communication from
+ * the device handler to allow reuse of these components.
+ * @details
+ * Documentation: Dissertation Baetz p.138.
+ * It works with the assumption that received data
+ * is polled by a component. There are four generic steps of device communication:
+ *
+ *   1. Send data to a device
+ *   2. Get acknowledgement for sending
+ *   3. Request reading data from a device
+ *   4. Read received data
+ *
+ *  To identify different connection over a single interface can return
+ *  so-called cookies to components.
+ *  The CommunicationMessage message type can be used to extend the
+ *  functionality of the ComIF if a separate polling task is required.
+ *  @ingroup interfaces
+ *  @ingroup comm
+ */
 class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
 
-	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x01);
+	//! Standard Error Codes
-	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x02);
+	//! General protocol error. Define more concrete errors in child handler
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x04);
+	//! If cookie is a null pointer
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CANT_CHANGE_REPLY_LEN = MAKE_RETURN_CODE(0x07);
+	// is this needed if there is no open/close call?
+	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t CANT_CHANGE_REPLY_LEN = MAKE_RETURN_CODE(0x08);
 
-	virtual ~DeviceCommunicationIF() {
+	//! Can be used in readReceivedMessage() if no reply was received.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0xA1);
 
-	}
+	virtual ~DeviceCommunicationIF() {}
 
-	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
-			uint32_t maxReplyLen) = 0;
 
 	/**
-	 * Use an existing cookie to open a connection to a new DeviceCommunication.
+	 * @brief Device specific initialization, using the cookie.
-	 * The previous connection must not be closed.
+	 * @details
-	 * If the returnvalue is not RETURN_OK, the cookie is unchanged and
+	 * The cookie is already prepared in the factory. If the communication
-	 * can be used with the previous connection.
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return - @c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with
+	 * 		     returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
+	 * and communication specific action should be taken (e.g. read nothing
+	 * or read everything).
 	 *
 	 * @param cookie
-	 * @param address
+	 * @param requestLen Size of data to read
-	 * @param maxReplyLen
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
-	 * @return
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-			uint32_t maxReplyLen) = 0;
+			size_t requestLen) = 0;
-
-	virtual void close(Cookie *cookie) = 0;
-
-	//SHOULDDO can data be const?
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
-			uint32_t len) = 0;
-
-	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
-
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
-
-	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
-			uint32_t *size) = 0;
-
-	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address) = 0;
-
-	virtual uint32_t getAddress(Cookie *cookie) = 0;
-
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter) = 0;
-
-	virtual uint32_t getParameter(Cookie *cookie) = 0;
 
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param buffer [out] Set reply here (by using *buffer = ...)
+	 * @param size [out] size pointer to set (by using *size = ...).
+	 * 	           Set to 0 if no reply was received
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * 		   	   0 has the same effect
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+			size_t *size) = 0;
 };
 
 #endif /* DEVICECOMMUNICATIONIF_H_ */

devicehandlers/DeviceHandlerBase.cpp

@@ -1,52 +1,60 @@
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolVariable.h>
-#include <framework/datapool/PoolVector.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/globalfunctions/CRC.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/SubsystemBase.h>
 #include <framework/thermal/ThermalComponentIF.h>
+#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
+
+#include <framework/datapool/DataSet.h>
+#include <framework/datapool/PoolVariable.h>
+#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
+#include <framework/globalfunctions/CRC.h>
+#include <framework/subsystem/SubsystemBase.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+#include <iomanip>
+
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
+		object_id_t deviceCommunication, CookieIF * comCookie,
-		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
+		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance,
-		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
+		size_t cmdQueueSize) :
-		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(
+		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
-				MODE_OFF), submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(
+		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-				maxDeviceReplyLen), wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(
+		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
-				StorageManagerIF::INVALID_ADDRESS), requestedRawTraffic(0), powerSwitcher(
+		deviceThermalStatePoolId(thermalStatePoolId),
-		NULL), IPCStore(NULL), deviceCommunicationId(deviceCommunication), communicationInterface(
+		deviceThermalRequestPoolId(thermalRequestPoolId),
-		NULL), cookie(
+		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		NULL), commandQueue(NULL), deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(
+		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
-				thermalRequestPoolId), healthHelper(this, setObjectId), modeHelper(
+		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-				this), parameterHelper(this), childTransitionFailure(RETURN_OK), ignoreMissedRepliesCount(
+		switchOffWasReported(false), actionHelper(this, nullptr),
-				0), fdirInstance(fdirInstance), hkSwitcher(this), defaultFDIRUsed(
+		childTransitionDelay(5000),
-				fdirInstance == NULL), switchOffWasReported(false),executingTask(NULL), actionHelper(this, NULL), cookieInfo(), ioBoardAddress(
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
-				ioBoardAddress), timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(
+		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
-				_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(
-				setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			CommandMessage::MAX_MESSAGE_SIZE);
-	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
-	if (this->fdirInstance == NULL) {
+	cookieInfo.state = COOKIE_UNUSED;
+	cookieInfo.pendingCommand = deviceCommandMap.end();
+	if (comCookie == nullptr) {
+		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex <<
+				std::setw(8) << std::setfill('0') << this->getObjectId() <<
+				std::dec << ": Do not pass nullptr as a cookie, consider "
+				<< std::setfill(' ') << "passing a dummy cookie instead!" <<
+				std::endl;
+	}
+	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
 				defaultFDIRParentId);
 	}
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	communicationInterface->close(cookie);
+	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -56,7 +64,7 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
 
-	if (counter == 0) {
+	if (getComAction() == SEND_WRITE) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
 		doStateMachine();
@@ -64,11 +72,12 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
+		performOperationHook();
 	}
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
-	switch (getRmapAction()) {
+	switch (getComAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
 			buildInternalCommand();
@@ -91,13 +100,91 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	return RETURN_OK;
 }
 
+ReturnValue_t DeviceHandlerBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	communicationInterface = objectManager->get<DeviceCommunicationIF>(
+			deviceCommunicationId);
+	if (communicationInterface == NULL) {
+		return RETURN_FAILED;
+	}
+
+	result = communicationInterface->initializeInterface(comCookie);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == NULL) {
+		return RETURN_FAILED;
+	}
+
+	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+			AcceptsDeviceResponsesIF>(rawDataReceiverId);
+
+	if (rawReceiver == NULL) {
+		return RETURN_FAILED;
+	}
+
+	defaultRawReceiver = rawReceiver->getDeviceQueue();
+
+	powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+	if (powerSwitcher == NULL) {
+		return RETURN_FAILED;
+	}
+
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = actionHelper.initialize(commandQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = fdirInstance->initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = hkSwitcher.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	fillCommandAndReplyMap();
+
+	//Set temperature target state to NON_OP.
+	DataSet mySet;
+	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+			PoolVariableIF::VAR_WRITE);
+	mySet.read();
+	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+	mySet.commit(PoolVariableIF::VALID);
+
+	return RETURN_OK;
+
+}
+
 void DeviceHandlerBase::decrementDeviceReplyMap() {
 	for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
 			deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
 		if (iter->second.delayCycles != 0) {
 			iter->second.delayCycles--;
 			if (iter->second.delayCycles == 0) {
-				if (iter->second.periodic != 0) {
+				if (iter->second.periodic) {
 					iter->second.delayCycles = iter->second.maxDelayCycles;
 				}
 				replyToReply(iter, TIMEOUT);
@@ -256,55 +343,49 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
+ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
+		uint16_t maxDelayCycles, size_t replyLen, bool periodic,
-		uint8_t periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+		bool hasDifferentReplyId, DeviceCommandId_t replyId) {
-//No need to check, as we may try to insert multiple times.
+	//No need to check, as we may try to insert multiple times.
 	insertInCommandMap(deviceCommand);
 	if (hasDifferentReplyId) {
-		return insertInReplyMap(replyId, maxDelayCycles, periodic);
+		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
 	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, periodic);
+		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
 	}
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, uint8_t periodic) {
+		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
 	info.delayCycles = 0;
+	info.replyLen = replyLen;
 	info.command = deviceCommandMap.end();
-	std::pair<std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator, bool> returnValue;
+	auto resultPair = deviceReplyMap.emplace(replyId, info);
-	returnValue = deviceReplyMap.insert(
+	if (resultPair.second) {
-			std::pair<DeviceCommandId_t, DeviceReplyInfo>(replyId, info));
-	if (returnValue.second) {
 		return RETURN_OK;
 	} else {
 		return RETURN_FAILED;
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandMap(
+ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceCommand) {
-		DeviceCommandId_t deviceCommand) {
 	DeviceCommandInfo info;
 	info.expectedReplies = 0;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
-	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
+	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
-	returnValue = deviceCommandMap.insert(
+	if (resultPair.second) {
-			std::pair<DeviceCommandId_t, DeviceCommandInfo>(deviceCommand,
-					info));
-	if (returnValue.second) {
 		return RETURN_OK;
 	} else {
 		return RETURN_FAILED;
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(
+ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
-		DeviceCommandId_t deviceReply, uint16_t delayCycles,
+		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
-		uint16_t maxDelayCycles, uint8_t periodic) {
 	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
 			deviceReplyMap.find(deviceReply);
 	if (iter == deviceReplyMap.end()) {
@@ -429,7 +510,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 void DeviceHandlerBase::doSendWrite() {
 	if (cookieInfo.state == COOKIE_WRITE_READY) {
 
-		ReturnValue_t result = communicationInterface->sendMessage(cookie,
+		ReturnValue_t result = communicationInterface->sendMessage(comCookie,
 				rawPacket, rawPacketLen);
 
 		if (result == RETURN_OK) {
@@ -450,12 +531,14 @@ void DeviceHandlerBase::doGetWrite() {
 		return;
 	}
 	cookieInfo.state = COOKIE_UNUSED;
-	ReturnValue_t result = communicationInterface->getSendSuccess(cookie);
+	ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
 	if (result == RETURN_OK) {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
-		//We need to distinguish here, because a raw command never expects a reply. (Could be done in eRIRM, but then child implementations need to be careful.
+
+		//We need to distinguish here, because a raw command never expects a reply.
+		//(Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
 	} else {
 		//always generate a failure event, so that FDIR knows what's up
@@ -471,7 +554,17 @@ void DeviceHandlerBase::doGetWrite() {
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
 
-	result = communicationInterface->requestReceiveMessage(cookie);
+	size_t requestLen = 0;
+	if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+		DeviceReplyIter iter = deviceReplyMap.find(
+				cookieInfo.pendingCommand->first);
+		if(iter != deviceReplyMap.end()) {
+			requestLen = iter->second.replyLen;
+		}
+	}
+
+	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
@@ -485,10 +578,10 @@ void DeviceHandlerBase::doSendRead() {
 }
 
 void DeviceHandlerBase::doGetRead() {
-	uint32_t receivedDataLen;
+	size_t receivedDataLen;
 	uint8_t *receivedData;
 	DeviceCommandId_t foundId = 0xFFFFFFFF;
-	uint32_t foundLen = 0;
+	size_t foundLen = 0;
 	ReturnValue_t result;
 
 	if (cookieInfo.state != COOKIE_READ_SENT) {
@@ -498,8 +591,8 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(cookie, &receivedData,
+	result = communicationInterface->readReceivedMessage(comCookie,
-			&receivedDataLen);
+			&receivedData, &receivedDataLen);
 
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -508,7 +601,7 @@ void DeviceHandlerBase::doGetRead() {
 		return;
 	}
 
-	if (receivedDataLen == 0)
+	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
 		return;
 
 	if (wiretappingMode == RAW) {
@@ -539,6 +632,8 @@ void DeviceHandlerBase::doGetRead() {
 				break;
 			case IGNORE_REPLY_DATA:
 				break;
+			case IGNORE_FULL_PACKET:
+				return;
 			default:
 				//We need to wait for timeout.. don't know what command failed and who sent it.
 				replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -560,8 +655,8 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 		uint8_t * *data, uint32_t * len) {
 	size_t lenTmp;
 
-	if (IPCStore == NULL) {
+	if (IPCStore == nullptr) {
-		*data = NULL;
+		*data = nullptr;
 		*len = 0;
 		return RETURN_FAILED;
 	}
@@ -572,90 +667,10 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 	} else {
 		triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
 				storageAddress.raw);
-		*data = NULL;
+		*data = nullptr;
 		*len = 0;
 		return result;
 	}
-
-}
-
-ReturnValue_t DeviceHandlerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	communicationInterface = objectManager->get<DeviceCommunicationIF>(
-			deviceCommunicationId);
-	if (communicationInterface == NULL) {
-		return RETURN_FAILED;
-	}
-
-	result = communicationInterface->open(&cookie, ioBoardAddress,
-			maxDeviceReplyLen);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
-	}
-
-	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-			AcceptsDeviceResponsesIF>(rawDataReceiverId);
-
-	if (rawReceiver == NULL) {
-		return RETURN_FAILED;
-	}
-
-	defaultRawReceiver = rawReceiver->getDeviceQueue();
-
-	powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-	if (powerSwitcher == NULL) {
-		return RETURN_FAILED;
-	}
-
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = actionHelper.initialize(commandQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = fdirInstance->initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = hkSwitcher.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	fillCommandAndReplyMap();
-
-	//Set temperature target state to NON_OP.
-	DataSet mySet;
-	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	mySet.read();
-	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-	mySet.commit(PoolVariableIF::VALID);
-
-	return RETURN_OK;
-
 }
 
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
@@ -687,8 +702,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 }
 
 //Default child implementations
-
+DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
-DeviceHandlerBase::RmapAction_t DeviceHandlerBase::getRmapAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
@@ -727,7 +741,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 
 	if (info->delayCycles != 0) {
 
-		if (info->periodic != 0) {
+		if (info->periodic) {
 			info->delayCycles = info->maxDelayCycles;
 		} else {
 			info->delayCycles = 0;
@@ -748,20 +762,20 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
+//ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
-	DeviceCommunicationIF *newCommunication = objectManager->get<
+//	DeviceCommunicationIF *newCommunication = objectManager->get<
-			DeviceCommunicationIF>(newChannelId);
+//			DeviceCommunicationIF>(newChannelId);
-
+//
-	if (newCommunication != NULL) {
+//	if (newCommunication != NULL) {
-		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
+//		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
-				maxDeviceReplyLen);
+//				maxDeviceReplyLen);
-		if (result != RETURN_OK) {
+//		if (result != RETURN_OK) {
-			return result;
+//			return result;
-		}
+//		}
-		return RETURN_OK;
+//		return RETURN_OK;
-	}
+//	}
-	return RETURN_FAILED;
+//	return RETURN_FAILED;
-}
+//}
 
 void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
@@ -1022,7 +1036,6 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
-	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case DeviceHandlerMessage::CMD_WIRETAPPING:
 		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
@@ -1044,19 +1057,19 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-		if (mode != MODE_OFF) {
+//		if (mode != MODE_OFF) {
-			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-		} else {
+//		} else {
-			result = switchCookieChannel(
+//			result = switchCookieChannel(
-					DeviceHandlerMessage::getIoBoardObjectId(message));
+//					DeviceHandlerMessage::getIoBoardObjectId(message));
-			if (result == RETURN_OK) {
+//			if (result == RETURN_OK) {
-				replyReturnvalueToCommand(RETURN_OK);
+//				replyReturnvalueToCommand(RETURN_OK);
-			} else {
+//			} else {
-				replyReturnvalueToCommand(CANT_SWITCH_IOBOARD);
+//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-			}
+//			}
-		}
+//		}
-		return RETURN_OK;
+//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
@@ -1270,3 +1283,9 @@ void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
+
+// Default implementations empty.
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
+		object_id_t objectId, uint32_t parameter) {}
+
+void DeviceHandlerBase::performOperationHook() {}

devicehandlers/DeviceHandlerIF.h

@@ -8,7 +8,8 @@
 #include <framework/ipc/MessageQueueSenderIF.h>
 
 /**
- * This is the Interface used to communicate with a device handler.
+ * @brief 	This is the Interface used to communicate with a device handler.
+ * @details Includes all expected return values, events and modes.
  *
  */
 class DeviceHandlerIF {
@@ -22,22 +23,62 @@ public:
 	 *
 	 * @details The mode of the device handler must not be confused with the mode the device is in.
 	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
+	 * MODE_ON and MODE_OFF are included in hasModesIF.h
 	 */
-//		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+
-//		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-		static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
+	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-		static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
+	//! The device is powered on and the device handler periodically sends
-		static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
+	//! commands. The commands to be sent are selected by the handler
-		static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
+	//! according to the submode.
-		static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
 	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
 	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
 	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-		static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
+	//! This is a transitional state which can not be commanded.
-		static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
+	//! The device is shut down and ready to be switched off.
-		static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
+	//! After the command to set the switch off has been sent,
-		static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
+	//! the mode changes to @c MODE_WAIT_OFF
-		static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
 	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
@@ -53,11 +94,13 @@ public:
 	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-		static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0);
+
-		static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1);
+	// Standard codes used when building commands.
-		static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2);
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
 	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-		static const ReturnValue_t CANT_SWITCH_IOBOARD = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
 	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
 	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
 	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
@@ -65,50 +108,42 @@ public:
 	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
 	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
-		//standard codes used in scan for reply
+	// Standard codes used in scanForReply
-	//	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
-		static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
-		static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
-		static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
-		static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
 
-		//standard codes used in  interpret device reply
+	// Standard codes used in  interpretDeviceReply
-		static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
-		static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-		static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
-		static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
 
-		//Standard codes used in buildCommandFromCommand
+	// Standard codes used in buildCommandFromCommand
-		static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
-				0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
-		static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =
-				MAKE_RETURN_CODE(0xD1);
 
 	/**
-		 * RMAP Action that will be executed.
+	 * Communication action that will be executed.
 	 *
 	 * This is used by the child class to tell the base class what to do.
 	 */
-		enum RmapAction_t {
+	enum CommunicationAction_t: uint8_t {
-			SEND_WRITE,//!< RMAP send write
+		SEND_WRITE,//!< Send write
-			GET_WRITE, //!< RMAP get write
+		GET_WRITE, //!< Get write
-			SEND_READ, //!< RMAP send read
+		SEND_READ, //!< Send read
-			GET_READ,  //!< RMAP get read
+		GET_READ,  //!< Get read
 		NOTHING    //!< Do nothing.
 	};
+
 	/**
 	 * Default Destructor
 	 */
-	virtual ~DeviceHandlerIF() {
+	virtual ~DeviceHandlerIF() {}
-
-	}
 
 	/**
 	 * This MessageQueue is used to command the device handler.
-	 *
-	 * To command a device handler, a DeviceHandlerCommandMessage can be sent to this Queue.
-	 * The handler replies with a DeviceHandlerCommandMessage containing the DeviceHandlerCommand_t reply.
-	 *
 	 * @return the id of the MessageQueue
 	 */
 	virtual MessageQueueId_t getCommandQueue() const = 0;

devicehandlers/FixedSequenceSlot.cpp

@@ -16,6 +16,5 @@ FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 	handler->setTaskIF(executingTask);
 }
 
-FixedSequenceSlot::~FixedSequenceSlot() {
+FixedSequenceSlot::~FixedSequenceSlot() {}
-}
 

devicehandlers/FixedSequenceSlot.h

@@ -13,35 +13,47 @@
 class PeriodicTaskIF;
 
 /**
- * \brief	This class is the representation of a single polling sequence table entry.
+ * @brief	This class is the representation of a single polling sequence table entry.
  *
- * \details	The PollingSlot class is the representation of a single polling sequence table entry.
+ * @details	The PollingSlot class is the representation of a single polling
+ * 			sequence table entry.
  */
 class FixedSequenceSlot {
 public:
-			FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs, int8_t setSequenceId, PeriodicTaskIF* executingTask );
+	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
+			int8_t setSequenceId, PeriodicTaskIF* executingTask );
 	virtual ~FixedSequenceSlot();
 
 	/**
-	 * \brief	\c handler identifies which device handler object is executed in this slot.
+	 * @brief	Handler identifies which device handler object is executed in this slot.
 	 */
 	ExecutableObjectIF*	handler;
 
 	/**
-	 * \brief	This attribute defines when a device handler object is executed.
+	 * @brief	This attribute defines when a device handler object is executed.
 	 *
-	 * \details	The pollingTime attribute identifies the time the handler is executed in ms. It must be
+	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
-	 * 			smaller than the period length of the polling sequence, what is ensured by automated calculation
+	 * 			It must be smaller than the period length of the polling sequence.
-	 * 			from a database.
 	 */
 	uint32_t	pollingTimeMs;
 
 	/**
-	 * \brief	This value defines the type of device communication.
+	 * @brief	This value defines the type of device communication.
 	 *
-	 * \details	The state of this value decides what communication routine is called in the PST executable or the device handler object.
+	 * @details	The state of this value decides what communication routine is
+	 * 			called in the PST executable or the device handler object.
 	 */
 	uint8_t			opcode;
+
+	/**
+	 * @brief 	Operator overload for the comparison operator to
+	 * 			allow sorting by polling time.
+	 * @param fixedSequenceSlot
+	 * @return
+	 */
+	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
+		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
+	}
 };
 
 

devicehandlers/FixedSlotSequence.cpp

@@ -7,17 +7,12 @@ FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
 }
 
 FixedSlotSequence::~FixedSlotSequence() {
-	std::list<FixedSequenceSlot*>::iterator slotIt;
+	// Call the destructor on each list entry.
-	//Iterate through slotList and delete all entries.
+	slotList.clear();
-	slotIt = this->slotList.begin();
-	while (slotIt != this->slotList.end()) {
-		delete (*slotIt);
-		slotIt++;
-	}
 }
 
 void FixedSlotSequence::executeAndAdvance() {
-	(*this->current)->handler->performOperation((*this->current)->opcode);
+	current->handler->performOperation(current->opcode);
 //	if (returnValue != RETURN_OK) {
 //		this->sendErrorMessage( returnValue );
 //	}
@@ -31,53 +26,50 @@ void FixedSlotSequence::executeAndAdvance() {
 
 uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
 	uint32_t oldTime;
-	std::list<FixedSequenceSlot*>::iterator it;
+	SlotListIter slotListIter = current;
-	it = current;
 	// Get the pollingTimeMs of the current slot object.
-	oldTime = (*it)->pollingTimeMs;
+	oldTime = slotListIter->pollingTimeMs;
 	// Advance to the next object.
-	it++;
+	slotListIter++;
 	// Find the next interval which is not 0.
-	while (it != slotList.end()) {
+	while (slotListIter != slotList.end()) {
-		if (oldTime != (*it)->pollingTimeMs) {
+		if (oldTime != slotListIter->pollingTimeMs) {
-			return (*it)->pollingTimeMs - oldTime;
+			return slotListIter->pollingTimeMs - oldTime;
 		} else {
-			it++;
+			slotListIter++;
 		}
 	}
 	// If the list end is reached (this is definitely an interval != 0),
 	// the interval is calculated by subtracting the remaining time of the PST
 	// and adding the start time of the first handler in the list.
-	it = slotList.begin();
+	slotListIter = slotList.begin();
-	return lengthMs - oldTime + (*it)->pollingTimeMs;
+	return lengthMs - oldTime + slotListIter->pollingTimeMs;
 }
 
 uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
 	uint32_t currentTime;
-	std::list<FixedSequenceSlot*>::iterator it;
+	SlotListIter slotListIter = current;
-	it = current;
 	// Get the pollingTimeMs of the current slot object.
-	currentTime = (*it)->pollingTimeMs;
+	currentTime = slotListIter->pollingTimeMs;
 
 	//if it is the first slot, calculate difference to last slot
-	if (it == slotList.begin()){
+	if (slotListIter == slotList.begin()){
-		return lengthMs - (*(--slotList.end()))->pollingTimeMs + currentTime;
+		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
 	}
 	// get previous slot
-	it--;
+	slotListIter--;
 
-	return currentTime - (*it)->pollingTimeMs;
+	return currentTime - slotListIter->pollingTimeMs;
 }
 
 bool FixedSlotSequence::slotFollowsImmediately() {
-	uint32_t currentTime = (*current)->pollingTimeMs;
+	uint32_t currentTime = current->pollingTimeMs;
-	std::list<FixedSequenceSlot*>::iterator it;
+	SlotListIter fixedSequenceIter = this->current;
-	it = this->current;
 	// Get the pollingTimeMs of the current slot object.
-	if (it == slotList.begin())
+	if (fixedSequenceIter == slotList.begin())
 		return false;
-	it--;
+	fixedSequenceIter--;
-	if ((*it)->pollingTimeMs == currentTime) {
+	if (fixedSequenceIter->pollingTimeMs == currentTime) {
 		return true;
 	} else {
 		return false;
@@ -93,26 +85,30 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+
 	auto slotIt = slotList.begin();
 	uint32_t count = 0;
 	uint32_t time = 0;
 	while (slotIt != slotList.end()) {
-		if ((*slotIt)->handler == NULL) {
+		if (slotIt->handler == nullptr) {
 			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
 					<< std::endl;
 			count++;
-		} else if ((*slotIt)->pollingTimeMs < time) {
+		} else if (slotIt->pollingTimeMs < time) {
 			sif::error << "FixedSlotSequence::initialize: Time: "
-					<< (*slotIt)->pollingTimeMs
+					<< slotIt->pollingTimeMs
 					<< " is smaller than previous with " << time << std::endl;
 			count++;
 		} else {
-			//All ok, print slot.
+			// All ok, print slot.
-//			(*slotIt)->print();
+			//info << "Current slot polling time: " << std::endl;
+			//info << std::dec << slotIt->pollingTimeMs << std::endl;
 		}
-		time = (*slotIt)->pollingTimeMs;
+		time = slotIt->pollingTimeMs;
 		slotIt++;
 	}
+	//info << "Number of elements in slot list: "
+	//	   << slotList.size() << std::endl;
 	if (count > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -121,8 +117,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 
 void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 		int8_t executionStep, PeriodicTaskIF* executingTask) {
-	this->slotList.push_back(
+	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
-			new FixedSequenceSlot(componentId, slotTimeMs, executionStep,
 			executingTask));
 	this->current = slotList.begin();
 }

devicehandlers/FixedSlotSequence.h

@@ -1,9 +1,9 @@
-#ifndef FIXEDSLOTSEQUENCE_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_FIXEDSLOTSEQUENCE_H_
-#define FIXEDSLOTSEQUENCE_H_
+#define FRAMEWORK_DEVICEHANDLERS_FIXEDSLOTSEQUENCE_H_
 
 #include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObject.h>
-#include <list>
+#include <set>
 
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
@@ -24,30 +24,39 @@
  */
 class FixedSlotSequence {
 public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 	/**
-	 * \brief	The constructor of the FixedSlotSequence object.
+	 * @brief	The constructor of the FixedSlotSequence object.
 	 *
-	 * \details	The constructor takes two arguments, the period length and the init function.
+	 * @details	The constructor takes two arguments, the period length and the init function.
 	 *
-	 * \param	setLength	The period length, expressed in ms.
+	 * @param	setLength	The period length, expressed in ms.
 	 */
 	FixedSlotSequence(uint32_t setLengthMs);
 
 	/**
-	 * \brief	The destructor of the FixedSlotSequence object.
+	 * @brief	The destructor of the FixedSlotSequence object.
 	 *
-	 * \details	The destructor frees all allocated memory by iterating through the slotList
+	 * @details	The destructor frees all allocated memory by iterating through the slotList
 	 *  		and deleting all allocated resources.
 	 */
 	virtual ~FixedSlotSequence();
 
 	/**
-	 * \brief	This is a method to add an PollingSlot object to slotList.
+	 * @brief	This is a method to add an PollingSlot object to slotList.
 	 *
-	 * \details	Here, a polling slot object is added to the slot list. It is appended
+	 * @details	Here, a polling slot object is added to the slot list. It is appended
 	 * 			to the end of the list. The list is currently NOT reordered.
 	 * 			Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param Object ID of the object to add
+	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 				   will be called inside the slot period.
+	 * 	@param setSequenceId ID which can be used to distinguish
+	 * 	                     different task operations
+	 * 	@param
+	 * 	@param
 	 */
 	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
 			PeriodicTaskIF* executingTask);
@@ -61,47 +70,59 @@ public:
 	bool slotFollowsImmediately();
 
 	/**
-	 * \brief	This method returns the time until the next software component is invoked.
+	 * @brief	This method returns the time until the next software
+	 * 			component is invoked.
 	 *
-	 * \details	This method is vitally important for the operation of the PST. By fetching the polling time
+	 * @details
-	 * 			of the current slot and that of the next one (or the first one, if the list end is reached)
+	 * This method is vitally important for the operation of the PST.
-	 * 			it calculates and returns the interval in milliseconds within which the handler execution
+	 * By fetching the polling time of the current slot and that of the
-	 * 			shall take place. If the next slot has the same time as the current one, it is ignored until
+	 * next one (or the first one, if the list end is reached)
-	 * 			a slot with different time or the end of the PST is found.
+	 * it calculates and returns the interval in milliseconds within
+	 * which the handler execution shall take place.
+	 * If the next slot has the same time as the current one, it is ignored
+	 * until a slot with different time or the end of the PST is found.
 	 */
 	uint32_t getIntervalToNextSlotMs();
 
 	/**
-	 * \brief	This method returns the time difference between the current slot and the previous slot
+	 * @brief	This method returns the time difference between the current
+	 * 			slot and the previous slot
 	 *
-	 * \details	This method is vitally important for the operation of the PST. By fetching the polling time
+	 * @details
-	 * 			of the current slot and that of the prevous one (or the last one, if the slot is the first one)
+	 * This method is vitally important for the operation of the PST.
-	 * 			it calculates and returns the interval in milliseconds that the handler execution shall be delayed.
+	 * By fetching the polling time of the current slot and that of the previous
+	 * one (or the last one, if the slot is the first one) it calculates and
+	 * returns the interval in milliseconds that the handler execution shall
+	 * be delayed.
 	 */
 	uint32_t getIntervalToPreviousSlotMs();
 
 	/**
-	 * \brief	This method returns the length of this FixedSlotSequence instance.
+	 * @brief	This method returns the length of this FixedSlotSequence instance.
 	 */
 	uint32_t getLengthMs() const;
 
 	/**
-	 * \brief	The method to execute the device handler entered in the current OPUSPollingSlot object.
+	 * @brief	The method to execute the device handler entered in the current
+	 * 			PollingSlot object.
 	 *
-	 * \details	Within this method the device handler object to be executed is chosen by looking up the
+	 * @details
-	 * 			handler address of the current slot in the handlerMap. Either the device handler's
+	 * Within this method the device handler object to be executed is chosen by
-	 * 			talkToInterface or its listenToInterface method is invoked, depending on the isTalking flag
+	 * looking up the handler address of the current slot in the handlerMap.
-	 * 			of the polling slot. After execution the iterator current is increased or, by reaching the
+	 * Either the device handler's talkToInterface or its listenToInterface
+	 * method is invoked, depending on the isTalking flag of the polling slot.
+	 * After execution the iterator current is increased or, by reaching the
 	 * end of slotList, reset to the beginning.
 	 */
 	void executeAndAdvance();
 
 	/**
-	 * \brief	An iterator that indicates the current polling slot to execute.
+	 * @brief	An iterator that indicates the current polling slot to execute.
 	 *
-	 * \details	This is an iterator for slotList and always points to the polling slot which is executed next.
+	 * @details	This is an iterator for slotList and always points to the
+	 * 			polling slot which is executed next.
 	 */
-	std::list<FixedSequenceSlot*>::iterator current;
+	SlotListIter current;
 
 	/**
 	 * Iterate through slotList and check successful creation.
@@ -109,18 +130,21 @@ public:
 	 * @return
 	 */
 	ReturnValue_t checkSequence() const;
+
 protected:
 
 	/**
-	 * \brief	This list contains all OPUSPollingSlot objects, defining order and execution time of the
+	 * @brief	This list contains all PollingSlot objects, defining order and
-	 * 			device handler objects.
+	 * 			execution time of the device handler objects.
 	 *
-	 * \details	The slot list is a std:list object that contains all created OPUSPollingSlot instances.
+	 * @details
-	 * 			They are NOT ordered automatically, so by adding entries, the correct order needs to be ensured.
+	 * The slot list is a std:list object that contains all created
-	 * 			By iterating through this list the polling sequence is executed. Two entries with identical
+	 * PollingSlot instances. They are NOT ordered automatically, so by
-	 * 			polling times are executed immediately one after another.
+	 * adding entries, the correct order needs to be ensured. By iterating
+	 * through this list the polling sequence is executed. Two entries with
+	 * identical polling times are executed immediately one after another.
 	 */
-	std::list<FixedSequenceSlot*> slotList;
+	SlotList slotList;
 
 	uint32_t lengthMs;
 };

ipc/QueueFactory.h

@@ -18,8 +18,8 @@ public:
 	 */
 	static QueueFactory* instance();
 
-	MessageQueueIF* createMessageQueue(uint32_t message_depth = 3,
+	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
-			uint32_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE);
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
 
 	void deleteMessageQueue(MessageQueueIF* queue);
 private:

osal/FreeRTOS/FixedTimeslotTask.cpp

@@ -82,10 +82,10 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 
 void FixedTimeslotTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+	auto slotListIter = pst.current;
 
 	//The start time for the first entry is read.
-	uint32_t intervalMs = (*it)->pollingTimeMs;
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
 	TickType_t interval = pdMS_TO_TICKS(intervalMs);
 
 	TickType_t xLastWakeTime;
@@ -120,4 +120,3 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
 }
-

osal/FreeRTOS/FixedTimeslotTask.h

@@ -5,8 +5,10 @@
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
-#include <FreeRTOS.h>
+extern "C" {
+#include "FreeRTOS.h"
 #include "task.h"
+}
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:

osal/FreeRTOS/QueueFactory.cpp

@@ -25,8 +25,8 @@ QueueFactory::~QueueFactory() {
 }
 
 MessageQueueIF* QueueFactory::createMessageQueue(uint32_t message_depth,
-		uint32_t max_message_size) {
+		size_t maxMessageSize) {
-	return new MessageQueue(message_depth, max_message_size);
+	return new MessageQueue(message_depth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {

osal/linux/FixedTimeslotTask.cpp

@@ -1,10 +1,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <unistd.h>
-#include <limits.h>
-#include <signal.h>
-#include <errno.h>
 #include <framework/osal/linux/FixedTimeslotTask.h>
 
+#include <limits.h>
 
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
@@ -23,7 +20,7 @@ void* FixedTimeslotTask::taskEntryPoint(void* arg) {
 	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
-	return NULL;
+	return nullptr;
 }
 
 ReturnValue_t FixedTimeslotTask::startTask() {

osal/linux/FixedTimeslotTask.h

@@ -8,7 +8,20 @@
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
 public:
-	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t periodMs_);
 	virtual ~FixedTimeslotTask();
 
 	virtual ReturnValue_t startTask();
@@ -17,7 +30,9 @@ public:
 
 	virtual uint32_t getPeriodMs() const;
 
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep);
+
 	virtual ReturnValue_t checkSequence() const;
 
 	/**
@@ -34,11 +49,10 @@ public:
 protected:
 	/**
 	 * @brief	This function holds the main functionality of the thread.
-	 *
+	 * @details
-	 *
+	 * Holding the main functionality of the task, this method is most important.
-	 * @details	Holding the main functionality of the task, this method is most important.
+	 * It links the functionalities provided by FixedSlotSequence with the
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
+	 * OS's System Calls to keep the timing of the periods.
-	 * 			to keep the timing of the periods.
 	 */
 	virtual void taskFunctionality();
 
@@ -46,8 +60,13 @@ private:
 	/**
 	 * @brief	This is the entry point in a new thread.
 	 *
-	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
+	 * @details
-	 * 			Needs a valid pointer to the derived class.
+	 * This method, that is the entry point in the new thread and calls
+	 * taskFunctionality of the child class. Needs a valid pointer to the
+	 * derived class.
+	 *
+	 * The void* returnvalue is not used yet but could be used to return
+	 * arbitrary data.
 	 */
 	static void* taskEntryPoint(void* arg);
 	FixedSlotSequence pst;

osal/linux/MessageQueue.cpp

@@ -1,56 +1,37 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <fcntl.h>           /* For O_* constants */
-#include <sys/stat.h>        /* For mode constants */
-#include <mqueue.h>
-#include <cstring>
-#include <errno.h>
 #include <framework/osal/linux/MessageQueue.h>
 
+#include <fstream>
 
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+#include <fcntl.h>           /* For O_* constants */
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE) {
+#include <sys/stat.h>        /* For mode constants */
+#include <cstring>
+#include <errno.h>
+
+
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
+		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
+		defaultDestination(MessageQueueIF::NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;
 	//Set attributes
 	attributes.mq_curmsgs = 0;
-	attributes.mq_maxmsg = message_depth;
+	attributes.mq_maxmsg = messageDepth;
-	attributes.mq_msgsize = max_message_size;
+	attributes.mq_msgsize = maxMessageSize;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-	//Set the name of the queue
+	//Set the name of the queue. The slash is mandatory!
-	sprintf(name, "/Q%u\n", queueCounter++);
+	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
 
-	//Create a nonblocking queue if the name is available (the queue is Read and
+	// Create a nonblocking queue if the name is available (the queue is read
-	// writable for the owner as well as the group)
+	// and writable for the owner as well as the group)
-	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
-	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
+	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
+	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
 	if (tempId == -1) {
-		//An error occured during open
+		handleError(&attributes, messageDepth);
-		//We need to distinguish if it is caused by an already created queue
-		if (errno == EEXIST) {
-			//There's another queue with the same name
-			//We unlink the other queue
-			int status = mq_unlink(name);
-			if (status != 0) {
-				sif::error << "mq_unlink Failed with status: " << strerror(errno)
-						   << std::endl;
-			} else {
-				//Successful unlinking, try to open again
-				mqd_t tempId = mq_open(name,
-				O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-				S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, &attributes);
-				if (tempId != -1) {
-					//Successful mq_open
-					this->id = tempId;
-					return;
 	}
-			}
+	else {
-		}
-		//Failed either the first time or the second time
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status: "
-				<< strerror(errno) << std::endl;
-	} else {
 		//Successful mq_open call
 		this->id = tempId;
 	}
@@ -69,6 +50,73 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
+		uint32_t messageDepth) {
+	switch(errno) {
+	case(EINVAL): {
+		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
+				" for message size" << std::endl;
+		size_t defaultMqMaxMsg = 0;
+		// Not POSIX conformant, but should work for all UNIX systems.
+		// 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
+			// It is ignored if the executable is run in privileged mode.
+			// Run the unlockRealtime script or grant the mode manually by using:
+			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+
+			// Persistent solution for session:
+			// echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+
+			// Permanent solution:
+			// sudo nano /etc/sysctl.conf
+			// Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			// Apply changes with: sudo sysctl -p
+			sif::error << "MessageQueue::MessageQueue: Default MQ size "
+					<< defaultMqMaxMsg << " is too small for requested size "
+					<< messageDepth << std::endl;
+		}
+		break;
+	}
+	case(EEXIST): {
+		// An error occured during open
+		// We need to distinguish if it is caused by an already created queue
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+													<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		break;
+	}
+
+	default:
+		// Failed either the first time or the second time
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		<< name << std::dec << " failed with status: "
+		<< strerror(errno) << std::endl;
+
+	}
+	return HasReturnvaluesIF::RETURN_FAILED;
+
+
+
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), false);
@@ -108,12 +156,13 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		//Success but no message received
 		return MessageQueueIF::EMPTY;
 	} else {
-		//No message was received. Keep lastPartner anyway, I might send something later.
+		//No message was received. Keep lastPartner anyway, I might send
-		//But still, delete packet content.
+		//something later. But still, delete packet content.
 		memset(message->getData(), 0, message->MAX_DATA_SIZE);
 		switch(errno){
 		case EAGAIN:
-			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages currently on the specified queue.
+			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
+			//currently on the specified queue.
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
@@ -123,9 +172,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * The pointer to the buffer for storing the received message, msg_ptr, is NULL.
+			 * - The pointer to the buffer for storing the received message,
-			 * * The number of bytes requested, msg_len is less than zero.
+			 *   msg_ptr, is NULL.
-			 * * msg_len is anything other than the mq_msgsize of the specified queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't been set in the queue's mq_flags.
+			 * - The number of bytes requested, msg_len is less than zero.
+			 * - msg_len is anything other than the mq_msgsize of the specified
+			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
+			 *   been set in the queue's mq_flags.
 			 */
 			sif::error << "MessageQueue::receive: configuration error "
 					   << strerror(errno)  << std::endl;
@@ -133,8 +185,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		case EMSGSIZE:
 			/*
 			 * This value indicates one of the following:
-			 * * the QNX extended option MQ_READBUF_DYNAMIC hasn't been set, and the given msg_len is shorter than the mq_msgsize for the given queue.
+			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
-			 * * the extended option MQ_READBUF_DYNAMIC has been set, but the given msg_len is too short for the message that would have been received.
+			 *   and the given msg_len is shorter than the mq_msgsize for
+			 *   the given queue.
+			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
+			 *   given msg_len is too short for the message that would have
+			 *   been received.
 			 */
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
@@ -182,9 +238,10 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * mq_attr is NULL.
+			 *  - mq_attr is NULL.
-			 * * MQ_MULT_NOTIFY had been set for this queue, and the given mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once MQ_MULT_NOTIFY has been turned on, it may never be turned off.
+			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
-			 *
+			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
+			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
 			 */
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
@@ -233,7 +290,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	//TODO: Check if we're in ISR.
 	if (result != 0) {
 		if(!ignoreFault){
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
 						objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != NULL) {
 				internalErrorReporter->queueMessageNotSent();
@@ -241,10 +299,13 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		}
 		switch(errno){
 		case EAGAIN:
-			//The O_NONBLOCK flag was set when opening the queue, or the MQ_NONBLOCK flag was set in its attributes, and the specified queue is full.
+			//The O_NONBLOCK flag was set when opening the queue, or the
+			//MQ_NONBLOCK flag was set in its attributes, and the
+			//specified queue is full.
 			return MessageQueueIF::FULL;
 		case EBADF:
-			//mq_des doesn't represent a valid message queue descriptor, or mq_des wasn't opened for writing.
+			//mq_des doesn't represent a valid message queue descriptor,
+			//or mq_des wasn't opened for writing.
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send mqSendTo: " << sendTo
 					   << " sent from " << sentFrom << std::endl;
@@ -254,18 +315,22 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * msg_ptr is NULL.
+			 * - msg_ptr is NULL.
-			 * * msg_len is negative.
+			 * - msg_len is negative.
-			 * * msg_prio is greater than MQ_PRIO_MAX.
+			 * - msg_prio is greater than MQ_PRIO_MAX.
-			 * * msg_prio is less than 0.
+			 * - msg_prio is less than 0.
-			 * * MQ_PRIO_RESTRICT is set in the mq_attr of mq_des,
+			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
-			 *   and msg_prio is greater than the priority of the calling process.
+			 *   msg_prio is greater than the priority of the calling process.
-			 * */
+			 */
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send" << std::endl;
 			/*NO BREAK*/
 		case EMSGSIZE:
-			//The msg_len is greater than the msgsize associated with the specified queue.
+			// The msg_len is greater than the msgsize associated with
+			//the specified queue.
+			sif::error << "MessageQueue::sendMessage: Size error [" <<
+					strerror(errno) << "] in mq_send" << std::endl;
+			/*NO BREAK*/
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}

osal/linux/MessageQueue.h

@@ -4,21 +4,26 @@
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
+
+#include <mqueue.h>
 /**
  * @brief		This class manages sending and receiving of message queue messages.
  *
- *	@details	Message queues are used to pass asynchronous messages between processes.
+ * @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
+ * received messages. Being a child of MessageQueueSender, this class also
- *				methods to send a message to a user-defined or a default destination. In addition
+ * provides methods to send a message to a user-defined or a default destination.
- *				it also provides a reply method to answer to the queue it received its last message
+ * In addition it also provides a reply method to answer to the queue it
- *				from.
+ * received its last message from.
- *				The MessageQueue should be used as "post box" for a single owning object. So all
+ *
- *				message queue communication is "n-to-one".
+ * The MessageQueue should be used as "post box" for a single owning object.
- *				For creating the queue, as well as sending and receiving messages, the class makes
+ * So all message queue communication is "n-to-one".
- *				use of the operating system calls provided.
+ *
- *	\ingroup message_queue
+ * The creation of message queues, as well as sending and receiving messages,
+ * makes use of the operating system calls provided.
+ *	@ingroup message_queue
  */
 class MessageQueue : public MessageQueueIF {
 	friend class MessageQueueSenderIF;
@@ -35,7 +40,8 @@ public:
 	 * @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(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
 	 * @details	This is accomplished by using the delete call provided by the operating system.
@@ -168,6 +174,8 @@ private:
 	char name[5];
 
 	static uint16_t queueCounter;
+
+	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
 
 #endif /* MESSAGEQUEUE_H_ */

osal/linux/PeriodicPosixTask.cpp

@@ -3,9 +3,10 @@
 #include <errno.h>
 #include <framework/osal/linux/PeriodicPosixTask.h>
 
-PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):PosixThread(name_,priority_,stackSize_),objectList(),started(false),periodMs(period_),deadlineMissedFunc(
+PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
-		deadlineMissedFunc_) {
+		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
-
+		PosixThread(name_,priority_,stackSize_),objectList(),started(false),
+		periodMs(period_),deadlineMissedFunc(deadlineMissedFunc_) {
 }
 
 PeriodicPosixTask::~PeriodicPosixTask() {
@@ -37,7 +38,8 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 
 ReturnValue_t PeriodicPosixTask::startTask(void){
 	started = true;
-	createTask(&taskEntryPoint,this);
+	//sif::info << stackSize << std::endl;
+	PosixThread::createTask(&taskEntryPoint,this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -56,9 +58,11 @@ void PeriodicPosixTask::taskFunctionality(void){
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
 			if(status==0){
-				sif::error << "ObjectTask: " << name << " Deadline missed." << std::endl;
+				sif::error << "PeriodicPosixTask " << name << ": Deadline "
+						"missed." << std::endl;
 			}else{
-				sif::error << "ObjectTask: X Deadline missed. " << status << std::endl;
+				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+						status << std::endl;
 			}
 			if (this->deadlineMissedFunc != NULL) {
 				this->deadlineMissedFunc();

osal/linux/PeriodicPosixTask.h

@@ -9,9 +9,22 @@
 
 class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
 public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
 	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
 			uint32_t period_, void(*deadlineMissedFunc_)());
 	virtual ~PeriodicPosixTask();
+
 	/**
 	 * @brief	The method to start the task.
 	 * @details	The method starts the task with the respective system call.

osal/linux/PosixThread.cpp

@@ -1,8 +1,13 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/linux/PosixThread.h>
 #include <cstring>
 #include <errno.h>
-#include <framework/osal/linux/PosixThread.h>
 
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
+    name[0] = '\0';
+    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
+}
 
 PosixThread::~PosixThread() {
 	//No deletion and no free of Stack Pointer
@@ -55,10 +60,6 @@ void PosixThread::resume(){
 	pthread_kill(thread,SIGUSR1);
 }
 
-
-
-
-
 bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
 		const uint64_t delayTime_ms) {
 	uint64_t nextTimeToWake_ms;
@@ -113,12 +114,6 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 	return currentTime_ms;
 }
 
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0),priority(priority_),stackSize(stackSize_) {
-	strcpy(name,name_);
-}
-
-
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	//sif::debug << "PosixThread::createTask" << std::endl;
@@ -135,14 +130,24 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 		sif::error << "Posix Thread attribute init failed with: " <<
 				strerror(status) << std::endl;
 	}
-	void* sp;
+	void* stackPointer;
-	status = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stackSize);
+	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
-		sif::error << "Posix Thread stack init failed with: " <<
+		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
+		if(errno == ENOMEM) {
+			uint64_t stackMb = stackSize/10e6;
+			sif::error << "PosixThread::createTask: Insufficient memory for"
+					" the requested " << stackMb << " MB" << std::endl;
+		}
+		else if(errno == EINVAL) {
+			sif::error << "PosixThread::createTask: Wrong alignment argument!"
+					<< std::endl;
+		}
+		return;
 	}
 
-	status = pthread_attr_setstack(&attributes, sp, stackSize);
+	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
 		sif::error << "Posix Thread attribute setStack failed with: " <<
 				strerror(status) << std::endl;
@@ -154,7 +159,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 					strerror(status) << std::endl;
 	}
 
-//TODO FIFO -> This needs root privileges for the process
+	// TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
 		sif::error << "Posix Thread attribute schedule policy failed with: " <<
@@ -188,8 +193,18 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
-		sif::error << "Posix Thread setname failed with: " <<
+		sif::error << "PosixThread::createTask: setname failed with: " <<
 				strerror(status) << std::endl;
+		if(status == ERANGE) {
+			sif::error << "PosixThread::createTask: Task name length longer"
+					" than 16 chars. Truncating.." << std::endl;
+			name[15] = '\0';
+			status = pthread_setname_np(thread,name);
+			if(status != 0){
+				sif::error << "PosixThread::createTask: Setting name"
+						" did not work.." << std::endl;
+			}
+		}
 	}
 
 	status = pthread_attr_destroy(&attributes);

osal/linux/PosixThread.h

@@ -1,15 +1,15 @@
 #ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
 #define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
 
-#include <pthread.h>
-#include <sched.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <pthread.h>
+#include <signal.h>
+#include <cstdlib>
+#include <unistd.h>
 
 class PosixThread {
 public:
+	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
 	PosixThread(const char* name_, int priority_, size_t stackSize_);
 	virtual ~PosixThread();
 	/**
@@ -54,21 +54,24 @@ protected:
 	pthread_t thread;
 
 	/**
-	 * @brief Function that has to be called by derived class because the derived class pointer has to be valid as argument
+	 * @brief 	Function that has to be called by derived class because the
-	 * @details This function creates a pthread with the given parameters. As the function requires a pointer to the derived object
+	 *  		derived class pointer has to be valid as argument.
-	 * 			it has to be called after the this pointer of the derived object is valid. Sets the taskEntryPoint as
+	 * @details
-	 * 			function to be called by new a thread.
+	 * This function creates a pthread with the given parameters. As the
-	 * @param name_ Name of the task
+	 * function requires a pointer to the derived object it has to be called
-	 * @param priority_ Priority of the task according to POSIX
+	 * after the this pointer of the derived object is valid.
-	 * @param stackSize_ Size of the stack attached to that task
+	 * Sets the taskEntryPoint as function to be called by new a thread.
-	 * @param arg_ argument of the taskEntryPoint function, needs to be this pointer of derived class
+	 * @param fnc_ Function which will be executed by the thread.
+	 * @param arg_
+	 * argument of the taskEntryPoint function, needs to be this pointer
+	 * of derived class
 	 */
 	void createTask(void* (*fnc_)(void*),void* arg_);
 
 private:
-	char name[10];
+	char name[PTHREAD_MAX_NAMELEN];
 	int priority;
-	size_t stackSize;
+	size_t stackSize = 0;
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */

osal/linux/QueueFactory.cpp

@@ -5,16 +5,18 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
-QueueFactory* QueueFactory::factoryInstance = NULL;
+QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
+	if (factoryInstance == nullptr) {
 		factoryInstance = new QueueFactory;
 	}
 	return factoryInstance;
@@ -26,9 +28,9 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t message_depth,
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		uint32_t max_message_size) {
+		size_t maxMessageSize) {
-	return new MessageQueue(message_depth, max_message_size);
+	return new MessageQueue(messageDepth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {

osal/linux/TaskFactory.cpp

@@ -13,12 +13,20 @@ TaskFactory* TaskFactory::instance() {
 	return TaskFactory::factoryInstance;
 }
 
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-	return static_cast<PeriodicTaskIF*>(new PeriodicPosixTask(name_, taskPriority_,stackSize_,periodInSeconds_ * 1000,deadLineMissedFunction_));
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_ * 1000, deadLineMissedFunction_);
 }
 
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-	return static_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_, taskPriority_,stackSize_,periodInSeconds_*1000));
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_*1000);
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

osal/rtems/QueueFactory.cpp

@@ -49,9 +49,9 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t message_depth,
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		uint32_t max_message_size) {
+		size_t maxMessageSize) {
-	return new MessageQueue(message_depth, max_message_size);
+	return new MessageQueue(messageDepth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {

returnvalues/FwClassIds.h

@@ -24,6 +24,7 @@ enum {
 	MEMORY_HELPER, //MH
 	SERIALIZE_IF, //SE
 	FIXED_MAP, //FM
+	FIXED_MULTIMAP, //FMM
 	HAS_HEALTH_IF, //HHI
 	FIFO_CLASS, //FF
 	MESSAGE_PROXY, //MQP
@@ -54,11 +55,15 @@ enum {
 	HAS_ACTIONS_IF, //HF
 	DEVICE_COMMUNICATION_IF, //DC
 	BSP, //BSP
-	TIME_STAMPER_IF, //TSI 52
+	TIME_STAMPER_IF, //TSI 53
 	//TODO This will shift all IDs for FLP
-	SGP4PROPAGATOR_CLASS, //SGP4 53
+	SGP4PROPAGATOR_CLASS, //SGP4 54
-	MUTEX_IF, //MUX 54
+	MUTEX_IF, //MUX 55
-	MESSAGE_QUEUE_IF,//MQI 55
+	MESSAGE_QUEUE_IF,//MQI 56
+	SEMAPHORE_IF, //SPH 57
+	LOCAL_POOL_OWNER_IF, //LPIF 58
+	POOL_VARIABLE_IF, //PVA 59
+	HOUSEKEEPING_MANAGER, //HKM 60
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

returnvalues/HasReturnvaluesIF.h

@@ -1,27 +1,23 @@
-#ifndef HASRETURNVALUESIF_H_
+#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-#define HASRETURNVALUESIF_H_
+#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
 
-#include <stdint.h>
 #include <framework/returnvalues/FwClassIds.h>
 #include <config/returnvalues/classIds.h>
+#include <cstdint>
 
 #define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
 typedef uint16_t ReturnValue_t;
 
 
-
-
-
-
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
 	static const ReturnValue_t RETURN_FAILED = 1;
-	virtual ~HasReturnvaluesIF() {
+	virtual ~HasReturnvaluesIF() {}
-	}
 
+	static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
+	    return (interfaceId << 8) + number;
+	}
 };
 
-
+#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
-
-#endif /* HASRETURNVALUESIF_H_ */

rmap/RMAPCookie.h

@@ -1,12 +1,12 @@
 #ifndef RMAPCOOKIE_H_
 #define RMAPCOOKIE_H_
 
-#include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/rmap/rmapStructs.h>
 
 class RMAPChannelIF;
 
-class RMAPCookie : public Cookie{
+class RMAPCookie : public CookieIF {
 public:
 	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
 	RMAPCookie();

rmap/RmapDeviceCommunicationIF.cpp

@@ -5,43 +5,43 @@
 RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF* cookie,
 		uint8_t* data, uint32_t len) {
 	return RMAP::sendWriteCommand((RMAPCookie *) cookie, data, len);
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(Cookie* cookie) {
+ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
 	return RMAP::getWriteReply((RMAPCookie *) cookie);
 }
 
 ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
-		Cookie* cookie) {
+		CookieIF* cookie) {
 	return RMAP::sendReadCommand((RMAPCookie *) cookie,
 				((RMAPCookie *) cookie)->getMaxReplyLen());
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
 		uint8_t** buffer, uint32_t* size) {
 	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::setAddress(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
 		uint32_t address) {
 
 	((RMAPCookie *) cookie)->setAddress(address);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint32_t RmapDeviceCommunicationIF::getAddress(Cookie* cookie) {
+uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
 	return ((RMAPCookie *) cookie)->getAddress();
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::setParameter(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
 		uint32_t parameter) {
 	//TODO Empty?
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-uint32_t RmapDeviceCommunicationIF::getParameter(Cookie* cookie) {
+uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
 	return 0;
 }

rmap/RmapDeviceCommunicationIF.h

@@ -25,7 +25,7 @@ public:
 	 * @param maxReplyLen Maximum length of expected reply
 	 * @return
 	 */
-	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
+	virtual ReturnValue_t open(CookieIF **cookie, uint32_t address,
 			uint32_t maxReplyLen) = 0;
 
 	/**
@@ -39,7 +39,7 @@ public:
 	 * @param maxReplyLen
 	 * @return
 	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
+	virtual ReturnValue_t reOpen(CookieIF *cookie, uint32_t address,
 			uint32_t maxReplyLen) = 0;
 
 
@@ -47,7 +47,7 @@ public:
 	 * Closing call of connection and memory free of cookie. Mission dependent call
 	 * @param cookie
 	 */
-	virtual void close(Cookie *cookie) = 0;
+	virtual void close(CookieIF *cookie) = 0;
 
 	//SHOULDDO can data be const?
 	/**
@@ -58,23 +58,23 @@ public:
 	 * @param len Length of the data to be send
 	 * @return - Return codes of RMAP::sendWriteCommand()
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, uint8_t *data,
 			uint32_t len);
 
-	virtual ReturnValue_t getSendSuccess(Cookie *cookie);
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
 
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie);
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie);
 
-	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 			uint32_t *size);
 
-	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address);
+	virtual ReturnValue_t setAddress(CookieIF *cookie, uint32_t address);
 
-	virtual uint32_t getAddress(Cookie *cookie);
+	virtual uint32_t getAddress(CookieIF *cookie);
 
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter);
+	virtual ReturnValue_t setParameter(CookieIF *cookie, uint32_t parameter);
 
-	virtual uint32_t getParameter(Cookie *cookie);
+	virtual uint32_t getParameter(CookieIF *cookie);
 };
 
 #endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */