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

Merge pull request 'Modes and Memory convergence' (#214) from KSat/fsfw:mueller/modes-memory into master

Browse Source 
Reviewed-on: fsfw/fsfw#214
This commit is contained in:
Steffen Gaisser 2020-09-29 15:13:34 +02:00
commit ce983953ff
11 changed files with 172 additions and 177 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 @@
/**
* @file AcceptsMemoryMessagesIF.h
* @brief This file defines the AcceptsMemoryMessagesIF class.
* @date 11.07.2013
* @author baetz
*/
#ifndef ACCEPTSMEMORYMESSAGESIF_H_
#define ACCEPTSMEMORYMESSAGESIF_H_
#ifndef FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
#define FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
#include "HasMemoryIF.h"
#include "MemoryMessage.h"
@ -18,4 +11,4 @@ public:
};
#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
#endif /* FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */

47
memory/MemoryHelper.cpp
View File

@ -1,14 +1,15 @@
#include "../globalfunctions/CRC.h"
#include "MemoryHelper.h"
#include "MemoryMessage.h"
#include "../globalfunctions/CRC.h"
#include "../objectmanager/ObjectManagerIF.h"
#include "../serialize/EndianConverter.h"
#include "../serviceinterface/ServiceInterfaceStream.h"
MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue) :
workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(NULL), ipcAddress(), lastCommand(
CommandMessage::CMD_NONE), lastSender(0), reservedSpaceInIPC(
NULL), busy(false) {
MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
MessageQueueIF* useThisQueue):
workOnThis(workOnThis), queueToUse(useThisQueue), ipcAddress(),
lastCommand(CommandMessage::CMD_NONE), busy(false) {
}
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,
const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
const uint8_t* dataToCopy, const size_t size, uint8_t* copyHere) {
busy = false;
switch (errorCode) {
case HasMemoryIF::DO_IT_MYSELF:
@ -67,13 +59,13 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
return;
}
//Only reached on success
CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
queueToUse->sendMessage(lastSender, &reply);
ipcStore->deleteData(ipcAddress);
}
void MemoryHelper::completeDump(ReturnValue_t errorCode,
const uint8_t* dataToCopy, const uint32_t size) {
const uint8_t* dataToCopy, const size_t size) {
busy = false;
CommandMessage reply;
MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
@ -125,12 +117,12 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
break;
}
if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
reply.clearCommandMessage();
reply.clear();
}
}
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){
return;
}
@ -185,11 +177,18 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
}
ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
if(queueToUse_!=NULL){
this->queueToUse = queueToUse_;
}else{
return MessageQueueIF::NO_QUEUE;
if(queueToUse_ == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
}
this->queueToUse = queueToUse_;
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_
#define MEMORYHELPER_H_
#include "../ipc/CommandMessage.h"
#ifndef FSFW_MEMORY_MEMORYHELPER_H_
#define FSFW_MEMORY_MEMORYHELPER_H_
#include "AcceptsMemoryMessagesIF.h"
#include "../ipc/CommandMessage.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include "../storagemanager/StorageManagerIF.h"
#include "../ipc/MessageQueueIF.h"
/**
* @brief TODO: documentation.
*/
class MemoryHelper : public HasReturnvaluesIF {
public:
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_SIZE = MAKE_RETURN_CODE(0xE2);
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:
HasMemoryIF* workOnThis;
MessageQueueIF* queueToUse;
StorageManagerIF* ipcStore;
StorageManagerIF* ipcStore = nullptr;
store_address_t ipcAddress;
Command_t lastCommand;
MessageQueueId_t lastSender;
uint8_t* reservedSpaceInIPC;
MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
uint8_t* reservedSpaceInIPC = nullptr;
bool busy;
void handleMemoryLoad(CommandMessage* message);
void handleMemoryCheckOrDump(CommandMessage* message);
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_ */

28
memory/MemoryMessage.cpp
View File

@ -1,7 +1,6 @@
#include "MemoryMessage.h"
#include "../objectmanager/ObjectManagerIF.h"
MemoryMessage::MemoryMessage() {
}
uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
return message->getParameter();
@ -17,26 +16,24 @@ uint32_t MemoryMessage::getLength(const CommandMessage* message) {
return message->getParameter2();
}
ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
void MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
uint32_t address, uint32_t length) {
message->setCommand(CMD_MEMORY_DUMP);
message->setParameter( address );
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->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) {
message->setCommand(CMD_MEMORY_LOAD);
message->setParameter( address );
message->setParameter2( storageID.raw );
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
@ -65,22 +62,21 @@ void MemoryMessage::clear(CommandMessage* message) {
}
}
ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
void MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
uint32_t address, uint32_t length) {
message->setCommand(CMD_MEMORY_CHECK);
message->setParameter( address );
message->setParameter2( length );
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
void MemoryMessage::setMemoryCheckReply(CommandMessage* message,
uint16_t crc) {
message->setCommand(REPLY_MEMORY_CHECK);
message->setParameter( crc );
return HasReturnvaluesIF::RETURN_OK;
}
void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
void MemoryMessage::setCrcReturnValue(CommandMessage* message,
ReturnValue_t returnValue){
message->setParameter(returnValue<<16);
};
@ -96,18 +92,16 @@ Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
return message->getParameter2();
}
ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
void MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
ReturnValue_t errorCode, Command_t initialCommand) {
message->setCommand(REPLY_MEMORY_FAILED);
message->setParameter(errorCode);
message->setParameter2(initialCommand);
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
void MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
message->setCommand(END_OF_MEMORY_COPY);
message->setParameter(0);
message->setParameter2(0);
return HasReturnvaluesIF::RETURN_OK;
}

43
memory/MemoryMessage.h
View File

@ -1,14 +1,15 @@
#ifndef MEMORYMESSAGE_H_
#define MEMORYMESSAGE_H_
#ifndef FSFW_MEMORY_MEMORYMESSAGE_H_
#define FSFW_MEMORY_MEMORYMESSAGE_H_
#include "../ipc/CommandMessage.h"
#include "../storagemanager/StorageManagerIF.h"
class MemoryMessage {
private:
MemoryMessage(); //A private ctor inhibits instantiation
public:
// Instantiation forbidden.
MemoryMessage() = delete;
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_DUMP = MAKE_COMMAND_ID( 0x02 );
@ -19,21 +20,29 @@ public:
static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
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 ReturnValue_t getErrorCode( const CommandMessage* message );
static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
static ReturnValue_t 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 ReturnValue_t getErrorCode(const CommandMessage* message);
static uint16_t getCrc(const CommandMessage* message );
static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
static Command_t getInitialCommand(const CommandMessage* message);
static void setMemoryDumpCommand(CommandMessage* message,
uint32_t address, uint32_t length );
static void setMemoryDumpReply(CommandMessage* message,
store_address_t storageID);
static void setMemoryLoadCommand(CommandMessage* message,
uint32_t address, store_address_t storageID );
static void setMemoryCheckCommand(CommandMessage* message,
uint32_t address, uint32_t length);
static void setMemoryCheckReply(CommandMessage* message,
uint16_t crc);
static void setMemoryReplyFailed(CommandMessage* message,
ReturnValue_t errorCode, Command_t initialCommand);
static void setMemoryCopyEnd(CommandMessage* message);
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);
};
#endif /* MEMORYMESSAGE_H_ */
#endif /* FSFW_MEMORY_MEMORYMESSAGE_H_ */

22
memory/MemoryProxyIF.h
View File

@ -1,22 +0,0 @@
#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
#include "AcceptsMemoryMessagesIF.h"
/**
* This was a nice idea to transparently forward incoming messages to another object.
* But it doesn't work like that.
*/
class MemoryProxyIF : public AcceptsMemoryMessagesIF {
public:
virtual MessageQueueId_t getProxyQueue() const = 0;
MessageQueueId_t getCommandQueue() const {
return getProxyQueue();
}
virtual ~MemoryProxyIF() {}
};
#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */

34
modes/HasModesIF.h
View File

