restructure repository

src/core/controller/CMakeLists.txt

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

src/core/controller/ControllerBase.cpp

@@ -0,0 +1,138 @@
+#include "ControllerBase.h"
+
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+#include "../action/HasActionsIF.h"
+#include "../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/core/controller/ExtendedControllerBase.cpp

@@ -0,0 +1,104 @@
+#include "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;
+}