232 lines
9.2 KiB
C++
232 lines
9.2 KiB
C++
#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
|
|
#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
|
|
|
|
#include "../../internalError/InternalErrorReporterIF.h"
|
|
#include "../../ipc/MessageQueueIF.h"
|
|
#include "../../ipc/MessageQueueMessage.h"
|
|
#include "../../ipc/MutexIF.h"
|
|
#include "../../timemanager/Clock.h"
|
|
|
|
#include <queue>
|
|
#include <memory>
|
|
|
|
/**
|
|
* @brief This class manages sending and receiving of
|
|
* message queue messages.
|
|
* @details
|
|
* Message queues are used to pass asynchronous messages between processes.
|
|
* They work like post boxes, where all incoming messages are stored in FIFO
|
|
* order. This class creates a new receiving queue and provides methods to fetch
|
|
* received messages. Being a child of MessageQueueSender, this class also
|
|
* provides methods to send a message to a user-defined or a default destination.
|
|
* In addition it also provides a reply method to answer to the queue it
|
|
* received its last message from.
|
|
*
|
|
* The MessageQueue should be used as "post box" for a single owning object.
|
|
* So all message queue communication is "n-to-one".
|
|
* For creating the queue, as well as sending and receiving messages, the class
|
|
* makes use of the operating system calls provided.
|
|
*
|
|
* Please keep in mind that FreeRTOS offers different calls for message queue
|
|
* operations if called from an ISR.
|
|
* For now, the system context needs to be switched manually.
|
|
* @ingroup osal
|
|
* @ingroup message_queue
|
|
*/
|
|
class MessageQueue : public MessageQueueIF {
|
|
friend class MessageQueueSenderIF;
|
|
public:
|
|
/**
|
|
* @brief The constructor initializes and configures the message queue.
|
|
* @details
|
|
* By making use of the according operating system call, a message queue is
|
|
* created and initialized. The message depth - the maximum number of
|
|
* messages to be buffered - may be set with the help of a parameter,
|
|
* whereas the message size is automatically set to the maximum message
|
|
* queue message size. The operating system sets the message queue id, or
|
|
* in case of failure, it is set to zero.
|
|
* @param message_depth
|
|
* The number of messages to be buffered before passing an error to the
|
|
* sender. Default is three.
|
|
* @param max_message_size
|
|
* With this parameter, the maximum message size can be adjusted.
|
|
* This should be left default.
|
|
*/
|
|
MessageQueue(size_t messageDepth = 3,
|
|
size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
|
|
|
|
/** Copying message queues forbidden */
|
|
MessageQueue(const MessageQueue&) = delete;
|
|
MessageQueue& operator=(const MessageQueue&) = delete;
|
|
|
|
/**
|
|
* @brief The destructor deletes the formerly created message queue.
|
|
* @details This is accomplished by using the delete call provided
|
|
* by the operating system.
|
|
*/
|
|
virtual ~MessageQueue();
|
|
|
|
/**
|
|
* @brief This operation sends a message to the given destination.
|
|
* @details It directly uses the sendMessage call of the MessageQueueSender
|
|
* parent, but passes its queue id as "sentFrom" parameter.
|
|
* @param sendTo This parameter specifies the message queue id of the
|
|
* destination message queue.
|
|
* @param message A pointer to a previously created message, which is sent.
|
|
* @param ignoreFault If set to true, the internal software fault counter
|
|
* is not incremented if queue is full.
|
|
*/
|
|
ReturnValue_t sendMessage(MessageQueueId_t sendTo,
|
|
MessageQueueMessageIF* message, bool ignoreFault = false) override;
|
|
/**
|
|
* @brief This operation sends a message to the default destination.
|
|
* @details As in the sendMessage method, this function uses the
|
|
* sendToDefault call of the MessageQueueSender parent class and adds its
|
|
* queue id as "sentFrom" information.
|
|
* @param message A pointer to a previously created message, which is sent.
|
|
*/
|
|
ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
|
|
/**
|
|
* @brief This operation sends a message to the last communication partner.
|
|
* @details This operation simplifies answering an incoming message by using
|
|
* the stored lastPartner information as destination. If there was no
|
|
* message received yet (i.e. lastPartner is zero), an error code is returned.
|
|
* @param message A pointer to a previously created message, which is sent.
|
|
*/
|
|
ReturnValue_t reply(MessageQueueMessageIF* message) override;
|
|
|
|
/**
|
|
* @brief With the sendMessage call, a queue message is sent to a
|
|
* receiving queue.
|
|
* @details
|
|
* This method takes the message provided, adds the sentFrom information and
|
|
* passes it on to the destination provided with an operating system call.
|
|
* The OS's return value is returned.
|
|
* @param sendTo This parameter specifies the message queue id to send
|
|
* the message to.
|
|
* @param message This is a pointer to a previously created message,
|
|
* which is sent.
|
|
* @param sentFrom The sentFrom information can be set to inject the
|
|
* sender's queue id into the message. This variable is set to zero by
|
|
* default.
|
|
* @param ignoreFault If set to true, the internal software fault counter
|
|
* is not incremented if queue is full.
|
|
*/
|
|
virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
|
|
MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
|
|
bool ignoreFault = false) override;
|
|
|
|
/**
|
|
* @brief The sendToDefault method sends a queue message to the default
|
|
* destination.
|
|
* @details
|
|
* In all other aspects, it works identical to the sendMessage method.
|
|
* @param message This is a pointer to a previously created message,
|
|
* which is sent.
|
|
* @param sentFrom The sentFrom information can be set to inject the
|
|
* sender's queue id into the message. This variable is set to zero by
|
|
* default.
|
|
*/
|
|
virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
|
|
MessageQueueId_t sentFrom = NO_QUEUE,
|
|
bool ignoreFault = false) override;
|
|
|
|
/**
|
|
* @brief This function reads available messages from the message queue
|
|
* and returns the sender.
|
|
* @details
|
|
* It works identically to the other receiveMessage call, but in addition
|
|
* returns the sender's queue id.
|
|
* @param message A pointer to a message in which the received data is stored.
|
|
* @param receivedFrom A pointer to a queue id in which the sender's id is stored.
|
|
*/
|
|
ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
|
|
MessageQueueId_t *receivedFrom) override;
|
|
|
|
/**
|
|
* @brief This function reads available messages from the message queue.
|
|
* @details
|
|
* If data is available it is stored in the passed message pointer.
|
|
* The message's original content is overwritten and the sendFrom
|
|
* information is stored in the lastPartner attribute. Else, the lastPartner
|
|
* information remains untouched, the message's content is cleared and the
|
|
* function returns immediately.
|
|
* @param message A pointer to a message in which the received data is stored.
|
|
*/
|
|
ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
|
|
/**
|
|
* Deletes all pending messages in the queue.
|
|
* @param count The number of flushed messages.
|
|
* @return RETURN_OK on success.
|
|
*/
|
|
ReturnValue_t flush(uint32_t* count) override;
|
|
/**
|
|
* @brief This method returns the message queue id of the last
|
|
* communication partner.
|
|
*/
|
|
MessageQueueId_t getLastPartner() const override;
|
|
/**
|
|
* @brief This method returns the message queue id of this class's
|
|
* message queue.
|
|
*/
|
|
MessageQueueId_t getId() const override;
|
|
|
|
/**
|
|
* @brief This method is a simple setter for the default destination.
|
|
*/
|
|
void setDefaultDestination(MessageQueueId_t defaultDestination) override;
|
|
/**
|
|
* @brief This method is a simple getter for the default destination.
|
|
*/
|
|
MessageQueueId_t getDefaultDestination() const override;
|
|
|
|
bool isDefaultDestinationSet() const override;
|
|
|
|
ReturnValue_t lockQueue(MutexIF::TimeoutType timeoutType,
|
|
dur_millis_t lockTimeout);
|
|
ReturnValue_t unlockQueue();
|
|
protected:
|
|
/**
|
|
* @brief Implementation to be called from any send Call within
|
|
* MessageQueue and MessageQueueSenderIF.
|
|
* @details
|
|
* This method takes the message provided, adds the sentFrom information and
|
|
* passes it on to the destination provided with an operating system call.
|
|
* The OS's return value is returned.
|
|
* @param sendTo
|
|
* This parameter specifies the message queue id to send the message to.
|
|
* @param message
|
|
* This is a pointer to a previously created message, which is sent.
|
|
* @param sentFrom
|
|
* The sentFrom information can be set to inject the sender's queue id into
|
|
* the message. This variable is set to zero by default.
|
|
* @param ignoreFault
|
|
* If set to true, the internal software fault counter is not incremented
|
|
* if queue is full.
|
|
* @param context Specify whether call is made from task or from an ISR.
|
|
*/
|
|
static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
|
|
MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
|
|
bool ignoreFault=false);
|
|
|
|
//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
|
|
|
|
private:
|
|
std::queue<std::vector<uint8_t>> messageQueue;
|
|
/**
|
|
* @brief The class stores the queue id it got assigned.
|
|
* If initialization fails, the queue id is set to zero.
|
|
*/
|
|
MessageQueueId_t mqId = MessageQueueIF::NO_QUEUE;
|
|
size_t messageSize = 0;
|
|
size_t messageDepth = 0;
|
|
|
|
MutexIF* queueLock;
|
|
|
|
bool defaultDestinationSet = false;
|
|
MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
|
|
MessageQueueId_t lastPartner = MessageQueueIF::NO_QUEUE;
|
|
};
|
|
|
|
#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
|