esbo_ds/fsfw
3
0
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases Wiki Activity

MessageQueue refactoring complete

Browse Source
This commit is contained in:
Robin Müller 2020-06-09 02:18:39 +02:00
parent b1f91439c6
commit 8ff6506ad9
34 changed files with 293 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
action/ActionHelper.cpp
View File

@ -16,7 +16,7 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
ActionMessage::getStoreId(command)); ActionMessage::getStoreId(command));
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} else { } else {
return CommandMessage::UNKNOW_COMMAND; return CommandMessage::UNKNOWN_COMMAND;
} }
} }
@ -33,13 +33,15 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
} }
void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) { void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result); ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
queueToUse->sendMessage(reportTo, &reply); queueToUse->sendMessage(reportTo, &reply);
} }
void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) { void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ActionMessage::setCompletionReply(&reply, commandId, result); ActionMessage::setCompletionReply(&reply, commandId, result);
queueToUse->sendMessage(reportTo, &reply); queueToUse->sendMessage(reportTo, &reply);
} }
@ -54,7 +56,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
size_t size = 0; size_t size = 0;
ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size); ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ActionMessage::setStepReply(&reply, actionId, 0, result); ActionMessage::setStepReply(&reply, actionId, 0, result);
queueToUse->sendMessage(commandedBy, &reply); queueToUse->sendMessage(commandedBy, &reply);
return; return;
@ -62,7 +65,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
result = owner->executeAction(actionId, commandedBy, dataPtr, size); result = owner->executeAction(actionId, commandedBy, dataPtr, size);
ipcStore->deleteData(dataAddress); ipcStore->deleteData(dataAddress);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ActionMessage::setStepReply(&reply, actionId, 0, result); ActionMessage::setStepReply(&reply, actionId, 0, result);
queueToUse->sendMessage(commandedBy, &reply); queueToUse->sendMessage(commandedBy, &reply);
return; return;
@ -71,7 +75,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
ActionId_t replyId, SerializeIF* data, bool hideSender) { ActionId_t replyId, SerializeIF* data, bool hideSender) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
store_address_t storeAddress; store_address_t storeAddress;
uint8_t *dataPtr; uint8_t *dataPtr;
size_t maxSize = data->getSerializedSize(); size_t maxSize = data->getSerializedSize();

3
action/CommandActionHelper.cpp
View File

@ -53,7 +53,8 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId, ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
ActionId_t actionId, store_address_t storeId) { ActionId_t actionId, store_address_t storeId) {
CommandMessage command; MessageQueueMessage message;
CommandMessage command(&message);
ActionMessage::setCommand(&command, actionId, storeId); ActionMessage::setCommand(&command, actionId, storeId);
ReturnValue_t result = queueToUse->sendMessage(queueId, &command); ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {

3
action/SimpleActionHelper.cpp
View File

@ -36,7 +36,8 @@ void SimpleActionHelper::resetHelper() {
void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
ActionId_t actionId, store_address_t dataAddress) { ActionId_t actionId, store_address_t dataAddress) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
if (isExecuting) { if (isExecuting) {
ipcStore->deleteData(dataAddress); ipcStore->deleteData(dataAddress);
ActionMessage::setStepReply(&reply, actionId, 0, ActionMessage::setStepReply(&reply, actionId, 0,

17
controller/ControllerBase.cpp
View File

@ -56,26 +56,27 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
} }
void ControllerBase::handleQueue() { void ControllerBase::handleQueue() {
CommandMessage message; MessageQueueMessage message;
CommandMessage command(&message);
ReturnValue_t result; ReturnValue_t result;
for (result = commandQueue->receiveMessage(&message); result == RETURN_OK; for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
result = commandQueue->receiveMessage(&message)) { result = commandQueue->receiveMessage(&command)) {
result = modeHelper.handleModeCommand(&message); result = modeHelper.handleModeCommand(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
result = healthHelper.handleHealthCommand(&message); result = healthHelper.handleHealthCommand(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
result = handleCommandMessage(&message); result = handleCommandMessage(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
message.setToUnknownCommand(); command.setToUnknownCommand();
commandQueue->reply(&message); commandQueue->reply(&command);
} }
} }

6
datalinklayer/MapPacketExtraction.cpp
View File

@ -16,9 +16,9 @@
MapPacketExtraction::MapPacketExtraction(uint8_t setMapId, MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
object_id_t setPacketDestination) : object_id_t setPacketDestination) :
lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition( lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
packetBuffer), packetDestination(setPacketDestination), packetStore( bufferPosition(packetBuffer), packetDestination(setPacketDestination),
NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) { packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
memset(packetBuffer, 0, sizeof(packetBuffer)); memset(packetBuffer, 0, sizeof(packetBuffer));
} }

11
datapool/HkSwitchHelper.cpp
View File

@ -21,14 +21,15 @@ ReturnValue_t HkSwitchHelper::initialize() {
} }
ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) { ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
CommandMessage message; MessageQueueMessage message;
while (actionQueue->receiveMessage(&message) == HasReturnvaluesIF::RETURN_OK) { CommandMessage command(&message);
ReturnValue_t result = commandActionHelper.handleReply(&message); while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
ReturnValue_t result = commandActionHelper.handleReply(&command);
if (result == HasReturnvaluesIF::RETURN_OK) { if (result == HasReturnvaluesIF::RETURN_OK) {
continue; continue;
} }
message.setToUnknownCommand(); command.setToUnknownCommand();
actionQueue->reply(&message); actionQueue->reply(&command);
} }
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;

9
datapoolglob/DataPoolAdmin.cpp
View File

@ -66,7 +66,8 @@ ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
} }
void DataPoolAdmin::handleCommand() { void DataPoolAdmin::handleCommand() {
CommandMessage command; MessageQueueMessage message;
CommandMessage command(&message);
ReturnValue_t result = commandQueue->receiveMessage(&command); ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return; return;
@ -282,7 +283,8 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
return result; return result;
} }
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ParameterMessage::setParameterDumpReply(&reply, id, address); ParameterMessage::setParameterDumpReply(&reply, id, address);
@ -294,7 +296,8 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
//identical to ParameterHelper::rejectCommand() //identical to ParameterHelper::rejectCommand()
void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason, void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
Command_t initialCommand) { Command_t initialCommand) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
reply.setReplyRejected(reason, initialCommand); reply.setReplyRejected(reason, initialCommand);
commandQueue->sendMessage(to, &reply); commandQueue->sendMessage(to, &reply);
} }

3
devicehandlers/AssemblyBase.cpp
View File

