From 0a40391a7504db3a50f24d8081ccb3cec6405c27 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 9 Nov 2023 10:36:45 +0100 Subject: [PATCH 1/9] thats the baseline --- src/fsfw/controller/ControllerBase.cpp | 9 +- src/fsfw/devicehandlers/CMakeLists.txt | 1 + .../devicehandlers/FreshDeviceHandlerBase.cpp | 142 ++++++++++++++++++ .../devicehandlers/FreshDeviceHandlerBase.h | 116 ++++++++++++++ 4 files changed, 263 insertions(+), 5 deletions(-) create mode 100644 src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp create mode 100644 src/fsfw/devicehandlers/FreshDeviceHandlerBase.h diff --git a/src/fsfw/controller/ControllerBase.cpp b/src/fsfw/controller/ControllerBase.cpp index 2c151f5a..a4f51217 100644 --- a/src/fsfw/controller/ControllerBase.cpp +++ b/src/fsfw/controller/ControllerBase.cpp @@ -72,18 +72,17 @@ void ControllerBase::getMode(Mode_t* mode_, Submode_t* submode_) { *submode_ = this->submode; } -void ControllerBase::setToExternalControl() { healthHelper.setHealth(EXTERNAL_CONTROL); } - void ControllerBase::announceMode(bool recursive) { triggerEvent(MODE_INFO, mode, submode); } +void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {} + +void ControllerBase::setToExternalControl() { healthHelper.setHealth(EXTERNAL_CONTROL); } + ReturnValue_t ControllerBase::performOperation(uint8_t opCode) { handleQueue(); performControlOperation(); return returnvalue::OK; } - -void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {} - ReturnValue_t ControllerBase::setHealth(HealthState health) { switch (health) { case HEALTHY: diff --git a/src/fsfw/devicehandlers/CMakeLists.txt b/src/fsfw/devicehandlers/CMakeLists.txt index 180a89da..77254bdd 100644 --- a/src/fsfw/devicehandlers/CMakeLists.txt +++ b/src/fsfw/devicehandlers/CMakeLists.txt @@ -7,4 +7,5 @@ target_sources( DeviceHandlerFailureIsolation.cpp DeviceHandlerMessage.cpp DeviceTmReportingWrapper.cpp + FreshDeviceHandlerBase.cpp HealthDevice.cpp) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp new file mode 100644 index 00000000..106f8dc4 --- /dev/null +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp @@ -0,0 +1,142 @@ +#include "FreshDeviceHandlerBase.h" + +#include "fsfw/ipc/QueueFactory.h" +#include "fsfw/subsystem/helper.h" + +FreshDeviceHandlerBase::FreshDeviceHandlerBase(DhbConfig config) + : SystemObject(config.objectId), + actionHelper(this, nullptr), + modeHelper(this), + healthHelper(this, getObjectId()), + poolManager(this, nullptr) { + auto mqArgs = MqArgs(config.objectId, static_cast(this)); + messageQueue = QueueFactory::instance()->createMessageQueue( + config.msgQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs); +} +FreshDeviceHandlerBase::~FreshDeviceHandlerBase() { + QueueFactory::instance()->deleteMessageQueue(messageQueue); +} + +[[nodiscard]] object_id_t FreshDeviceHandlerBase::getObjectId() const { + return SystemObject::getObjectId(); +} + +ReturnValue_t FreshDeviceHandlerBase::performOperation(uint8_t opCode) { + handleQueue(); + performDeviceOperation(opCode); + return returnvalue::OK; +} + +void FreshDeviceHandlerBase::startTransition(Mode_t mode_, Submode_t submode_) { + triggerEvent(CHANGING_MODE, mode_, submode_); + mode = mode_; + submode = submode_; + modeHelper.modeChanged(mode, submode); + modeChanged(mode, submode); + announceMode(false); +} + +void FreshDeviceHandlerBase::getMode(Mode_t* mode_, Submode_t* submode_) { + *mode_ = this->mode; + *submode_ = this->submode; +} + +void FreshDeviceHandlerBase::announceMode(bool recursive) { + triggerEvent(MODE_INFO, mode, submode); +} + +void FreshDeviceHandlerBase::modeChanged(Mode_t mode_, Submode_t submode_) {} + +[[nodiscard]] MessageQueueId_t FreshDeviceHandlerBase::getCommandQueue() const { + return messageQueue->getId(); +} + +ReturnValue_t FreshDeviceHandlerBase::handleQueue() { + CommandMessage command; + ReturnValue_t result; + for (result = messageQueue->receiveMessage(&command); result == returnvalue::OK; + result = messageQueue->receiveMessage(&command)) { + result = actionHelper.handleActionMessage(&command); + if (result == returnvalue::OK) { + continue; + } + + result = modeHelper.handleModeCommand(&command); + if (result == returnvalue::OK) { + continue; + } + + result = healthHelper.handleHealthCommand(&command); + if (result == returnvalue::OK) { + continue; + } + + result = poolManager.handleHousekeepingMessage(&command); + if (result == returnvalue::OK) { + continue; + } + + result = handleCommandMessage(&command); + if (result == returnvalue::OK) { + continue; + } + command.setToUnknownCommand(); + messageQueue->reply(&command); + } +} + +HasHealthIF::HealthState FreshDeviceHandlerBase::getHealth() { return healthHelper.getHealth(); } + +const HasHealthIF* FreshDeviceHandlerBase::getOptHealthIF() const { return this; } + +const HasModesIF& FreshDeviceHandlerBase::getModeIF() const { return *this; } + +ModeTreeChildIF& FreshDeviceHandlerBase::getModeTreeChildIF() { return *this; } + +ReturnValue_t FreshDeviceHandlerBase::connectModeTreeParent(HasModeTreeChildrenIF& parent) { + return modetree::connectModeTreeParent(parent, *this, &healthHelper, modeHelper); +} + +// Executable Overrides. +void FreshDeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_) { executingTask = task_; } + +// Pool Manager overrides. +LocalDataPoolManager* FreshDeviceHandlerBase::getHkManagerHandle() { return &poolManager; } + +[[nodiscard]] uint32_t FreshDeviceHandlerBase::getPeriodicOperationFrequency() const { + return this->executingTask->getPeriodMs(); +} + +ReturnValue_t FreshDeviceHandlerBase::initializeAfterTaskCreation() { + return poolManager.initializeAfterTaskCreation(); +} + +ReturnValue_t FreshDeviceHandlerBase::setHealth(HasHealthIF::HealthState health) { + if (health == HasHealthIF::FAULTY or health == HasHealthIF::PERMANENT_FAULTY) { + // TODO: Go to off where applicable. Health state machine? How does DHB do it? + } + healthHelper.setHealth(health); + return returnvalue::OK; +} + +// System Object overrides. +ReturnValue_t FreshDeviceHandlerBase::initialize() { + ReturnValue_t result = modeHelper.initialize(); + if (result != returnvalue::OK) { + return result; + } + result = healthHelper.initialize(); + if (result != returnvalue::OK) { + return result; + } + result = actionHelper.initialize(messageQueue); + if (result != returnvalue::OK) { + return result; + } + + result = poolManager.initialize(messageQueue); + if (result != returnvalue::OK) { + return result; + } + return SystemObject::initialize(); +} diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h new file mode 100644 index 00000000..ed5dd15a --- /dev/null +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h @@ -0,0 +1,116 @@ +#pragma once + +#include "fsfw/action.h" +#include "fsfw/datapoollocal/HasLocalDataPoolIF.h" +#include "fsfw/datapoollocal/LocalDataPoolManager.h" +#include "fsfw/devicehandlers/DeviceHandlerIF.h" +#include "fsfw/health/HasHealthIF.h" +#include "fsfw/health/HealthHelper.h" +#include "fsfw/modes/HasModesIF.h" +#include "fsfw/objectmanager.h" +#include "fsfw/retval.h" +#include "fsfw/subsystem/ModeTreeChildIF.h" +#include "fsfw/subsystem/ModeTreeConnectionIF.h" +#include "fsfw/tasks/ExecutableObjectIF.h" +#include "fsfw/tasks/PeriodicTaskIF.h" + +struct DhbConfig { + explicit DhbConfig(object_id_t objectId) : objectId(objectId) {} + + object_id_t objectId; + uint32_t msgQueueDepth = 10; +}; +class FreshDeviceHandlerBase : public SystemObject, + public DeviceHandlerIF, + public HasModesIF, + public HasHealthIF, + public ExecutableObjectIF, + public ModeTreeChildIF, + public ModeTreeConnectionIF, + public HasActionsIF, + public HasLocalDataPoolIF { + public: + explicit FreshDeviceHandlerBase(DhbConfig config); + virtual ~FreshDeviceHandlerBase() override; + + /** + * Implemented by child class. Handle all command messages which are + * not health, mode, action or housekeeping messages. + * @param message + * @return + */ + virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0; + + // HK manager abstract functions. + LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0; + ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, + LocalDataPoolManager& poolManager) override = 0; + + // Mode abstract functions + ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, + uint32_t* msToReachTheMode) override = 0; + + /** + * Periodic helper executed function, implemented by child class. + */ + virtual void performDeviceOperation(uint8_t opCode) = 0; + + [[nodiscard]] object_id_t getObjectId() const override; + + // Executable overrides. + ReturnValue_t performOperation(uint8_t opCode) override; + ReturnValue_t initializeAfterTaskCreation() override; + + // System Object overrides. + ReturnValue_t initialize() override; + [[nodiscard]] MessageQueueId_t getCommandQueue() const override; + + // Health Overrides. + ReturnValue_t setHealth(HealthState health) override; + HasHealthIF::HealthState getHealth() override; + + // Executable Overrides. + void setTaskIF(PeriodicTaskIF* task) override; + + // Mode Tree Overrides. + [[nodiscard]] const HasHealthIF* getOptHealthIF() const override; + [[nodiscard]] const HasModesIF& getModeIF() const override; + ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override; + ModeTreeChildIF& getModeTreeChildIF() override; + + // Action overrides. + virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, + const uint8_t* data, size_t size) = 0; + + [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override; + + protected: + virtual ReturnValue_t handleQueue(); + + // Mode Helpers. + virtual void modeChanged(Mode_t mode, Submode_t submode); + void startTransition(Mode_t mode, Submode_t submode) override; + void getMode(Mode_t* mode, Submode_t* submode) override; + void setToExternalControl() override; + void announceMode(bool recursive) override; + + private: + ActionHelper actionHelper; + ModeHelper modeHelper; + HealthHelper healthHelper; + LocalDataPoolManager poolManager; + + /** + * Pointer to the task which executes this component, + * is invalid before setTaskIF was called. + */ + PeriodicTaskIF* executingTask = nullptr; + + Mode_t mode = HasModesIF::MODE_UNDEFINED; + Submode_t submode = 0; + + MessageQueueIF* messageQueue; + + // Pool Manager overrides. + LocalDataPoolManager* getHkManagerHandle() override; +}; From 133ca51d183470f659086d8be64bb3a2c169b9b8 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 9 Nov 2023 10:45:21 +0100 Subject: [PATCH 2/9] visibility changes --- .../devicehandlers/FreshDeviceHandlerBase.cpp | 6 +- .../devicehandlers/FreshDeviceHandlerBase.h | 81 +++++++++---------- 2 files changed, 42 insertions(+), 45 deletions(-) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp index 106f8dc4..bc3cf1a6 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp @@ -83,6 +83,7 @@ ReturnValue_t FreshDeviceHandlerBase::handleQueue() { command.setToUnknownCommand(); messageQueue->reply(&command); } + return result; } HasHealthIF::HealthState FreshDeviceHandlerBase::getHealth() { return healthHelper.getHealth(); } @@ -112,9 +113,7 @@ ReturnValue_t FreshDeviceHandlerBase::initializeAfterTaskCreation() { } ReturnValue_t FreshDeviceHandlerBase::setHealth(HasHealthIF::HealthState health) { - if (health == HasHealthIF::FAULTY or health == HasHealthIF::PERMANENT_FAULTY) { - // TODO: Go to off where applicable. Health state machine? How does DHB do it? - } + // Assembly should handle commanding to OFF. healthHelper.setHealth(health); return returnvalue::OK; } @@ -140,3 +139,4 @@ ReturnValue_t FreshDeviceHandlerBase::initialize() { } return SystemObject::initialize(); } +void FreshDeviceHandlerBase::setToExternalControl() { setHealth(HealthState::EXTERNAL_CONTROL); } diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h index ed5dd15a..24b23a79 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h @@ -31,7 +31,12 @@ class FreshDeviceHandlerBase : public SystemObject, public HasLocalDataPoolIF { public: explicit FreshDeviceHandlerBase(DhbConfig config); - virtual ~FreshDeviceHandlerBase() override; + ~FreshDeviceHandlerBase() override; + + /** + * Periodic helper executed function, implemented by child class. + */ + virtual void performDeviceOperation(uint8_t opCode) = 0; /** * Implemented by child class. Handle all command messages which are @@ -41,60 +46,23 @@ class FreshDeviceHandlerBase : public SystemObject, */ virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0; - // HK manager abstract functions. - LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0; - ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, - LocalDataPoolManager& poolManager) override = 0; - - // Mode abstract functions - ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, - uint32_t* msToReachTheMode) override = 0; - - /** - * Periodic helper executed function, implemented by child class. - */ - virtual void performDeviceOperation(uint8_t opCode) = 0; - [[nodiscard]] object_id_t getObjectId() const override; - // Executable overrides. - ReturnValue_t performOperation(uint8_t opCode) override; - ReturnValue_t initializeAfterTaskCreation() override; - - // System Object overrides. - ReturnValue_t initialize() override; [[nodiscard]] MessageQueueId_t getCommandQueue() const override; - // Health Overrides. - ReturnValue_t setHealth(HealthState health) override; HasHealthIF::HealthState getHealth() override; - // Executable Overrides. - void setTaskIF(PeriodicTaskIF* task) override; - // Mode Tree Overrides. [[nodiscard]] const HasHealthIF* getOptHealthIF() const override; [[nodiscard]] const HasModesIF& getModeIF() const override; ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override; ModeTreeChildIF& getModeTreeChildIF() override; - // Action overrides. - virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, - const uint8_t* data, size_t size) = 0; - [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override; protected: - virtual ReturnValue_t handleQueue(); - - // Mode Helpers. - virtual void modeChanged(Mode_t mode, Submode_t submode); - void startTransition(Mode_t mode, Submode_t submode) override; - void getMode(Mode_t* mode, Submode_t* submode) override; - void setToExternalControl() override; - void announceMode(bool recursive) override; - - private: + // Pool Manager overrides. + LocalDataPoolManager* getHkManagerHandle() override; ActionHelper actionHelper; ModeHelper modeHelper; HealthHelper healthHelper; @@ -111,6 +79,35 @@ class FreshDeviceHandlerBase : public SystemObject, MessageQueueIF* messageQueue; - // Pool Manager overrides. - LocalDataPoolManager* getHkManagerHandle() override; + virtual ReturnValue_t handleQueue(); + + // Mode Helpers. + virtual void modeChanged(Mode_t mode, Submode_t submode); + void startTransition(Mode_t mode, Submode_t submode) override; + void getMode(Mode_t* mode, Submode_t* submode) override; + void setToExternalControl() override; + void announceMode(bool recursive) override; + // System Object overrides. + ReturnValue_t initialize() override; + + // HK manager abstract functions. + LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0; + ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, + LocalDataPoolManager& poolManager) override = 0; + + // Mode abstract functions + ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, + uint32_t* msToReachTheMode) override = 0; + // Health Overrides. + ReturnValue_t setHealth(HealthState health) override; + // Action override. Forward to user. + ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, + const uint8_t* data, size_t size) override = 0; + // Executable overrides. + ReturnValue_t performOperation(uint8_t opCode) override; + ReturnValue_t initializeAfterTaskCreation() override; + + private: + // Executable Overrides. + void setTaskIF(PeriodicTaskIF* task) override; }; From 18cc870c8ebc3ff0565b3b8f5ed85e9a54685358 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 9 Nov 2023 11:04:45 +0100 Subject: [PATCH 3/9] add FDIR handling --- .../devicehandlers/FreshDeviceHandlerBase.cpp | 39 ++++++++++++++++++- .../devicehandlers/FreshDeviceHandlerBase.h | 36 ++++++++++++++++- 2 files changed, 72 insertions(+), 3 deletions(-) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp index bc3cf1a6..8de20494 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp @@ -1,5 +1,6 @@ #include "FreshDeviceHandlerBase.h" +#include "fsfw/devicehandlers/DeviceHandlerFailureIsolation.h" #include "fsfw/ipc/QueueFactory.h" #include "fsfw/subsystem/helper.h" @@ -8,13 +9,17 @@ FreshDeviceHandlerBase::FreshDeviceHandlerBase(DhbConfig config) actionHelper(this, nullptr), modeHelper(this), healthHelper(this, getObjectId()), - poolManager(this, nullptr) { + poolManager(this, nullptr), + defaultFdirParent(config.defaultFdirParent) { auto mqArgs = MqArgs(config.objectId, static_cast(this)); messageQueue = QueueFactory::instance()->createMessageQueue( config.msgQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs); } FreshDeviceHandlerBase::~FreshDeviceHandlerBase() { QueueFactory::instance()->deleteMessageQueue(messageQueue); + if (not hasCustomFdir) { + delete fdirInstance; + } } [[nodiscard]] object_id_t FreshDeviceHandlerBase::getObjectId() const { @@ -118,6 +123,17 @@ ReturnValue_t FreshDeviceHandlerBase::setHealth(HasHealthIF::HealthState health) return returnvalue::OK; } +void FreshDeviceHandlerBase::triggerEvent(Event event, uint32_t parameter1, uint32_t parameter2) { + fdirInstance->triggerEvent(event, parameter1, parameter2); +} + +void FreshDeviceHandlerBase::forwardEvent(Event event, uint32_t parameter1, + uint32_t parameter2) const { + fdirInstance->triggerEvent(event, parameter1, parameter2); +} + +void FreshDeviceHandlerBase::setToExternalControl() { setHealth(HealthState::EXTERNAL_CONTROL); } + // System Object overrides. ReturnValue_t FreshDeviceHandlerBase::initialize() { ReturnValue_t result = modeHelper.initialize(); @@ -137,6 +153,25 @@ ReturnValue_t FreshDeviceHandlerBase::initialize() { if (result != returnvalue::OK) { return result; } + if (fdirInstance == nullptr) { + hasCustomFdir = false; + fdirInstance = new DeviceHandlerFailureIsolation(getObjectId(), defaultFdirParent); + } + + result = fdirInstance->initialize(); + if (result != returnvalue::OK) { + return result; + } return SystemObject::initialize(); } -void FreshDeviceHandlerBase::setToExternalControl() { setHealth(HealthState::EXTERNAL_CONTROL); } +ReturnValue_t FreshDeviceHandlerBase::getParameter(uint8_t domainId, uint8_t uniqueId, + ParameterWrapper* parameterWrapper, + const ParameterWrapper* newValues, + uint16_t startAtIndex) { + ReturnValue_t result = + fdirInstance->getParameter(domainId, uniqueId, parameterWrapper, newValues, startAtIndex); + if (result != INVALID_DOMAIN_ID) { + return result; + } + return INVALID_DOMAIN_ID; +} diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h index 24b23a79..c6002699 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h @@ -4,6 +4,7 @@ #include "fsfw/datapoollocal/HasLocalDataPoolIF.h" #include "fsfw/datapoollocal/LocalDataPoolManager.h" #include "fsfw/devicehandlers/DeviceHandlerIF.h" +#include "fsfw/fdir/FailureIsolationBase.h" #include "fsfw/health/HasHealthIF.h" #include "fsfw/health/HealthHelper.h" #include "fsfw/modes/HasModesIF.h" @@ -16,8 +17,9 @@ struct DhbConfig { explicit DhbConfig(object_id_t objectId) : objectId(objectId) {} - object_id_t objectId; + FailureIsolationBase* fdirInstance = nullptr; + object_id_t defaultFdirParent = objects::NO_OBJECT; uint32_t msgQueueDepth = 10; }; class FreshDeviceHandlerBase : public SystemObject, @@ -28,6 +30,7 @@ class FreshDeviceHandlerBase : public SystemObject, public ModeTreeChildIF, public ModeTreeConnectionIF, public HasActionsIF, + public HasParametersIF, public HasLocalDataPoolIF { public: explicit FreshDeviceHandlerBase(DhbConfig config); @@ -68,6 +71,10 @@ class FreshDeviceHandlerBase : public SystemObject, HealthHelper healthHelper; LocalDataPoolManager poolManager; + bool hasCustomFdir = false; + FailureIsolationBase* fdirInstance; + object_id_t defaultFdirParent; + /** * Pointer to the task which executes this component, * is invalid before setTaskIF was called. @@ -107,6 +114,33 @@ class FreshDeviceHandlerBase : public SystemObject, ReturnValue_t performOperation(uint8_t opCode) override; ReturnValue_t initializeAfterTaskCreation() override; + /** + * This calls the FDIR instance event trigger function. + * @param event + * @param parameter1 + * @param parameter2 + */ + void triggerEvent(Event event, uint32_t parameter1, uint32_t parameter2) override; + /** + * This calls the FDIR instance event forward function. + * @param event + * @param parameter1 + * @param parameter2 + */ + void forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const override; + /** + * This implementation handles the FDIR parameters. The user can override this to handle + * custom parameters. + * @param domainId + * @param uniqueId + * @param parameterWrapper + * @param newValues + * @param startAtIndex + * @return + */ + ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper, + const ParameterWrapper* newValues, uint16_t startAtIndex) override; + private: // Executable Overrides. void setTaskIF(PeriodicTaskIF* task) override; From 35be7da3534423af2b4db2b86e75371749181213 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 9 Nov 2023 11:28:59 +0100 Subject: [PATCH 4/9] some more docs --- .../devicehandlers/FreshDeviceHandlerBase.cpp | 2 +- .../devicehandlers/FreshDeviceHandlerBase.h | 22 ++++++++++++------- 2 files changed, 15 insertions(+), 9 deletions(-) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp index 8de20494..22bf6f77 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp @@ -174,4 +174,4 @@ ReturnValue_t FreshDeviceHandlerBase::getParameter(uint8_t domainId, uint8_t uni return result; } return INVALID_DOMAIN_ID; -} +} \ No newline at end of file diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h index c6002699..3646efd1 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h @@ -41,14 +41,6 @@ class FreshDeviceHandlerBase : public SystemObject, */ virtual void performDeviceOperation(uint8_t opCode) = 0; - /** - * Implemented by child class. Handle all command messages which are - * not health, mode, action or housekeeping messages. - * @param message - * @return - */ - virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0; - [[nodiscard]] object_id_t getObjectId() const override; [[nodiscard]] MessageQueueId_t getCommandQueue() const override; @@ -90,6 +82,12 @@ class FreshDeviceHandlerBase : public SystemObject, // Mode Helpers. virtual void modeChanged(Mode_t mode, Submode_t submode); + /** + * The default implementation sets the new mode immediately. If this is not applicable for + * certain modes, the user should provide a custom implementation, which performs rougly + * the same functionality of this function, when all the steps have been taken to reach the + * new mode. + */ void startTransition(Mode_t mode, Submode_t submode) override; void getMode(Mode_t* mode, Submode_t* submode) override; void setToExternalControl() override; @@ -97,6 +95,14 @@ class FreshDeviceHandlerBase : public SystemObject, // System Object overrides. ReturnValue_t initialize() override; + /** + * Implemented by child class. Handle all command messages which are + * not health, mode, action or housekeeping messages. + * @param message + * @return + */ + virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0; + // HK manager abstract functions. LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0; ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, From bf7fac071c6d181251dbf9dee908728455be0925 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 9 Nov 2023 17:18:33 +0100 Subject: [PATCH 5/9] add mode setters --- src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp | 13 ++++++++++--- src/fsfw/devicehandlers/FreshDeviceHandlerBase.h | 2 ++ 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp index 22bf6f77..542fdcc7 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp @@ -34,13 +34,20 @@ ReturnValue_t FreshDeviceHandlerBase::performOperation(uint8_t opCode) { void FreshDeviceHandlerBase::startTransition(Mode_t mode_, Submode_t submode_) { triggerEvent(CHANGING_MODE, mode_, submode_); - mode = mode_; - submode = submode_; + // Complete mode transition immediately by default. + setMode(mode_, submode_); +} + +void FreshDeviceHandlerBase::setMode(Mode_t newMode, Submode_t newSubmode) { + mode = newMode; + submode = newSubmode; modeHelper.modeChanged(mode, submode); modeChanged(mode, submode); announceMode(false); } +void FreshDeviceHandlerBase::setMode(Mode_t newMode) { setMode(newMode, submode); } + void FreshDeviceHandlerBase::getMode(Mode_t* mode_, Submode_t* submode_) { *mode_ = this->mode; *submode_ = this->submode; @@ -174,4 +181,4 @@ ReturnValue_t FreshDeviceHandlerBase::getParameter(uint8_t domainId, uint8_t uni return result; } return INVALID_DOMAIN_ID; -} \ No newline at end of file +} diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h index 3646efd1..bd963e26 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h @@ -89,6 +89,8 @@ class FreshDeviceHandlerBase : public SystemObject, * new mode. */ void startTransition(Mode_t mode, Submode_t submode) override; + virtual void setMode(Mode_t newMode, Submode_t newSubmode); + virtual void setMode(Mode_t newMode); void getMode(Mode_t* mode, Submode_t* submode) override; void setToExternalControl() override; void announceMode(bool recursive) override; From d554062b86999fd4d94ce9c3fe0341b73984d1ce Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Mon, 13 Nov 2023 15:32:42 +0100 Subject: [PATCH 6/9] trigger event default arguments --- src/fsfw/devicehandlers/FreshDeviceHandlerBase.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h index bd963e26..ba1b6b34 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h @@ -128,7 +128,7 @@ class FreshDeviceHandlerBase : public SystemObject, * @param parameter1 * @param parameter2 */ - void triggerEvent(Event event, uint32_t parameter1, uint32_t parameter2) override; + void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) override; /** * This calls the FDIR instance event forward function. * @param event From 698897bfc5203af54d104ea5ead3a433de824656 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 14 Nov 2023 11:48:17 +0100 Subject: [PATCH 7/9] default args --- src/fsfw/devicehandlers/FreshDeviceHandlerBase.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h index bd963e26..ba1b6b34 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h @@ -128,7 +128,7 @@ class FreshDeviceHandlerBase : public SystemObject, * @param parameter1 * @param parameter2 */ - void triggerEvent(Event event, uint32_t parameter1, uint32_t parameter2) override; + void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) override; /** * This calls the FDIR instance event forward function. * @param event From 7673d8b396764186d93c3378496ccfc3c1b2e2e8 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 15 Nov 2023 10:03:56 +0100 Subject: [PATCH 8/9] add paramHelper --- src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp | 11 +++++++++++ src/fsfw/devicehandlers/FreshDeviceHandlerBase.h | 6 +++++- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp index 542fdcc7..01359368 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp @@ -9,6 +9,7 @@ FreshDeviceHandlerBase::FreshDeviceHandlerBase(DhbConfig config) actionHelper(this, nullptr), modeHelper(this), healthHelper(this, getObjectId()), + paramHelper(this), poolManager(this, nullptr), defaultFdirParent(config.defaultFdirParent) { auto mqArgs = MqArgs(config.objectId, static_cast(this)); @@ -83,6 +84,11 @@ ReturnValue_t FreshDeviceHandlerBase::handleQueue() { continue; } + result = paramHelper.handleParameterMessage(&command); + if (result == returnvalue::OK) { + continue; + } + result = poolManager.handleHousekeepingMessage(&command); if (result == returnvalue::OK) { continue; @@ -155,6 +161,10 @@ ReturnValue_t FreshDeviceHandlerBase::initialize() { if (result != returnvalue::OK) { return result; } + result = paramHelper.initialize(); + if (result != returnvalue::OK) { + return result; + } result = poolManager.initialize(messageQueue); if (result != returnvalue::OK) { @@ -171,6 +181,7 @@ ReturnValue_t FreshDeviceHandlerBase::initialize() { } return SystemObject::initialize(); } + ReturnValue_t FreshDeviceHandlerBase::getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues, diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h index ba1b6b34..97f672b1 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h @@ -9,6 +9,8 @@ #include "fsfw/health/HealthHelper.h" #include "fsfw/modes/HasModesIF.h" #include "fsfw/objectmanager.h" +#include "fsfw/parameters/ParameterHelper.h" +#include "fsfw/parameters/ReceivesParameterMessagesIF.h" #include "fsfw/retval.h" #include "fsfw/subsystem/ModeTreeChildIF.h" #include "fsfw/subsystem/ModeTreeConnectionIF.h" @@ -22,6 +24,7 @@ struct DhbConfig { object_id_t defaultFdirParent = objects::NO_OBJECT; uint32_t msgQueueDepth = 10; }; + class FreshDeviceHandlerBase : public SystemObject, public DeviceHandlerIF, public HasModesIF, @@ -30,7 +33,7 @@ class FreshDeviceHandlerBase : public SystemObject, public ModeTreeChildIF, public ModeTreeConnectionIF, public HasActionsIF, - public HasParametersIF, + public ReceivesParameterMessagesIF, public HasLocalDataPoolIF { public: explicit FreshDeviceHandlerBase(DhbConfig config); @@ -61,6 +64,7 @@ class FreshDeviceHandlerBase : public SystemObject, ActionHelper actionHelper; ModeHelper modeHelper; HealthHelper healthHelper; + ParameterHelper paramHelper; LocalDataPoolManager poolManager; bool hasCustomFdir = false; From 8d7bb51d44c6fde88719c35cc51f3986a16f9956 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 15 Nov 2023 11:39:04 +0100 Subject: [PATCH 9/9] add missing call to perform HK op --- src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp index 01359368..c113bee9 100644 --- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp +++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp @@ -30,6 +30,7 @@ FreshDeviceHandlerBase::~FreshDeviceHandlerBase() { ReturnValue_t FreshDeviceHandlerBase::performOperation(uint8_t opCode) { handleQueue(); performDeviceOperation(opCode); + poolManager.performHkOperation(); return returnvalue::OK; }