Today's the day. Renamed platform to framework.

action/ActionHelper.cpp

@@ -0,0 +1,92 @@
+
+#include <framework/action/ActionHelper.h>
+#include <framework/action/HasActionsIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueue* useThisQueue) :
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(
+				NULL) {
+}
+
+ActionHelper::~ActionHelper() {
+}
+
+ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
+	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
+		ActionId_t currentAction = ActionMessage::getActionId(command);
+		prepareExecution(command->getSender(), currentAction,
+				ActionMessage::getStoreId(command));
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return CommandMessage::UNKNOW_COMMAND;
+	}
+}
+
+ReturnValue_t ActionHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+	CommandMessage reply;
+	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
+	queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+	CommandMessage reply;
+	ActionMessage::setCompletionReply(&reply, commandId, result);
+	queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+		store_address_t dataAddress) {
+	const uint8_t* dataPtr = NULL;
+	uint32_t size = 0;
+	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		CommandMessage reply;
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+	ipcStore->deleteData(dataAddress);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		CommandMessage reply;
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+}
+
+void ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data) {
+	CommandMessage reply;
+	store_address_t storeAddress;
+	uint8_t *dataPtr;
+	uint32_t maxSize = data->getSerializedSize();
+	if (maxSize == 0) {
+		return;
+	}
+	uint32_t size = 0;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
+			&dataPtr);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		//TODO event?
+		return;
+	}
+	result = data->serialize(&dataPtr, &size, maxSize, true);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ipcStore->deleteData(storeAddress);
+		//TODO event?
+		return;
+	}
+	ActionMessage::setDataReply(&reply, replyId, storeAddress);
+	if (queueToUse->sendMessage(reportTo, &reply) != HasReturnvaluesIF::RETURN_OK){
+		ipcStore->deleteData(storeAddress);
+	}
+	//We don't neeed the objectId, as we receive REQUESTED data before the completion success message.
+	//True aperiodic replies need to be reported with dedicated DH message.
+}

action/ActionHelper.h

@@ -0,0 +1,28 @@
+
+#ifndef ACTIONHELPER_H_
+#define ACTIONHELPER_H_
+
+#include <framework/action/ActionMessage.h>
+#include <framework/serialize/SerializeIF.h>
+
+class HasActionsIF;
+//TODO: Change MessageQueueId usage.
+class ActionHelper {
+public:
+	ActionHelper(HasActionsIF* setOwner, MessageQueue* useThisQueue);
+	virtual ~ActionHelper();
+	ReturnValue_t handleActionMessage(CommandMessage* command);
+	ReturnValue_t initialize();
+	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data);
+protected:
+	static const uint8_t STEP_OFFSET = 1;
+	HasActionsIF* owner;
+	MessageQueue* queueToUse;
+	StorageManagerIF* ipcStore;
+	virtual void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+	void resetHelper();
+};
+
+#endif /* ACTIONHELPER_H_ */

action/ActionMessage.cpp

@@ -0,0 +1,80 @@
+
+#include <framework/action/ActionMessage.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+ActionMessage::ActionMessage() {
+}
+
+ActionMessage::~ActionMessage() {
+}
+
+void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
+		store_address_t parameters) {
+	message->setCommand(EXECUTE_ACTION);
+	message->setParameter(fid);
+	message->setParameter2(parameters.raw);
+}
+
+ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
+	return ActionId_t(message->getParameter());
+}
+
+store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
+		ReturnValue_t result) {
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		message->setCommand(STEP_SUCCESS);
+	} else {
+		message->setCommand(STEP_FAILED);
+	}
+	message->setParameter(fid);
+	message->setParameter2((step << 16) + result);
+}
+
+uint8_t ActionMessage::getStep(const CommandMessage* message) {
+	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+}
+
+ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
+	return message->getParameter2() & 0xFFFF;
+}
+
+void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
+		store_address_t data) {
+	message->setCommand(DATA_REPLY);
+	message->setParameter(actionId);
+	message->setParameter2(data.raw);
+}
+
+void ActionMessage::setCompletionReply(CommandMessage* message,
+		ActionId_t fid, ReturnValue_t result) {
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		message->setCommand(COMPLETION_SUCCESS);
+	} else {
+		message->setCommand(COMPLETION_FAILED);
+	}
+	message->setParameter(fid);
+	message->setParameter2(result);
+}
+
+void ActionMessage::clear(CommandMessage* message) {
+	switch(message->getCommand()) {
+	case EXECUTE_ACTION:
+	case DATA_REPLY: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}

action/ActionMessage.h

@@ -0,0 +1,33 @@
+
+#ifndef ACTIONMESSAGE_H_
+#define ACTIONMESSAGE_H_
+
+#include <framework/ipc/CommandMessage.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+typedef uint32_t ActionId_t;
+
+class ActionMessage {
+private:
+	ActionMessage();
+public:
+	static const uint8_t MESSAGE_ID = FUNCTION_MESSAGE_ID;
+	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
+	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
+	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
+	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
+	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+	virtual ~ActionMessage();
+	static void setCommand(CommandMessage* message, ActionId_t fid, store_address_t parameters);
+	static ActionId_t getActionId(const CommandMessage* message );
+	static store_address_t getStoreId(const CommandMessage* message );
+	static void setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	static uint8_t getStep(const CommandMessage* message );
+	static ReturnValue_t getReturnCode(const CommandMessage* message );
+	static void setDataReply(CommandMessage* message, ActionId_t actionId, store_address_t data);
+	static void setCompletionReply(CommandMessage* message, ActionId_t fid, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	static void clear(CommandMessage* message);
+};
+
+#endif /* ACTIONMESSAGE_H_ */

action/CommandActionHelper.cpp

@@ -0,0 +1,120 @@
+
+#include <framework/action/ActionMessage.h>
+#include <framework/action/CommandActionHelper.h>
+#include <framework/action/CommandsActionsIF.h>
+#include <framework/action/HasActionsIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+
+CommandActionHelper::CommandActionHelper(CommandsActionsIF* setOwner) :
+		owner(setOwner), queueToUse(setOwner->getCommandQueuePtr()), ipcStore(
+				NULL), commandCount(0), lastTarget(0) {
+}
+
+CommandActionHelper::~CommandActionHelper() {
+}
+
+ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
+		ActionId_t actionId, SerializeIF* data) {
+	HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
+	if (receiver == NULL) {
+		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+	}
+	store_address_t storeId;
+	uint8_t* storePointer;
+	uint32_t maxSize = data->getSerializedSize();
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
+			&storePointer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	uint32_t size = 0;
+	result = data->serialize(&storePointer, &size, maxSize, true);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+}
+
+ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
+		ActionId_t actionId, const uint8_t* data, uint32_t size) {
+//	if (commandCount != 0) {
+//		return CommandsFunctionsIF::ALREADY_COMMANDING;
+//	}
+	HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
+	if (receiver == NULL) {
+		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+	}
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+}
+
+ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
+		ActionId_t actionId, store_address_t storeId) {
+	CommandMessage command;
+	ActionMessage::setCommand(&command, actionId, storeId);
+	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ipcStore->deleteData(storeId);
+	}
+	lastTarget = queueId;
+	commandCount++;
+	return result;
+}
+
+ReturnValue_t CommandActionHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore != NULL) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
+	if (reply->getSender() != lastTarget) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	switch (reply->getCommand()) {
+	case ActionMessage::COMPLETION_SUCCESS:
+		commandCount--;
+		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::COMPLETION_FAILED:
+		commandCount--;
+		owner->completionFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getReturnCode(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::STEP_SUCCESS:
+		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getStep(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::STEP_FAILED:
+		commandCount--;
+		owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
+				ActionMessage::getReturnCode(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::DATA_REPLY:
+		extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t CommandActionHelper::getCommandCount() const {
+	return commandCount;
+}
+
+void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
+	const uint8_t * data = NULL;
+	uint32_t size = 0;
+	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	owner->dataReceived(actionId, data, size);
+	ipcStore->deleteData(storeId);
+}

action/CommandActionHelper.h

@@ -0,0 +1,37 @@
+
+#ifndef COMMANDACTIONHELPER_H_
+#define COMMANDACTIONHELPER_H_
+
+#include <framework/action/ActionMessage.h>
+#include <framework/ipc/MessageQueue.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serialize/SerializeIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+class CommandsActionsIF;
+
+class CommandActionHelper {
+	friend class CommandsActionsIF;
+public:
+	CommandActionHelper(CommandsActionsIF* owner);
+	virtual ~CommandActionHelper();
+	ReturnValue_t commandAction(object_id_t commandTo,
+			ActionId_t actionId, const uint8_t* data, uint32_t size);
+	ReturnValue_t commandAction(object_id_t commandTo,
+			ActionId_t actionId, SerializeIF* data);
+	ReturnValue_t initialize();
+	ReturnValue_t handleReply(CommandMessage* reply);
+	uint8_t getCommandCount() const;
+private:
+	CommandsActionsIF* owner;
+	MessageQueue* queueToUse;
+	StorageManagerIF* ipcStore;
+	uint8_t commandCount;
+	MessageQueueId_t lastTarget;
+	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
+	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
+			store_address_t storeId);
+};
+
+#endif /* COMMANDACTIONHELPER_H_ */

action/CommandsActionsIF.h

@@ -0,0 +1,35 @@
+
+#ifndef COMMANDSACTIONSIF_H_
+#define COMMANDSACTIONSIF_H_
+
+#include <framework/action/CommandActionHelper.h>
+#include <framework/ipc/MessageQueue.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * Interface to separate commanding actions of other objects.
+ * In next iteration, IF should be shortened to three calls:
+ * - dataReceived(data)
+ * - successReceived(id, step)
+ * - failureReceived(id, step, cause)
+ * or even
+ * - replyReceived(id, step, cause) (if cause == OK, it's a success).
+ */
+class CommandsActionsIF {
+	friend class CommandActionHelper;
+public:
+	static const uint8_t INTERFACE_ID = COMMANDS_ACTIONS_IF;
+	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
+	virtual ~CommandsActionsIF() {}
+	virtual MessageQueue* getCommandQueuePtr() = 0;
+protected:
+	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) = 0;
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) = 0;
+	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
+	virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) = 0;
+};
+
+
+#endif /* COMMANDSACTIONSIF_H_ */

