Merge pull request 'Subsystem Update' (#306) from KSat/fsfw:mueller/subsyste-update into development

Reviewed-on: fsfw/fsfw#306
This commit is contained in:
Steffen Gaisser 2020-12-15 15:16:58 +01:00
commit a343baa813
10 changed files with 156 additions and 154 deletions

View File

@ -1,29 +1,21 @@
#include "Subsystem.h"
#include "../health/HealthMessage.h" #include "../health/HealthMessage.h"
#include "../objectmanager/ObjectManagerIF.h" #include "../objectmanager/ObjectManagerIF.h"
#include "../serialize/SerialArrayListAdapter.h" #include "../serialize/SerialArrayListAdapter.h"
#include "../serialize/SerialFixedArrayListAdapter.h" #include "../serialize/SerialFixedArrayListAdapter.h"
#include "../serialize/SerializeElement.h" #include "../serialize/SerializeElement.h"
#include "../serialize/SerialLinkedListAdapter.h" #include "../serialize/SerialLinkedListAdapter.h"
#include "Subsystem.h"
#include <string> #include <string>
Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent, Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) : uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
SubsystemBase(setObjectId, parent, 0), isInTransition(false), childrenChangedHealth( SubsystemBase(setObjectId, parent, 0), isInTransition(false),
false), uptimeStartTable(0), currentTargetTable(), targetMode( childrenChangedHealth(false), currentTargetTable(),
0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables( targetSubmode(SUBMODE_NONE), currentSequenceIterator(),
maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore( modeTables(maxNumberOfTables), modeSequences(maxNumberOfSequences) {}
NULL)
#ifdef USE_MODESTORE
,modeStore(NULL)
#endif
{
} Subsystem::~Subsystem() {}
Subsystem::~Subsystem() {
//Auto-generated destructor stub
}
ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter, ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
Mode_t fallbackSequence) { Mode_t fallbackSequence) {
@ -349,7 +341,8 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
ReturnValue_t result; ReturnValue_t result;
//Before initialize() is called, tables must not be checked as the children are not added yet. //Before initialize() is called, tables must not be checked as the
//children are not added yet.
//Sequences added before are checked by initialize() //Sequences added before are checked by initialize()
if (!preInit) { if (!preInit) {
result = checkSequence( result = checkSequence(
@ -374,7 +367,7 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
} }
if (inStore) { if (inStore) {
#ifdef USE_MODESTORE #if FSFW_USE_MODESTORE == 1
result = modeStore->storeArray(sequence, result = modeStore->storeArray(sequence,
&(modeSequences.find(id)->entries.firstLinkedElement)); &(modeSequences.find(id)->entries.firstLinkedElement));
if (result != RETURN_OK) { if (result != RETURN_OK) {
@ -395,8 +388,8 @@ ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
ReturnValue_t result; ReturnValue_t result;
//Before initialize() is called, tables must not be checked as the children are not added yet. //Before initialize() is called, tables must not be checked as the children
//Tables added before are checked by initialize() //are not added yet. Tables added before are checked by initialize()
if (!preInit) { if (!preInit) {
result = checkTable( result = checkTable(
HybridIterator<ModeListEntry>(table->front(), table->back())); HybridIterator<ModeListEntry>(table->front(), table->back()));
@ -417,7 +410,7 @@ ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
} }
if (inStore) { if (inStore) {
#ifdef USE_MODESTORE #if FSFW_USE_MODESTORE == 1
result = modeStore->storeArray(table, result = modeStore->storeArray(table,
&(modeTables.find(id)->firstLinkedElement)); &(modeTables.find(id)->firstLinkedElement));
if (result != RETURN_OK) { if (result != RETURN_OK) {
@ -447,7 +440,7 @@ ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
return ACCESS_DENIED; return ACCESS_DENIED;
} }
#ifdef USE_MODESTORE #if FSFW_USE_MODESTORE == 1
modeStore->deleteList(sequenceInfo->entries.firstLinkedElement); modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
#endif #endif
modeSequences.erase(id); modeSequences.erase(id);
@ -470,7 +463,7 @@ ReturnValue_t Subsystem::deleteTable(Mode_t id) {
return ACCESS_DENIED; return ACCESS_DENIED;
} }
#ifdef USE_MODESTORE #if FSFW_USE_MODESTORE == 1
modeStore->deleteList(pointer->firstLinkedElement); modeStore->deleteList(pointer->firstLinkedElement);
#endif #endif
modeSequences.erase(id); modeSequences.erase(id);
@ -489,10 +482,10 @@ ReturnValue_t Subsystem::initialize() {
return RETURN_FAILED; return RETURN_FAILED;
} }
#ifdef USE_MODESTORE #if FSFW_USE_MODESTORE == 1
modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE); modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
if (modeStore == NULL) { if (modeStore == nullptr) {
return RETURN_FAILED; return RETURN_FAILED;
} }
#endif #endif
@ -587,12 +580,14 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter); triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
if (mode == targetMode) { if (mode == targetMode) {
//already tried going back to the current mode //already tried going back to the current mode
//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail //go into fallback mode, also set current mode to fallback mode,
//so we come here at the next fail
modeHelper.setForced(true); modeHelper.setForced(true);
ReturnValue_t result; ReturnValue_t result;
if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) { if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode)); triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
isInTransition = false; //keep still and allow arbitrary mode commands to recover //keep still and allow arbitrary mode commands to recover
isInTransition = false;
return; return;
} }
mode = getFallbackSequence(mode); mode = getFallbackSequence(mode);
@ -656,8 +651,10 @@ void Subsystem::cantKeepMode() {
modeHelper.setForced(true); modeHelper.setForced(true);
//already set the mode, so that we do not try to go back in our old mode when the transition fails //already set the mode, so that we do not try to go back in our old mode
//when the transition fails
mode = getFallbackSequence(mode); mode = getFallbackSequence(mode);
//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely. //SHOULDDO: We should store submodes for fallback sequence as well,
//otherwise we should get rid of submodes completely.
startTransition(mode, SUBMODE_NONE); startTransition(mode, SUBMODE_NONE);
} }

View File

@ -1,14 +1,21 @@
#ifndef SUBSYSTEM_H_ #ifndef FSFW_SUBSYSTEM_SUBSYSTEM_H_
#define SUBSYSTEM_H_ #define FSFW_SUBSYSTEM_SUBSYSTEM_H_
#include "SubsystemBase.h"
#include "modes/ModeDefinitions.h"
#include "../container/FixedArrayList.h" #include "../container/FixedArrayList.h"
#include "../container/FixedMap.h" #include "../container/FixedMap.h"
#include "../container/HybridIterator.h" #include "../container/HybridIterator.h"
#include "../container/SinglyLinkedList.h" #include "../container/SinglyLinkedList.h"
#include "../serialize/SerialArrayListAdapter.h" #include "../serialize/SerialArrayListAdapter.h"
#include "modes/ModeDefinitions.h"
#include "SubsystemBase.h"
#include <FSFWConfig.h>
/**
* @brief TODO: documentation missing
* @details
*/
class Subsystem: public SubsystemBase, public HasModeSequenceIF { class Subsystem: public SubsystemBase, public HasModeSequenceIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM; static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
@ -30,8 +37,13 @@ public:
static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1); static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2); static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
/**
* TODO: Doc for constructor
* @param setObjectId
* @param parent
* @param maxNumberOfSequences
* @param maxNumberOfTables
*/
Subsystem(object_id_t setObjectId, object_id_t parent, Subsystem(object_id_t setObjectId, object_id_t parent,
uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables); uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
virtual ~Subsystem(); virtual ~Subsystem();
@ -44,31 +56,12 @@ public:
void setInitialMode(Mode_t mode); void setInitialMode(Mode_t mode);
virtual ReturnValue_t initialize(); virtual ReturnValue_t initialize() override;
virtual ReturnValue_t checkObjectConnections(); virtual ReturnValue_t checkObjectConnections() override;
virtual MessageQueueId_t getSequenceCommandQueue() const; virtual MessageQueueId_t getSequenceCommandQueue() const override;
/**
*
*
* IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
*
* @param sequence
* @return
*/
ReturnValue_t checkSequence(Mode_t sequence);
/**
*
*
* IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
*
* @param iter
* @return
*/
ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
protected: protected:
struct EntryPointer { struct EntryPointer {
@ -92,15 +85,15 @@ protected:
bool childrenChangedHealth; bool childrenChangedHealth;
uint32_t uptimeStartTable; uint32_t uptimeStartTable = 0;
HybridIterator<ModeListEntry> currentTargetTable; HybridIterator<ModeListEntry> currentTargetTable;
Mode_t targetMode; Mode_t targetMode = 0;
Submode_t targetSubmode; Submode_t targetSubmode;
Mode_t initialMode; Mode_t initialMode = 0;
HybridIterator<ModeListEntry> currentSequenceIterator; HybridIterator<ModeListEntry> currentSequenceIterator;
@ -108,10 +101,10 @@ protected:
FixedMap<Mode_t, SequenceInfo> modeSequences; FixedMap<Mode_t, SequenceInfo> modeSequences;
StorageManagerIF *IPCStore; StorageManagerIF *IPCStore = nullptr;
#ifdef USE_MODESTORE #if FSFW_USE_MODESTORE == 1
ModeStoreIF *modeStore; ModeStoreIF *modeStore = nullptr;
#endif #endif
bool existsModeSequence(Mode_t id); bool existsModeSequence(Mode_t id);
@ -124,8 +117,6 @@ protected:
HybridIterator<ModeListEntry> getCurrentTable(); HybridIterator<ModeListEntry> getCurrentTable();
// void startSequence(Mode_t sequence);
/** /**
* DO NOT USE ON NON EXISTING SEQUENCE * DO NOT USE ON NON EXISTING SEQUENCE
* *
@ -153,12 +144,29 @@ protected:
virtual void startTransition(Mode_t mode, Submode_t submode); virtual void startTransition(Mode_t mode, Submode_t submode);
void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count); void sendSerializablesAsCommandMessage(Command_t command,
SerializeIF **elements, uint8_t count);
void transitionFailed(ReturnValue_t failureCode, uint32_t parameter); void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
void cantKeepMode(); void cantKeepMode();
/**
* @brief Checks whether a sequence, identified by a mode.
* @param sequence
* @return
*/
ReturnValue_t checkSequence(Mode_t sequence);
/**
* @brief Checks whether a sequence, identified by a mode list iterator
* and a fallback sequence. Iterator needs to point to a valid
* sequence.
* @param iter
* @return
*/
ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
Mode_t fallbackSequence);
}; };
#endif /* SUBSYSTEM_H_ */ #endif /* FSFW_SUBSYSTEM_SUBSYSTEM_H_ */

View File

@ -1,15 +1,15 @@
#include "../serviceinterface/ServiceInterfaceStream.h" #include "../serviceinterface/ServiceInterfaceStream.h"
#include "../serviceinterface/ServiceInterfaceStream.h" #include "../serviceinterface/ServiceInterfaceStream.h"
#include "SubsystemBase.h" #include "../subsystem/SubsystemBase.h"
#include "../ipc/QueueFactory.h" #include "../ipc/QueueFactory.h"
SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent, SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
Mode_t initialMode, uint16_t commandQueueDepth) : Mode_t initialMode, uint16_t commandQueueDepth) :
SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE), childrenChangedMode( SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
false), commandsOutstanding(0), commandQueue(NULL), healthHelper(this, childrenChangedMode(false),
setObjectId), modeHelper(this), parentId(parent) { commandQueue(QueueFactory::instance()->createMessageQueue(
commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth, commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE)),
CommandMessage::MAX_MESSAGE_SIZE); healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
} }
SubsystemBase::~SubsystemBase() { SubsystemBase::~SubsystemBase() {
@ -21,10 +21,11 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
ChildInfo info; ChildInfo info;
HasModesIF *child = objectManager->get<HasModesIF>(objectId); HasModesIF *child = objectManager->get<HasModesIF>(objectId);
//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs). // This is a rather ugly hack to have the changedHealth info for all
// children available.
HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId); HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
if (child == NULL) { if (child == nullptr) {
if (healthChild == NULL) { if (healthChild == nullptr) {
return CHILD_DOESNT_HAVE_MODES; return CHILD_DOESNT_HAVE_MODES;
} else { } else {
info.commandQueue = healthChild->getCommandQueue(); info.commandQueue = healthChild->getCommandQueue();
@ -38,14 +39,11 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
info.submode = SUBMODE_NONE; info.submode = SUBMODE_NONE;
info.healthChanged = false; info.healthChanged = false;
std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue = auto resultPair = childrenMap.emplace(objectId, info);
childrenMap.insert( if (not resultPair.second) {
std::pair<object_id_t, ChildInfo>(objectId, info));
if (!(returnValue.second)) {
return COULD_NOT_INSERT_CHILD; return COULD_NOT_INSERT_CHILD;
} else {
return RETURN_OK;
} }
return RETURN_OK;
} }
ReturnValue_t SubsystemBase::checkStateAgainstTable( ReturnValue_t SubsystemBase::checkStateAgainstTable(
@ -76,15 +74,15 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
return RETURN_OK; return RETURN_OK;
} }
void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) { void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
Submode_t targetSubmode) {
CommandMessage message; CommandMessage command;
std::map<object_id_t, ChildInfo>::iterator iter; std::map<object_id_t, ChildInfo>::iterator iter;
commandsOutstanding = 0; commandsOutstanding = 0;
for (; tableIter.value != NULL; ++tableIter) { for (; tableIter.value != nullptr; ++tableIter) {
object_id_t object = tableIter.value->getObject(); object_id_t object = tableIter.value->getObject();
if ((iter = childrenMap.find(object)) == childrenMap.end()) { if ((iter = childrenMap.find(object)) == childrenMap.end()) {
//illegal table entry, should only happen due to misconfigured mode table //illegal table entry, should only happen due to misconfigured mode table
@ -100,17 +98,17 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
if (healthHelper.healthTable->hasHealth(object)) { if (healthHelper.healthTable->hasHealth(object)) {
if (healthHelper.healthTable->isFaulty(object)) { if (healthHelper.healthTable->isFaulty(object)) {
ModeMessage::setModeMessage(&message, ModeMessage::setModeMessage(&command,
ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF, ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
SUBMODE_NONE); SUBMODE_NONE);
} else { } else {
if (modeHelper.isForced()) { if (modeHelper.isForced()) {
ModeMessage::setModeMessage(&message, ModeMessage::setModeMessage(&command,
ModeMessage::CMD_MODE_COMMAND_FORCED, ModeMessage::CMD_MODE_COMMAND_FORCED,
tableIter.value->getMode(), submodeToCommand); tableIter.value->getMode(), submodeToCommand);
} else { } else {
if (healthHelper.healthTable->isCommandable(object)) { if (healthHelper.healthTable->isCommandable(object)) {
ModeMessage::setModeMessage(&message, ModeMessage::setModeMessage(&command,
ModeMessage::CMD_MODE_COMMAND, ModeMessage::CMD_MODE_COMMAND,
tableIter.value->getMode(), submodeToCommand); tableIter.value->getMode(), submodeToCommand);
} else { } else {
@ -119,17 +117,17 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
} }
} }
} else { } else {
ModeMessage::setModeMessage(&message, ModeMessage::CMD_MODE_COMMAND, ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
tableIter.value->getMode(), submodeToCommand); tableIter.value->getMode(), submodeToCommand);
} }
if ((iter->second.mode == ModeMessage::getMode(&message)) if ((iter->second.mode == ModeMessage::getMode(&command))
&& (iter->second.submode == ModeMessage::getSubmode(&message)) && (iter->second.submode == ModeMessage::getSubmode(&command))
&& !modeHelper.isForced()) { && !modeHelper.isForced()) {
continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
} }
ReturnValue_t result = commandQueue->sendMessage( ReturnValue_t result = commandQueue->sendMessage(
iter->second.commandQueue, &message); iter->second.commandQueue, &command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
++commandsOutstanding; ++commandsOutstanding;
} }
@ -306,31 +304,31 @@ void SubsystemBase::announceMode(bool recursive) {
void SubsystemBase::checkCommandQueue() { void SubsystemBase::checkCommandQueue() {
ReturnValue_t result; ReturnValue_t result;
CommandMessage message; CommandMessage command;
for (result = commandQueue->receiveMessage(&message); result == RETURN_OK; for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
result = commandQueue->receiveMessage(&message)) { result = commandQueue->receiveMessage(&command)) {
result = healthHelper.handleHealthCommand(&message); result = healthHelper.handleHealthCommand(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
result = modeHelper.handleModeCommand(&message); result = modeHelper.handleModeCommand(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
result = handleModeReply(&message); result = handleModeReply(&command);
if (result == RETURN_OK) { if (result == RETURN_OK) {
continue; continue;
} }
result = handleCommandMessage(&message); result = handleCommandMessage(&command);
if (result != RETURN_OK) { if (result != RETURN_OK) {
CommandMessage reply; CommandMessage reply;
reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND, reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
message.getCommand()); command.getCommand());
replyToCommand(&reply); replyToCommand(&reply);
} }
} }

View File

@ -1,5 +1,7 @@
#ifndef SUBSYSTEMBASE_H_ #ifndef FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_
#define SUBSYSTEMBASE_H_ #define FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_
#include "modes/HasModeSequenceIF.h"
#include "../container/HybridIterator.h" #include "../container/HybridIterator.h"
#include "../health/HasHealthIF.h" #include "../health/HasHealthIF.h"
@ -7,11 +9,14 @@
#include "../modes/HasModesIF.h" #include "../modes/HasModesIF.h"
#include "../objectmanager/SystemObject.h" #include "../objectmanager/SystemObject.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#include "modes/HasModeSequenceIF.h"
#include "../tasks/ExecutableObjectIF.h" #include "../tasks/ExecutableObjectIF.h"
#include "../ipc/MessageQueueIF.h" #include "../ipc/MessageQueueIF.h"
#include <map> #include <map>
/**
* @defgroup subsystems Subsystem Objects
* Contains all Subsystem and Assemblies
*/
class SubsystemBase: public SystemObject, class SubsystemBase: public SystemObject,
public HasModesIF, public HasModesIF,
public HasHealthIF, public HasHealthIF,
@ -30,17 +35,17 @@ public:
Mode_t initialMode = 0, uint16_t commandQueueDepth = 8); Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
virtual ~SubsystemBase(); virtual ~SubsystemBase();
virtual MessageQueueId_t getCommandQueue() const; virtual MessageQueueId_t getCommandQueue() const override;
ReturnValue_t registerChild(object_id_t objectId); ReturnValue_t registerChild(object_id_t objectId);
virtual ReturnValue_t initialize(); virtual ReturnValue_t initialize() override;
virtual ReturnValue_t performOperation(uint8_t opCode); virtual ReturnValue_t performOperation(uint8_t opCode) override;
virtual ReturnValue_t setHealth(HealthState health); virtual ReturnValue_t setHealth(HealthState health) override;
virtual HasHealthIF::HealthState getHealth(); virtual HasHealthIF::HealthState getHealth() override;
protected: protected:
struct ChildInfo { struct ChildInfo {
@ -58,9 +63,9 @@ protected:
/** /**
* Always check this against <=0, so you are robust against too many replies * Always check this against <=0, so you are robust against too many replies
*/ */
int32_t commandsOutstanding; int32_t commandsOutstanding = 0;
MessageQueueIF* commandQueue; MessageQueueIF* commandQueue = nullptr;
HealthHelper healthHelper; HealthHelper healthHelper;
@ -122,4 +127,4 @@ protected:
virtual void modeChanged(); virtual void modeChanged();
}; };
#endif /* SUBSYSTEMBASE_H_ */ #endif /* FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_ */

View File

@ -1,22 +1,19 @@
#ifndef MODEDEFINITIONS_H_ #ifndef FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
#define MODEDEFINITIONS_H_ #define FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
#include "../../modes/HasModesIF.h" #include "../../modes/HasModesIF.h"
#include "../../objectmanager/SystemObjectIF.h" #include "../../objectmanager/SystemObjectIF.h"
#include "../../serialize/SerializeIF.h" #include "../../serialize/SerializeIF.h"
#include "../../serialize/SerialLinkedListAdapter.h" #include "../../serialize/SerialLinkedListAdapter.h"
class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> { class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
public: public:
ModeListEntry() : ModeListEntry(): LinkedElement<ModeListEntry>(this) {}
LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
0) {
} uint32_t value1 = 0;
uint32_t value2 = 0;
uint32_t value1; uint8_t value3 = 0;
uint32_t value2; uint8_t value4 = 0;
uint8_t value3;
uint8_t value4;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const { size_t maxSize, Endianness streamEndianness) const {
@ -149,4 +146,4 @@ public:
} }
}; };
#endif //MODEDEFINITIONS_H_ #endif /* FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_ */

View File

@ -1,8 +1,7 @@
#include "../../objectmanager/ObjectManagerIF.h" #include "ModeSequenceMessage.h"
#include "../../objectmanager/ObjectManagerIF.h"
#include "../../objectmanager/ObjectManagerIF.h" #include "../../objectmanager/ObjectManagerIF.h"
#include "../../storagemanager/StorageManagerIF.h" #include "../../storagemanager/StorageManagerIF.h"
#include "ModeSequenceMessage.h"
void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message, void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
Command_t command, Mode_t sequence, store_address_t storeAddress) { Command_t command, Mode_t sequence, store_address_t storeAddress) {
@ -11,25 +10,12 @@ void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
message->setParameter2(sequence); message->setParameter2(sequence);
} }
//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
// Command_t command, ModeTableId_t table, store_address_t storeAddress) {
// message->setCommand(command);
// message->setParameter(storeAddress.raw);
// message->setParameter2(table);
//}
void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message, void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
Command_t command, Mode_t sequence) { Command_t command, Mode_t sequence) {
message->setCommand(command); message->setCommand(command);
message->setParameter2(sequence); message->setParameter2(sequence);
} }
//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
// Command_t command, ModeTableId_t table) {
// message->setCommand(command);
// message->setParameter2(table);
//}
void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message, void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
Command_t command, store_address_t storeAddress) { Command_t command, store_address_t storeAddress) {
message->setCommand(command); message->setCommand(command);
@ -63,9 +49,10 @@ void ModeSequenceMessage::clear(CommandMessage *message) {
case SEQUENCE_LIST: case SEQUENCE_LIST:
case TABLE_LIST: case TABLE_LIST:
case TABLE: case TABLE:
case SEQUENCE:{ case SEQUENCE: {
StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE); StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
if (ipcStore != NULL){ objects::IPC_STORE);
if (ipcStore != nullptr){
ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message)); ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
} }
} }

