bsp_hosted/ObjectFactory.cpp

@@ -51,7 +51,7 @@ void ObjectFactory::produce(void* args){
     new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
 #else
     sif::info << "Setting up TCP TMTC bridge with listener port " <<
-            TcpTmTcBridge::DEFAULT_TCP_SERVER_PORT << std::endl;
+            TcpTmTcBridge::DEFAULT_SERVER_PORT << std::endl;
     new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
     new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
 #endif

bsp_q7s/core/CoreController.cpp

@@ -10,7 +10,7 @@
 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
 #include "fsfw/osal/common/UdpTmTcBridge.h"
 #else
-#include "fsfw/osal/common/TcpTmTcBridge.h"
+#include "fsfw/osal/common/TcpTmTcServer.h"
 #endif
 
 #include "bsp_q7s/memory/scratchApi.h"
@@ -782,10 +782,10 @@ void CoreController::initPrint() {
 #if OBSW_VERBOSE_LEVEL >= 1
 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
     sif::info << "Created UDP server for TMTC commanding with listener port " <<
-            UdpTmTcBridge::DEFAULT_UDP_SERVER_PORT << std::endl;
+            UdpTmTcBridge::DEFAULT_SERVER_PORT << std::endl;
 #else
     sif::info << "Created TCP server for TMTC commanding with listener port " <<
-            TcpTmTcBridge::DEFAULT_TCP_SERVER_PORT << std::endl;
+            TcpTmTcServer::DEFAULT_SERVER_PORT << std::endl;
 #endif
 
     if(watchdogFifoFd > 0) {

bsp_q7s/core/ObjectFactory.cpp

@@ -38,11 +38,9 @@
 #include "mission/devices/RadiationSensorHandler.h"
 #include "mission/devices/RwHandler.h"
 #include "mission/devices/StarTrackerHandler.h"
-#include "mission/devices/PlocUpdater.h"
 #include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
 #include "mission/devices/devicedefinitions/SyrlinksDefinitions.h"
 #include "mission/devices/devicedefinitions/PlocMPSoCDefinitions.h"
-#include "mission/devices/devicedefinitions/PlocSupervisorDefinitions.h"
 #include "mission/devices/devicedefinitions/RadSensorDefinitions.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"
 #include "mission/devices/devicedefinitions/RwDefinitions.h"

bsp_q7s/devices/PlocSupervisorHandler.h

@@ -1,11 +1,12 @@
 #ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
 #define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
 
-#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include "devicedefinitions/PlocSupervisorDefinitions.h"
-#include <mission/devices/devicedefinitions/PlocSupervisorDefinitions.h>
-#include <fsfw_hal/linux/uart/UartComIF.h>
 #include <bsp_q7s/memory/SdCardManager.h>
 
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <fsfw_hal/linux/uart/UartComIF.h>
+
 /**
  * @brief	This is the device handler for the supervisor of the PLOC which is programmed by
  *          Thales.

bsp_q7s/devices/PlocUpdater.h

@@ -1,6 +1,9 @@
 #ifndef MISSION_DEVICES_PLOCUPDATER_H_
 #define MISSION_DEVICES_PLOCUPDATER_H_
 
+#include "OBSWConfig.h"
+#include "devicedefinitions/PlocSupervisorDefinitions.h"
+
 #include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/HasActionsIF.h"
@@ -11,8 +14,7 @@
 #include "bsp_q7s/memory/SdCardManager.h"
 #include "linux/fsfwconfig/objects/systemObjectList.h"
 #include "fsfw/tmtcpacket/SpacePacket.h"
-#include "OBSWConfig.h"
+
-#include <mission/devices/devicedefinitions/PlocSupervisorDefinitions.h>
 
 /**
  * @brief   An object of this class can be used to perform the software updates of the PLOC. The

common/config/commonConfig.h.in

@@ -5,6 +5,6 @@
 
 // Use TCP instead of UDP for the TMTC bridge. This allows using the TMTC client locally
 // because UDP packets are not allowed in the VPN
-#define OBSW_USE_TMTC_TCP_BRIDGE        0
+#define OBSW_USE_TMTC_TCP_BRIDGE        1
 
 #endif /* COMMON_CONFIG_COMMONCONFIG_H_ */

fsfw

@@ -1 +1 @@
-Subproject commit 82bcb695b76956b4709de634097795cf771df481
+Subproject commit ba5e2ad8bb97faf22702fa9aaaf47931db7ca6bb

mission/devices/CMakeLists.txt

@@ -17,7 +17,6 @@ target_sources(${TARGET_NAME} PUBLIC
 	GyroADIS16507Handler.cpp
 	RwHandler.cpp
 	StarTrackerHandler.cpp
-	PlocUpdater.cpp
 )
 
 

mission/devices/PlocUpdater.cpp

@@ -1,396 +0,0 @@
-#include "fsfw/ipc/QueueFactory.h"
-#include <mission/devices/PlocUpdater.h>
-#include <fstream>
-#include <filesystem>
-#include <string>
-
-PlocUpdater::PlocUpdater(object_id_t objectId) :
-        SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
-    commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
-}
-
-PlocUpdater::~PlocUpdater() {
-}
-
-ReturnValue_t PlocUpdater::initialize() {
-    sdcMan = SdCardManager::instance();
-
-    ReturnValue_t result = SystemObject::initialize();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    result = commandActionHelper.initialize();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    result = actionHelper.initialize(commandQueue);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PlocUpdater::performOperation(uint8_t operationCode) {
-    readCommandQueue();
-    doStateMachine();
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PlocUpdater::executeAction(ActionId_t actionId,
-        MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-    ReturnValue_t result = RETURN_FAILED;
-
-    if (state != State::IDLE) {
-        return IS_BUSY;
-    }
-
-    if (size > MAX_PLOC_UPDATE_PATH) {
-        return NAME_TOO_LONG;
-    }
-
-    switch (actionId) {
-    case UPDATE_NVM0_A:
-        updatePartition = Partition::A;
-        updateMemory = Memory::NVM0;
-        break;
-    case UPDATE_NVM0_B:
-        updatePartition = Partition::B;
-        updateMemory = Memory::NVM0;
-        break;
-    case UPDATE_NVM1_A:
-        updatePartition = Partition::A;
-        updateMemory = Memory::NVM1;
-        break;
-    case UPDATE_NVM1_B:
-        updatePartition = Partition::B;
-        updateMemory = Memory::NVM1;
-        break;
-    default:
-        return INVALID_ACTION_ID;
-    }
-
-    result = getImageLocation(data, size);
-
-    if (result != RETURN_OK) {
-        return result;
-    }
-
-    state = State::UPDATE_AVAILABLE;
-
-    return EXECUTION_FINISHED;
-}
-
-MessageQueueId_t PlocUpdater::getCommandQueue() const {
-    return commandQueue->getId();
-}
-
-MessageQueueIF* PlocUpdater::getCommandQueuePtr() {
-    return commandQueue;
-}
-
-void PlocUpdater::readCommandQueue() {
-    CommandMessage message;
-    ReturnValue_t result;
-
-    for (result = commandQueue->receiveMessage(&message); result == HasReturnvaluesIF::RETURN_OK;
-            result = commandQueue->receiveMessage(&message)) {
-        if (result != RETURN_OK) {
-            continue;
-        }
-        result = actionHelper.handleActionMessage(&message);
-        if (result == HasReturnvaluesIF::RETURN_OK) {
-            continue;
-        }
-
-        result = commandActionHelper.handleReply(&message);
-        if (result == HasReturnvaluesIF::RETURN_OK) {
-            continue;
-        }
-
-        sif::debug << "PlocUpdater::readCommandQueue: Received message with invalid format"
-                << std::endl;
-    }
-}
-
-void PlocUpdater::doStateMachine() {
-    switch (state) {
-    case State::IDLE:
-        break;
-    case State::UPDATE_AVAILABLE:
-        commandUpdateAvailable();
-        break;
-    case State::UPDATE_TRANSFER:
-        commandUpdatePacket();
-        break;
-    case State::UPDATE_VERIFY:
-        commandUpdateVerify();
-        break;
-    case State::COMMAND_EXECUTING:
-        break;
-    default:
-        sif::debug << "PlocUpdater::doStateMachine: Invalid state" << std::endl;
-        break;
-    }
-}
-
-ReturnValue_t PlocUpdater::checkNameLength(size_t size) {
-    if (size > MAX_PLOC_UPDATE_PATH) {
-        return NAME_TOO_LONG;
-    }
-    return RETURN_OK;
-}
-
-ReturnValue_t PlocUpdater::getImageLocation(const uint8_t* data, size_t size) {
-    ReturnValue_t result = checkNameLength(size);
-    if (result != RETURN_OK) {
-        return result;
-    }
-
-    // Check if file is stored on SD card and if associated SD card is mounted
-    if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) == std::string(SdCardManager::SD_0_MOUNT_POINT)) {
-        if (!isSdCardMounted(sd::SLOT_0)) {
-            sif::warning << "PlocUpdater::prepareNvm0AUpdate: SD card 0 not mounted" << std::endl;
-            return SD_NOT_MOUNTED;
-        }
-    }
-    else if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) == std::string(SdCardManager::SD_1_MOUNT_POINT)) {
-        if (!isSdCardMounted(sd::SLOT_0)) {
-            sif::warning << "PlocUpdater::prepareNvm0AUpdate: SD card 1 not mounted" << std::endl;
-            return SD_NOT_MOUNTED;
-        }
-    }
-    else {
-        //update image not stored on SD card
-    }
-
-    updateFile = std::string(reinterpret_cast<const char*>(data), size);
-
-    // Check if file exists
-    if(not std::filesystem::exists(updateFile)) {
-        return FILE_NOT_EXISTS;
-    }
-    return RETURN_OK;
-}
-
-bool PlocUpdater::isSdCardMounted(sd::SdCard sdCard) {
-    SdCardManager::SdStatePair active;
-    ReturnValue_t result = sdcMan->getSdCardActiveStatus(active);
-    if (result != RETURN_OK) {
-        sif::debug << "PlocUpdater::isSdCardMounted: Failed to get SD card active state";
-        return false;
-    }
-    if (sdCard == sd::SLOT_0) {
-        if (active.first == sd::MOUNTED) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    else if (sdCard == sd::SLOT_1) {
-        if (active.second == sd::MOUNTED) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    else {
-        sif::debug << "PlocUpdater::isSdCardMounted: Unknown SD card specified" << std::endl;
-    }
-    return false;
-}
-
-void PlocUpdater::stepSuccessfulReceived(ActionId_t actionId,
-        uint8_t step) {
-}
-
-void PlocUpdater::stepFailedReceived(ActionId_t actionId, uint8_t step,
-        ReturnValue_t returnCode) {
-}
-
-void PlocUpdater::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
-
-}
-
-void PlocUpdater::completionSuccessfulReceived(ActionId_t actionId) {
-    switch (pendingCommand) {
-    case (PLOC_SPV::UPDATE_AVAILABLE):
-        state = State::UPDATE_TRANSFER;
-        break;
-    case (PLOC_SPV::UPDATE_IMAGE_DATA):
-        if (remainingPackets == 0) {
-            packetsSent = 0; // Reset packets sent variable for next update sequence
-            state = State::UPDATE_VERIFY;
-        }
-        else {
-            state = State::UPDATE_TRANSFER;
-        }
-        break;
-    case (PLOC_SPV::UPDATE_VERIFY):
-        triggerEvent(UPDATE_FINISHED);
-        state = State::IDLE;
-        pendingCommand = PLOC_SPV::NONE;
-        break;
-    default:
-        sif::debug << "PlocUpdater::completionSuccessfulReceived: Invalid pending command"
-                << std::endl;
-        state = State::IDLE;
-        break;
-    }
-}
-
-void PlocUpdater::completionFailedReceived(ActionId_t actionId,
-        ReturnValue_t returnCode) {
-    switch(pendingCommand) {
-    case(PLOC_SPV::UPDATE_AVAILABLE): {
-        triggerEvent(UPDATE_AVAILABLE_FAILED);
-        break;
-    }
-    case(PLOC_SPV::UPDATE_IMAGE_DATA): {
-        triggerEvent(UPDATE_TRANSFER_FAILED, packetsSent);
-        break;
-    }
-    case(PLOC_SPV::UPDATE_VERIFY): {
-        triggerEvent(UPDATE_VERIFY_FAILED);
-        break;
-    }
-    default:
-        sif::debug << "PlocUpdater::completionFailedReceived: Invalid pending command "
-                << std::endl;
-        break;
-    }
-    state = State::IDLE;
-}
-
-void PlocUpdater::commandUpdateAvailable() {
-    ReturnValue_t result = RETURN_OK;
-
-    if (not std::filesystem::exists(updateFile)) {
-        triggerEvent(UPDATE_FILE_NOT_EXISTS, static_cast<uint8_t>(state));
-        state = State::IDLE;
-        return;
-    }
-
-    std::ifstream file(updateFile, std::ifstream::binary);
-    file.seekg(0, file.end);
-    imageSize = static_cast<size_t>(file.tellg());
-    file.close();
-
-    numOfUpdatePackets = imageSize / MAX_SP_DATA ;
-    if (imageSize % MAX_SP_DATA) {
-        numOfUpdatePackets++;
-    }
-
-    remainingPackets = numOfUpdatePackets;
-    packetsSent = 0;
-
-    uint32_t imageCrc = makeCrc();
-
-    PLOC_SPV::UpdateInfo packet(PLOC_SPV::APID_UPDATE_AVAILABLE, static_cast<uint8_t>(updateMemory),
-            static_cast<uint8_t>(updatePartition), imageSize, imageCrc, numOfUpdatePackets);
-
-    result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
-            PLOC_SPV::UPDATE_AVAILABLE, packet.getWholeData(), packet.getFullSize());
-    if (result != RETURN_OK) {
-        sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update available"
-                << " packet to supervisor handler" << std::endl;
-        triggerEvent(ACTION_COMMANDING_FAILED, result, PLOC_SPV::UPDATE_AVAILABLE);
-        state = State::IDLE;
-        pendingCommand = PLOC_SPV::NONE;
-        return;
-    }
-
-    pendingCommand = PLOC_SPV::UPDATE_AVAILABLE;
-    state = State::COMMAND_EXECUTING;
-    return;
-}
-
-void PlocUpdater::commandUpdatePacket() {
-    ReturnValue_t result = RETURN_OK;
-    uint16_t payloadLength = 0;
-
-    if (not std::filesystem::exists(updateFile)) {
-        triggerEvent(UPDATE_FILE_NOT_EXISTS, static_cast<uint8_t>(state), packetsSent);
-        state = State::IDLE;
-        return;
-    }
-
-    std::ifstream file(updateFile, std::ifstream::binary);
-    file.seekg(packetsSent * MAX_SP_DATA, file.beg);
-
-    if (remainingPackets == 1) {
-        payloadLength = imageSize - static_cast<uint16_t>(file.tellg());
-    }
-    else {
-        payloadLength = MAX_SP_DATA;
-    }
-
-    PLOC_SPV::UpdatePacket packet(payloadLength);
-    file.read(reinterpret_cast<char*>(packet.getDataFieldPointer()), payloadLength);
-    file.close();
-    // sequence count of first packet is 1
-    packet.setPacketSequenceCount((packetsSent + 1) & PLOC_SPV::SEQUENCE_COUNT_MASK);
-    if (numOfUpdatePackets > 0) {
-        adjustSequenceFlags(packet);
-    }
-    packet.makeCrc();
-
-    result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
-            PLOC_SPV::UPDATE_IMAGE_DATA, packet.getWholeData(), packet.getFullSize());
-
-    if (result != RETURN_OK) {
-        sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update"
-                << " packet to supervisor handler" << std::endl;
-        triggerEvent(ACTION_COMMANDING_FAILED, result, PLOC_SPV::UPDATE_IMAGE_DATA);
-        state = State::IDLE;
-        pendingCommand = PLOC_SPV::NONE;
-        return;
-    }
-
-    remainingPackets--;
-    packetsSent++;
-
-    pendingCommand = PLOC_SPV::UPDATE_IMAGE_DATA;
-    state = State::COMMAND_EXECUTING;
-}
-
-void PlocUpdater::commandUpdateVerify() {
-    ReturnValue_t result = RETURN_OK;
-
-    PLOC_SPV::UpdateInfo packet(PLOC_SPV::APID_UPDATE_VERIFY, static_cast<uint8_t>(updateMemory),
-            static_cast<uint8_t>(updatePartition), imageSize, imageCrc, numOfUpdatePackets);
-
-    result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
-            PLOC_SPV::UPDATE_VERIFY, packet.getWholeData(), packet.getFullSize());
-    if (result != RETURN_OK) {
-        sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update available"
-                << " packet to supervisor handler" << std::endl;
-        triggerEvent(ACTION_COMMANDING_FAILED, result, PLOC_SPV::UPDATE_VERIFY);
-        state = State::IDLE;
-        pendingCommand = PLOC_SPV::NONE;
-        return;
-    }
-    state = State::COMMAND_EXECUTING;
-    pendingCommand = PLOC_SPV::UPDATE_VERIFY;
-    return;
-}
-
-ReturnValue_t PlocUpdater::makeCrc() {
-    //TODO: Waiting on input from TAS about the CRC to use
-    return 0;
-}
-
-void PlocUpdater::adjustSequenceFlags(PLOC_SPV::UpdatePacket& packet) {
-    if (packetsSent == 0) {
-        packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT));
-    }
-    else if (remainingPackets == 1) {
-        packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT));
-    }
-    else {
-        packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::CONTINUED_PKT));
-    }
-}
-

mission/devices/PlocUpdater.h

@@ -1,171 +0,0 @@
-#ifndef MISSION_DEVICES_PLOCUPDATER_H_
-#define MISSION_DEVICES_PLOCUPDATER_H_
-
-#include "fsfw/action/CommandActionHelper.h"
-#include "fsfw/action/ActionHelper.h"
-#include "fsfw/action/HasActionsIF.h"
-#include "fsfw/action/CommandsActionsIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw/objectmanager/SystemObject.h"
-#include "bsp_q7s/memory/SdCardManager.h"
-#include "linux/fsfwconfig/objects/systemObjectList.h"
-#include "fsfw/tmtcpacket/SpacePacket.h"
-#include "OBSWConfig.h"
-#include <mission/devices/devicedefinitions/PlocSupervisorDefinitions.h>
-
-/**
- * @brief   An object of this class can be used to perform the software updates of the PLOC. The
- *          software update will be read from one of the SD cards, split into multiple space
- *          packets and sent to the PlocSupervisorHandler.
- *
- * @details The MPSoC has two boot memories (NVM0 and NVM1) where each stores two images (Partition A
- *          and Partition B)
- *
- * @author  J. Meier
- */
-class PlocUpdater : public SystemObject,
-        public HasActionsIF,
-        public ExecutableObjectIF,
-        public HasReturnvaluesIF,
-        public CommandsActionsIF {
-public:
-
-    static const ActionId_t UPDATE_NVM0_A = 0;
-    static const ActionId_t UPDATE_NVM0_B = 1;
-    static const ActionId_t UPDATE_NVM1_A = 2;
-    static const ActionId_t UPDATE_NVM1_B = 3;
-
-    PlocUpdater(object_id_t objectId);
-    virtual ~PlocUpdater();
-
-    ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-    ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-            const uint8_t* data, size_t size);
-    MessageQueueId_t getCommandQueue() const;
-    ReturnValue_t initialize() override;
-    MessageQueueIF* getCommandQueuePtr() override;
-    void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) override;
-    void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) override;
-    void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) override;
-    void completionSuccessfulReceived(ActionId_t actionId) override;
-    void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
-
-private:
-
-    static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_UPDATER;
-
-    //! [EXPORT] : [COMMENT] Updater is already performing an update
-    static const ReturnValue_t UPDATER_BUSY = MAKE_RETURN_CODE(0xA0);
-    //! [EXPORT] : [COMMENT] Received update command with invalid path string (too long).
-    static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xA1);
-    //! [EXPORT] : [COMMENT] Received command to initiate update but SD card with update image not mounted.
-    static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0xA2);
-    //! [EXPORT] : [COMMENT] Update file received with update command does not exist.
-    static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xA3);
-
-    static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_UPDATER;
-
-    //! [EXPORT] : [COMMENT] Try to read update file but the file does not exist.
-    //! P1: Indicates in which state the file read fails
-    //! P2: During the update transfer the second parameter gives information about the number of already sent packets
-    static const Event UPDATE_FILE_NOT_EXISTS = MAKE_EVENT(0, severity::LOW);
-    //! [EXPORT] : [COMMENT] Failed to send command to supervisor handler
-    //! P1: Return value of CommandActionHelper::commandAction
-    //! P2: Action ID of command to send
-    static const Event ACTION_COMMANDING_FAILED = MAKE_EVENT(1, severity::LOW);
-    //! [EXPORT] : [COMMENT] Supervisor handler replied action message indicating a command execution failure of the update available command
-    static const Event UPDATE_AVAILABLE_FAILED = MAKE_EVENT(2, severity::LOW);
-    //! [EXPORT] : [COMMENT] Supervisor handler failed to transfer an update space packet.
-    //! P1: Parameter holds the number of update packets already sent (inclusive the failed packet)
-    static const Event UPDATE_TRANSFER_FAILED = MAKE_EVENT(3, severity::LOW);
-    //! [EXPORT] : [COMMENT] Supervisor failed to execute the update verify command.
-    static const Event UPDATE_VERIFY_FAILED = MAKE_EVENT(4, severity::LOW);
-    //! [EXPORT] : [COMMENT] MPSoC update successful completed
-    static const Event UPDATE_FINISHED =  MAKE_EVENT(5, severity::INFO);
-
-    static const uint32_t QUEUE_SIZE = config::PLOC_UPDATER_QUEUE_SIZE;
-    static const size_t MAX_PLOC_UPDATE_PATH = 50;
-    static const size_t SD_PREFIX_LENGTH = 8;
-    // Maximum size of update payload data per space packet (max size of space packet is 1024 bytes)
-    static const size_t MAX_SP_DATA = 1016;
-
-    MessageQueueIF* commandQueue = nullptr;
-
-    SdCardManager* sdcMan = nullptr;
-
-    CommandActionHelper commandActionHelper;
-
-    ActionHelper actionHelper;
-
-    enum class State: uint8_t {
-        IDLE,
-        UPDATE_AVAILABLE,
-        UPDATE_TRANSFER,
-        UPDATE_VERIFY,
-        COMMAND_EXECUTING
-    };
-
-    State state = State::IDLE;
-
-    ActionId_t pendingCommand = PLOC_SPV::NONE;
-
-    enum class Memory: uint8_t {
-        NVM0,
-        NVM1
-    };
-
-    Memory updateMemory = Memory::NVM0;
-
-    enum class Partition: uint8_t {
-        A,
-        B
-    };
-
-    Partition updatePartition = Partition::A;
-
-    uint32_t packetsSent = 0;
-    uint32_t remainingPackets = 0;
-    // Number of packets required to transfer the update image
-    uint32_t numOfUpdatePackets = 0;
-
-    std::string updateFile;
-    uint32_t imageSize = 0;
-    uint32_t imageCrc = 0;
-
-    void readCommandQueue();
-    void doStateMachine();
-
-    /**
-     * @brief   Extracts the path and name of the update image from the service 8 command data.
-     */
-    ReturnValue_t getImageLocation(const uint8_t* data, size_t size);
-
-    ReturnValue_t checkNameLength(size_t size);
-
-    /**
-     * @brief   Prepares and sends update available command to PLOC supervisor handler.
-     */
-    void commandUpdateAvailable();
-
-    /**
-     * @brief   Prepares and sends and update packet to the PLOC supervisor handler.
-     */
-    void commandUpdatePacket();
-
-    /**
-     * @brief   Prepares and sends the update verification packet to the PLOC supervisor handler.
-     */
-    void commandUpdateVerify();
-
-    /**
-     * @brief   Checks whether the SD card to read from is mounted or not.
-     */
-    bool isSdCardMounted(sd::SdCard sdCard);
-
-    ReturnValue_t makeCrc();
-
-    void adjustSequenceFlags(PLOC_SPV::UpdatePacket& packet);
-};
-
-#endif /* MISSION_DEVICES_PLOCUPDATER_H_ */