@ -1,18 +1,11 @@
/**
* @file HasModesIF.h
* @brief This file defines the HasModesIF class.
* @date 20.06.2013
* @author baetz
*/
#ifndef FSFW_MODES_HASMODESIF_H_
#define FSFW_MODES_HASMODESIF_H_
#ifndef HASMODESIF_H_
#define HASMODESIF_H_
#include "../events/Event.h"
#include "ModeHelper.h"
#include "ModeMessage.h"
#include "../events/Event.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include <stdint.h>
#include <cstdint>
class HasModesIF {
@ -37,21 +30,22 @@ public:
static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
virtual ~HasModesIF() {
}
virtual ~HasModesIF() {}
virtual MessageQueueId_t getCommandQueue() const = 0;
virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
protected:
virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
uint32_t *msToReachTheMode) {
return HasReturnvaluesIF::RETURN_FAILED;
}
virtual void startTransition(Mode_t mode, Submode_t submode) {
}
virtual void setToExternalControl() {
}
virtual void announceMode(bool recursive) {
}
virtual void startTransition(Mode_t mode, Submode_t submode) {}
virtual void setToExternalControl() {}
virtual void announceMode(bool recursive) {}
};
#endif /* HASMODESIF_H_ */
#endif /*FSFW_MODES_HASMODESIF_H_ */

72
modes/ModeHelper.cpp
View File

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

20
modes/ModeHelper.h
View File

@ -1,7 +1,8 @@
#ifndef MODEHELPER_H_
#define MODEHELPER_H_
#ifndef FSFW_MODES_MODEHELPER_H_
#define FSFW_MODES_MODEHELPER_H_
#include "ModeMessage.h"
#include "../ipc/MessageQueueIF.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include "../timemanager/Countdown.h"
@ -9,7 +10,7 @@ class HasModesIF;
class ModeHelper {
public:
MessageQueueId_t theOneWhoCommandedAMode;
MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
Mode_t commandedMode;
Submode_t commandedSubmode;
@ -19,14 +20,14 @@ public:
ReturnValue_t handleModeCommand(CommandMessage *message);
/**
*
* @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
* @param parentQueue the Queue id of the parent object.
* Set to 0 if no parent present
*/
void setParentQueue(MessageQueueId_t parentQueueId);
ReturnValue_t initialize(MessageQueueId_t parentQueueId);
ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
ReturnValue_t initialize(void);
void modeChanged(Mode_t mode, Submode_t submode);
@ -39,11 +40,14 @@ public:
void setForced(bool forced);
protected:
HasModesIF *owner;
MessageQueueId_t parentQueueId;
MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
Countdown countdown;
bool forced;
private:
void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
};
#endif /* MODEHELPER_H_ */
#endif /* FSFW_MODES_MODEHELPER_H_ */

8
modes/ModeMessage.cpp
View File

@ -8,12 +8,11 @@ Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
return message->getParameter2();
}
ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
Mode_t mode, Submode_t submode) {
void ModeMessage::setModeMessage(CommandMessage* message,
Command_t command, Mode_t mode, Submode_t submode) {
message->setCommand( command );
message->setParameter( mode );
message->setParameter2( submode );
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
@ -24,7 +23,8 @@ void ModeMessage::clear(CommandMessage* message) {
message->setCommand(CommandMessage::CMD_NONE);
}
void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
void ModeMessage::setCantReachMode(CommandMessage* message,
ReturnValue_t reason) {
message->setCommand(REPLY_CANT_REACH_MODE);
message->setParameter(reason);
message->setParameter2(0);

20
modes/ModeMessage.h
View File

@ -1,12 +1,5 @@
/**
* @file ModeMessage.h
* @brief This file defines the ModeMessage class.
* @date 17.07.2013
* @author baetz
*/
#ifndef MODEMESSAGE_H_
#define MODEMESSAGE_H_
#ifndef FSFW_MODES_MODEMESSAGE_H_
#define FSFW_MODES_MODEMESSAGE_H_
#include "../ipc/CommandMessage.h"
@ -30,11 +23,12 @@ public:
static Mode_t getMode(const CommandMessage* message);
static Submode_t getSubmode(const CommandMessage* message);
static ReturnValue_t setModeMessage(CommandMessage* message,
static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
static void setModeMessage(CommandMessage* message,
Command_t command, Mode_t mode, Submode_t submode);
static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
static void setCantReachMode(CommandMessage* message, ReturnValue_t reason);
static void clear(CommandMessage* message);
};
#endif /* MODEMESSAGE_H_ */
#endif /* FSFW_MODES_MODEMESSAGE_H_ */