action/HasActionsIF.h

@@ -0,0 +1,35 @@
+/*
+ * HasActionsIF.h
+ *
+ *  Created on: 20.02.2014
+ *      Author: baetz
+ */
+
+#ifndef HASACTIONSIF_H_
+#define HASACTIONSIF_H_
+
+#include <framework/action/ActionHelper.h>
+#include <framework/action/ActionMessage.h>
+#include <framework/action/SimpleActionHelper.h>
+#include <framework/ipc/MessageQueue.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+class HasActionsIF {
+public:
+	static const uint8_t INTERFACE_ID = HAS_ACTIONS_IF;
+	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
+	virtual ~HasActionsIF() { }
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Execute or initialize the execution of a certain function.
+	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to be done.
+	 * When needing more steps, return RETURN_OK and issue steps and completion manually. One "step failed" or completion report must
+	 * be issued!
+	 */
+	virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) = 0;
+};
+
+
+#endif /* HASACTIONSIF_H_ */

action/SimpleActionHelper.cpp

@@ -0,0 +1,75 @@
+
+#include <framework/action/HasActionsIF.h>
+#include <framework/action/SimpleActionHelper.h>
+SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
+		MessageQueue* useThisQueue) :
+		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
+				0), lastAction(0), stepCount(0) {
+}
+
+SimpleActionHelper::~SimpleActionHelper() {
+}
+
+void SimpleActionHelper::step(ReturnValue_t result) {
+	//STEP_OFFESET is subtracted to compensate for adding offset in base method, which is not necessary here.
+	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
+			result);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		resetHelper();
+	}
+}
+
+void SimpleActionHelper::finish(ReturnValue_t result) {
+	ActionHelper::finish(lastCommander, lastAction, result);
+	resetHelper();
+}
+
+void SimpleActionHelper::reportData(SerializeIF* data) {
+	ActionHelper::reportData(lastCommander, lastAction, data);
+}
+
+void SimpleActionHelper::resetHelper() {
+	stepCount = 0;
+	isExecuting = false;
+	lastAction = 0;
+	lastCommander = 0;
+}
+
+void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
+		ActionId_t actionId, store_address_t dataAddress) {
+	CommandMessage reply;
+	if (isExecuting) {
+		ipcStore->deleteData(dataAddress);
+		ActionMessage::setStepReply(&reply, actionId, 0,
+				HasActionsIF::IS_BUSY);
+		queueToUse->sendMessage(commandedBy, &reply);
+	}
+	const uint8_t* dataPtr = NULL;
+	uint32_t size = 0;
+	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+	lastCommander = commandedBy;
+	lastAction = actionId;
+	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+	ipcStore->deleteData(dataAddress);
+	switch (result) {
+	case HasReturnvaluesIF::RETURN_OK:
+		isExecuting = true;
+		stepCount++;
+		break;
+	case HasActionsIF::EXECUTION_FINISHED:
+		ActionMessage::setCompletionReply(&reply, actionId,
+				HasReturnvaluesIF::RETURN_OK);
+		queueToUse->sendMessage(commandedBy, &reply);
+		break;
+	default:
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		break;
+	}
+
+}

action/SimpleActionHelper.h

@@ -0,0 +1,24 @@
+
+#ifndef SIMPLEACTIONHELPER_H_
+#define SIMPLEACTIONHELPER_H_
+
+#include <framework/action/ActionHelper.h>
+
+class SimpleActionHelper: public ActionHelper {
+public:
+	SimpleActionHelper(HasActionsIF* setOwner, MessageQueue* useThisQueue);
+	virtual ~SimpleActionHelper();
+	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void reportData(SerializeIF* data);
+	void resetHelper();
+protected:
+	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+private:
+	bool isExecuting;
+	MessageQueueId_t lastCommander;
+	ActionId_t lastAction;
+	uint8_t stepCount;
+};
+
+#endif /* SIMPLEACTIONHELPER_H_ */