esbo_ds/fsfw
3
0
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'mueller/MQM_IF_UpdateLinux' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/MQM_IF_UpdateLinux

Browse Source
This commit is contained in:
Robin Müller 2020-09-29 15:21:42 +02:00
commit 00f89bb193
12 changed files with 179 additions and 182 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 /* FSFW_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_ */

28
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) {
@ -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) { uint32_t address, uint32_t length) {
message->setCommand(CMD_MEMORY_CHECK); message->setCommand(CMD_MEMORY_CHECK);
message->setParameter( address ); message->setParameter( address );
message->setParameter2( length ); message->setParameter2( length );
return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message, void MemoryMessage::setMemoryCheckReply(CommandMessage* message,
uint16_t crc) { uint16_t crc) {
message->setCommand(REPLY_MEMORY_CHECK); message->setCommand(REPLY_MEMORY_CHECK);
message->setParameter( crc ); 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); message->setParameter(returnValue<<16);
}; };
@ -96,18 +92,16 @@ Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
return message->getParameter2(); return message->getParameter2();
} }
ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message, void MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
ReturnValue_t errorCode, Command_t initialCommand) { ReturnValue_t errorCode, Command_t initialCommand) {
message->setCommand(REPLY_MEMORY_FAILED); message->setCommand(REPLY_MEMORY_FAILED);
message->setParameter(errorCode); message->setParameter(errorCode);
message->setParameter2(initialCommand); 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->setCommand(END_OF_MEMORY_COPY);
message->setParameter(0); message->setParameter(0);
message->setParameter2(0); message->setParameter2(0);
return HasReturnvaluesIF::RETURN_OK;
} }

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 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 uint16_t getCrc( const CommandMessage* message );
static ReturnValue_t getCrcReturnValue(const CommandMessage* message); static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
static Command_t getInitialCommand( 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 void clear(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 @@
/** #ifndef FSFW_MODES_HASMODESIF_H_
* @file HasModesIF.h #define FSFW_MODES_HASMODESIF_H_
* @brief This file defines the HasModesIF class.
* @date 20.06.2013
* @author baetz
*/
#ifndef HASMODESIF_H_
#define HASMODESIF_H_
#include "../events/Event.h"
#include "ModeHelper.h" #include "ModeHelper.h"
#include "ModeMessage.h" #include "ModeMessage.h"
#include "../events/Event.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#include <stdint.h> #include <cstdint>
class HasModesIF { 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_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 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". 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 MessageQueueId_t getCommandQueue() const = 0;
virtual void getMode(Mode_t *mode, Submode_t *submode) = 0; virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
protected: protected:
virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
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 /*FSFW_MODES_HASMODESIF_H_ */

66
modes/ModeHelper.cpp
View File

@ -1,38 +1,39 @@
#include "HasModesIF.h" #include "HasModesIF.h"
#include "ModeHelper.h" #include "ModeHelper.h"
#include "../ipc/MessageQueueSenderIF.h" #include "../ipc/MessageQueueSenderIF.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::setCantReachMode(&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;
@ -42,7 +43,6 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
} }
countdown.setTimeout(timeout); countdown.setTimeout(timeout);
owner->startTransition(mode, submode); owner->startTransition(mode, submode);
} }
break; break;
@ -50,7 +50,7 @@ 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;
@ -71,27 +71,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 != MessageQueueIF::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 != MessageQueueIF::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 = MessageQueueIF::NO_QUEUE;
} }
void ModeHelper::startTimer(uint32_t timeoutMs) { void ModeHelper::startTimer(uint32_t timeoutMs) {

20
modes/ModeHelper.h
View File

@ -1,7 +1,8 @@
#ifndef MODEHELPER_H_ #ifndef FSFW_MODES_MODEHELPER_H_
#define MODEHELPER_H_ #define FSFW_MODES_MODEHELPER_H_
#include "ModeMessage.h" #include "ModeMessage.h"
#include "../ipc/MessageQueueIF.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;
@ -19,14 +20,14 @@ public:
ReturnValue_t handleModeCommand(CommandMessage *message); ReturnValue_t handleModeCommand(CommandMessage *message);
/** /**
* * @param parentQueue the Queue id of the parent object.
* @param parentQueue the Queue id of the parent object. Set to 0 if no parent present * Set to 0 if no parent present
*/ */
void setParentQueue(MessageQueueId_t parentQueueId); void setParentQueue(MessageQueueId_t parentQueueId);
ReturnValue_t initialize(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); void modeChanged(Mode_t mode, Submode_t submode);
@ -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 /* FSFW_MODES_MODEHELPER_H_ */

8
modes/ModeMessage.cpp
View File

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

20
modes/ModeMessage.h
View File

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

12
tmtcservices/PusVerificationReport.h
View File

@ -1,9 +1,11 @@
#ifndef PUSVERIFICATIONREPORT_H_ #ifndef FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_
#define PUSVERIFICATIONREPORT_H_ #define FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_
#include "VerificationCodes.h"
#include "../ipc/MessageQueueMessage.h" #include "../ipc/MessageQueueMessage.h"
#include "../tmtcpacket/pus/TcPacketBase.h" #include "../tmtcpacket/pus/TcPacketBase.h"
#include "VerificationCodes.h" #include "../returnvalues/HasReturnvaluesIF.h"
class PusVerificationMessage: public MessageQueueMessage { class PusVerificationMessage: public MessageQueueMessage {
private: private:
@ -30,7 +32,7 @@ private:
public: public:
static const uint8_t VERIFICATION_MIN_SIZE = 6; static const uint8_t VERIFICATION_MIN_SIZE = 6;
PusVerificationMessage(); PusVerificationMessage();
// PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags, PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
uint16_t tcPacketId, uint16_t tcSequenceControl, uint16_t tcPacketId, uint16_t tcSequenceControl,
ReturnValue_t set_error_code = 0, uint8_t set_step = 0, ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
@ -74,4 +76,4 @@ public:
uint8_t* getReport(); uint8_t* getReport();
}; };
#endif /* PUSVERIFICATIONREPORT_H_ */ #endif /* FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_ */