replaced DHB sizes by size_t, rework

Cookie now passed to DHB, rework in progress

action/ActionHelper.cpp

@@ -49,7 +49,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
 		store_address_t dataAddress) {
 	const uint8_t* dataPtr = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		CommandMessage reply;

action/CommandActionHelper.cpp

@@ -113,7 +113,7 @@ uint8_t CommandActionHelper::getCommandCount() const {
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
 	const uint8_t * data = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;

action/SimpleActionHelper.cpp

@@ -44,7 +44,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 		queueToUse->sendMessage(commandedBy, &reply);
 	}
 	const uint8_t* dataPtr = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ActionMessage::setStepReply(&reply, actionId, 0, result);

datapool/DataPoolAdmin.cpp

@@ -215,7 +215,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 				ParameterMessage::getParameterId(command));
 
 		const uint8_t *storedStream;
-		uint32_t storedStreamSize;
+		size_t storedStreamSize;
 		result = storage->getData(ParameterMessage::getStoreId(command),
 				&storedStream, &storedStreamSize);
 		if (result != HasReturnvaluesIF::RETURN_OK) {

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, address_t logicalAddress,
-		object_id_t setObjectId, object_id_t deviceCommunication,
+		object_id_t deviceCommunication, Cookie * cookie,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		uint32_t parent, FailureIsolationBase* customFdir, uint32_t cmdQueueSize) :
+		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
+		DeviceHandlerBase(setObjectId, logicalAddress, deviceCommunication, cookie,
-				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
+			maxDeviceReplyLen, setDeviceSwitch,  thermalStatePoolId,
-				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
+			thermalRequestPoolId, (customFdir == NULL? &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, uint32_t logicalAddress,
-			object_id_t deviceCommunication, uint32_t maxDeviceReplyLen,
+			object_id_t deviceCommunication, Cookie * cookie,
-			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
+			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			uint32_t thermalRequestPoolId, uint32_t parent,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-			FailureIsolationBase* customFdir = NULL,
+			uint32_t parent, FailureIsolationBase* customFdir = nullptr,
-			uint32_t cmdQueueSize = 20);
+			size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();

devicehandlers/Cookie.cpp

@@ -0,0 +1,24 @@
+/**
+ * @file Cookie.cpp
+ *
+ * @date 23.03.2020
+ */
+#include <framework/devicehandlers/Cookie.h>
+
+//Cookie::Cookie(address_t logicalAddress_, size_t maxReplyLen_):
+//	logicalAddress(logicalAddress_), maxReplyLen(maxReplyLen_){}
+
+Cookie::Cookie(address_t logicalAddress_): logicalAddress(logicalAddress_) {
+}
+
+void Cookie::setMaxReplyLen(size_t maxReplyLen_) {
+	maxReplyLen = maxReplyLen_;
+}
+
+address_t Cookie::getAddress() const {
+	return logicalAddress;
+}
+
+size_t Cookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}

devicehandlers/Cookie.h

@@ -1,5 +1,6 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
+#include <framework/devicehandlers/DeviceHandlerIF.h>
 
 /**
  * @brief This datatype is used to identify different connection over a single interface
@@ -7,13 +8,27 @@
  * @details
  * To use this class, implement a communication specific child cookie. This cookie
  * can be used in the device communication interface by performing
- * a C++ dynamic cast. The cookie can be used to store all kinds of information
+ * a C++ dynamic cast and passing it to a child device handler, which stores
- * about the communication between read and send calls.
+ * it and passes the Cookie to the communication interface where it can be used
+ * by again performing a dynamic cast.
+ * 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 Cookie{
 public:
+	Cookie() = default;
+	Cookie(address_t logicalAddress_);
 	virtual ~Cookie(){}
+
+	void setMaxReplyLen(size_t maxReplyLen_);
+
+	address_t getAddress() const;
+	size_t getMaxReplyLen() const;
+private:
+	address_t logicalAddress = 0;
+	size_t maxReplyLen = 0;
 };
 
-
 #endif /* COOKIE_H_ */

devicehandlers/DeviceCommunicationIF.h

@@ -6,7 +6,12 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
  * @defgroup interfaces Interfaces
- * @brief Communication interfaces for flight software objects
+ * @brief Interfaces for flight software objects
+ */
+
+/**
+ * @defgroup communication comm
+ * @brief Communication software components.
  */
 
 /**
@@ -22,9 +27,12 @@
  *   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.
+ *  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:
@@ -32,52 +40,12 @@ public:
 
 	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t CANT_CHANGE_REPLY_LEN = MAKE_RETURN_CODE(0x07);
 
 	virtual ~DeviceCommunicationIF() {}
 
-	/**
-	 * Open a connection. Define a communication specific cookie which can
-	 * be used to store information about the communication.
-	 * The two optional parameter provide additional flexibility to
-	 * set up the communication interface as desired. If there are a lot of
-	 * variables to set, a store ID to the parameters stored in the IPC store
-	 * can also be passed.
-	 *
-	 * @param cookie [out] This data class stores information about the communication.
-	 * @param address Logical device address
-	 * @param maxReplyLen Maximum length of expected reply
-	 * @param comParameter1 Arbitrary parameter which can be used to set up the cookie or comIF.
-	 * @param comParameter2 Arbitrary parameter which can be used to set up the cookie or comIF.
-	 * @return
-	 */
-	virtual ReturnValue_t open(Cookie **cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
-
-	/**
-	 * Use an existing cookie to open a connection to a new DeviceCommunication.
-	 * The previous connection must not be closed.
-	 *
-	 * @param cookie
-	 * @param address
-	 * @param maxReplyLen
-	 * @return -@c RETURN_OK New communication set up successfully
-	 *         - Everything else: Cookie is unchanged and can be used with
-	 *           previous connection
-	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
-
-	/**
-	 * Closing call of connection. Don't forget to free memory of cookie.
-	 * @param cookie
-	 */
-	virtual void close(Cookie *cookie) = 0;
-
 	/**
 	 * Called by DHB in the SEND_WRITE doSendWrite().
 	 * This function is used to send data to the physical device
@@ -86,21 +54,29 @@ public:
 	 * @param data
 	 * @param len
 	 * @return -@c RETURN_OK for successfull send
-	 *         -Everything else triggers sending failed event with
+	 *         - Everything else triggers sending failed event with
-	 *          returnvalue as parameter 1
+	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t *data,
+	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t * sendData,
-			uint32_t len) = 0;
+			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 sending failed event with
+	 *           returnvalue as parameter 1
+	 */
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * Instructs the Communication Interface to prepare
+	 * Request a reply.
 	 * @param cookie
 	 * @return
 	 */
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
+	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie, size_t requestLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetRead().
@@ -110,30 +86,11 @@ public:
 	 * @param data
 	 * @param len
 	 * @return @c RETURN_OK for successfull receive
-	 *         Everything else triggers receiving failed with returnvalue as parameter 1
+	 *         - Everything else triggers receiving failed with
+	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
-			uint32_t *size) = 0;
+			size_t *size) = 0;
-
-	virtual ReturnValue_t setAddress(Cookie *cookie, address_t address) = 0;
-
-	virtual address_t getAddress(Cookie *cookie) = 0;
-
-	/**
-	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
-	 * @param cookie
-	 * @param parameter
-	 * @return
-	 */
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter) = 0;
-
-	/**
-	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
-	 * @param cookie
-	 * @param parameter
-	 * @return
-	 */
-	virtual uint32_t getParameter(Cookie *cookie) = 0;
 };
 
 #endif /* DEVICECOMMUNICATIONIF_H_ */

devicehandlers/DeviceHandlerBase.cpp

