diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp index 9d448aed..39290688 100644 --- a/ipc/CommandMessage.cpp +++ b/ipc/CommandMessage.cpp @@ -1,13 +1,5 @@ #include - -#include -#include -#include -#include -#include -#include -#include -#include +#include CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage): CommandMessageBase(receiverMessage) { @@ -50,23 +42,23 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet, uint32_t CommandMessage::getParameter() const { uint32_t parameter1; - memcpy(¶meter1, CommandMessageBase::getData(), sizeof(parameter1)); + std::memcpy(¶meter1, CommandMessageBase::getData(), sizeof(parameter1)); return parameter1; } void CommandMessage::setParameter(uint32_t parameter1) { - memcpy(CommandMessageBase::getData(), ¶meter1, sizeof(parameter1)); + std::memcpy(CommandMessageBase::getData(), ¶meter1, sizeof(parameter1)); } uint32_t CommandMessage::getParameter2() const { uint32_t parameter2; - memcpy(¶meter2, CommandMessageBase::getData() + sizeof(uint32_t), + std::memcpy(¶meter2, CommandMessageBase::getData() + sizeof(uint32_t), sizeof(parameter2)); return parameter2; } void CommandMessage::setParameter2(uint32_t parameter2) { - memcpy(CommandMessageBase::getData() + sizeof(uint32_t), ¶meter2, + std::memcpy(CommandMessageBase::getData() + sizeof(uint32_t), ¶meter2, sizeof(parameter2)); } @@ -84,60 +76,6 @@ bool CommandMessage::isClearedCommandMessage() { void CommandMessage::setToUnknownCommand() { Command_t initialCommand = getCommand(); - clearCommandMessage(); + this->clear(); setReplyRejected(UNKNOWN_COMMAND, initialCommand); } - -void CommandMessage::setReplyRejected(ReturnValue_t reason, - Command_t initialCommand) { - setCommand(REPLY_REJECTED); - setParameter(reason); - setParameter2(initialCommand); -} - -ReturnValue_t CommandMessage::getRejectedReplyReason( - Command_t* initialCommand) const { - if(initialCommand != nullptr) { - *initialCommand = getParameter2(); - } - return getParameter(); -} - -void CommandMessage::clear() { - clearCommandMessage(); -} - -void CommandMessage::clearCommandMessage() { - switch(this->getMessageType()){ - case messagetypes::MODE_COMMAND: - ModeMessage::clear(this); - break; - case messagetypes::HEALTH_COMMAND: - HealthMessage::clear(this); - break; - case messagetypes::MODE_SEQUENCE: - ModeSequenceMessage::clear(this); - break; - case messagetypes::ACTION: - ActionMessage::clear(this); - break; - case messagetypes::DEVICE_HANDLER_COMMAND: - DeviceHandlerMessage::clear(this); - break; - case messagetypes::MEMORY: - MemoryMessage::clear(this); - break; - case messagetypes::MONITORING: - MonitoringMessage::clear(this); - break; - case messagetypes::TM_STORE: - TmStoreMessage::clear(this); - break; - case messagetypes::PARAMETER: - ParameterMessage::clear(this); - break; - default: - messagetypes::clearMissionMessage(this); - break; - } -} diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h index 8e1e9c8c..72f39357 100644 --- a/ipc/CommandMessage.h +++ b/ipc/CommandMessage.h @@ -5,11 +5,6 @@ #include #include -namespace messagetypes { -// Implemented in config. -void clearMissionMessage(CommandMessageIF* message); -} - /** * @brief Default command message used to pass command messages between tasks. * Primary message type for IPC. Contains sender, 2-byte command ID @@ -27,17 +22,6 @@ void clearMissionMessage(CommandMessageIF* message); */ class CommandMessage: public CommandMessageBase { public: - static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE; - static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01); - - static const uint8_t MESSAGE_ID = messagetypes::COMMAND; - //! Used internally, will be ignored - static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 ); - static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 ); - //! Reply indicating that the current command was rejected, - //! par1 should contain the error code - static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 ); - /** * This is the size of a message as it is seen by the MessageQueue. * 14 of the 24 available MessageQueueMessage bytes are used. @@ -98,18 +82,6 @@ public: */ void setParameter2(uint32_t parameter2); - void clear() override; - - /** - * Set the command to CMD_NONE and try to find the correct class to handle - * a more detailed clear. - * Also, calls a mission-specific clearMissionMessage function to separate - * between framework and mission messages. Not optimal, may be replaced by - * totally different auto-delete solution (e.g. smart pointers). - * - */ - void clearCommandMessage(); - /** * check if a message was cleared * @@ -122,11 +94,6 @@ public: * Is needed quite often, so we better code it once only. */ void setToUnknownCommand(); - - void setReplyRejected(ReturnValue_t reason, - Command_t initialCommand = CMD_NONE); - ReturnValue_t getRejectedReplyReason( - Command_t* initialCommand = nullptr) const; }; diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp index 3ffe4daa..7085ab88 100644 --- a/ipc/CommandMessageBase.cpp +++ b/ipc/CommandMessageBase.cpp @@ -1,4 +1,5 @@ #include +#include #include CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message): @@ -57,3 +58,25 @@ size_t CommandMessageBase::getMessageSize() const { MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const { return internalMessage; } + +void CommandMessageBase::setReplyRejected(ReturnValue_t reason, + Command_t initialCommand) { + std::memcpy(getData(), &reason, sizeof(reason)); + std::memcpy(getData() + sizeof(reason), &initialCommand, + sizeof(initialCommand)); +} + +ReturnValue_t CommandMessageBase::getReplyRejectedReason( + Command_t *initialCommand) const { + ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED; + std::memcpy(&reason, getData(), sizeof(reason)); + if(initialCommand != nullptr) { + std::memcpy(initialCommand, getData() + sizeof(reason), + sizeof(Command_t)); + } + return reason; +} + +void CommandMessageBase::clear() { + CommandMessageCleaner::clearCommandMessage(this); +} diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h index b2b7d5f2..d2f24c7e 100644 --- a/ipc/CommandMessageBase.h +++ b/ipc/CommandMessageBase.h @@ -22,9 +22,6 @@ */ class CommandMessageBase: public CommandMessageIF { public: - static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) + - sizeof(Command_t); - CommandMessageBase(MessageQueueMessageIF* message); /** @@ -61,7 +58,25 @@ public: virtual void setMessageSize(size_t messageSize) override; virtual size_t getMessageSize() const override; + /** + * A command message can be rejected and needs to offer a function + * to set a rejected reply + * @param reason + * @param initialCommand + */ + void setReplyRejected(ReturnValue_t reason, + Command_t initialCommand) override; + /** + * Corrensonding getter function. + * @param initialCommand + * @return + */ + ReturnValue_t getReplyRejectedReason( + Command_t* initialCommand = nullptr) const override; + virtual MessageQueueMessageIF* getInternalMessage() const override; + + virtual void clear() override; protected: /** * @brief Pointer to the message containing the data. diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp new file mode 100644 index 00000000..7153a8e7 --- /dev/null +++ b/ipc/CommandMessageCleaner.cpp @@ -0,0 +1,45 @@ +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +void CommandMessageCleaner::clearCommandMessage(CommandMessageIF* message) { + switch(message->getMessageType()){ + case messagetypes::MODE_COMMAND: + ModeMessage::clear(dynamic_cast(message)); + break; + case messagetypes::HEALTH_COMMAND: + HealthMessage::clear(dynamic_cast(message)); + break; + case messagetypes::MODE_SEQUENCE: + ModeSequenceMessage::clear(dynamic_cast(message)); + break; + case messagetypes::ACTION: + ActionMessage::clear(dynamic_cast(message)); + break; + case messagetypes::DEVICE_HANDLER_COMMAND: + DeviceHandlerMessage::clear(dynamic_cast(message)); + break; + case messagetypes::MEMORY: + MemoryMessage::clear(dynamic_cast(message)); + break; + case messagetypes::MONITORING: + MonitoringMessage::clear(dynamic_cast(message)); + break; + case messagetypes::TM_STORE: + TmStoreMessage::clear(dynamic_cast(message)); + break; + case messagetypes::PARAMETER: + ParameterMessage::clear(dynamic_cast(message)); + break; + default: + messagetypes::clearMissionMessage(message); + break; + } +} diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h new file mode 100644 index 00000000..0bd369a2 --- /dev/null +++ b/ipc/CommandMessageCleaner.h @@ -0,0 +1,16 @@ +#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ +#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ +#include + +namespace messagetypes { +// Implemented in config. +void clearMissionMessage(CommandMessageIF* message); +} + +class CommandMessageCleaner { +public: + static void clearCommandMessage(CommandMessageIF* message); +}; + + +#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */ diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h index 44853c38..fbfbddbb 100644 --- a/ipc/CommandMessageIF.h +++ b/ipc/CommandMessageIF.h @@ -2,6 +2,9 @@ #define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ #include +#include +#include + #define MAKE_COMMAND_ID( number ) ((MESSAGE_ID << 8) + (number)) typedef uint16_t Command_t; @@ -14,6 +17,20 @@ typedef uint16_t Command_t; // we should just leave it like that. class CommandMessageIF: public MessageQueueMessageIF { public: + static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) + + sizeof(Command_t); + + static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE; + static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01); + + static const uint8_t MESSAGE_ID = messagetypes::COMMAND; + //! Used internally, shall be ignored + static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 ); + static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 ); + //! Reply indicating that the current command was rejected, + //! par1 should contain the error code + static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 ); + virtual ~CommandMessageIF() {}; /** @@ -27,6 +44,22 @@ public: */ virtual uint8_t getMessageType() const = 0; + /** + * A command message can be rejected and needs to offer a function + * to set a rejected reply + * @param reason + * @param initialCommand + */ + virtual void setReplyRejected(ReturnValue_t reason, + Command_t initialCommand) = 0; + /** + * Corrensonding getter function. + * @param initialCommand + * @return + */ + virtual ReturnValue_t getReplyRejectedReason( + Command_t* initialCommand = nullptr) const = 0; + /** * This function is used to get a pointer to the internal message, as * the command message implementations always operate on the memory @@ -36,6 +69,7 @@ public: * @return */ virtual MessageQueueMessageIF* getInternalMessage() const = 0; + }; #endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */ diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp index 2c384651..fb4d9eb6 100644 --- a/memory/MemoryHelper.cpp +++ b/memory/MemoryHelper.cpp @@ -119,7 +119,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode, break; } if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) { - reply.clearCommandMessage(); + reply.clear(); } } diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp index 65053cc8..97856b40 100644 --- a/tmtcservices/CommandingServiceBase.cpp +++ b/tmtcservices/CommandingServiceBase.cpp @@ -94,7 +94,7 @@ void CommandingServiceBase::handleCommandQueue() { } -void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) { +void CommandingServiceBase::handleCommandMessage(CommandMessageIF* reply) { bool isStep = false; MessageQueueMessage message; CommandMessage nextCommand(&message); @@ -119,7 +119,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) { * command as failure parameter 1 */ if(reply->getCommand() == CommandMessage::REPLY_REJECTED and result == RETURN_FAILED) { - result = reply->getRejectedReplyReason( + result = reply->getReplyRejectedReason( reinterpret_cast(&failureParameter1)); } @@ -156,8 +156,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) { } void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result, - CommandMapIter iter, CommandMessage* nextCommand, CommandMessage* reply, - bool& isStep) { + CommandMapIter iter, CommandMessageIF* nextCommand, + CommandMessageIF* reply, bool& isStep) { iter->command = nextCommand->getCommand(); // In case a new command is to be sent immediately, this is performed here. @@ -186,14 +186,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result, } else { if (isStep) { - nextCommand->clearCommandMessage(); + nextCommand->clear(); verificationReporter.sendFailureReport( TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl, sendResult, ++iter->step, failureParameter1, failureParameter2); } else { - nextCommand->clearCommandMessage(); + nextCommand->clear(); verificationReporter.sendFailureReport( TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, @@ -329,7 +329,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket, storedPacket->getPacketSequenceControl(); acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket); } else { - command.clearCommandMessage(); + command.clear(); rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult); checkAndExecuteFifo(iter); } @@ -346,7 +346,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket, acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket); checkAndExecuteFifo(iter); } else { - command.clearCommandMessage(); + command.clear(); rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult); checkAndExecuteFifo(iter); } diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h index 5adfe4a6..5e2c3171 100644 --- a/tmtcservices/CommandingServiceBase.h +++ b/tmtcservices/CommandingServiceBase.h @@ -141,7 +141,7 @@ protected: * @param objectId Target object ID * @return */ - virtual ReturnValue_t prepareCommand(CommandMessage *message, + virtual ReturnValue_t prepareCommand(CommandMessageIF *message, uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, uint32_t *state, object_id_t objectId) = 0; @@ -172,7 +172,7 @@ protected: */ virtual ReturnValue_t handleReply(const CommandMessageIF *reply, Command_t previousCommand, uint32_t *state, - CommandMessage *optionalNextCommand, object_id_t objectId, + CommandMessageIF *optionalNextCommand, object_id_t objectId, bool *isStep) = 0; /** @@ -312,9 +312,9 @@ private: void startExecution(TcPacketStored *storedPacket, CommandMapIter iter); - void handleCommandMessage(CommandMessage* reply); + void handleCommandMessage(CommandMessageIF* reply); void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter, - CommandMessage* nextCommand,CommandMessage* reply, bool& isStep); + CommandMessageIF* nextCommand,CommandMessageIF* reply, bool& isStep); void checkTimeout(); };