View File

@ -1,9 +1,11 @@
#ifndef MODESEQUENCEMESSAGE_H_ #ifndef FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
#define MODESEQUENCEMESSAGE_H_ #define FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
#include "ModeDefinitions.h"
#include "../../ipc/CommandMessage.h" #include "../../ipc/CommandMessage.h"
#include "../../storagemanager/StorageManagerIF.h" #include "../../storagemanager/StorageManagerIF.h"
#include "ModeDefinitions.h"
class ModeSequenceMessage { class ModeSequenceMessage {
public: public:
@ -45,4 +47,4 @@ private:
ModeSequenceMessage(); ModeSequenceMessage();
}; };
#endif /* MODESEQUENCEMESSAGE_H_ */ #endif /* FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_ */

View File

@ -1,6 +1,8 @@
#include "ModeStore.h" #include "ModeStore.h"
#ifdef USE_MODESTORE // todo: I think some parts are deprecated. If this is used, the define
// USE_MODESTORE could be part of the new FSFWConfig.h file.
#if FSFW_USE_MODESTORE == 1
ModeStore::ModeStore(object_id_t objectId, uint32_t slots) : ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
SystemObject(objectId), store(slots), emptySlot(store.front()) { SystemObject(objectId), store(slots), emptySlot(store.front()) {

View File

@ -1,12 +1,15 @@
#ifndef MODESTORE_H_ #ifndef FSFW_SUBSYSTEM_MODES_MODESTORE_H_
#define MODESTORE_H_ #define FSFW_SUBSYSTEM_MODES_MODESTORE_H_
#ifdef USE_MODESTORE #include <FSFWConfig.h>
#if FSFW_USE_MODESTORE == 1
#include "ModeStoreIF.h"
#include "../../container/ArrayList.h" #include "../../container/ArrayList.h"
#include "../../container/SinglyLinkedList.h" #include "../../container/SinglyLinkedList.h"
#include "../../objectmanager/SystemObject.h" #include "../../objectmanager/SystemObject.h"
#include "ModeStoreIF.h"
class ModeStore: public ModeStoreIF, public SystemObject { class ModeStore: public ModeStoreIF, public SystemObject {
public: public:
@ -41,5 +44,5 @@ private:
#endif #endif
#endif /* MODESTORE_H_ */ #endif /* FSFW_SUBSYSTEM_MODES_MODESTORE_H_ */

View File

@ -1,12 +1,15 @@
#ifndef MODESTOREIF_H_ #ifndef MODESTOREIF_H_
#define MODESTOREIF_H_ #define MODESTOREIF_H_
#ifdef USE_MODESTORE #include <FSFWConfig.h>
#if FSFW_USE_MODESTORE == 1
#include "ModeDefinitions.h"
#include "../../container/ArrayList.h" #include "../../container/ArrayList.h"
#include "../../container/SinglyLinkedList.h" #include "../../container/SinglyLinkedList.h"
#include "../../returnvalues/HasReturnvaluesIF.h" #include "../../returnvalues/HasReturnvaluesIF.h"
#include "ModeDefinitions.h"
class ModeStoreIF { class ModeStoreIF {
public: public: