trying to fuse header / inc

src/fsfw/controller/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE 
+    ControllerBase.cpp
+    ExtendedControllerBase.cpp
+)

src/fsfw/controller/ControllerBase.cpp

@@ -0,0 +1,138 @@
+#include "fsfw/controller/ControllerBase.h"
+
+#include "fsfw/subsystem/SubsystemBase.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+
+ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
+        size_t commandQueueDepth) :
+        SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
+        submode(SUBMODE_NONE), modeHelper(this),
+        healthHelper(this, setObjectId) {
+    commandQueue = QueueFactory::instance()->createMessageQueue(
+            commandQueueDepth);
+}
+
+ControllerBase::~ControllerBase() {
+    QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t ControllerBase::initialize() {
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
+
+    MessageQueueId_t parentQueue = 0;
+    if (parentId != objects::NO_OBJECT) {
+        SubsystemBase *parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
+        if (parent == nullptr) {
+            return RETURN_FAILED;
+        }
+        parentQueue = parent->getCommandQueue();
+
+        parent->registerChild(getObjectId());
+    }
+
+    result = healthHelper.initialize(parentQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
+
+    result = modeHelper.initialize(parentQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
+
+    return RETURN_OK;
+}
+
+MessageQueueId_t ControllerBase::getCommandQueue() const {
+    return commandQueue->getId();
+}
+
+void ControllerBase::handleQueue() {
+    CommandMessage command;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for (result = commandQueue->receiveMessage(&command);
+            result == RETURN_OK;
+            result = commandQueue->receiveMessage(&command)) {
+
+        result = modeHelper.handleModeCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        result = handleCommandMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        command.setToUnknownCommand();
+        commandQueue->reply(&command);
+    }
+
+}
+
+void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
+    changeHK(this->mode, this->submode, false);
+    triggerEvent(CHANGING_MODE, mode, submode);
+    this->mode = mode;
+    this->submode = submode;
+    modeHelper.modeChanged(mode, submode);
+    modeChanged(mode, submode);
+    announceMode(false);
+    changeHK(this->mode, this->submode, true);
+}
+
+void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
+    *mode = this->mode;
+    *submode = this->submode;
+}
+
+void ControllerBase::setToExternalControl() {
+    healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void ControllerBase::announceMode(bool recursive) {
+    triggerEvent(MODE_INFO, mode, submode);
+}
+
+ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
+    handleQueue();
+    performControlOperation();
+    return RETURN_OK;
+}
+
+void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
+    return;
+}
+
+ReturnValue_t ControllerBase::setHealth(HealthState health) {
+    switch (health) {
+    case HEALTHY:
+    case EXTERNAL_CONTROL:
+        healthHelper.setHealth(health);
+        return RETURN_OK;
+    default:
+        return INVALID_HEALTH_STATE;
+    }
+}
+
+HasHealthIF::HealthState ControllerBase::getHealth() {
+    return healthHelper.getHealth();
+}
+void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
+            executingTask = task_;
+}
+
+void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
+}
+
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}

src/fsfw/controller/ControllerBase.h

@@ -0,0 +1,94 @@
+#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
+#define FSFW_CONTROLLER_CONTROLLERBASE_H_
+
+#include "fsfw/health/HasHealthIF.h"
+#include "fsfw/health/HealthHelper.h"
+#include "fsfw/modes/HasModesIF.h"
+#include "fsfw/modes/ModeHelper.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/datapool/HkSwitchHelper.h"
+
+/**
+ * @brief   Generic base class for controller classes
+ * @details
+ * Implements common interfaces for controllers, which generally have
+ * a mode and a health state. This avoids boilerplate code.
+ */
+class ControllerBase: public HasModesIF,
+        public HasHealthIF,
+        public ExecutableObjectIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
+public:
+    static const Mode_t MODE_NORMAL = 2;
+
+    ControllerBase(object_id_t setObjectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+    virtual ~ControllerBase();
+
+    /** SystemObject override */
+    virtual ReturnValue_t initialize() override;
+
+    virtual MessageQueueId_t getCommandQueue() const override;
+
+    /** HasHealthIF overrides */
+    virtual ReturnValue_t setHealth(HealthState health) override;
+    virtual HasHealthIF::HealthState getHealth() override;
+
+    /** ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual void setTaskIF(PeriodicTaskIF* task) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+
+    /**
+     * Implemented by child class. Handle command messages which are not
+     * mode or health messages.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    /**
+     * Periodic helper, implemented by child class.
+     */
+    virtual void performControlOperation() = 0;
+
+    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode) = 0;
+
+    const object_id_t parentId;
+
+    Mode_t mode;
+
+    Submode_t submode;
+
+    MessageQueueIF* commandQueue = nullptr;
+
+    ModeHelper modeHelper;
+
+    HealthHelper healthHelper;
+
+    /**
+     * Pointer to the task which executes this component,
+     * is invalid before setTaskIF was called.
+     */
+    PeriodicTaskIF* executingTask = nullptr;
+
+    /** Handle mode and health messages */
+    virtual void handleQueue();
+
+    /** Mode helpers */
+    virtual void modeChanged(Mode_t mode, Submode_t submode);
+    virtual void startTransition(Mode_t mode, Submode_t submode);
+    virtual void getMode(Mode_t *mode, Submode_t *submode);
+    virtual void setToExternalControl();
+    virtual void announceMode(bool recursive);
+    /** HK helpers */
+    virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+};
+
+#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */

src/fsfw/controller/ExtendedControllerBase.cpp

@@ -0,0 +1,103 @@
+#include "fsfw/controller/ExtendedControllerBase.h"
+
+ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
+        object_id_t parentId, size_t commandQueueDepth):
+        ControllerBase(objectId, parentId, commandQueueDepth),
+        poolManager(this, commandQueue),
+        actionHelper(this, commandQueue) {
+}
+
+ExtendedControllerBase::~ExtendedControllerBase() {
+}
+
+ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
+        MessageQueueId_t commandedBy, const uint8_t *data, size_t size) {
+    /* Needs to be overriden and implemented by child class. */
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+object_id_t ExtendedControllerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
+    return this->executingTask->getPeriodMs();
+}
+
+ReturnValue_t ExtendedControllerBase::handleCommandMessage(
+        CommandMessage *message) {
+    ReturnValue_t result = actionHelper.handleActionMessage(message);
+    if(result == HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return poolManager.handleHousekeepingMessage(message);
+}
+
+void ExtendedControllerBase::handleQueue() {
+    CommandMessage command;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for (result = commandQueue->receiveMessage(&command);
+            result == RETURN_OK;
+            result = commandQueue->receiveMessage(&command)) {
+        result = actionHelper.handleActionMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = modeHelper.handleModeCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = poolManager.handleHousekeepingMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = handleCommandMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        command.setToUnknownCommand();
+        commandQueue->reply(&command);
+    }
+}
+
+ReturnValue_t ExtendedControllerBase::initialize() {
+    ReturnValue_t result = ControllerBase::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = actionHelper.initialize(commandQueue);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    return poolManager.initialize(commandQueue);
+}
+
+ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
+    return poolManager.initializeAfterTaskCreation();
+}
+
+ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
+    handleQueue();
+    performControlOperation();
+    /* We do this after performing control operation because variables will be set changed
+    in this function. */
+    poolManager.performHkOperation();
+    return RETURN_OK;
+}
+
+MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
+    return commandQueue->getId();
+}
+
+LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+    return &poolManager;
+}

src/fsfw/controller/ExtendedControllerBase.h

@@ -0,0 +1,76 @@
+#ifndef FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+#define FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+
+#include "ControllerBase.h"
+
+#include "fsfw/action.h"
+#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+
+/**
+ * @brief   Extendes the basic ControllerBase with the common components
+ *          HasActionsIF for commandability and HasLocalDataPoolIF to keep
+ *          a pool of local data pool variables.
+ * @details
+ * Default implementations required for the interfaces will be empty and have
+ * to be implemented by child class.
+ */
+class ExtendedControllerBase: public ControllerBase,
+        public HasActionsIF,
+        public HasLocalDataPoolIF {
+public:
+    ExtendedControllerBase(object_id_t objectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+    virtual ~ExtendedControllerBase();
+
+    /* SystemObjectIF overrides */
+    virtual ReturnValue_t initialize() override;
+
+    virtual MessageQueueId_t getCommandQueue() const override;
+
+    /* ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+    LocalDataPoolManager poolManager;
+    ActionHelper actionHelper;
+
+    /**
+     * 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;
+
+    /**
+     * Periodic helper from ControllerBase, implemented by child class.
+     */
+    virtual void performControlOperation() = 0;
+
+    /* Handle the four messages mentioned above */
+    void handleQueue() override;
+
+    /* HasActionsIF overrides */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data,
+            size_t size) override;
+
+    /* HasLocalDatapoolIF overrides */
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual object_id_t getObjectId() const override;
+    virtual uint32_t getPeriodicOperationFrequency() const override;
+
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override = 0;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
+
+    // Mode abstract functions
+    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode) override = 0;
+};
+
+
+
+#endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */