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

ipc update

Browse Source
This commit is contained in:
Robin Müller 2020-08-25 18:24:46 +02:00
parent 9465c8f2b2
commit 3f9d9b8770
9 changed files with 700 additions and 449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
devicehandlers/HealthDevice.cpp
View File

@ -5,7 +5,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId,
MessageQueueId_t parentQueue) : MessageQueueId_t parentQueue) :
SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue( SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
parentQueue), commandQueue(), healthHelper(this, setObjectId) { parentQueue), commandQueue(), healthHelper(this, setObjectId) {
commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::COMMAND_MESSAGE_SIZE); commandQueue = QueueFactory::instance()->createMessageQueue(3);
} }
HealthDevice::~HealthDevice() { HealthDevice::~HealthDevice() {

242
ipc/CommandMessage.cpp
View File

@ -1,131 +1,111 @@
/** #include "CommandMessage.h"
* @file CommandMessage.cpp #include "CommandMessageCleaner.h"
* @brief This file defines the CommandMessage class. #include <cstring>
* @date 20.06.2013
* @author baetz CommandMessage::CommandMessage() {
*/ MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
setCommand(CMD_NONE);
#include "../devicehandlers/DeviceHandlerMessage.h" }
#include "../health/HealthMessage.h"
#include "CommandMessage.h" CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
#include "../memory/MemoryMessage.h" uint32_t parameter2) {
#include "../modes/ModeMessage.h" MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
#include "../monitoring/MonitoringMessage.h" setCommand(command);
#include "../subsystem/modes/ModeSequenceMessage.h" setParameter(parameter1);
#include "../tmstorage/TmStoreMessage.h" setParameter2(parameter2);
#include "../parameters/ParameterMessage.h" }
namespace messagetypes { Command_t CommandMessage::getCommand() const {
void clearMissionMessage(CommandMessage* message); Command_t command;
} std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
return command;
}
CommandMessage::CommandMessage() {
this->messageSize = COMMAND_MESSAGE_SIZE; void CommandMessage::setCommand(Command_t command) {
setCommand(CMD_NONE); std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
} }
CommandMessage::CommandMessage(Command_t command, uint32_t parameter1, uint8_t CommandMessage::getMessageType() const {
uint32_t parameter2) { // first byte of command ID.
this->messageSize = COMMAND_MESSAGE_SIZE; return getCommand() >> 8 & 0xff;
setCommand(command); }
setParameter(parameter1);
setParameter2(parameter2); uint32_t CommandMessage::getParameter() const {
} uint32_t parameter1;
std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
Command_t CommandMessage::getCommand() const { return parameter1;
Command_t command; }
memcpy(&command, getData(), sizeof(Command_t));
return command; void CommandMessage::setParameter(uint32_t parameter1) {
} std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
}
void CommandMessage::setCommand(Command_t command) {
memcpy(getData(), &command, sizeof(command)); uint32_t CommandMessage::getParameter2() const {
} uint32_t parameter2;
std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
uint32_t CommandMessage::getParameter() const { sizeof(parameter2));
uint32_t parameter1; return parameter2;
memcpy(&parameter1, getData() + sizeof(Command_t), sizeof(parameter1)); }
return parameter1;
} void CommandMessage::setParameter2(uint32_t parameter2) {
std::memcpy(this->getData() + sizeof(uint32_t), &parameter2,
void CommandMessage::setParameter(uint32_t parameter1) { sizeof(parameter2));
memcpy(getData() + sizeof(Command_t), &parameter1, sizeof(parameter1)); }
}
uint32_t CommandMessage::getParameter3() const {
uint32_t CommandMessage::getParameter2() const { uint32_t parameter3;
uint32_t parameter2; std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
memcpy(&parameter2, getData() + sizeof(Command_t) + sizeof(uint32_t), sizeof(parameter3));
sizeof(parameter2)); return parameter3;
return parameter2; }
}
void CommandMessage::setParameter3(uint32_t parameter3) {
void CommandMessage::setParameter2(uint32_t parameter2) { std::memcpy(this->getData() + 2 * sizeof(uint32_t), &parameter3,
memcpy(getData() + sizeof(Command_t) + sizeof(uint32_t), &parameter2, sizeof(parameter3));
sizeof(parameter2)); }
}
size_t CommandMessage::getMinimumMessageSize() const {
void CommandMessage::clearCommandMessage() { return MINIMUM_COMMAND_MESSAGE_SIZE;
switch((getCommand()>>8) & 0xff){ }
case messagetypes::MODE_COMMAND:
ModeMessage::clear(this); void CommandMessage::clearCommandMessage() {
break; clear();
case messagetypes::HEALTH_COMMAND: }
HealthMessage::clear(this);
break; void CommandMessage::clear() {
case messagetypes::MODE_SEQUENCE: CommandMessageCleaner::clearCommandMessage(this);
ModeSequenceMessage::clear(this); }
break;
case messagetypes::ACTION: bool CommandMessage::isClearedCommandMessage() {
ActionMessage::clear(this); return getCommand() == CMD_NONE;
break; }
case messagetypes::DEVICE_HANDLER_COMMAND:
DeviceHandlerMessage::clear(this); void CommandMessage::setToUnknownCommand() {
break; Command_t initialCommand = getCommand();
case messagetypes::MEMORY: this->clear();
MemoryMessage::clear(this); setReplyRejected(UNKNOWN_COMMAND, initialCommand);
break; }
case messagetypes::MONITORING:
MonitoringMessage::clear(this); void CommandMessage::setReplyRejected(ReturnValue_t reason,
break; Command_t initialCommand) {
case messagetypes::TM_STORE: setCommand(REPLY_REJECTED);
TmStoreMessage::clear(this); setParameter(reason);
break; setParameter2(initialCommand);
case messagetypes::PARAMETER: }
ParameterMessage::clear(this);
break; ReturnValue_t CommandMessage::getReplyRejectedReason(
default: Command_t *initialCommand) const {
messagetypes::clearMissionMessage(this); ReturnValue_t reason = getParameter();
break; if(initialCommand != nullptr) {
} *initialCommand = getParameter2();
} }
return reason;
bool CommandMessage::isClearedCommandMessage() { }
return getCommand() == CMD_NONE;
} uint8_t* CommandMessage::getData() {
return MessageQueueMessage::getData() + sizeof(Command_t);
size_t CommandMessage::getMinimumMessageSize() const { }
return COMMAND_MESSAGE_SIZE;
} const uint8_t* CommandMessage::getData() const {
return MessageQueueMessage::getData() + sizeof(Command_t);
void CommandMessage::setToUnknownCommand() { }
Command_t initialCommand = getCommand();
clearCommandMessage();
setReplyRejected(UNKNOWN_COMMAND, initialCommand);
}
void CommandMessage::setReplyRejected(ReturnValue_t reason,
Command_t initialCommand) {
setCommand(REPLY_REJECTED);
setParameter(reason);
setParameter2(initialCommand);
}
ReturnValue_t CommandMessage::getReplyRejectedReason(
Command_t *initialCommand) const {
ReturnValue_t reason = getParameter();
if(initialCommand != nullptr) {
*initialCommand = getParameter2();
}
return reason;
}

