eive/fsfw
eive/fsfw
15
1
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases 1 Wiki Activity

Merge remote-tracking branch 'origin/mueller/ipc-updates' into mueller/MQMQ_IF_UpdateFreeRTOS

Browse Source
This commit is contained in:
Robin Müller 2020-09-26 14:33:35 +02:00
commit eec022f801
15 changed files with 658 additions and 654 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
action/ActionHelper.cpp
View File

@ -1,5 +1,6 @@
#include "ActionHelper.h" #include "ActionHelper.h"
#include "HasActionsIF.h" #include "HasActionsIF.h"
#include "../ipc/MessageQueueSenderIF.h"
#include "../objectmanager/ObjectManagerIF.h" #include "../objectmanager/ObjectManagerIF.h"
ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) : ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :

2
datalinklayer/MapPacketExtraction.cpp
View File

@ -18,7 +18,7 @@ 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), bufferPosition(
packetBuffer), packetDestination(setPacketDestination), packetStore( packetBuffer), packetDestination(setPacketDestination), packetStore(
NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) { NULL), tcQueueId(MessageQueueIF::NO_QUEUE) {
memset(packetBuffer, 0, sizeof(packetBuffer)); memset(packetBuffer, 0, sizeof(packetBuffer));
} }

222
ipc/CommandMessage.cpp
View File

@ -1,111 +1,111 @@
#include "CommandMessage.h" #include "CommandMessage.h"
#include "CommandMessageCleaner.h" #include "CommandMessageCleaner.h"
#include <cstring> #include <cstring>
CommandMessage::CommandMessage() { CommandMessage::CommandMessage() {
MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE); MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
setCommand(CMD_NONE); setCommand(CMD_NONE);
} }
CommandMessage::CommandMessage(Command_t command, uint32_t parameter1, CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
uint32_t parameter2) { uint32_t parameter2) {
MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE); MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
setCommand(command); setCommand(command);
setParameter(parameter1); setParameter(parameter1);
setParameter2(parameter2); setParameter2(parameter2);
} }
Command_t CommandMessage::getCommand() const { Command_t CommandMessage::getCommand() const {
Command_t command; Command_t command;
std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t)); std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
return command; return command;
} }
void CommandMessage::setCommand(Command_t command) { void CommandMessage::setCommand(Command_t command) {
std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t)); std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
} }
uint8_t CommandMessage::getMessageType() const { uint8_t CommandMessage::getMessageType() const {
// first byte of command ID. // first byte of command ID.
return getCommand() >> 8 & 0xff; return getCommand() >> 8 & 0xff;
} }
uint32_t CommandMessage::getParameter() const { uint32_t CommandMessage::getParameter() const {
uint32_t parameter1; uint32_t parameter1;
std::memcpy(&parameter1, this->getData(), sizeof(parameter1)); std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
return parameter1; return parameter1;
} }
void CommandMessage::setParameter(uint32_t parameter1) { void CommandMessage::setParameter(uint32_t parameter1) {
std::memcpy(this->getData(), &parameter1, sizeof(parameter1)); std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
} }
uint32_t CommandMessage::getParameter2() const { uint32_t CommandMessage::getParameter2() const {
uint32_t parameter2; uint32_t parameter2;
std::memcpy(&parameter2, this->getData() + sizeof(uint32_t), std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
sizeof(parameter2)); sizeof(parameter2));
return parameter2; return parameter2;
} }
void CommandMessage::setParameter2(uint32_t parameter2) { void CommandMessage::setParameter2(uint32_t parameter2) {
std::memcpy(this->getData() + sizeof(uint32_t), &parameter2, std::memcpy(this->getData() + sizeof(uint32_t), &parameter2,
sizeof(parameter2)); sizeof(parameter2));
} }
uint32_t CommandMessage::getParameter3() const { uint32_t CommandMessage::getParameter3() const {
uint32_t parameter3; uint32_t parameter3;
std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t), std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
sizeof(parameter3)); sizeof(parameter3));
return parameter3; return parameter3;
} }
void CommandMessage::setParameter3(uint32_t parameter3) { void CommandMessage::setParameter3(uint32_t parameter3) {
std::memcpy(this->getData() + 2 * sizeof(uint32_t), &parameter3, std::memcpy(this->getData() + 2 * sizeof(uint32_t), &parameter3,
sizeof(parameter3)); sizeof(parameter3));
} }
size_t CommandMessage::getMinimumMessageSize() const { size_t CommandMessage::getMinimumMessageSize() const {
return MINIMUM_COMMAND_MESSAGE_SIZE; return MINIMUM_COMMAND_MESSAGE_SIZE;
} }
void CommandMessage::clearCommandMessage() { void CommandMessage::clearCommandMessage() {
clear(); clear();
} }
void CommandMessage::clear() { void CommandMessage::clear() {
CommandMessageCleaner::clearCommandMessage(this); CommandMessageCleaner::clearCommandMessage(this);
} }
bool CommandMessage::isClearedCommandMessage() { bool CommandMessage::isClearedCommandMessage() {
return getCommand() == CMD_NONE; return getCommand() == CMD_NONE;
} }
void CommandMessage::setToUnknownCommand() { void CommandMessage::setToUnknownCommand() {
Command_t initialCommand = getCommand(); Command_t initialCommand = getCommand();
this->clear(); this->clear();
setReplyRejected(UNKNOWN_COMMAND, initialCommand); setReplyRejected(UNKNOWN_COMMAND, initialCommand);
} }
void CommandMessage::setReplyRejected(ReturnValue_t reason, void CommandMessage::setReplyRejected(ReturnValue_t reason,
Command_t initialCommand) { Command_t initialCommand) {
setCommand(REPLY_REJECTED); setCommand(REPLY_REJECTED);
setParameter(reason); setParameter(reason);
setParameter2(initialCommand); setParameter2(initialCommand);
} }
ReturnValue_t CommandMessage::getReplyRejectedReason( ReturnValue_t CommandMessage::getReplyRejectedReason(
Command_t *initialCommand) const { Command_t *initialCommand) const {
ReturnValue_t reason = getParameter(); ReturnValue_t reason = getParameter();
if(initialCommand != nullptr) { if(initialCommand != nullptr) {
*initialCommand = getParameter2(); *initialCommand = getParameter2();
} }
return reason; return reason;
} }
uint8_t* CommandMessage::getData() { uint8_t* CommandMessage::getData() {
return MessageQueueMessage::getData() + sizeof(Command_t); return MessageQueueMessage::getData() + sizeof(Command_t);
} }
const uint8_t* CommandMessage::getData() const { const uint8_t* CommandMessage::getData() const {
return MessageQueueMessage::getData() + sizeof(Command_t); return MessageQueueMessage::getData() + sizeof(Command_t);
} }

259
ipc/CommandMessage.h
View File

@ -1,129 +1,130 @@
#ifndef FSFW_IPC_COMMANDMESSAGE_H_ #ifndef FSFW_IPC_COMMANDMESSAGE_H_
#define FSFW_IPC_COMMANDMESSAGE_H_ #define FSFW_IPC_COMMANDMESSAGE_H_
#include "CommandMessageIF.h" #include "CommandMessageIF.h"
#include "MessageQueueMessage.h" #include "MessageQueueMessage.h"
#include "FwMessageTypes.h" #include "FwMessageTypes.h"
/** /**
* @brief Default command message used to pass command messages between tasks. * @brief Default command message used to pass command messages between tasks.
* Primary message type for IPC. Contains sender, 2-byte command ID * Primary message type for IPC. Contains sender, 2-byte command ID
* field, and 2 4-byte parameters. * field, and 3 4-byte parameter
* @details * @details
* It operates on an external memory which is contained inside a * It operates on an external memory which is contained inside a
* class implementing MessageQueueMessageIF by taking its address. * class implementing MessageQueueMessageIF by taking its address.
* This allows for a more flexible designs of message implementations. * This allows for a more flexible designs of message implementations.
* The pointer can be passed to different message implementations without * The pointer can be passed to different message implementations without
* the need of unnecessary copying. * the need of unnecessary copying.
* *
* The command message is based of the generic MessageQueueMessage which * The command message is based of the generic MessageQueueMessage which
* currently has an internal message size of 28 bytes. * currently has an internal message size of 28 bytes.
* @author Bastian Baetz * @author Bastian Baetz
*/ */
class CommandMessage: public MessageQueueMessage, public CommandMessageIF { class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
public: public:
/** /**
* Default size can accomodate 2 4-byte parameters. * Default size can accomodate 3 4-byte parameters.
*/ */
static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE = static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t); CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE +
3 * sizeof(uint32_t);
/**
* @brief Default Constructor, does not initialize anything. /**
* @details * @brief Default Constructor, does not initialize anything.
* This constructor should be used when receiving a Message, as the * @details
* content is filled by the MessageQueue. * This constructor should be used when receiving a Message, as the
*/ * content is filled by the MessageQueue.
CommandMessage(); */
/** CommandMessage();
* This constructor creates a new message with all message content /**
* initialized * This constructor creates a new message with all message content
* * initialized
* @param command The DeviceHandlerCommand_t that will be sent *
* @param parameter1 The first parameter * @param command The DeviceHandlerCommand_t that will be sent
* @param parameter2 The second parameter * @param parameter1 The first parameter
*/ * @param parameter2 The second parameter
CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2); */
CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
/**
* @brief Default Destructor /**
*/ * @brief Default Destructor
virtual ~CommandMessage() {} */
virtual ~CommandMessage() {}
/**
* Read the DeviceHandlerCommand_t that is stored in the message, /**
* usually used after receiving. * Read the DeviceHandlerCommand_t that is stored in the message,
* * usually used after receiving.
* @return the Command stored in the Message *
*/ * @return the Command stored in the Message
virtual Command_t getCommand() const override; */
/** virtual Command_t getCommand() const override;
* Set the command type of the message. Default implementation also /**
* sets the message type, which will be the first byte of the command ID. * Set the command type of the message. Default implementation also
* @param the Command to be sent * sets the message type, which will be the first byte of the command ID.
*/ * @param the Command to be sent
virtual void setCommand(Command_t command); */
virtual void setCommand(Command_t command);
virtual uint8_t* getData() override;
virtual const uint8_t* getData() const override; virtual uint8_t* getData() override;
virtual const uint8_t* getData() const override;
/**
* Get the first parameter of the message /**
* @return the first Parameter of the message * Get the first parameter of the message
*/ * @return the first Parameter of the message
uint32_t getParameter() const; */
/** uint32_t getParameter() const;
* Set the first parameter of the message /**
* @param the first parameter of the message * Set the first parameter of the message
*/ * @param the first parameter of the message
void setParameter(uint32_t parameter1); */
uint32_t getParameter2() const; void setParameter(uint32_t parameter1);
void setParameter2(uint32_t parameter2); uint32_t getParameter2() const;
uint32_t getParameter3() const; void setParameter2(uint32_t parameter2);
void setParameter3(uint32_t parameter3); uint32_t getParameter3() const;
void setParameter3(uint32_t parameter3);
/**
* check if a message was cleared /**
* * check if a message was cleared
* @return if the command is CMD_NONE *
*/ * @return if the command is CMD_NONE
bool isClearedCommandMessage(); */
bool isClearedCommandMessage();
/**
* Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND. /**
* Is needed quite often, so we better code it once only. * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
*/ * Is needed quite often, so we better code it once only.
void setToUnknownCommand() override; */
void setToUnknownCommand() override;
/**
* A command message can be rejected and needs to offer a function /**
* to set a rejected reply * A command message can be rejected and needs to offer a function
* @param reason * to set a rejected reply
* @param initialCommand * @param reason
*/ * @param initialCommand
void setReplyRejected(ReturnValue_t reason, */
Command_t initialCommand) override; void setReplyRejected(ReturnValue_t reason,
/** Command_t initialCommand) override;
* Corrensonding getter function. /**
* @param initialCommand * Corrensonding getter function.
* @return * @param initialCommand
*/ * @return
ReturnValue_t getReplyRejectedReason( */
Command_t* initialCommand = nullptr) const override; ReturnValue_t getReplyRejectedReason(
Command_t* initialCommand = nullptr) const override;
virtual void clear() override;
void clearCommandMessage(); virtual void clear() override;
void clearCommandMessage();
/**
* Extract message ID, which is the first byte of the command ID for the /**
* default implementation. * Extract message ID, which is the first byte of the command ID for the
* @return * default implementation.
*/ * @return
virtual uint8_t getMessageType() const override; */
virtual uint8_t getMessageType() const override;
/** MessageQueueMessageIF functions used for minimum size check. */
size_t getMinimumMessageSize() const override; /** MessageQueueMessageIF functions used for minimum size check. */
}; size_t getMinimumMessageSize() const override;
};
#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */

90
ipc/CommandMessageCleaner.cpp
View File

@ -1,45 +1,45 @@
#include "../ipc/CommandMessageCleaner.h" #include "../ipc/CommandMessageCleaner.h"
#include "../devicehandlers/DeviceHandlerMessage.h" #include "../devicehandlers/DeviceHandlerMessage.h"
#include "../health/HealthMessage.h" #include "../health/HealthMessage.h"
#include "../memory/MemoryMessage.h" #include "../memory/MemoryMessage.h"
#include "../modes/ModeMessage.h" #include "../modes/ModeMessage.h"
#include "../monitoring/MonitoringMessage.h" #include "../monitoring/MonitoringMessage.h"
#include "../subsystem/modes/ModeSequenceMessage.h" #include "../subsystem/modes/ModeSequenceMessage.h"
#include "../tmstorage/TmStoreMessage.h" #include "../tmstorage/TmStoreMessage.h"
#include "../parameters/ParameterMessage.h" #include "../parameters/ParameterMessage.h"
void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) { void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
switch(message->getMessageType()){ switch(message->getMessageType()){
case messagetypes::MODE_COMMAND: case messagetypes::MODE_COMMAND:
ModeMessage::clear(message); ModeMessage::clear(message);
break; break;
case messagetypes::HEALTH_COMMAND: case messagetypes::HEALTH_COMMAND:
HealthMessage::clear(message); HealthMessage::clear(message);
break; break;
case messagetypes::MODE_SEQUENCE: case messagetypes::MODE_SEQUENCE:
ModeSequenceMessage::clear(message); ModeSequenceMessage::clear(message);
break; break;
case messagetypes::ACTION: case messagetypes::ACTION:
ActionMessage::clear(message); ActionMessage::clear(message);
break; break;
case messagetypes::DEVICE_HANDLER_COMMAND: case messagetypes::DEVICE_HANDLER_COMMAND:
DeviceHandlerMessage::clear(message); DeviceHandlerMessage::clear(message);
break; break;
case messagetypes::MEMORY: case messagetypes::MEMORY:
MemoryMessage::clear(message); MemoryMessage::clear(message);
break; break;
case messagetypes::MONITORING: case messagetypes::MONITORING:
MonitoringMessage::clear(message); MonitoringMessage::clear(message);
break; break;
case messagetypes::TM_STORE: case messagetypes::TM_STORE:
TmStoreMessage::clear(message); TmStoreMessage::clear(message);
break; break;
case messagetypes::PARAMETER: case messagetypes::PARAMETER:
ParameterMessage::clear(message); ParameterMessage::clear(message);
break; break;
default: default:
messagetypes::clearMissionMessage(message); messagetypes::clearMissionMessage(message);
break; break;
} }
} }

32
ipc/CommandMessageCleaner.h
View File

@ -1,16 +1,16 @@
#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ #ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ #define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
#include "../ipc/CommandMessage.h" #include "../ipc/CommandMessage.h"
namespace messagetypes { namespace messagetypes {
// Implemented in config. // Implemented in config.
void clearMissionMessage(CommandMessage* message); void clearMissionMessage(CommandMessage* message);
} }
class CommandMessageCleaner { class CommandMessageCleaner {
public: public:
static void clearCommandMessage(CommandMessage* message); static void clearCommandMessage(CommandMessage* message);
}; };
#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */ #endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */

146
ipc/CommandMessageIF.h
View File

@ -1,73 +1,73 @@
#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_ #ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
#define FSFW_IPC_COMMANDMESSAGEIF_H_ #define FSFW_IPC_COMMANDMESSAGEIF_H_
#include "MessageQueueMessageIF.h" #include "MessageQueueMessageIF.h"
#include "FwMessageTypes.h" #include "FwMessageTypes.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#define MAKE_COMMAND_ID( number ) ((MESSAGE_ID << 8) + (number)) #define MAKE_COMMAND_ID( number ) ((MESSAGE_ID << 8) + (number))
typedef uint16_t Command_t; typedef uint16_t Command_t;
class CommandMessageIF { class CommandMessageIF {
public: public:
/** /**
* Header consists of sender ID and command ID. * Header consists of sender ID and command ID.
*/ */
static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE + static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
sizeof(Command_t); sizeof(Command_t);
/** /**
* This minimum size is derived from the interface requirement to be able * This minimum size is derived from the interface requirement to be able
* to set a rejected reply, which contains a returnvalue and the initial * to set a rejected reply, which contains a returnvalue and the initial
* command. * command.
*/ */
static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE = static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) + CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
sizeof(Command_t); sizeof(Command_t);
static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE; static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
static const ReturnValue_t UNKNOWN_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;
//! Used internally, shall be ignored //! Used internally, shall be ignored
static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 ); static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 ); static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
//! Reply indicating that the current command was rejected, //! Reply indicating that the current command was rejected,
//! par1 should contain the error code //! par1 should contain the error code
static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 ); static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
virtual ~CommandMessageIF() {}; virtual ~CommandMessageIF() {};
/** /**
* A command message shall have a uint16_t command ID field. * A command message shall have a uint16_t command ID field.
* @return * @return
*/ */
virtual Command_t getCommand() const = 0; virtual Command_t getCommand() const = 0;
/** /**
* A command message shall have a uint8_t message type ID field. * A command message shall have a uint8_t message type ID field.
* @return * @return
*/ */
virtual uint8_t getMessageType() const = 0; virtual uint8_t getMessageType() const = 0;
/** /**
* A command message can be rejected and needs to offer a function * A command message can be rejected and needs to offer a function
* to set a rejected reply * to set a rejected reply
* @param reason * @param reason
* @param initialCommand * @param initialCommand
*/ */
virtual void setReplyRejected(ReturnValue_t reason, virtual void setReplyRejected(ReturnValue_t reason,
Command_t initialCommand) = 0; Command_t initialCommand) = 0;
/** /**
* Corrensonding getter function. * Corrensonding getter function.
* @param initialCommand * @param initialCommand
* @return * @return
*/ */
virtual ReturnValue_t getReplyRejectedReason( virtual ReturnValue_t getReplyRejectedReason(
Command_t* initialCommand = nullptr) const = 0; Command_t* initialCommand = nullptr) const = 0;
virtual void setToUnknownCommand() = 0; virtual void setToUnknownCommand() = 0;
virtual void clear() = 0; virtual void clear() = 0;
}; };
#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */ #endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */

10
ipc/MessageQueueIF.h
View File

@ -1,15 +1,15 @@
#ifndef FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
#define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ #define FSFW_IPC_MESSAGEQUEUEIF_H_
// COULDDO: We could support blocking calls // COULDDO: We could support blocking calls
#include "messageQueueDefinitions.h"
#include "MessageQueueMessage.h" #include "MessageQueueMessage.h"
#include "MessageQueueSenderIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
class MessageQueueIF { class MessageQueueIF {
public: public:
static const MessageQueueId_t NO_QUEUE = 0;
static const MessageQueueId_t NO_QUEUE = MessageQueueSenderIF::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;
/** /**

168
ipc/MessageQueueMessage.cpp
View File

@ -1,84 +1,84 @@
#include "MessageQueueMessage.h" #include "MessageQueueMessage.h"
#include "../serviceinterface/ServiceInterfaceStream.h" #include "../serviceinterface/ServiceInterfaceStream.h"
#include "../globalfunctions/arrayprinter.h" #include "../globalfunctions/arrayprinter.h"
#include <cstring> #include <cstring>
MessageQueueMessage::MessageQueueMessage() : MessageQueueMessage::MessageQueueMessage() :
messageSize(getMinimumMessageSize()) { messageSize(getMinimumMessageSize()) {
memset(this->internalBuffer, 0, sizeof(this->internalBuffer)); memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
} }
MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) : MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
messageSize(this->HEADER_SIZE + size) { messageSize(this->HEADER_SIZE + size) {
if (size <= this->MAX_DATA_SIZE) { if (size <= this->MAX_DATA_SIZE) {
memcpy(this->getData(), data, size); memcpy(this->getData(), data, size);
this->messageSize = this->HEADER_SIZE + size; this->messageSize = this->HEADER_SIZE + size;
} }
else { else {
sif::warning << "MessageQueueMessage: Passed size larger than maximum" sif::warning << "MessageQueueMessage: Passed size larger than maximum"
"allowed size! Setting content to 0" << std::endl; "allowed size! Setting content to 0" << std::endl;
memset(this->internalBuffer, 0, sizeof(this->internalBuffer)); memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
this->messageSize = this->HEADER_SIZE; this->messageSize = this->HEADER_SIZE;
} }
} }
MessageQueueMessage::~MessageQueueMessage() { MessageQueueMessage::~MessageQueueMessage() {
} }
const uint8_t* MessageQueueMessage::getBuffer() const { const uint8_t* MessageQueueMessage::getBuffer() const {
return this->internalBuffer; return this->internalBuffer;
} }
uint8_t* MessageQueueMessage::getBuffer() { uint8_t* MessageQueueMessage::getBuffer() {
return this->internalBuffer; return this->internalBuffer;
} }
const uint8_t* MessageQueueMessage::getData() const { const uint8_t* MessageQueueMessage::getData() const {
return this->internalBuffer + this->HEADER_SIZE; return this->internalBuffer + this->HEADER_SIZE;
} }
uint8_t* MessageQueueMessage::getData() { uint8_t* MessageQueueMessage::getData() {
return this->internalBuffer + this->HEADER_SIZE; return this->internalBuffer + this->HEADER_SIZE;
} }
MessageQueueId_t MessageQueueMessage::getSender() const { MessageQueueId_t MessageQueueMessage::getSender() const {
MessageQueueId_t temp_id; MessageQueueId_t temp_id;
memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t)); memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
return temp_id; return temp_id;
} }
void MessageQueueMessage::setSender(MessageQueueId_t setId) { void MessageQueueMessage::setSender(MessageQueueId_t setId) {
memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t)); memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
} }
void MessageQueueMessage::print(bool printWholeMessage) { void MessageQueueMessage::print(bool printWholeMessage) {
sif::debug << "MessageQueueMessage content: " << std::endl; sif::debug << "MessageQueueMessage content: " << std::endl;
if(printWholeMessage) { if(printWholeMessage) {
arrayprinter::print(getData(), getMaximumMessageSize()); arrayprinter::print(getData(), getMaximumMessageSize());
} }
else { else {
arrayprinter::print(getData(), getMessageSize()); arrayprinter::print(getData(), getMessageSize());
} }
} }
void MessageQueueMessage::clear() { void MessageQueueMessage::clear() {
memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE); memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
} }
size_t MessageQueueMessage::getMessageSize() const { size_t MessageQueueMessage::getMessageSize() const {
return this->messageSize; return this->messageSize;
} }
void MessageQueueMessage::setMessageSize(size_t messageSize) { void MessageQueueMessage::setMessageSize(size_t messageSize) {
this->messageSize = messageSize; this->messageSize = messageSize;
} }
size_t MessageQueueMessage::getMinimumMessageSize() const { size_t MessageQueueMessage::getMinimumMessageSize() const {
return this->MIN_MESSAGE_SIZE; return this->MIN_MESSAGE_SIZE;
} }
size_t MessageQueueMessage::getMaximumMessageSize() const { size_t MessageQueueMessage::getMaximumMessageSize() const {
return this->MAX_MESSAGE_SIZE; return this->MAX_MESSAGE_SIZE;
} }

299
ipc/MessageQueueMessage.h
View File

@ -1,150 +1,149 @@
#ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ #ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
#define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ #define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
#include "../ipc/MessageQueueMessageIF.h" #include "../ipc/MessageQueueMessageIF.h"
#include "../ipc/MessageQueueSenderIF.h" #include <cstddef>
#include <cstddef>
/**
/** * @brief This class is the representation and data organizer
* @brief This class is the representation and data organizer * for interprocess messages.
* for interprocess messages. * @details
* @details * To facilitate and standardize interprocess communication, this class was
* To facilitate and standardize interprocess communication, this class was * created to handle a lightweight "interprocess message protocol".
* created to handle a lightweight "interprocess message protocol". *
* * It adds a header with the sender's queue id to every sent message and
* It adds a header with the sender's queue id to every sent message and * defines the maximum total message size. Specialized messages, such as
* defines the maximum total message size. Specialized messages, such as * device commanding messages, can be created by inheriting from this class
* device commanding messages, can be created by inheriting from this class * and filling the buffer provided by getData with additional content.
* and filling the buffer provided by getData with additional content. *
* * If larger amounts of data must be sent between processes, the data shall
* If larger amounts of data must be sent between processes, the data shall * be stored in the IPC Store object and only the storage id is passed in a
* be stored in the IPC Store object and only the storage id is passed in a * queue message.The class is used both to generate and send messages and to
* queue message.The class is used both to generate and send messages and to * receive messages from other tasks.
* receive messages from other tasks. * @ingroup message_queue
* @ingroup message_queue */
*/ class MessageQueueMessage: public MessageQueueMessageIF {
class MessageQueueMessage: public MessageQueueMessageIF { public:
public: /**
/** * @brief The class is initialized empty with this constructor.
* @brief The class is initialized empty with this constructor. * @details
* @details * The messageSize attribute is set to the header's size and the whole
* The messageSize attribute is set to the header's size and the whole * content is set to zero.
* content is set to zero. */
*/ MessageQueueMessage();
MessageQueueMessage(); /**
/** * @brief With this constructor the class is initialized with
* @brief With this constructor the class is initialized with * the given content.
* the given content. * @details
* @details * If the passed message size fits into the buffer, the passed data is
* If the passed message size fits into the buffer, the passed data is * copied to the internal buffer and the messageSize information is set.
* copied to the internal buffer and the messageSize information is set. * Otherwise, messageSize is set to the header's size and the whole
* Otherwise, messageSize is set to the header's size and the whole * content is set to zero.
* content is set to zero. * @param data The data to be put in the message.
* @param data The data to be put in the message. * @param size Size of the data to be copied. Must be smaller than
* @param size Size of the data to be copied. Must be smaller than * MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
* MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE. */
*/ MessageQueueMessage(uint8_t* data, size_t size);
MessageQueueMessage(uint8_t* data, size_t size);
/**
/** * @brief As no memory is allocated in this class,
* @brief As no memory is allocated in this class, * the destructor is empty.
* the destructor is empty. */
*/ virtual ~MessageQueueMessage();
virtual ~MessageQueueMessage();
/**
/** * @brief The size information of each message is stored in
* @brief The size information of each message is stored in * this attribute.
* this attribute. * @details
* @details * It is public to simplify usage and to allow for passing the size
* It is public to simplify usage and to allow for passing the size * address as a pointer. Care must be taken when inheriting from this class,
* address as a pointer. Care must be taken when inheriting from this class, * as every child class is responsible for managing the size information by
* as every child class is responsible for managing the size information by * itself. When using the class to receive a message, the size information
* itself. When using the class to receive a message, the size information * is updated automatically.
* is updated automatically. *
* * Please note that the minimum size is limited by the size of the header
* Please note that the minimum size is limited by the size of the header * while the maximum size is limited by the maximum allowed message size.
* while the maximum size is limited by the maximum allowed message size. */
*/ size_t messageSize;
size_t messageSize; /**
/** * @brief This constant defines the maximum size of the data content,
* @brief This constant defines the maximum size of the data content, * excluding the header.
* excluding the header. * @details
* @details * It may be changed if necessary, but in general should be kept
* It may be changed if necessary, but in general should be kept * as small as possible.
* as small as possible. */
*/ static const size_t MAX_DATA_SIZE = 24;
static const size_t MAX_DATA_SIZE = 24;
/**
/** * @brief This constant defines the maximum total size in bytes
* @brief This constant defines the maximum total size in bytes * of a sent message.
* of a sent message. * @details
* @details * It is the sum of the maximum data and the header size. Be aware that
* It is the sum of the maximum data and the header size. Be aware that * this constant is used to define the buffer sizes for every message
* this constant is used to define the buffer sizes for every message * queue in the system. So, a change here may have significant impact on
* queue in the system. So, a change here may have significant impact on * the required resources.
* the required resources. */
*/ static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE; /**
/** * @brief Defines the minimum size of a message where only the
* @brief Defines the minimum size of a message where only the * header is included
* header is included */
*/ static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE; private:
private: /**
/** * @brief This is the internal buffer that contains the
* @brief This is the internal buffer that contains the * actual message data.
* actual message data. */
*/ uint8_t internalBuffer[MAX_MESSAGE_SIZE];
uint8_t internalBuffer[MAX_MESSAGE_SIZE]; public:
public: /**
/** * @brief This method is used to get the complete data of the message.
* @brief This method is used to get the complete data of the message. */
*/ const uint8_t* getBuffer() const override;
const uint8_t* getBuffer() const override; /**
/** * @brief This method is used to get the complete data of the message.
* @brief This method is used to get the complete data of the message. */
*/ uint8_t* getBuffer() override;
uint8_t* getBuffer() override; /**
/** * @brief This method is used to fetch the data content of the message.
* @brief This method is used to fetch the data content of the message. * @details
* @details * It shall be used by child classes to add data at the right position.
* It shall be used by child classes to add data at the right position. */
*/ const uint8_t* getData() const override;
const uint8_t* getData() const override; /**
/** * @brief This method is used to fetch the data content of the message.
* @brief This method is used to fetch the data content of the message. * @details
* @details * It shall be used by child classes to add data at the right position.
* It shall be used by child classes to add data at the right position. */
*/ uint8_t* getData() override;
uint8_t* getData() override; /**
/** * @brief This method is used to extract the sender's message
* @brief This method is used to extract the sender's message * queue id information from a received message.
* queue id information from a received message. */
*/ MessageQueueId_t getSender() const override;
MessageQueueId_t getSender() const override; /**
/** * @brief With this method, the whole content
* @brief With this method, the whole content * and the message size is set to zero.
* and the message size is set to zero. */
*/ void clear() override;
void clear() override;
/**
/** * @brief This method is used to set the sender's message queue id
* @brief This method is used to set the sender's message queue id * information prior to ing the message.
* information prior to ing the message. * @param setId
* @param setId * The message queue id that identifies the sending message queue.
* The message queue id that identifies the sending message queue. */
*/ void setSender(MessageQueueId_t setId) override;
void setSender(MessageQueueId_t setId) override;
virtual size_t getMessageSize() const override;
virtual size_t getMessageSize() const override; virtual void setMessageSize(size_t messageSize) override;
virtual void setMessageSize(size_t messageSize) override; virtual size_t getMinimumMessageSize() const override;
virtual size_t getMinimumMessageSize() const override; virtual size_t getMaximumMessageSize() const override;
virtual size_t getMaximumMessageSize() const override;
/**
/** * @brief This is a debug method that prints the content.
* @brief This is a debug method that prints the content. */
*/ void print(bool printWholeMessage);
void print(bool printWholeMessage); };
};
#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */

17
ipc/MessageQueueMessageIF.h
View File

@ -1,24 +1,13 @@
#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
#include <fsfw/ipc/messageQueueDefinitions.h>
#include <cstddef> #include <cstddef>
#include <cstdint> #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 = -1;
/** /**
* @brief This constants defines the size of the header, * @brief This constants defines the size of the header,
* which is added to every message. * which is added to every message.

29
ipc/MessageQueueSenderIF.h
View File

@ -1,37 +1,26 @@
#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ #ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ #define FSFW_IPC_MESSAGEQUEUESENDERIF_H_
#include "../ipc/MessageQueueIF.h"
#include "../ipc/MessageQueueMessageIF.h"
#include "../objectmanager/ObjectManagerIF.h" #include "../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 = 0;
virtual ~MessageQueueSenderIF() {} virtual ~MessageQueueSenderIF() {}
/** /**
* Allows sending messages without actually "owing" a message queue. * Allows sending messages without actually "owning" a message queue.
* Not sure whether this is actually a good idea. * Not sure whether this is actually a good idea.
* 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 = MessageQueueMessage* message,
MessageQueueSenderIF::NO_QUEUE, bool ignoreFault=false); MessageQueueId_t sentFrom = MessageQueueIF::NO_QUEUE,
bool ignoreFault = false);
private: private:
MessageQueueSenderIF() {} MessageQueueSenderIF() {}
}; };
#endif /* FSFW_IPC_MESSAGEQUEUESENDERIF_H_ */
#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */

19
ipc/messageQueueDefinitions.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
#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..
*/
using MessageQueueId_t = uint32_t;
#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */

8
modes/ModeHelper.cpp
View File

@ -36,7 +36,7 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
commandedMode = mode; commandedMode = mode;
commandedSubmode = submode; commandedSubmode = submode;
if ((parentQueueId != MessageQueueSenderIF::NO_QUEUE) if ((parentQueueId != MessageQueueIF::NO_QUEUE)
&& (theOneWhoCommandedAMode != parentQueueId)) { && (theOneWhoCommandedAMode != parentQueueId)) {
owner->setToExternalControl(); owner->setToExternalControl();
} }
@ -74,7 +74,7 @@ ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
void ModeHelper::modeChanged(Mode_t mode, Submode_t submode) { void ModeHelper::modeChanged(Mode_t mode, Submode_t submode) {
forced = false; forced = false;
CommandMessage reply; CommandMessage reply;
if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE) { if (theOneWhoCommandedAMode != MessageQueueIF::NO_QUEUE) {
if ((mode != commandedMode) || (submode != commandedSubmode)) { if ((mode != commandedMode) || (submode != commandedSubmode)) {
ModeMessage::setModeMessage(&reply, ModeMessage::setModeMessage(&reply,
ModeMessage::REPLY_WRONG_MODE_REPLY, mode, submode); ModeMessage::REPLY_WRONG_MODE_REPLY, mode, submode);
@ -86,12 +86,12 @@ void ModeHelper::modeChanged(Mode_t mode, Submode_t submode) {
owner->getCommandQueue()); owner->getCommandQueue());
} }
if (theOneWhoCommandedAMode != parentQueueId if (theOneWhoCommandedAMode != parentQueueId
&& parentQueueId != MessageQueueSenderIF::NO_QUEUE) { && parentQueueId != MessageQueueIF::NO_QUEUE) {
ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO, mode, ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO, mode,
submode); submode);
MessageQueueSenderIF::sendMessage(parentQueueId, &reply, owner->getCommandQueue()); MessageQueueSenderIF::sendMessage(parentQueueId, &reply, owner->getCommandQueue());
} }
theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE; theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
} }
void ModeHelper::startTimer(uint32_t timeoutMs) { void ModeHelper::startTimer(uint32_t timeoutMs) {

10
osal/linux/QueueFactory.cpp
View File

@ -1,8 +1,14 @@
#include "../../ipc/QueueFactory.h" #include "../../ipc/QueueFactory.h"
#include "MessageQueue.h"
#include "../../ipc/messageQueueDefinitions.h"
#include "../../ipc/MessageQueueSenderIF.h"
#include "../../serviceinterface/ServiceInterfaceStream.h"
#include <mqueue.h> #include <mqueue.h>
#include <errno.h> #include <errno.h>
#include "MessageQueue.h"
#include "../../serviceinterface/ServiceInterfaceStream.h"
#include <cstring> #include <cstring>
QueueFactory* QueueFactory::factoryInstance = nullptr; QueueFactory* QueueFactory::factoryInstance = nullptr;