@ -148,7 +148,8 @@ void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo, void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
HealthState health) { HealthState health) {
CommandMessage command; MessageQueueMessage message;
CommandMessage command(&message);
HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET, HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
health); health);
if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) { if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {

29
devicehandlers/DeviceHandlerBase.cpp
View File

@ -218,8 +218,9 @@ void DeviceHandlerBase::readCommandQueue() {
// message with 3 parameters). The full buffer is filled anyway // message with 3 parameters). The full buffer is filled anyway
// and I could just copy the content into the other message but // and I could just copy the content into the other message but
// all I need are few additional functions the other message type offers. // all I need are few additional functions the other message type offers.
CommandMessage cmdMessage; MessageQueueMessage message;
ReturnValue_t result = commandQueue->receiveMessage(&cmdMessage); CommandMessage command(&message);
ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return; return;
} }
@ -234,23 +235,23 @@ void DeviceHandlerBase::readCommandQueue() {
// } // }
if(healthHelperActive) { if(healthHelperActive) {
result = healthHelper.handleHealthCommand(&cmdMessage); result = healthHelper.handleHealthCommand(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
return; return;
} }
} }
result = modeHelper.handleModeCommand(&cmdMessage); result = modeHelper.handleModeCommand(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
return; return;
} }
result = actionHelper.handleActionMessage(&cmdMessage); result = actionHelper.handleActionMessage(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
return; return;
} }
result = parameterHelper.handleParameterMessage(&cmdMessage); result = parameterHelper.handleParameterMessage(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
return; return;
} }
@ -261,17 +262,17 @@ void DeviceHandlerBase::readCommandQueue() {
// return; // return;
// } // }
result = handleDeviceHandlerMessage(&cmdMessage); result = handleDeviceHandlerMessage(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
return; return;
} }
result = letChildHandleMessage(&cmdMessage); result = letChildHandleMessage(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
return; return;
} }
replyReturnvalueToCommand(CommandMessage::UNKNOW_COMMAND); replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
} }
@ -492,12 +493,13 @@ void DeviceHandlerBase::setMode(Mode_t newMode) {
void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status, void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
uint32_t parameter) { uint32_t parameter) {
MessageQueueMessage message;
//This is actually the reply protocol for raw and misc DH commands. //This is actually the reply protocol for raw and misc DH commands.
if (status == RETURN_OK) { if (status == RETURN_OK) {
CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter); CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, parameter);
commandQueue->reply(&reply); commandQueue->reply(&reply);
} else { } else {
CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter); CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, parameter);
commandQueue->reply(&reply); commandQueue->reply(&reply);
} }
} }
@ -767,9 +769,10 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
return; return;
} }
CommandMessage message; MessageQueueMessage message;
CommandMessage command(&message);
DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message, DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
getObjectId(), address, isCommand); getObjectId(), address, isCommand);
// this->DeviceHandlerCommand = CommandMessage::CMD_NONE; // this->DeviceHandlerCommand = CommandMessage::CMD_NONE;

7
devicehandlers/HealthDevice.cpp
View File

@ -13,10 +13,11 @@ HealthDevice::~HealthDevice() {
} }
ReturnValue_t HealthDevice::performOperation(uint8_t opCode) { ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
CommandMessage message; MessageQueueMessage message;
ReturnValue_t result = commandQueue->receiveMessage(&message); CommandMessage command(&message);
ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result == HasReturnvaluesIF::RETURN_OK) { if (result == HasReturnvaluesIF::RETURN_OK) {
healthHelper.handleHealthCommand(&message); healthHelper.handleHealthCommand(&command);
} }
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }

20
health/HealthHelper.cpp
View File