263
ipc/CommandMessage.h
View File

@ -1,134 +1,129 @@
/** #ifndef FSFW_IPC_COMMANDMESSAGE_H_
* @file CommandMessage.h #define FSFW_IPC_COMMANDMESSAGE_H_
* @brief This file defines the CommandMessage class.
* @date 20.06.2013 #include "CommandMessageIF.h"
* @author baetz #include "MessageQueueMessage.h"
*/ #include "FwMessageTypes.h"
#ifndef COMMANDMESSAGE_H_ /**
#define COMMANDMESSAGE_H_ * @brief Default command message used to pass command messages between tasks.
* Primary message type for IPC. Contains sender, 2-byte command ID
* field, and 2 4-byte parameters.
#include "FwMessageTypes.h" * @details
#include <config/ipc/MissionMessageTypes.h> * It operates on an external memory which is contained inside a
* class implementing MessageQueueMessageIF by taking its address.
#include "MessageQueueMessage.h" * This allows for a more flexible designs of message implementations.
* The pointer can be passed to different message implementations without
#define MAKE_COMMAND_ID( number ) ((MESSAGE_ID << 8) + (number)) * the need of unnecessary copying.
typedef ReturnValue_t Command_t; *
* The command message is based of the generic MessageQueueMessage which
class CommandMessage : public MessageQueueMessage { * currently has an internal message size of 28 bytes.
public: * @author Bastian Baetz
static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE; */
static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01); class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
public:
/**
static const uint8_t MESSAGE_ID = messagetypes::COMMAND; * Default size can accomodate 2 4-byte parameters.
static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );//!< Used internally, will be ignored */
static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 ); static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );//!< Reply indicating that the current command was rejected, par1 should contain the error code CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
/** /**
* This is the size of a message as it is seen by the MessageQueue * @brief Default Constructor, does not initialize anything.
*/ * @details
static const size_t COMMAND_MESSAGE_SIZE = HEADER_SIZE * This constructor should be used when receiving a Message, as the
+ sizeof(Command_t) + 2 * sizeof(uint32_t); * content is filled by the MessageQueue.
*/
/** CommandMessage();
* Default Constructor, does not initialize anything. /**
* * This constructor creates a new message with all message content
* This constructor should be used when receiving a Message, as the content is filled by the MessageQueue. * initialized
*/ *
CommandMessage(); * @param command The DeviceHandlerCommand_t that will be sent
/** * @param parameter1 The first parameter
* This constructor creates a new message with all message content initialized * @param parameter2 The second parameter
* */
* @param command The DeviceHandlerCommand_t that will be sent CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
* @param parameter1 The first parameter
* @param parameter2 The second parameter /**
*/ * @brief Default Destructor
CommandMessage(Command_t command, */
uint32_t parameter1, uint32_t parameter2); virtual ~CommandMessage() {}
/** /**
* Default Destructor * Read the DeviceHandlerCommand_t that is stored in the message,
*/ * usually used after receiving.
virtual ~CommandMessage() { *
} * @return the Command stored in the Message
*/
/** virtual Command_t getCommand() const override;
* Read the DeviceHandlerCommand_t that is stored in the message, usually used after receiving /**
* * Set the command type of the message. Default implementation also
* @return the Command stored in the Message * sets the message type, which will be the first byte of the command ID.
*/ * @param the Command to be sent
Command_t getCommand() const; */
virtual void setCommand(Command_t command);
/**
* Set the DeviceHandlerCOmmand_t of the message virtual uint8_t* getData() override;
* virtual const uint8_t* getData() const override;
* @param the Command to be sent
*/ /**
void setCommand(Command_t command); * Get the first parameter of the message
* @return the first Parameter of the message
/** */
* Get the first parameter of the message uint32_t getParameter() const;
* /**
* @return the first Parameter of the message * Set the first parameter of the message
*/ * @param the first parameter of the message
uint32_t getParameter() const; */
void setParameter(uint32_t parameter1);
/** uint32_t getParameter2() const;
* Set the first parameter of the message void setParameter2(uint32_t parameter2);
* uint32_t getParameter3() const;
* @param the first parameter of the message void setParameter3(uint32_t parameter3);
*/
void setParameter(uint32_t parameter1); /**
* check if a message was cleared
/** *
* Get the second parameter of the message * @return if the command is CMD_NONE
* */
* @return the second Parameter of the message bool isClearedCommandMessage();
*/
uint32_t getParameter2() const; /**
* Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
/** * Is needed quite often, so we better code it once only.
* Set the second parameter of the message */
* void setToUnknownCommand() override;
* @param the second parameter of the message
*/ /**
void setParameter2(uint32_t parameter2); * A command message can be rejected and needs to offer a function
* to set a rejected reply
/** * @param reason
* Set the command to CMD_NONE and try to find * @param initialCommand
* the correct class to handle a more detailed */
* clear. void setReplyRejected(ReturnValue_t reason,
* Also, calls a mission-specific clearMissionMessage Command_t initialCommand) override;
* function to separate between framework and mission /**
* messages. Not optimal, may be replaced by totally * Corrensonding getter function.
* different auto-delete solution (e.g. smart pointers). * @param initialCommand
* * @return
*/ */
void clearCommandMessage(); ReturnValue_t getReplyRejectedReason(
Command_t* initialCommand = nullptr) const override;
/**
* check if a message was cleared
* virtual void clear() override;
* @return if the command is CMD_NONE void clearCommandMessage();
*/
bool isClearedCommandMessage(); /**
* Extract message ID, which is the first byte of the command ID for the
* default implementation.
/** * @return
* Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND. */
* Is needed quite often, so we better code it once only. virtual uint8_t getMessageType() const override;
*/
void setToUnknownCommand(); /** MessageQueueMessageIF functions used for minimum size check. */
void setReplyRejected(ReturnValue_t reason, Command_t initialCommand = CMD_NONE); size_t getMinimumMessageSize() const override;
ReturnValue_t getReplyRejectedReason( };
Command_t *initialCommand = nullptr) const;
#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
size_t getMinimumMessageSize() const;
};
#endif /* COMMANDMESSAGE_H_ */

45
ipc/CommandMessageCleaner.cpp Normal file
View File

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

16
ipc/CommandMessageCleaner.h Normal file
View File

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

73
ipc/CommandMessageIF.h Normal file
View File

@ -0,0 +1,73 @@
#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
#define FSFW_IPC_COMMANDMESSAGEIF_H_
#include "MessageQueueMessageIF.h"
#include "FwMessageTypes.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#define MAKE_COMMAND_ID( number ) ((MESSAGE_ID << 8) + (number))
typedef uint16_t Command_t;
class CommandMessageIF {
public:
/**
* Header consists of sender ID and command ID.
*/
static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
sizeof(Command_t);
/**
* This minimum size is derived from the interface requirement to be able
* to set a rejected reply, which contains a returnvalue and the initial
* command.
*/
static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_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() {};
/**
* A command message shall have a uint16_t command ID field.
* @return
*/
virtual Command_t getCommand() const = 0;
/**
* A command message shall have a uint8_t message type ID field.
* @return
*/
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;
virtual void setToUnknownCommand() = 0;
virtual void clear() = 0;
};
#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */

149
ipc/MessageQueueMessage.cpp
View File

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

268
ipc/MessageQueueMessage.h
View File

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

91
ipc/MessageQueueMessageIF.h Normal file
View File

@ -0,0 +1,91 @@
#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
#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 {
public:
static const MessageQueueId_t NO_QUEUE = -1;
/**
* @brief This constants defines the size of the header,
* which is added to every message.
*/
static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
virtual ~MessageQueueMessageIF() {};
/**
* @brief With this method, the whole content and the message
* size is set to zero.
* @details
* Implementations should also take care to clear data which is stored
* indirectly (e.g. storage data).
*/
virtual void clear() = 0;
/**
* @brief Get read-only pointer to the complete data of the message.
* @return
*/
virtual const uint8_t* getBuffer() const = 0;
/**
* @brief This method is used to get the complete data of the message.
*/
virtual uint8_t* getBuffer() = 0;
/**
* @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.
*/
virtual void setSender(MessageQueueId_t setId) = 0;
/**
* @brief This method is used to extract the sender's message queue id
* information from a received message.
*/
virtual MessageQueueId_t getSender() const = 0;
/**
* @brief This method is used to fetch the data content of the message.
* @details
* It shall be used by child classes to add data at the right position.
*/
virtual const uint8_t* getData() const = 0;
/**
* @brief This method is used to fetch the data content of the message.
* @details
* It shall be used by child classes to add data at the right position.
*/
virtual uint8_t* getData() = 0;
/**
* Get constant message size of current message implementation.
* @return
*/
virtual size_t getMessageSize() const = 0;
virtual void setMessageSize(size_t messageSize) = 0;
virtual size_t getMinimumMessageSize() const = 0;
virtual size_t getMaximumMessageSize() const = 0;
};
#endif /* FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ */