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

starting convergence

Browse Source
This commit is contained in:
Robin Müller 2020-09-26 14:51:00 +02:00
parent d1fb512c1f
commit 7b57f372bf
10 changed files with 147 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
memory/AcceptsMemoryMessagesIF.h
View File

@ -1,12 +1,5 @@
/** #ifndef FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
* @file AcceptsMemoryMessagesIF.h #define FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
* @brief This file defines the AcceptsMemoryMessagesIF class.
* @date 11.07.2013
* @author baetz
*/
#ifndef ACCEPTSMEMORYMESSAGESIF_H_
#define ACCEPTSMEMORYMESSAGESIF_H_
#include "HasMemoryIF.h" #include "HasMemoryIF.h"
#include "MemoryMessage.h" #include "MemoryMessage.h"
@ -18,4 +11,4 @@ public:
}; };
#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */ #endif /* AFSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */

47
memory/MemoryHelper.cpp
View File

@ -1,14 +1,15 @@
#include "../globalfunctions/CRC.h"
#include "MemoryHelper.h" #include "MemoryHelper.h"
#include "MemoryMessage.h" #include "MemoryMessage.h"
#include "../globalfunctions/CRC.h"
#include "../objectmanager/ObjectManagerIF.h" #include "../objectmanager/ObjectManagerIF.h"
#include "../serialize/EndianConverter.h" #include "../serialize/EndianConverter.h"
#include "../serviceinterface/ServiceInterfaceStream.h" #include "../serviceinterface/ServiceInterfaceStream.h"
MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue) : MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(NULL), ipcAddress(), lastCommand( MessageQueueIF* useThisQueue):
CommandMessage::CMD_NONE), lastSender(0), reservedSpaceInIPC( workOnThis(workOnThis), queueToUse(useThisQueue), ipcAddress(),
NULL), busy(false) { lastCommand(CommandMessage::CMD_NONE), busy(false) {
} }
ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) { ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
@ -33,17 +34,8 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
} }
} }
ReturnValue_t MemoryHelper::initialize() {
ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
if (ipcStore != NULL) {
return RETURN_OK;
} else {
return RETURN_FAILED;
}
}
void MemoryHelper::completeLoad(ReturnValue_t errorCode, void MemoryHelper::completeLoad(ReturnValue_t errorCode,
const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) { const uint8_t* dataToCopy, const size_t size, uint8_t* copyHere) {
busy = false; busy = false;
switch (errorCode) { switch (errorCode) {
case HasMemoryIF::DO_IT_MYSELF: case HasMemoryIF::DO_IT_MYSELF:
@ -67,13 +59,13 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
return; return;
} }
//Only reached on success //Only reached on success
CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0); CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
queueToUse->sendMessage(lastSender, &reply); queueToUse->sendMessage(lastSender, &reply);
ipcStore->deleteData(ipcAddress); ipcStore->deleteData(ipcAddress);
} }
void MemoryHelper::completeDump(ReturnValue_t errorCode, void MemoryHelper::completeDump(ReturnValue_t errorCode,
const uint8_t* dataToCopy, const uint32_t size) { const uint8_t* dataToCopy, const size_t size) {
busy = false; busy = false;
CommandMessage reply; CommandMessage reply;
MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand); MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
@ -125,12 +117,12 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
break; break;
} }
if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) { if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
reply.clearCommandMessage(); reply.clear();
} }
} }
void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in, void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
uint32_t totalSize, uint8_t datatypeSize) { size_t totalSize, uint8_t datatypeSize) {
if (totalSize % datatypeSize != 0){ if (totalSize % datatypeSize != 0){
return; return;
} }
@ -185,11 +177,18 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
} }
ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) { ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
if(queueToUse_!=NULL){ if(queueToUse_ == nullptr) {
this->queueToUse = queueToUse_; return HasReturnvaluesIF::RETURN_FAILED;
}else{
return MessageQueueIF::NO_QUEUE;
} }
this->queueToUse = queueToUse_;
return initialize(); return initialize();
} }
ReturnValue_t MemoryHelper::initialize() {
ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
if (ipcStore != nullptr) {
return RETURN_OK;
} else {
return RETURN_FAILED;
}
}

42
memory/MemoryHelper.h
View File

@ -1,11 +1,16 @@
#ifndef MEMORYHELPER_H_ #ifndef FSFW_MEMORY_MEMORYHELPER_H_
#define MEMORYHELPER_H_ #define FSFW_MEMORY_MEMORYHELPER_H_
#include "../ipc/CommandMessage.h"
#include "AcceptsMemoryMessagesIF.h" #include "AcceptsMemoryMessagesIF.h"
#include "../ipc/CommandMessage.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#include "../storagemanager/StorageManagerIF.h" #include "../storagemanager/StorageManagerIF.h"
#include "../ipc/MessageQueueIF.h" #include "../ipc/MessageQueueIF.h"
/**
* @brief TODO: documentation.
*/
class MemoryHelper : public HasReturnvaluesIF { class MemoryHelper : public HasReturnvaluesIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER; static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
@ -13,25 +18,32 @@ public:
static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1); static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2); static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3); static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue);
~MemoryHelper();
ReturnValue_t handleMemoryCommand(CommandMessage* message);
void completeLoad(ReturnValue_t errorCode,
const uint8_t* dataToCopy = nullptr, const size_t size = 0,
uint8_t* copyHere = nullptr);
void completeDump(ReturnValue_t errorCode,
const uint8_t* dataToCopy = nullptr, const size_t size = 0);
void swapMatrixCopy(uint8_t *out, const uint8_t *in, size_t totalSize,
uint8_t datatypeSize);
ReturnValue_t initialize(MessageQueueIF* queueToUse_);
private: private:
HasMemoryIF* workOnThis; HasMemoryIF* workOnThis;
MessageQueueIF* queueToUse; MessageQueueIF* queueToUse;
StorageManagerIF* ipcStore; StorageManagerIF* ipcStore = nullptr;
store_address_t ipcAddress; store_address_t ipcAddress;
Command_t lastCommand; Command_t lastCommand;
MessageQueueId_t lastSender; MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
uint8_t* reservedSpaceInIPC; uint8_t* reservedSpaceInIPC = nullptr;
bool busy; bool busy;
void handleMemoryLoad(CommandMessage* message); void handleMemoryLoad(CommandMessage* message);
void handleMemoryCheckOrDump(CommandMessage* message); void handleMemoryCheckOrDump(CommandMessage* message);
ReturnValue_t initialize(); ReturnValue_t initialize();
public:
ReturnValue_t handleMemoryCommand(CommandMessage* message);
void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
void completeDump( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
ReturnValue_t initialize(MessageQueueIF* queueToUse_);
MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
~MemoryHelper();
}; };
#endif /* MEMORYHELPER_H_ */ #endif /* FSFW_MEMORY_MEMORYHELPER_H_ */

13
memory/MemoryMessage.cpp
View File

@ -1,7 +1,6 @@
#include "MemoryMessage.h" #include "MemoryMessage.h"
#include "../objectmanager/ObjectManagerIF.h" #include "../objectmanager/ObjectManagerIF.h"
MemoryMessage::MemoryMessage() {
}
uint32_t MemoryMessage::getAddress(const CommandMessage* message) { uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
return message->getParameter(); return message->getParameter();
@ -17,26 +16,24 @@ uint32_t MemoryMessage::getLength(const CommandMessage* message) {
return message->getParameter2(); return message->getParameter2();
} }
ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message, void MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
uint32_t address, uint32_t length) { uint32_t address, uint32_t length) {
message->setCommand(CMD_MEMORY_DUMP); message->setCommand(CMD_MEMORY_DUMP);
message->setParameter( address ); message->setParameter( address );
message->setParameter2( length ); message->setParameter2( length );
return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) { void MemoryMessage::setMemoryDumpReply(CommandMessage* message,
store_address_t storageID) {
message->setCommand(REPLY_MEMORY_DUMP); message->setCommand(REPLY_MEMORY_DUMP);
message->setParameter2( storageID.raw ); message->setParameter2( storageID.raw );
return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t MemoryMessage::setMemoryLoadCommand(CommandMessage* message, void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
uint32_t address, store_address_t storageID) { uint32_t address, store_address_t storageID) {
message->setCommand(CMD_MEMORY_LOAD); message->setCommand(CMD_MEMORY_LOAD);
message->setParameter( address ); message->setParameter( address );
message->setParameter2( storageID.raw ); message->setParameter2( storageID.raw );
return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) { ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {

43
memory/MemoryMessage.h
View File

@ -1,14 +1,15 @@
#ifndef MEMORYMESSAGE_H_ #ifndef FSFW_MEMORY_MEMORYMESSAGE_H_
#define MEMORYMESSAGE_H_ #define FSFW_MEMORY_MEMORYMESSAGE_H_
#include "../ipc/CommandMessage.h" #include "../ipc/CommandMessage.h"
#include "../storagemanager/StorageManagerIF.h" #include "../storagemanager/StorageManagerIF.h"
class MemoryMessage { class MemoryMessage {
private:
MemoryMessage(); //A private ctor inhibits instantiation
public: public:
// Instantiation forbidden.
MemoryMessage() = delete;
static const uint8_t MESSAGE_ID = messagetypes::MEMORY; static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 ); static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 ); static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
@ -19,21 +20,29 @@ public:
static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0); static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
static uint32_t getAddress( const CommandMessage* message ); static uint32_t getAddress( const CommandMessage* message );
static store_address_t getStoreID( const CommandMessage* message ); static store_address_t getStoreID(const CommandMessage* message);
static uint32_t getLength( const CommandMessage* message ); static uint32_t getLength( const CommandMessage* message );
static ReturnValue_t getErrorCode( const CommandMessage* message ); static ReturnValue_t getErrorCode(const CommandMessage* message);
static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length ); static uint16_t getCrc(const CommandMessage* message );
static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID ); static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
static ReturnValue_t setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID ); static Command_t getInitialCommand(const CommandMessage* message);
static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
static ReturnValue_t setMemoryCheckReply( CommandMessage* message, uint16_t crc ); static void setMemoryDumpCommand(CommandMessage* message,
static ReturnValue_t setMemoryReplyFailed( CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand ); uint32_t address, uint32_t length );
static ReturnValue_t setMemoryCopyEnd( CommandMessage* message); static void setMemoryDumpReply(CommandMessage* message,
store_address_t storageID);
static void setMemoryLoadCommand(CommandMessage* message,
uint32_t address, store_address_t storageID );
static ReturnValue_t setMemoryCheckCommand(CommandMessage* message,
uint32_t address, uint32_t length);
static ReturnValue_t setMemoryCheckReply(CommandMessage* message,
uint16_t crc);
static ReturnValue_t setMemoryReplyFailed(CommandMessage* message,
ReturnValue_t errorCode, Command_t initialCommand);
static ReturnValue_t setMemoryCopyEnd(CommandMessage* message);
static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue); static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
static uint16_t getCrc( const CommandMessage* message );
static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
static Command_t getInitialCommand( const CommandMessage* message );
static void clear(CommandMessage* message); static void clear(CommandMessage* message);
}; };
#endif /* MEMORYMESSAGE_H_ */ #endif /* FSFW_MEMORY_MEMORYMESSAGE_H_ */

2
memory/MemoryProxyIF.h
View File

@ -1,7 +1,7 @@
#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ #ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ #define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
#include "AcceptsMemoryMessagesIF.h" #include "../memory/AcceptsMemoryMessagesIF.h"
/** /**
* This was a nice idea to transparently forward incoming messages to another object. * This was a nice idea to transparently forward incoming messages to another object.

16
modes/HasModesIF.h
View File

@ -9,8 +9,8 @@
#define HASMODESIF_H_ #define HASMODESIF_H_
#include "../events/Event.h" #include "../events/Event.h"
#include "ModeHelper.h" #include "../modes/ModeHelper.h"
#include "ModeMessage.h" #include "../modes/ModeMessage.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#include <stdint.h> #include <stdint.h>
@ -46,12 +46,12 @@ protected:
uint32_t *msToReachTheMode) { uint32_t *msToReachTheMode) {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
virtual void startTransition(Mode_t mode, Submode_t submode) {
} virtual void startTransition(Mode_t mode, Submode_t submode) {}
virtual void setToExternalControl() {
} virtual void setToExternalControl() {}
virtual void announceMode(bool recursive) {
} virtual void announceMode(bool recursive) {}
}; };
#endif /* HASMODESIF_H_ */ #endif /* HASMODESIF_H_ */

75
modes/ModeHelper.cpp
View File

@ -1,48 +1,47 @@
#include "HasModesIF.h"
#include "ModeHelper.h"
#include "../ipc/MessageQueueSenderIF.h" #include "../ipc/MessageQueueSenderIF.h"
#include "../modes/HasModesIF.h"
#include "../modes/ModeHelper.h"
#include "../serviceinterface/ServiceInterfaceStream.h"
ModeHelper::ModeHelper(HasModesIF *owner) : ModeHelper::ModeHelper(HasModesIF *owner) :
theOneWhoCommandedAMode(0), commandedMode(HasModesIF::MODE_OFF), commandedSubmode( commandedMode(HasModesIF::MODE_OFF),
HasModesIF::SUBMODE_NONE), owner(owner), parentQueueId(0), forced( commandedSubmode(HasModesIF::SUBMODE_NONE),
false) { owner(owner), forced(false) {}
}
ModeHelper::~ModeHelper() { ModeHelper::~ModeHelper() {
} }
ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) { ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
CommandMessage reply; CommandMessage reply;
Mode_t mode; Mode_t mode;
Submode_t submode; Submode_t submode;
switch (message->getCommand()) { switch (command->getCommand()) {
case ModeMessage::CMD_MODE_COMMAND_FORCED: case ModeMessage::CMD_MODE_COMMAND_FORCED:
forced = true; forced = true;
/* NO BREAK falls through*/ /* NO BREAK falls through*/
case ModeMessage::CMD_MODE_COMMAND: { case ModeMessage::CMD_MODE_COMMAND: {
mode = ModeMessage::getMode(message); mode = ModeMessage::getMode(command);
submode = ModeMessage::getSubmode(message); submode = ModeMessage::getSubmode(command);
uint32_t timeout; uint32_t timeout;
ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout); ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
ModeMessage::cantReachMode(&reply, result); ModeMessage::cantReachMode(&reply, result);
MessageQueueSenderIF::sendMessage(message->getSender(), &reply, MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
owner->getCommandQueue()); owner->getCommandQueue());
break; break;
} }
//Free to start transition //Free to start transition
theOneWhoCommandedAMode = message->getSender(); theOneWhoCommandedAMode = command->getSender();
commandedMode = mode; commandedMode = mode;
commandedSubmode = submode; commandedSubmode = submode;
if ((parentQueueId != MessageQueueSenderIF::NO_QUEUE) if ((parentQueueId != MessageQueueIF::NO_QUEUE)
&& (theOneWhoCommandedAMode != parentQueueId)) { && (theOneWhoCommandedAMode != parentQueueId)) {
owner->setToExternalControl(); owner->setToExternalControl();
} }
countdown.setTimeout(timeout); countdown.setTimeout(timeout);
owner->startTransition(mode, submode); owner->startTransition(mode, submode);
} }
break; break;
@ -50,8 +49,8 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
owner->getMode(&mode, &submode); owner->getMode(&mode, &submode);
ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode, ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
submode); submode);
MessageQueueSenderIF::sendMessage(message->getSender(), &reply, MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
owner->getCommandQueue()); owner->getCommandQueue());
} }
break; break;
case ModeMessage::CMD_MODE_ANNOUNCE: case ModeMessage::CMD_MODE_ANNOUNCE:
@ -71,27 +70,45 @@ ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
return initialize(); return initialize();
} }
void ModeHelper::modeChanged(Mode_t mode, Submode_t submode) { void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
forced = false; forced = false;
sendModeReplyMessage(ownerMode, ownerSubmode);
sendModeInfoMessage(ownerMode, ownerSubmode);
theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
}
void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
Submode_t ownerSubmode) {
CommandMessage reply; CommandMessage reply;
if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE) { if (theOneWhoCommandedAMode != MessageQueueIF::NO_QUEUE)
if ((mode != commandedMode) || (submode != commandedSubmode)) { {
if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
{
ModeMessage::setModeMessage(&reply, ModeMessage::setModeMessage(&reply,
ModeMessage::REPLY_WRONG_MODE_REPLY, mode, submode); ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
} else { ownerSubmode);
}
else
{
ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
mode, submode); ownerMode, ownerSubmode);
} }
MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply, MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
owner->getCommandQueue()); owner->getCommandQueue());
} }
}
void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
Submode_t ownerSubmode) {
CommandMessage reply;
if (theOneWhoCommandedAMode != parentQueueId if (theOneWhoCommandedAMode != parentQueueId
&& parentQueueId != MessageQueueSenderIF::NO_QUEUE) { and parentQueueId != MessageQueueIF::NO_QUEUE)
ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO, mode, {
submode); ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
MessageQueueSenderIF::sendMessage(parentQueueId, &reply, owner->getCommandQueue()); ownerMode, ownerSubmode);
MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
owner->getCommandQueue());
} }
theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE;
} }
void ModeHelper::startTimer(uint32_t timeoutMs) { void ModeHelper::startTimer(uint32_t timeoutMs) {

10
modes/ModeHelper.h
View File

@ -1,7 +1,8 @@
#ifndef MODEHELPER_H_ #ifndef MODEHELPER_H_
#define MODEHELPER_H_ #define MODEHELPER_H_
#include "ModeMessage.h" #include "../ipc/MessageQueueIF.h"
#include "../modes/ModeMessage.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#include "../timemanager/Countdown.h" #include "../timemanager/Countdown.h"
@ -9,7 +10,7 @@ class HasModesIF;
class ModeHelper { class ModeHelper {
public: public:
MessageQueueId_t theOneWhoCommandedAMode; MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
Mode_t commandedMode; Mode_t commandedMode;
Submode_t commandedSubmode; Submode_t commandedSubmode;
@ -39,11 +40,14 @@ public:
void setForced(bool forced); void setForced(bool forced);
protected: protected:
HasModesIF *owner; HasModesIF *owner;
MessageQueueId_t parentQueueId; MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
Countdown countdown; Countdown countdown;
bool forced; bool forced;
private:
void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
}; };
#endif /* MODEHELPER_H_ */ #endif /* MODEHELPER_H_ */

2
modes/ModeMessage.cpp
View File

@ -1,4 +1,4 @@
#include "ModeMessage.h" #include "../modes/ModeMessage.h"
Mode_t ModeMessage::getMode(const CommandMessage* message) { Mode_t ModeMessage::getMode(const CommandMessage* message) {
return message->getParameter(); return message->getParameter();