@ -65,29 +65,31 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
if (parentQueue == 0) { if (parentQueue == 0) {
return; return;
} }
CommandMessage message; MessageQueueMessage message;
HealthMessage::setHealthMessage(&message, HealthMessage::HEALTH_INFO, CommandMessage information(&message);
HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
health, oldHealth); health, oldHealth);
if (MessageQueueSenderIF::sendMessage(parentQueue, &message, if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) { owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
sif::debug << "HealthHelper::informParent: sending health reply failed." sif::debug << "HealthHelper::informParent: sending health reply failed."
<< std::endl; << std::endl;
} }
} }
void HealthHelper::handleSetHealthCommand(CommandMessage* message) { void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(message)); ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
if (message->getSender() == 0) { if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
return; return;
} }
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
if (result == HasReturnvaluesIF::RETURN_OK) { if (result == HasReturnvaluesIF::RETURN_OK) {
HealthMessage::setHealthMessage(&reply, HealthMessage::setHealthMessage(&reply,
HealthMessage::REPLY_HEALTH_SET); HealthMessage::REPLY_HEALTH_SET);
} else { } else {
reply.setReplyRejected(result, message->getCommand()); reply.setReplyRejected(result, command->getCommand());
} }
if (MessageQueueSenderIF::sendMessage(message->getSender(), &reply, if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) { owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
sif::debug << "HealthHelper::handleHealthCommand: sending health " sif::debug << "HealthHelper::handleHealthCommand: sending health "
"reply failed." << std::endl; "reply failed." << std::endl;

62
ipc/CommandMessage.cpp
View File

@ -14,14 +14,26 @@ void clearMissionMessage(CommandMessage* message);
} }
CommandMessage::CommandMessage() { CommandMessage::CommandMessage(MessageQueueMessage* receiverMessage):
this->messageSize = COMMAND_MESSAGE_SIZE; internalMessage(receiverMessage) {
if(receiverMessage == nullptr) {
sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
" as the message queue message, pass the address of an actual"
" message!" << std::endl;
}
internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
setCommand(CMD_NONE); setCommand(CMD_NONE);
} }
CommandMessage::CommandMessage(Command_t command, uint32_t parameter1, CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
uint32_t parameter2) { Command_t command, uint32_t parameter1, uint32_t parameter2):
this->messageSize = COMMAND_MESSAGE_SIZE; internalMessage(messageToSet) {
if(messageToSet == nullptr) {
sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
" as the message queue message, pass the address of an actual"
" message!" << std::endl;
}
internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
setCommand(command); setCommand(command);
setParameter(parameter1); setParameter(parameter1);
setParameter2(parameter2); setParameter2(parameter2);
@ -29,7 +41,7 @@ CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
Command_t CommandMessage::getCommand() const { Command_t CommandMessage::getCommand() const {
Command_t command; Command_t command;
memcpy(&command, getData(), sizeof(Command_t)); memcpy(&command, internalMessage->getData(), sizeof(Command_t));
return command; return command;
} }
@ -38,29 +50,35 @@ uint8_t CommandMessage::getMessageType() const {
} }
void CommandMessage::setCommand(Command_t command) { void CommandMessage::setCommand(Command_t command) {
memcpy(getData(), &command, sizeof(command)); memcpy(internalMessage->getData(), &command, sizeof(command));
} }
uint32_t CommandMessage::getParameter() const { uint32_t CommandMessage::getParameter() const {
uint32_t parameter1; uint32_t parameter1;
memcpy(&parameter1, getData() + sizeof(Command_t), sizeof(parameter1)); memcpy(&parameter1, internalMessage->getData() + sizeof(Command_t),
sizeof(parameter1));
return parameter1; return parameter1;
} }
void CommandMessage::setParameter(uint32_t parameter1) { void CommandMessage::setParameter(uint32_t parameter1) {
memcpy(getData() + sizeof(Command_t), &parameter1, sizeof(parameter1)); memcpy(internalMessage->getData() + sizeof(Command_t),
&parameter1, sizeof(parameter1));
} }
uint32_t CommandMessage::getParameter2() const { uint32_t CommandMessage::getParameter2() const {
uint32_t parameter2; uint32_t parameter2;
memcpy(&parameter2, getData() + sizeof(Command_t) + sizeof(uint32_t), memcpy(&parameter2, internalMessage->getData() + sizeof(Command_t)
sizeof(parameter2)); + sizeof(uint32_t), sizeof(parameter2));
return parameter2; return parameter2;
} }
void CommandMessage::setParameter2(uint32_t parameter2) { void CommandMessage::setParameter2(uint32_t parameter2) {
memcpy(getData() + sizeof(Command_t) + sizeof(uint32_t), &parameter2, memcpy(internalMessage-> getData() + sizeof(Command_t) + sizeof(uint32_t),
sizeof(parameter2)); &parameter2, sizeof(parameter2));
}
void CommandMessage::clear() {
clearCommandMessage();
} }
void CommandMessage::clearCommandMessage() { void CommandMessage::clearCommandMessage() {
@ -109,7 +127,7 @@ size_t CommandMessage::getMinimumMessageSize() const {
void CommandMessage::setToUnknownCommand() { void CommandMessage::setToUnknownCommand() {
Command_t initialCommand = getCommand(); Command_t initialCommand = getCommand();
clearCommandMessage(); clearCommandMessage();
setReplyRejected(UNKNOW_COMMAND, initialCommand); setReplyRejected(UNKNOWN_COMMAND, initialCommand);
} }
void CommandMessage::setReplyRejected(ReturnValue_t reason, void CommandMessage::setReplyRejected(ReturnValue_t reason,
@ -118,3 +136,19 @@ void CommandMessage::setReplyRejected(ReturnValue_t reason,
setParameter(reason); setParameter(reason);
setParameter2(initialCommand); setParameter2(initialCommand);
} }
MessageQueueId_t CommandMessage::getSender() const {
return internalMessage->getSender();
}
uint8_t* CommandMessage::getBuffer() {
return internalMessage->getBuffer();
}
void CommandMessage::setSender(MessageQueueId_t setId) {
internalMessage->setSender(setId);
}
const uint8_t* CommandMessage::getBuffer() const {
return internalMessage->getBuffer();
}

28
ipc/CommandMessage.h
View File

@ -13,10 +13,10 @@ typedef uint16_t Command_t;
* @brief Used to pass command messages between tasks * @brief Used to pass command messages between tasks
* @author Bastian Baetz * @author Bastian Baetz
*/ */
class CommandMessage : public MessageQueueMessage { class CommandMessage: public MessageQueueMessageIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE; static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
static const ReturnValue_t UNKNOW_COMMAND = MAKE_RETURN_CODE(0x01); static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
static const uint8_t MESSAGE_ID = messagetypes::COMMAND; static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
@ -31,7 +31,7 @@ public:
* This is the size of a message as it is seen by the MessageQueue. * This is the size of a message as it is seen by the MessageQueue.
* 14 of the 24 available MessageQueueMessage bytes are used. * 14 of the 24 available MessageQueueMessage bytes are used.
*/ */
static const size_t COMMAND_MESSAGE_SIZE = HEADER_SIZE static const size_t COMMAND_MESSAGE_SIZE = MessageQueueMessage::HEADER_SIZE
+ sizeof(Command_t) + 2 * sizeof(uint32_t); + sizeof(Command_t) + 2 * sizeof(uint32_t);
/** /**
@ -40,7 +40,7 @@ public:
* This constructor should be used when receiving a Message, as the * This constructor should be used when receiving a Message, as the
* content is filled by the MessageQueue. * content is filled by the MessageQueue.
*/ */
CommandMessage(); CommandMessage(MessageQueueMessage* receiverMessage);
/** /**
* This constructor creates a new message with all message content * This constructor creates a new message with all message content
* initialized * initialized
@ -49,7 +49,7 @@ public:
* @param parameter1 The first parameter * @param parameter1 The first parameter
* @param parameter2 The second parameter * @param parameter2 The second parameter
*/ */
CommandMessage(Command_t command, CommandMessage(MessageQueueMessage* messageToSet, Command_t command,
uint32_t parameter1, uint32_t parameter2); uint32_t parameter1, uint32_t parameter2);
/** /**
@ -58,6 +58,8 @@ public:
virtual ~CommandMessage() { virtual ~CommandMessage() {
} }
uint8_t * getBuffer() override;
const uint8_t * getBuffer() const override;
/** /**
* Read the DeviceHandlerCommand_t that is stored in the message, * Read the DeviceHandlerCommand_t that is stored in the message,
* usually used after receiving. * usually used after receiving.
@ -66,6 +68,16 @@ public:
*/ */
Command_t getCommand() const; Command_t getCommand() const;
/**
* @brief This method is used to set the sender's message queue id
* information prior to sending the message.
* @param setId
* The message queue id that identifies the sending message queue.
*/
void setSender(MessageQueueId_t setId) override;
MessageQueueId_t getSender() const override;
uint8_t getMessageType() const; uint8_t getMessageType() const;
/** /**
* Set the DeviceHandlerCOmmand_t of the message * Set the DeviceHandlerCOmmand_t of the message
@ -102,6 +114,7 @@ public:
*/ */
void setParameter2(uint32_t parameter2); void setParameter2(uint32_t parameter2);
void clear() override;
/** /**
* Set the command to CMD_NONE and try to find * Set the command to CMD_NONE and try to find
* the correct class to handle a more detailed * the correct class to handle a more detailed
@ -129,7 +142,10 @@ public:
void setToUnknownCommand(); void setToUnknownCommand();
void setReplyRejected(ReturnValue_t reason, void setReplyRejected(ReturnValue_t reason,
Command_t initialCommand = CMD_NONE); Command_t initialCommand = CMD_NONE);
size_t getMinimumMessageSize() const; size_t getMinimumMessageSize() const override;
private:
MessageQueueMessage* internalMessage;
}; };

16
ipc/MessageQueueIF.h
View File

@ -15,7 +15,7 @@
#include <framework/returnvalues/HasReturnvaluesIF.h> #include <framework/returnvalues/HasReturnvaluesIF.h>
class MessageQueueIF { class MessageQueueIF {
public: public:
static const MessageQueueId_t NO_QUEUE = MessageQueueSenderIF::NO_QUEUE; //!< Ugly hack. static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF; static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
/** /**
@ -41,7 +41,7 @@ public:
* @return RETURN_OK if ok * @return RETURN_OK if ok
* @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
*/ */
virtual ReturnValue_t reply( MessageQueueMessage* message ) = 0; virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
/** /**
* @brief This function reads available messages from the message queue and returns the sender. * @brief This function reads available messages from the message queue and returns the sender.
@ -50,7 +50,7 @@ public:
* @param message A pointer to a message in which the received data is stored. * @param message A pointer to a message in which the received data is stored.
* @param receivedFrom A pointer to a queue id in which the sender's id is stored. * @param receivedFrom A pointer to a queue id in which the sender's id is stored.
*/ */
virtual ReturnValue_t receiveMessage(MessageQueueMessage* message, virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
MessageQueueId_t *receivedFrom) = 0; MessageQueueId_t *receivedFrom) = 0;
/** /**
@ -65,7 +65,7 @@ public:
* @return -@c RETURN_OK on success * @return -@c RETURN_OK on success
* -@c MessageQueueIF::EMPTY if queue is empty * -@c MessageQueueIF::EMPTY if queue is empty
*/ */
virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) = 0; virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
/** /**
* Deletes all pending messages in the queue. * Deletes all pending messages in the queue.
* @param count The number of flushed messages. * @param count The number of flushed messages.
@ -95,7 +95,7 @@ public:
* -@c MessageQueueIF::FULL if queue is full * -@c MessageQueueIF::FULL if queue is full
*/ */
virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
MessageQueueMessage* message, MessageQueueId_t sentFrom, MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
bool ignoreFault = false ) = 0; bool ignoreFault = false ) = 0;
/** /**
@ -107,7 +107,7 @@ public:
* @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full. * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
*/ */
virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo, virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
MessageQueueMessage* message, bool ignoreFault = false ) = 0; MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
/** /**
* @brief The sendToDefaultFrom method sends a queue message to the default destination. * @brief The sendToDefaultFrom method sends a queue message to the default destination.
@ -118,7 +118,7 @@ public:
* @return -@c RETURN_OK on success * @return -@c RETURN_OK on success
* -@c MessageQueueIF::FULL if queue is full * -@c MessageQueueIF::FULL if queue is full
*/ */
virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0; MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
/** /**
* @brief This operation sends a message to the default destination. * @brief This operation sends a message to the default destination.
@ -128,7 +128,7 @@ public:
* @return -@c RETURN_OK on success * @return -@c RETURN_OK on success
* -@c MessageQueueIF::FULL if queue is full * -@c MessageQueueIF::FULL if queue is full
*/ */
virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) = 0; virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) = 0;
/** /**
* \brief This method is a simple setter for the default destination. * \brief This method is a simple setter for the default destination.
*/ */

2
ipc/MessageQueueMessage.cpp
View File

@ -51,7 +51,7 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t)); memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
} }
size_t MessageQueueMessage::getMinimumMessageSize() { size_t MessageQueueMessage::getMinimumMessageSize() const {
return this->HEADER_SIZE; return this->HEADER_SIZE;
} }

2
ipc/MessageQueueMessage.h
View File

@ -132,7 +132,7 @@ public:
* @details The method must be overwritten by child classes if size checks shall be more strict. * @details The method must be overwritten by child classes if size checks shall be more strict.
* @return The default implementation returns HEADER_SIZE. * @return The default implementation returns HEADER_SIZE.
*/ */
virtual size_t getMinimumMessageSize(); virtual size_t getMinimumMessageSize() const;
}; };
#endif /* MESSAGEQUEUEMESSAGE_H_ */ #endif /* MESSAGEQUEUEMESSAGE_H_ */

29
ipc/MessageQueueMessageIF.h
View File

@ -1,10 +1,23 @@
#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
#include <framework/ipc/MessageQueueSenderIF.h>
#include <cstddef> #include <cstddef>
#include <cstdint>
/*
* TODO: Actually, the definition of this ID to be a uint32_t is not ideal and
* breaks layering. However, it is difficult to keep layering, as the ID is
* stored in many places and sent around in MessageQueueMessage.
* Ideally, one would use the (current) object_id_t only, however, doing a
* lookup of queueIDs for every call does not sound ideal.
* In a first step, I'll circumvent the issue by not touching it,
* maybe in a second step. This also influences Interface design
* (getCommandQueue) and some other issues.. */
typedef uint32_t MessageQueueId_t;
class MessageQueueMessageIF { class MessageQueueMessageIF {
public: public:
static const MessageQueueId_t NO_QUEUE = 0xffffffff;
virtual ~MessageQueueMessageIF() {}; virtual ~MessageQueueMessageIF() {};
/** /**
@ -12,11 +25,11 @@ public:
* size is set to zero. * size is set to zero.
*/ */
virtual void clear() = 0; virtual void clear() = 0;
/** // /**
* @brief This is a debug method that prints the content // * @brief This is a debug method that prints the content
* (till messageSize) to the debug output. // * (till messageSize) to the debug output.
*/ // */
virtual void print() = 0; // virtual void print() = 0;
/** /**
* @brief Get read-only pointer to the raw buffer. * @brief Get read-only pointer to the raw buffer.
@ -37,11 +50,13 @@ public:
*/ */
virtual void setSender(MessageQueueId_t setId) = 0; virtual void setSender(MessageQueueId_t setId) = 0;
virtual MessageQueueId_t getSender() const = 0;
/** /**
* @brief This helper function is used by the MessageQueue class to * @brief This helper function is used by the MessageQueue class to
* check the size of an incoming message. * check the size of an incoming message.
*/ */
virtual size_t getMinimumMessageSize() = 0; virtual size_t getMinimumMessageSize() const = 0;
}; };

16
ipc/MessageQueueSenderIF.h
View File

@ -1,22 +1,11 @@
#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ #ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ #define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
#include <framework/ipc/MessageQueueMessageIF.h>
#include <framework/objectmanager/ObjectManagerIF.h> #include <framework/objectmanager/ObjectManagerIF.h>
class MessageQueueMessage;
//TODO: Actually, the definition of this ID to be a uint32_t is not ideal and breaks layering.
//However, it is difficult to keep layering, as the ID is stored in many places and sent around in
//MessageQueueMessage.
//Ideally, one would use the (current) object_id_t only, however, doing a lookup of queueIDs for every
//call does not sound ideal.
//In a first step, I'll circumvent the issue by not touching it, maybe in a second step.
//This also influences Interface design (getCommandQueue) and some other issues..
typedef uint32_t MessageQueueId_t;
class MessageQueueSenderIF { class MessageQueueSenderIF {
public: public:
static const MessageQueueId_t NO_QUEUE = 0xffffffff;
virtual ~MessageQueueSenderIF() {} virtual ~MessageQueueSenderIF() {}
@ -26,7 +15,8 @@ public:
* Must be implemented by a subclass. * Must be implemented by a subclass.
*/ */
static ReturnValue_t sendMessage(MessageQueueId_t sendTo, static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
MessageQueueMessage* message, MessageQueueId_t sentFrom = MessageQueueSenderIF::NO_QUEUE, MessageQueueMessageIF* message,
MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
bool ignoreFault=false); bool ignoreFault=false);
private: private:
MessageQueueSenderIF() {} MessageQueueSenderIF() {}

15
memory/MemoryHelper.cpp
View File

@ -51,14 +51,16 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
break; break;
default: default:
ipcStore->deleteData(ipcAddress); ipcStore->deleteData(ipcAddress);
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
MemoryMessage::setMemoryReplyFailed(&reply, errorCode, MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
MemoryMessage::CMD_MEMORY_LOAD); MemoryMessage::CMD_MEMORY_LOAD);
queueToUse->sendMessage(lastSender, &reply); queueToUse->sendMessage(lastSender, &reply);
return; return;
} }
//Only reached on success //Only reached on success
CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0); MessageQueueMessage message;
CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
queueToUse->sendMessage(lastSender, &reply); queueToUse->sendMessage(lastSender, &reply);
ipcStore->deleteData(ipcAddress); ipcStore->deleteData(ipcAddress);
} }
@ -66,7 +68,8 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
void MemoryHelper::completeDump(ReturnValue_t errorCode, void MemoryHelper::completeDump(ReturnValue_t errorCode,
const uint8_t* dataToCopy, const uint32_t size) { const uint8_t* dataToCopy, const uint32_t size) {
busy = false; busy = false;
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand); MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
switch (errorCode) { switch (errorCode) {
case HasMemoryIF::DO_IT_MYSELF: case HasMemoryIF::DO_IT_MYSELF:
@ -151,7 +154,8 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
completeLoad(returnCode, p_data, size, dataPointer); completeLoad(returnCode, p_data, size, dataPointer);
} else { } else {
//At least inform sender. //At least inform sender.
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
MemoryMessage::setMemoryReplyFailed(&reply, returnCode, MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
MemoryMessage::CMD_MEMORY_LOAD); MemoryMessage::CMD_MEMORY_LOAD);
queueToUse->sendMessage(lastSender, &reply); queueToUse->sendMessage(lastSender, &reply);
@ -169,7 +173,8 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
reservedSpaceInIPC); reservedSpaceInIPC);
completeDump(returnCode, dataPointer, size); completeDump(returnCode, dataPointer, size);
} else { } else {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand); MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
queueToUse->sendMessage(lastSender, &reply); queueToUse->sendMessage(lastSender, &reply);
} }

31
modes/ModeHelper.cpp
View File

@ -11,31 +11,32 @@ ModeHelper::~ModeHelper() {
} }
ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) { ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
Mode_t mode; Mode_t mode;
Submode_t submode; Submode_t submode;
switch (message->getCommand()) { switch (command->getCommand()) {
case ModeMessage::CMD_MODE_COMMAND_FORCED: case ModeMessage::CMD_MODE_COMMAND_FORCED:
forced = true; forced = true;
/* NO BREAK falls through*/ /* NO BREAK falls through*/
case ModeMessage::CMD_MODE_COMMAND: { case ModeMessage::CMD_MODE_COMMAND: {
mode = ModeMessage::getMode(message); mode = ModeMessage::getMode(command);
submode = ModeMessage::getSubmode(message); submode = ModeMessage::getSubmode(command);
uint32_t timeout; uint32_t timeout;
ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout); ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
ModeMessage::cantReachMode(&reply, result); ModeMessage::cantReachMode(&reply, result);
MessageQueueSenderIF::sendMessage(message->getSender(), &reply, MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
owner->getCommandQueue()); owner->getCommandQueue());
break; break;
} }
//Free to start transition //Free to start transition
theOneWhoCommandedAMode = message->getSender(); theOneWhoCommandedAMode = command->getSender();
commandedMode = mode; commandedMode = mode;
commandedSubmode = submode; commandedSubmode = submode;
if ((parentQueueId != MessageQueueSenderIF::NO_QUEUE) if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
&& (theOneWhoCommandedAMode != parentQueueId)) { && (theOneWhoCommandedAMode != parentQueueId)) {
owner->setToExternalControl(); owner->setToExternalControl();
} }
@ -48,7 +49,7 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
owner->getMode(&mode, &submode); owner->getMode(&mode, &submode);
ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode, ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
submode); submode);
MessageQueueSenderIF::sendMessage(message->getSender(), &reply, MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
owner->getCommandQueue()); owner->getCommandQueue());
} }
break; break;
@ -73,13 +74,14 @@ void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
forced = false; forced = false;
sendModeReplyMessage(ownerMode, ownerSubmode); sendModeReplyMessage(ownerMode, ownerSubmode);
sendModeInfoMessage(ownerMode, ownerSubmode); sendModeInfoMessage(ownerMode, ownerSubmode);
theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE; theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
} }
void ModeHelper::sendModeReplyMessage(Mode_t ownerMode, void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
Submode_t ownerSubmode) { Submode_t ownerSubmode) {
CommandMessage reply; MessageQueueMessage message;
if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE) CommandMessage reply(&message);
if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
{ {
if (ownerMode != commandedMode or ownerSubmode != commandedSubmode) if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
{ {
@ -99,9 +101,10 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
void ModeHelper::sendModeInfoMessage(Mode_t ownerMode, void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
Submode_t ownerSubmode) { Submode_t ownerSubmode) {
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
if (theOneWhoCommandedAMode != parentQueueId if (theOneWhoCommandedAMode != parentQueueId
and parentQueueId != MessageQueueSenderIF::NO_QUEUE) and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
{ {
ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO, ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
ownerMode, ownerSubmode); ownerMode, ownerSubmode);

3
monitoring/LimitViolationReporter.cpp
View File

@ -31,7 +31,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
CommandMessage report; MessageQueueMessage message;
CommandMessage report(&message);
MonitoringMessage::setLimitViolationReport(&report, storeId); MonitoringMessage::setLimitViolationReport(&report, storeId);
return MessageQueueSenderIF::sendMessage(reportQueue, &report); return MessageQueueSenderIF::sendMessage(reportQueue, &report);
} }

18
osal/FreeRTOS/MessageQueue.cpp
View File

@ -25,21 +25,21 @@ void MessageQueue::switchSystemContext(CallContext callContext) {
} }
ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo, ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
MessageQueueMessage* message, bool ignoreFault) { MessageQueueMessageIF* message, bool ignoreFault) {
return sendMessageFrom(sendTo, message, this->getId(), ignoreFault); return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
} }
ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) { ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
return sendToDefaultFrom(message, this->getId()); return sendToDefaultFrom(message, this->getId());
} }
ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message, ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
MessageQueueId_t sentFrom, bool ignoreFault) { MessageQueueId_t sentFrom, bool ignoreFault) {
return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault); return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
} }
ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) { ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
if (this->lastPartner != 0) { if (this->lastPartner != MessageQueueMessageIF::NO_QUEUE) {
return sendMessageFrom(this->lastPartner, message, this->getId()); return sendMessageFrom(this->lastPartner, message, this->getId());
} else { } else {
return NO_REPLY_PARTNER; return NO_REPLY_PARTNER;
@ -47,7 +47,7 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
} }
ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo, ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
MessageQueueMessage* message, MessageQueueId_t sentFrom, MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
bool ignoreFault) { bool ignoreFault) {
return sendMessageFromMessageQueue(sendTo, message, sentFrom, return sendMessageFromMessageQueue(sendTo, message, sentFrom,
ignoreFault, callContext); ignoreFault, callContext);
@ -69,7 +69,7 @@ ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message, ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
MessageQueueId_t* receivedFrom) { MessageQueueId_t* receivedFrom) {
ReturnValue_t status = this->receiveMessage(message); ReturnValue_t status = this->receiveMessage(message);
if(status == HasReturnvaluesIF::RETURN_OK) { if(status == HasReturnvaluesIF::RETURN_OK) {
@ -78,7 +78,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
return status; return status;
} }
ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) { ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>( BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
message->getBuffer()), 0); message->getBuffer()), 0);
if (result == pdPASS){ if (result == pdPASS){
@ -120,7 +120,7 @@ bool MessageQueue::isDefaultDestinationSet() const {
// static core function to send messages. // static core function to send messages.
ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo, ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
MessageQueueMessage *message, MessageQueueId_t sentFrom, MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
bool ignoreFault, CallContext callContext) { bool ignoreFault, CallContext callContext) {
message->setSender(sentFrom); message->setSender(sentFrom);
BaseType_t result; BaseType_t result;

19
osal/FreeRTOS/MessageQueue.h
View File

@ -85,14 +85,14 @@ public:
* @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full. * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
*/ */
ReturnValue_t sendMessage(MessageQueueId_t sendTo, ReturnValue_t sendMessage(MessageQueueId_t sendTo,
MessageQueueMessage* message, bool ignoreFault = false ); MessageQueueMessageIF* message, bool ignoreFault = false );
/** /**
* @brief This operation sends a message to the default destination. * @brief This operation sends a message to the default destination.
* @details As in the sendMessage method, this function uses the sendToDefault call of the * @details As in the sendMessage method, this function uses the sendToDefault call of the
* MessageQueueSender parent class and adds its queue id as "sentFrom" information. * MessageQueueSender parent class and adds its queue id as "sentFrom" information.
* @param message A pointer to a previously created message, which is sent. * @param message A pointer to a previously created message, which is sent.
*/ */
ReturnValue_t sendToDefault( MessageQueueMessage* message ); ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
/** /**
* @brief This operation sends a message to the last communication partner. * @brief This operation sends a message to the last communication partner.
* @details This operation simplifies answering an incoming message by using the stored * @details This operation simplifies answering an incoming message by using the stored
@ -100,7 +100,7 @@ public:
* (i.e. lastPartner is zero), an error code is returned. * (i.e. lastPartner is zero), an error code is returned.
* @param message A pointer to a previously created message, which is sent. * @param message A pointer to a previously created message, which is sent.
*/ */
ReturnValue_t reply( MessageQueueMessage* message ); ReturnValue_t reply( MessageQueueMessageIF* message );
/** /**
* @brief With the sendMessage call, a queue message is sent to a receiving queue. * @brief With the sendMessage call, a queue message is sent to a receiving queue.
@ -113,8 +113,9 @@ public:
* This variable is set to zero by default. * This variable is set to zero by default.
* @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full. * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
*/ */
virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false ); MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
bool ignoreFault = false );
/** /**
* @brief The sendToDefault method sends a queue message to the default destination. * @brief The sendToDefault method sends a queue message to the default destination.
@ -123,7 +124,7 @@ public:
* @param sentFrom The sentFrom information can be set to inject the sender's queue id into the message. * @param sentFrom The sentFrom information can be set to inject the sender's queue id into the message.
* This variable is set to zero by default. * This variable is set to zero by default.
*/ */
virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false ); MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
/** /**
@ -133,7 +134,7 @@ public:
* @param message A pointer to a message in which the received data is stored. * @param message A pointer to a message in which the received data is stored.
* @param receivedFrom A pointer to a queue id in which the sender's id is stored. * @param receivedFrom A pointer to a queue id in which the sender's id is stored.
*/ */
ReturnValue_t receiveMessage(MessageQueueMessage* message, ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
MessageQueueId_t *receivedFrom); MessageQueueId_t *receivedFrom);
/** /**
@ -144,7 +145,7 @@ public:
* message's content is cleared and the function returns immediately. * message's content is cleared and the function returns immediately.
* @param message A pointer to a message in which the received data is stored. * @param message A pointer to a message in which the received data is stored.
*/ */
ReturnValue_t receiveMessage(MessageQueueMessage* message); ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
/** /**
* Deletes all pending messages in the queue. * Deletes all pending messages in the queue.
* @param count The number of flushed messages. * @param count The number of flushed messages.
@ -191,7 +192,7 @@ protected:
* @param context Specify whether call is made from task or from an ISR. * @param context Specify whether call is made from task or from an ISR.
*/ */
static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo, static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
bool ignoreFault=false, CallContext callContext = CallContext::TASK); bool ignoreFault=false, CallContext callContext = CallContext::TASK);
static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault); static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);

2
osal/FreeRTOS/QueueFactory.cpp
View File

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

9
parameters/ParameterHelper.cpp
View File

@ -102,7 +102,8 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
return result; return result;
} }
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ParameterMessage::setParameterDumpReply(&reply, id, address); ParameterMessage::setParameterDumpReply(&reply, id, address);
@ -123,8 +124,10 @@ ReturnValue_t ParameterHelper::initialize() {
} }
} }
void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason, Command_t initialCommand) { void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
CommandMessage reply; Command_t initialCommand) {
MessageQueueMessage message;
CommandMessage reply(&message);
reply.setReplyRejected(reason, initialCommand); reply.setReplyRejected(reason, initialCommand);
MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId); MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
} }

3
power/Fuse.cpp
View File

@ -163,7 +163,8 @@ void Fuse::setAllMonitorsToUnchecked() {
} }
void Fuse::checkCommandQueue() { void Fuse::checkCommandQueue() {
CommandMessage command; MessageQueueMessage message;
CommandMessage command(&message);
ReturnValue_t result = commandQueue->receiveMessage(&command); ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return; return;

3
power/PowerSensor.cpp
View File

@ -74,7 +74,8 @@ void PowerSensor::setAllMonitorsToUnchecked() {
} }
void PowerSensor::checkCommandQueue() { void PowerSensor::checkCommandQueue() {
CommandMessage command; MessageQueueMessage message;
CommandMessage command(&message);
ReturnValue_t result = commandQueue->receiveMessage(&command); ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return; return;

14
subsystem/Subsystem.cpp
View File

@ -309,7 +309,8 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
break; break;
case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: { case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size(); uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ModeSequenceMessage::setModeSequenceMessage(&reply, ModeSequenceMessage::setModeSequenceMessage(&reply,
ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots); ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
commandQueue->reply(&reply); commandQueue->reply(&reply);
@ -317,7 +318,8 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
break; break;
case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: { case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
uint32_t free = modeTables.maxSize() - modeTables.size(); uint32_t free = modeTables.maxSize() - modeTables.size();
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ModeSequenceMessage::setModeSequenceMessage(&reply, ModeSequenceMessage::setModeSequenceMessage(&reply,
ModeSequenceMessage::FREE_TABLE_SLOTS, free); ModeSequenceMessage::FREE_TABLE_SLOTS, free);
commandQueue->reply(&reply); commandQueue->reply(&reply);
@ -330,11 +332,12 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
} }
void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) { void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
MessageQueueMessage message;
if (status == RETURN_OK) { if (status == RETURN_OK) {
CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0); CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
commandQueue->reply(&reply); commandQueue->reply(&reply);
} else { } else {
CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0); CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, 0);
commandQueue->reply(&reply); commandQueue->reply(&reply);
} }
} }
@ -617,7 +620,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
for (uint8_t i = 0; i < count; i++) { for (uint8_t i = 0; i < count; i++) {
elements[i]->serialize(&storeBuffer, &size, maxSize, true); elements[i]->serialize(&storeBuffer, &size, maxSize, true);
} }
CommandMessage reply; MessageQueueMessage message;
CommandMessage reply(&message);
ModeSequenceMessage::setModeSequenceMessage(&reply, command, address); ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
if (commandQueue->reply(&reply) != RETURN_OK) { if (commandQueue->reply(&reply) != RETURN_OK) {
IPCStore->deleteData(address); IPCStore->deleteData(address);

43
subsystem/SubsystemBase.cpp
View File

@ -9,7 +9,7 @@ SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
false), commandsOutstanding(0), commandQueue(NULL), healthHelper(this, false), commandsOutstanding(0), commandQueue(NULL), healthHelper(this,
setObjectId), modeHelper(this), parentId(parent) { setObjectId), modeHelper(this), parentId(parent) {
commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth, commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
CommandMessage::MAX_MESSAGE_SIZE); MessageQueueMessage::MAX_MESSAGE_SIZE);
} }
SubsystemBase::~SubsystemBase() { SubsystemBase::~SubsystemBase() {
@ -77,8 +77,8 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
} }
void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) { void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
MessageQueueMessage message;
CommandMessage message; CommandMessage command(&message);
std::map<object_id_t, ChildInfo>::iterator iter; std::map<object_id_t, ChildInfo>::iterator iter;
@ -100,17 +100,17 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
if (healthHelper.healthTable->hasHealth(object)) { if (healthHelper.healthTable->hasHealth(object)) {
if (healthHelper.healthTable->isFaulty(object)) { if (healthHelper.healthTable->isFaulty(object)) {
ModeMessage::setModeMessage(&message, ModeMessage::setModeMessage(&command,
ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF, ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
SUBMODE_NONE); SUBMODE_NONE);
} else { } else {
if (modeHelper.isForced()) { if (modeHelper.isForced()) {
ModeMessage::setModeMessage(&message, ModeMessage::setModeMessage(&command,
ModeMessage::CMD_MODE_COMMAND_FORCED, ModeMessage::CMD_MODE_COMMAND_FORCED,
tableIter.value->getMode(), submodeToCommand); tableIter.value->getMode(), submodeToCommand);
} else { } else {
if (healthHelper.healthTable->isCommandable(object)) { if (healthHelper.healthTable->isCommandable(object)) {
ModeMessage::setModeMessage(&message, ModeMessage::setModeMessage(&command,
ModeMessage::CMD_MODE_COMMAND, ModeMessage::CMD_MODE_COMMAND,
tableIter.value->getMode(), submodeToCommand); tableIter.value->getMode(), submodeToCommand);
} else { } else {
@ -119,12 +119,12 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
} }
} }
} else { } else {
ModeMessage::setModeMessage(&message, ModeMessage::CMD_MODE_COMMAND, ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
tableIter.value->getMode(), submodeToCommand); tableIter.value->getMode(), submodeToCommand);
} }
if ((iter->second.mode == ModeMessage::getMode(&message)) if ((iter->second.mode == ModeMessage::getMode(&command))
&& (iter->second.submode == ModeMessage::getSubmode(&message)) && (iter->second.submode == ModeMessage::getSubmode(&command))
&& !modeHelper.isForced()) { && !modeHelper.isForced()) {
continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
} }
@ -297,7 +297,8 @@ void SubsystemBase::setToExternalControl() {
void SubsystemBase::announceMode(bool recursive) { void SubsystemBase::announceMode(bool recursive) {
triggerEvent(MODE_INFO, mode, submode); triggerEvent(MODE_INFO, mode, submode);
if (recursive) { if (recursive) {
CommandMessage command; MessageQueueMessage message;
CommandMessage command(&message);
ModeMessage::setModeMessage(&command, ModeMessage::setModeMessage(&command,
ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0); ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
commandAllChildren(&command); commandAllChildren(&command);
@ -306,31 +307,33 @@ void SubsystemBase::announceMode(bool recursive) {
void SubsystemBase::checkCommandQueue() { void SubsystemBase::checkCommandQueue() {
ReturnValue_t result; ReturnValue_t result;
CommandMessage message; MessageQueueMessage message;
CommandMessage command(&message);
for (result = commandQueue->receiveMessage(&message); result == RETURN_OK; for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
result = commandQueue->receiveMessage(&message)) { result = commandQueue->receiveMessage(&command)) {
result = healthHelper.handleHealthCommand(&message); result = healthHelper.handleHealthCommand(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
result = modeHelper.handleModeCommand(&message); result = modeHelper.handleModeCommand(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
result = handleModeReply(&message); result = handleModeReply(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
result = handleCommandMessage(&message); result = handleCommandMessage(&command);
if (result != RETURN_OK) { if (result != RETURN_OK) {
CommandMessage reply; MessageQueueMessage message;
reply.setReplyRejected(CommandMessage::UNKNOW_COMMAND, CommandMessage reply(&message);
message.getCommand()); reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
command.getCommand());
replyToCommand(&reply); replyToCommand(&reply);
} }
} }

11
thermal/AbstractTemperatureSensor.cpp
View File

@ -44,18 +44,19 @@ ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
} }
void AbstractTemperatureSensor::handleCommandQueue() { void AbstractTemperatureSensor::handleCommandQueue() {
CommandMessage message; MessageQueueMessage message;
ReturnValue_t result = commandQueue->receiveMessage(&message); CommandMessage command(&message);
ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result == HasReturnvaluesIF::RETURN_OK) { if (result == HasReturnvaluesIF::RETURN_OK) {
result = healthHelper.handleHealthCommand(&message); result = healthHelper.handleHealthCommand(&command);
if (result == HasReturnvaluesIF::RETURN_OK) { if (result == HasReturnvaluesIF::RETURN_OK) {
return; return;
} }
result = parameterHelper.handleParameterMessage(&message); result = parameterHelper.handleParameterMessage(&command);
if (result == HasReturnvaluesIF::RETURN_OK) { if (result == HasReturnvaluesIF::RETURN_OK) {
return; return;
} }
message.setToUnknownCommand(); command.setToUnknownCommand();
commandQueue->reply(&message); commandQueue->reply(&message);
} }
} }

9
thermal/Heater.cpp
View File

@ -279,14 +279,15 @@ ReturnValue_t Heater::initialize() {
} }
void Heater::handleQueue() { void Heater::handleQueue() {
CommandMessage message; MessageQueueMessage message;
ReturnValue_t result = commandQueue->receiveMessage(&message); CommandMessage command(&message);
ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result == HasReturnvaluesIF::RETURN_OK) { if (result == HasReturnvaluesIF::RETURN_OK) {
result = healthHelper.handleHealthCommand(&message); result = healthHelper.handleHealthCommand(&command);
if (result == HasReturnvaluesIF::RETURN_OK) { if (result == HasReturnvaluesIF::RETURN_OK) {
return; return;
} }
parameterHelper.handleParameterMessage(&message); parameterHelper.handleParameterMessage(&command);
} }
} }

2
tmstorage/TmStoreMessage.cpp
View File

@ -74,7 +74,7 @@ void TmStoreMessage::clear(CommandMessage* cmd) {
case DELETE_STORE_CONTENT_BLOCKS: case DELETE_STORE_CONTENT_BLOCKS:
case DOWNLINK_STORE_CONTENT_BLOCKS: case DOWNLINK_STORE_CONTENT_BLOCKS:
case REPORT_INDEX_REQUEST: case REPORT_INDEX_REQUEST:
cmd->setCommand(UNKNOW_COMMAND); cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
cmd->setParameter(0); cmd->setParameter(0);
cmd->setParameter2(0); cmd->setParameter2(0);
break; break;

2
tmstorage/TmStoreMessage.h
View File

@ -5,7 +5,7 @@
#include <framework/storagemanager/StorageManagerIF.h> #include <framework/storagemanager/StorageManagerIF.h>
#include <framework/tmstorage/TmStorePackets.h> #include <framework/tmstorage/TmStorePackets.h>
#include <framework/objectmanager/SystemObjectIF.h> #include <framework/objectmanager/SystemObjectIF.h>
class TmStoreMessage: public CommandMessage { class TmStoreMessage {
public: public:
static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd, static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
bool setEnabled); bool setEnabled);

20
tmtcservices/CommandingServiceBase.cpp
View File

@ -77,7 +77,10 @@ ReturnValue_t CommandingServiceBase::initialize() {
} }
void CommandingServiceBase::handleCommandQueue() { void CommandingServiceBase::handleCommandQueue() {
CommandMessage reply, nextCommand; MessageQueueMessage replyMessage;
CommandMessage reply(&replyMessage);
MessageQueueMessage nextCommandMessage;
CommandMessage nextCommand(&nextCommandMessage);
ReturnValue_t result, sendResult = RETURN_OK; ReturnValue_t result, sendResult = RETURN_OK;
bool isStep = false; bool isStep = false;
for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK; for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
@ -268,16 +271,17 @@ void CommandingServiceBase::startExecution(
typename FixedMap<MessageQueueId_t, typename FixedMap<MessageQueueId_t,
CommandingServiceBase::CommandInfo>::Iterator *iter) { CommandingServiceBase::CommandInfo>::Iterator *iter) {
ReturnValue_t result, sendResult = RETURN_OK; ReturnValue_t result, sendResult = RETURN_OK;
CommandMessage message; MessageQueueMessage message;
CommandMessage command(&message);
(*iter)->subservice = storedPacket->getSubService(); (*iter)->subservice = storedPacket->getSubService();
result = prepareCommand(&message, (*iter)->subservice, result = prepareCommand(&command, (*iter)->subservice,
storedPacket->getApplicationData(), storedPacket->getApplicationData(),
storedPacket->getApplicationDataSize(), &(*iter)->state, storedPacket->getApplicationDataSize(), &(*iter)->state,
(*iter)->objectId); (*iter)->objectId);
switch (result) { switch (result) {
case RETURN_OK: case RETURN_OK:
if (message.getCommand() != CommandMessage::CMD_NONE) { if (command.getCommand() != CommandMessage::CMD_NONE) {
sendResult = commandQueue->sendMessage((*iter).value->first, sendResult = commandQueue->sendMessage((*iter).value->first,
&message); &message);
} }
@ -286,20 +290,20 @@ void CommandingServiceBase::startExecution(
(*iter)->step = 0; (*iter)->step = 0;
// (*iter)->state = 0; // (*iter)->state = 0;
(*iter)->subservice = storedPacket->getSubService(); (*iter)->subservice = storedPacket->getSubService();
(*iter)->command = message.getCommand(); (*iter)->command = command.getCommand();
(*iter)->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags(); (*iter)->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
(*iter)->tcInfo.tcPacketId = storedPacket->getPacketId(); (*iter)->tcInfo.tcPacketId = storedPacket->getPacketId();
(*iter)->tcInfo.tcSequenceControl = (*iter)->tcInfo.tcSequenceControl =
storedPacket->getPacketSequenceControl(); storedPacket->getPacketSequenceControl();
acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket); acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
} else { } else {
message.clearCommandMessage(); command.clearCommandMessage();
rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult); rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
checkAndExecuteFifo(iter); checkAndExecuteFifo(iter);
} }
break; break;
case EXECUTION_COMPLETE: case EXECUTION_COMPLETE:
if (message.getCommand() != CommandMessage::CMD_NONE) { if (command.getCommand() != CommandMessage::CMD_NONE) {
//Fire-and-forget command. //Fire-and-forget command.
sendResult = commandQueue->sendMessage((*iter).value->first, sendResult = commandQueue->sendMessage((*iter).value->first,
&message); &message);
@ -310,7 +314,7 @@ void CommandingServiceBase::startExecution(
acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket); acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
checkAndExecuteFifo(iter); checkAndExecuteFifo(iter);
} else { } else {
message.clearCommandMessage(); command.clearCommandMessage();
rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult); rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
checkAndExecuteFifo(iter); checkAndExecuteFifo(iter);
} }