@@ -16,37 +16,34 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
-		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
+		object_id_t deviceCommunication, Cookie * cookie_, size_t maxReplyLen,
-		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
+		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
-		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
+		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
-		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
+	    deviceCommunicationId(deviceCommunication), cookie(cookie_),
-		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+		deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(thermalRequestPoolId),
-		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
+		healthHelper(this, setObjectId), modeHelper(this), parameterHelper(this),
-		deviceCommunicationId(deviceCommunication), communicationInterface(NULL),
+		fdirInstance(fdirInstance), hkSwitcher(this),
-		cookie(NULL), commandQueue(NULL), deviceThermalStatePoolId(thermalStatePoolId),
+		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
-		deviceThermalRequestPoolId(thermalRequestPoolId), healthHelper(this, setObjectId),
+		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
-		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
+		logicalAddress(logicalAddress_), childTransitionDelay(5000),
-		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
-		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
+		deviceSwitch(setDeviceSwitch)
-		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
-		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
 {
+	this->cookie->setMaxReplyLen(maxReplyLen);
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
-	if (this->fdirInstance == NULL) {
+	if (this->fdirInstance == nullptr) {
 		this->fdirInstance =
 				new DeviceHandlerFailureIsolation(setObjectId, defaultFDIRParentId);
 	}
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	communicationInterface->close(cookie);
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -105,11 +102,11 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_FAILED;
 	}
 
-	result = communicationInterface->open(&cookie, logicalAddress,
+//	result = communicationInterface->open(&cookie, logicalAddress,
-			maxDeviceReplyLen, comParameter1, comParameter2);
+//			maxDeviceReplyLen, comParameter1, comParameter2);
-	if (result != RETURN_OK) {
+//	if (result != RETURN_OK) {
-		return result;
+//		return result;
-	}
+//	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == NULL) {
@@ -551,7 +548,7 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
-	result = communicationInterface->requestReceiveMessage(cookie);
+	result = communicationInterface->requestReceiveMessage(cookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
@@ -565,10 +562,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) {
@@ -639,8 +636,8 @@ void DeviceHandlerBase::doGetRead() {
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t * *data, uint32_t * len) {
+		uint8_t ** data, size_t * len) {
-	uint32_t lenTmp;
+	size_t lenTmp;
 
 	if (IPCStore == NULL) {
 		*data = NULL;
@@ -751,20 +748,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, logicalAddress,
+//		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-				maxDeviceReplyLen, comParameter1, comParameter2);
+//				maxDeviceReplyLen, comParameter1, comParameter2);
-		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);
@@ -1048,12 +1045,13 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+	case DeviceHandlerMessage::CMD_SWITCH_ADDRESS:
 		if (mode != MODE_OFF) {
 			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
 		} else {
-			result = switchCookieChannel(
+			// rework in progress
-					DeviceHandlerMessage::getIoBoardObjectId(message));
+			//result = switchCookieChannel(
+			//		DeviceHandlerMessage::getIoBoardObjectId(message));
 			if (result == RETURN_OK) {
 				replyReturnvalueToCommand(RETURN_OK);
 			} else {

devicehandlers/DeviceHandlerBase.h

@@ -29,7 +29,7 @@ void setStaticFrameworkObjectIds();
 class StorageManagerIF;
 
 /**
- * \defgroup devices Devices
+ * @defgroup devices Devices
  * Contains all devices and the DeviceHandlerBase class.
  */
 
@@ -93,12 +93,11 @@ public:
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
-	DeviceHandlerBase(address_t logicalAddress, object_id_t setObjectId,
+	DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
-			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+			object_id_t deviceCommunication, Cookie* cookie_, size_t maxReplyLen,
-			object_id_t deviceCommunication,
+			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
-			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
+			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
 	/**
 	 * @brief This function is the device handler base core component and is called periodically.
@@ -283,8 +282,8 @@ protected:
 	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
 	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
-			DeviceCommandId_t *foundId, uint32_t *foundLen) = 0;
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
 
 	/**
 	 * @brief Interpret a reply from the device.
@@ -412,11 +411,16 @@ protected:
 	/**
 	 * Pointer to the raw packet that will be sent.
 	 */
-	uint8_t *rawPacket;
+	uint8_t *rawPacket = nullptr;
 	/**
 	 * Size of the #rawPacket.
 	 */
-	uint32_t rawPacketLen;
+	size_t rawPacketLen = 0;
+
+	/**
+	 * Size of data to request.
+	 */
+	size_t requestLen = 0;
 
 //	/**
 //	 * This union (or std::variant) type can be used to set comParameters which
@@ -431,8 +435,8 @@ protected:
 //	 * 4 bytes of parameters AND a store ID.
 //	 */
 //	comParameters_t comParameters;
-	uint32_t comParameter1 = 0;
+	// uint32_t comParameter1 = 0;
-	uint32_t comParameter2 = 0;
+	// uint32_t comParameter2 = 0;
 
 	/**
 	 * The mode the device handler is currently in.
@@ -451,12 +455,12 @@ protected:
 	/**
 	 * This is the counter value from performOperation().
 	 */
-	uint8_t pstStep;
+	uint8_t pstStep = 0;
 
 	/**
 	 * This will be used in the RMAP getRead command as expected length, is set by the constructor, can be modiefied at will.
 	 */
-	const uint32_t maxDeviceReplyLen;
+	const uint32_t maxDeviceReplyLen = 0;
 
 	/**
 	 * wiretapping flag:
@@ -474,7 +478,7 @@ protected:
 	 * Statically initialized in initialize() to a configurable object. Used when there is no method
 	 * of finding a recipient, ie raw mode and reporting erreonous replies
 	 */
-	MessageQueueId_t defaultRawReceiver;
+	MessageQueueId_t defaultRawReceiver = 0;
 
 	store_address_t storedRawData;
 
@@ -483,19 +487,19 @@ protected:
 	 *
 	 * if #isWiretappingActive all raw communication from and to the device will be sent to this queue
 	 */
-	MessageQueueId_t requestedRawTraffic;
+	MessageQueueId_t requestedRawTraffic = 0;
 
 	/**
 	 * the object used to set power switches
 	 */
-	PowerSwitchIF *powerSwitcher;
+	PowerSwitchIF *powerSwitcher = nullptr;
 
 	/**
 	 * Pointer to the IPCStore.
 	 *
 	 * This caches the pointer received from the objectManager in the constructor.
 	 */
-	StorageManagerIF *IPCStore;
+	StorageManagerIF *IPCStore = nullptr;
 
 	/**
 	 * cached for init
@@ -505,7 +509,7 @@ protected:
 	/**
 	 * Communication object used for device communication
 	 */
-	DeviceCommunicationIF *communicationInterface;
+	DeviceCommunicationIF *communicationInterface = nullptr;
 
 	/**
 	 * Cookie used for communication. This is passed to the communication
@@ -516,7 +520,7 @@ protected:
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
 	 */
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	/**
 	 * this is the datapool variable with the thermal state of the device
@@ -545,9 +549,9 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure;
+	ReturnValue_t childTransitionFailure = RETURN_OK;
 
-	uint32_t ignoreMissedRepliesCount; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 
 	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
 
@@ -962,7 +966,7 @@ private:
 	 *
 	 * Set when setMode() is called.
 	 */
-	uint32_t timeoutStart;
+	uint32_t timeoutStart = 0;
 
 	/**
 	 * Delay for the current mode transition, used for time out
@@ -1084,8 +1088,8 @@ private:
 	 *   - @c RETURN_FAILED IPCStore is NULL
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
+	ReturnValue_t getStorageData(store_address_t storageAddress,
-			uint32_t *len);
+			uint8_t ** data, size_t * len);
 
 	/**
 	 * set all switches returned by getSwitches()
@@ -1114,7 +1118,7 @@ private:
 	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+	//ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
 	/**
 	 * Handle device handler messages (e.g. commands sent by PUS Service 2)

devicehandlers/DeviceHandlerMessage.cpp

@@ -47,7 +47,7 @@ void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
 
 void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
 		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_IOBOARD);
+	message->setCommand(CMD_SWITCH_ADDRESS);
 	message->setParameter(ioBoardIdentifier);
 }
 
@@ -90,7 +90,7 @@ void DeviceHandlerMessage::clear(CommandMessage* message) {
 		}
 	}
 		/* NO BREAK falls through*/
-	case CMD_SWITCH_IOBOARD:
+	case CMD_SWITCH_ADDRESS:
 	case CMD_WIRETAPPING:
 		message->setCommand(CommandMessage::CMD_NONE);
 		message->setParameter(0);

devicehandlers/DeviceHandlerMessage.h

@@ -28,7 +28,7 @@ public:
 	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::DEVICE_HANDLER_COMMAND;
 	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
 //	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
-	static const Command_t CMD_SWITCH_IOBOARD = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
 	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
 
 	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)

memory/MemoryHelper.cpp

@@ -152,7 +152,7 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
 	ipcAddress = MemoryMessage::getStoreID(message);
 	const uint8_t* p_data = NULL;
 	uint8_t* dataPointer = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
 	if (returnCode == RETURN_OK) {
 		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,

osal/FreeRTOS/BinarySemaphore.cpp

@@ -11,7 +11,7 @@
 #include "task.h"
 
 BinarySemaphore::BinarySemaphore() {
-	vSemaphoreCreateBinary(handle);
+	xSemaphoreCreateBinary(handle); // @suppress("Function cannot be resolved")
 	if(handle == NULL) {
 		error << "Binary semaphore creation failure" << std::endl;
 	}
@@ -81,7 +81,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 
 void BinarySemaphore::resetSemaphore() {
 	vSemaphoreDelete(handle);
-	vSemaphoreCreateBinary(handle);
+	xSemaphoreCreateBinary(handle);
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,

parameters/ParameterHelper.cpp

@@ -37,7 +37,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 				ParameterMessage::getParameterId(message));
 
 		const uint8_t *storedStream;
-		uint32_t storedStreamSize;
+		size_t storedStreamSize;
 		result = storage->getData(
 				ParameterMessage::getStoreId(message), &storedStream,
 				&storedStreamSize);

storagemanager/LocalPool.h

@@ -100,7 +100,7 @@ public:
 	 * @return @c RETURN_OK if data retrieval was successfull
 	 */
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			uint32_t* size);
+			size_t * size);
 
 	/**
 	 * Modify data by supplying a packet pointer and using that packet pointer
@@ -111,7 +111,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			uint32_t* size);
+			size_t * size);
 	virtual ReturnValue_t deleteData(store_address_t);
 	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
 			store_address_t* storeId = NULL);
@@ -348,7 +348,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
 
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, uint32_t* size) {
+		store_address_t packet_id, const uint8_t** packet_ptr, size_t * size) {
 	uint8_t* tempData = NULL;
 	ReturnValue_t status = modifyData(packet_id, &tempData, size);
 	*packet_ptr = tempData;
@@ -357,7 +357,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(store_address_t packet_id,
-		uint8_t** packet_ptr, uint32_t* size) {
+		uint8_t** packet_ptr, size_t * size) {
 	ReturnValue_t status = RETURN_FAILED;
 	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
 		return ILLEGAL_STORAGE_ID;

storagemanager/StorageManagerIF.h

@@ -125,12 +125,12 @@ public:
 	 * 				(e.g. an illegal packet_id was passed).
 	 */
 	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, uint32_t* size) = 0;
+			const uint8_t** packet_ptr, size_t * size) = 0;
 	/**
 	 * Same as above, but not const and therefore modifiable.
 	 */
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, uint32_t* size) = 0;
+			uint8_t** packet_ptr, size_t * size) = 0;
 	/**
 	 * This method reserves an element of \c size.
 	 *

subsystem/Subsystem.cpp

@@ -162,7 +162,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 	case ModeSequenceMessage::ADD_SEQUENCE: {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
 		const uint8_t *pointer;
-		uint32_t sizeRead;
+		size_t sizeRead;
 		result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
@@ -188,7 +188,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 	case ModeSequenceMessage::ADD_TABLE: {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
 		const uint8_t *pointer;
-		uint32_t sizeRead;
+		size_t sizeRead;
 		result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);

tcdistribution/CCSDSDistributor.cpp

@@ -13,7 +13,7 @@ CCSDSDistributor::~CCSDSDistributor() {
 iterator_t CCSDSDistributor::selectDestination() {
 //	debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
 	const uint8_t* p_packet = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	//TODO check returncode?
 	this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
 	SpacePacketBase current_packet( p_packet );

tmtcpacket/pus/TcPacketStored.cpp

@@ -59,7 +59,7 @@ bool TcPacketStored::checkAndSetStore() {
 void TcPacketStored::setStoreAddress(store_address_t setAddress) {
 	this->storeAddress = setAddress;
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
 	if (this->checkAndSetStore()) {
 		status = this->store->getData(this->storeAddress, &temp_data,
@@ -79,7 +79,7 @@ store_address_t TcPacketStored::getStoreAddress() {
 
 bool TcPacketStored::isSizeCorrect() {
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
 			&temp_size);
 	if (status == StorageManagerIF::RETURN_OK) {

tmtcpacket/pus/TmPacketStored.cpp

@@ -82,7 +82,7 @@ void TmPacketStored::deletePacket() {
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
 	}

tmtcservices/TmTcBridge.cpp

@@ -76,7 +76,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 ReturnValue_t TmTcBridge::readTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -127,7 +127,7 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 				<< (int) fifo.size() << " left to send" << std::endl;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
-		uint32_t size = 0;
+		size_t size = 0;
 		fifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
 		sendTm(data,size);