From 38e74e6eaf099b2d86dce16148359ae6a22734e4 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 15 Nov 2022 17:24:38 +0100 Subject: [PATCH] rename ploc supv uart man --- bsp_hosted/ObjectFactory.cpp | 2 +- bsp_hosted/scheduling.cpp | 6 ++ linux/devices/ploc/PlocSupervisorHandler.cpp | 20 ++-- linux/devices/ploc/PlocSupervisorHandler.h | 4 +- linux/devices/ploc/PlocSupvUartMan.cpp | 99 ++++++++++---------- linux/devices/ploc/PlocSupvUartMan.h | 10 +- 6 files changed, 74 insertions(+), 67 deletions(-) diff --git a/bsp_hosted/ObjectFactory.cpp b/bsp_hosted/ObjectFactory.cpp index 01d6da22..c384c7ad 100644 --- a/bsp_hosted/ObjectFactory.cpp +++ b/bsp_hosted/ObjectFactory.cpp @@ -98,7 +98,7 @@ void ObjectFactory::produce(void* args) { new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvString, uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL); supervisorCookie->setNoFixedSizeReply(); - auto supvHelper = new PlocSupvHelper(objects::PLOC_SUPERVISOR_HELPER); + auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER); new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::PLOC_SUPERVISOR_HELPER, supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF), pcdu::PDU1_CH6_PLOC_12V, supvHelper); diff --git a/bsp_hosted/scheduling.cpp b/bsp_hosted/scheduling.cpp index 9c239eb3..d7238a80 100644 --- a/bsp_hosted/scheduling.cpp +++ b/bsp_hosted/scheduling.cpp @@ -195,6 +195,12 @@ void scheduling::initTasks() { pstTask->startTask(); thermalTask->startTask(); +#if OBSW_ADD_PLOC_SUPERVISOR == 1 + supvHelperTask->startTask(); +#endif +#if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1 + plTask->startTask(); +#endif #if OBSW_ADD_TEST_CODE == 1 testTask->startTask(); diff --git a/linux/devices/ploc/PlocSupervisorHandler.cpp b/linux/devices/ploc/PlocSupervisorHandler.cpp index f5f333fa..9e9653ed 100644 --- a/linux/devices/ploc/PlocSupervisorHandler.cpp +++ b/linux/devices/ploc/PlocSupervisorHandler.cpp @@ -20,7 +20,7 @@ using namespace returnvalue; PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie, Gpio uartIsolatorSwitch, power::Switch_t powerSwitch, - PlocSupvHelper* supvHelper) + PlocSupvUartManager* supvHelper) : DeviceHandlerBase(objectId, uartComIFid, comCookie), uartIsolatorSwitch(uartIsolatorSwitch), hkset(this), @@ -796,12 +796,12 @@ void PlocSupervisorHandler::handleEvent(EventMessage* eventMessage) { plocSupvHelperExecuting = false; // After execution of update procedure, PLOC is in a state where it draws approx. 700 mA of // current. To leave this state the shutdown MPSoC command must be sent here. - if (event == PlocSupvHelper::SUPV_UPDATE_FAILED || - event == PlocSupvHelper::SUPV_UPDATE_SUCCESSFUL || - event == PlocSupvHelper::SUPV_CONTINUE_UPDATE_FAILED || - event == PlocSupvHelper::SUPV_CONTINUE_UPDATE_SUCCESSFUL || - event == PlocSupvHelper::SUPV_MEM_CHECK_FAIL || - event == PlocSupvHelper::SUPV_MEM_CHECK_OK) { + if (event == PlocSupvUartManager::SUPV_UPDATE_FAILED || + event == PlocSupvUartManager::SUPV_UPDATE_SUCCESSFUL || + event == PlocSupvUartManager::SUPV_CONTINUE_UPDATE_FAILED || + event == PlocSupvUartManager::SUPV_CONTINUE_UPDATE_SUCCESSFUL || + event == PlocSupvUartManager::SUPV_MEM_CHECK_FAIL || + event == PlocSupvUartManager::SUPV_MEM_CHECK_OK) { result = this->executeAction(supv::SHUTDOWN_MPSOC, NO_COMMANDER, nullptr, 0); if (result != returnvalue::OK) { triggerEvent(SUPV_MPSOC_SHUWDOWN_BUILD_FAILED); @@ -1856,9 +1856,9 @@ ReturnValue_t PlocSupervisorHandler::eventSubscription() { if (result != returnvalue::OK) { return result; } - result = manager->subscribeToEventRange(eventQueue->getId(), - event::getEventId(PlocSupvHelper::SUPV_UPDATE_FAILED), - event::getEventId(PlocSupvHelper::SUPV_MEM_CHECK_FAIL)); + result = manager->subscribeToEventRange( + eventQueue->getId(), event::getEventId(PlocSupvUartManager::SUPV_UPDATE_FAILED), + event::getEventId(PlocSupvUartManager::SUPV_MEM_CHECK_FAIL)); if (result != returnvalue::OK) { #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "PlocSupervisorHandler::eventSubscritpion: Failed to subscribe to events from " diff --git a/linux/devices/ploc/PlocSupervisorHandler.h b/linux/devices/ploc/PlocSupervisorHandler.h index 27f80ae0..a152349c 100644 --- a/linux/devices/ploc/PlocSupervisorHandler.h +++ b/linux/devices/ploc/PlocSupervisorHandler.h @@ -34,7 +34,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase { public: PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie, Gpio uartIsolatorSwitch, power::Switch_t powerSwitch, - PlocSupvHelper* supvHelper); + PlocSupvUartManager* supvHelper); virtual ~PlocSupervisorHandler(); virtual ReturnValue_t initialize() override; @@ -130,7 +130,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase { const power::Switch_t powerSwitch = power::NO_SWITCH; supv::TmBase tmReader; - PlocSupvHelper* supvHelper = nullptr; + PlocSupvUartManager* supvHelper = nullptr; MessageQueueIF* eventQueue = nullptr; /** Number of expected replies following the MRAM dump command */ diff --git a/linux/devices/ploc/PlocSupvUartMan.cpp b/linux/devices/ploc/PlocSupvUartMan.cpp index 3189cb65..f17033a7 100644 --- a/linux/devices/ploc/PlocSupvUartMan.cpp +++ b/linux/devices/ploc/PlocSupvUartMan.cpp @@ -27,7 +27,7 @@ using namespace returnvalue; using namespace supv; -PlocSupvHelper::PlocSupvHelper(object_id_t objectId) +PlocSupvUartManager::PlocSupvUartManager(object_id_t objectId) : SystemObject(objectId), recRingBuf(4096, true), decodedRingBuf(1200 * MAX_STORED_DECODED_PACKETS, true), @@ -39,9 +39,9 @@ PlocSupvHelper::PlocSupvHelper(object_id_t objectId) ipcLock = MutexFactory::instance()->createMutex(); } -PlocSupvHelper::~PlocSupvHelper() = default; +PlocSupvUartManager::~PlocSupvUartManager() = default; -ReturnValue_t PlocSupvHelper::initializeInterface(CookieIF* cookie) { +ReturnValue_t PlocSupvUartManager::initializeInterface(CookieIF* cookie) { auto* uartCookie = dynamic_cast(cookie); if (uartCookie == nullptr) { return FAILED; @@ -80,7 +80,7 @@ ReturnValue_t PlocSupvHelper::initializeInterface(CookieIF* cookie) { return OK; } -ReturnValue_t PlocSupvHelper::initialize() { +ReturnValue_t PlocSupvUartManager::initialize() { #ifdef XIPHOS_Q7S sdcMan = SdCardManager::instance(); if (sdcMan == nullptr) { @@ -91,7 +91,7 @@ ReturnValue_t PlocSupvHelper::initialize() { return returnvalue::OK; } -ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) { +ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) { bool putTaskToSleep = false; while (true) { semaphore->acquire(); @@ -129,7 +129,7 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) { } } -bool PlocSupvHelper::handleUartReception() { +bool PlocSupvUartManager::handleUartReception() { ReturnValue_t result = OK; ssize_t bytesRead = read(serialPort, reinterpret_cast(recBuf.data()), static_cast(recBuf.size())); @@ -160,8 +160,8 @@ bool PlocSupvHelper::handleUartReception() { return false; } -ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId, - uint32_t startAddress) { +ReturnValue_t PlocSupvUartManager::startUpdate(std::string file, uint8_t memoryId, + uint32_t startAddress) { supv::UpdateParams params; params.file = file; params.memId = memoryId; @@ -172,7 +172,7 @@ ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId, return performUpdate(params); } -ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) { +ReturnValue_t PlocSupvUartManager::performUpdate(const supv::UpdateParams& params) { lock->lockMutex(); InternalState current = state; lock->unlockMutex(); @@ -226,8 +226,8 @@ ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) { return result; } -ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId, - uint32_t startAddress) { +ReturnValue_t PlocSupvUartManager::performMemCheck(std::string file, uint8_t memoryId, + uint32_t startAddress) { lock->lockMutex(); InternalState current = state; lock->unlockMutex(); @@ -237,9 +237,9 @@ ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId return performMemCheck(file, memoryId, startAddress, getFileSize(update.file), true); } -ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId, - uint32_t startAddress, size_t sizeToCheck, - bool checkCrc) { +ReturnValue_t PlocSupvUartManager::performMemCheck(std::string file, uint8_t memoryId, + uint32_t startAddress, size_t sizeToCheck, + bool checkCrc) { { MutexGuard mg(lock); update.file = file; @@ -254,7 +254,7 @@ ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId return returnvalue::OK; } -ReturnValue_t PlocSupvHelper::initiateUpdateContinuation() { +ReturnValue_t PlocSupvUartManager::initiateUpdateContinuation() { lock->lockMutex(); InternalState current = state; lock->unlockMutex(); @@ -284,12 +284,12 @@ ReturnValue_t PlocSupvHelper::initiateUpdateContinuation() { // return returnvalue::OK; // } -void PlocSupvHelper::stop() { +void PlocSupvUartManager::stop() { MutexGuard mg(lock); state = InternalState::GO_TO_SLEEP; } -void PlocSupvHelper::executeFullCheckMemoryCommand() { +void PlocSupvUartManager::executeFullCheckMemoryCommand() { ReturnValue_t result; if (update.crcShouldBeChecked) { sif::info << "PLOC SUPV Mem Check: Calculating Image CRC" << std::endl; @@ -315,7 +315,7 @@ void PlocSupvHelper::executeFullCheckMemoryCommand() { handleCheckMemoryCommand(); } -ReturnValue_t PlocSupvHelper::executeUpdate() { +ReturnValue_t PlocSupvUartManager::executeUpdate() { ReturnValue_t result = returnvalue::OK; sif::info << "PLOC SUPV Update MPSoC: Calculating Image CRC" << std::endl; result = calcImageCrc(); @@ -342,7 +342,7 @@ ReturnValue_t PlocSupvHelper::executeUpdate() { return updateOperation(); } -ReturnValue_t PlocSupvHelper::continueUpdate() { +ReturnValue_t PlocSupvUartManager::continueUpdate() { ReturnValue_t result = prepareUpdate(); if (result != returnvalue::OK) { return result; @@ -350,7 +350,7 @@ ReturnValue_t PlocSupvHelper::continueUpdate() { return updateOperation(); } -ReturnValue_t PlocSupvHelper::updateOperation() { +ReturnValue_t PlocSupvUartManager::updateOperation() { sif::info << "PlocSupvHelper::performUpdate: Writing Update Packets" << std::endl; auto result = writeUpdatePackets(); if (result != returnvalue::OK) { @@ -360,7 +360,7 @@ ReturnValue_t PlocSupvHelper::updateOperation() { return handleCheckMemoryCommand(); } -ReturnValue_t PlocSupvHelper::writeUpdatePackets() { +ReturnValue_t PlocSupvUartManager::writeUpdatePackets() { ReturnValue_t result = returnvalue::OK; #if OBSW_DEBUG_PLOC_SUPERVISOR == 1 ProgressPrinter progressPrinter("Supervisor update", update.fullFileSize, @@ -437,7 +437,7 @@ ReturnValue_t PlocSupvHelper::writeUpdatePackets() { return result; } -uint32_t PlocSupvHelper::buildProgParams1(uint8_t percent, uint16_t seqCount) { +uint32_t PlocSupvUartManager::buildProgParams1(uint8_t percent, uint16_t seqCount) { return (static_cast(percent) << 24) | static_cast(seqCount); } @@ -482,7 +482,7 @@ uint32_t PlocSupvHelper::buildProgParams1(uint8_t percent, uint16_t seqCount) { // return result; // } -ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader) { +ReturnValue_t PlocSupvUartManager::handleRemainingExeReport(ploc::SpTmReader& reader) { size_t remBytes = reader.getPacketDataLen() + 1; ReturnValue_t result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN); if (result != returnvalue::OK) { @@ -495,7 +495,7 @@ ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader) return result; } -ReturnValue_t PlocSupvHelper::selectMemory() { +ReturnValue_t PlocSupvUartManager::selectMemory() { ReturnValue_t result = returnvalue::OK; resetSpParams(); supv::MPSoCBootSelect packet(spParams); @@ -510,7 +510,7 @@ ReturnValue_t PlocSupvHelper::selectMemory() { return returnvalue::OK; } -ReturnValue_t PlocSupvHelper::prepareUpdate() { +ReturnValue_t PlocSupvUartManager::prepareUpdate() { ReturnValue_t result = returnvalue::OK; resetSpParams(); supv::NoPayloadPacket packet(spParams, Apid::BOOT_MAN, @@ -526,7 +526,7 @@ ReturnValue_t PlocSupvHelper::prepareUpdate() { return returnvalue::OK; } -ReturnValue_t PlocSupvHelper::eraseMemory() { +ReturnValue_t PlocSupvUartManager::eraseMemory() { ReturnValue_t result = returnvalue::OK; resetSpParams(); supv::EraseMemory eraseMemory(spParams); @@ -542,8 +542,8 @@ ReturnValue_t PlocSupvHelper::eraseMemory() { return returnvalue::OK; } -ReturnValue_t PlocSupvHelper::handlePacketTransmissionNoReply(supv::TcBase& packet, - uint32_t timeoutExecutionReport) { +ReturnValue_t PlocSupvUartManager::handlePacketTransmissionNoReply( + supv::TcBase& packet, uint32_t timeoutExecutionReport) { ReturnValue_t result = returnvalue::OK; result = encodeAndSendPacket(packet.getFullPacket(), packet.getFullPacketLen()); if (result != returnvalue::OK) { @@ -599,7 +599,7 @@ ReturnValue_t PlocSupvHelper::handlePacketTransmissionNoReply(supv::TcBase& pack return returnvalue::OK; } -int PlocSupvHelper::handleAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen) { +int PlocSupvUartManager::handleAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen) { if (serviceId == static_cast(supv::tm::TmtcId::ACK) or serviceId == static_cast(supv::tm::TmtcId::NAK)) { AcknowledgmentReport ackReport(tmReader); @@ -629,7 +629,8 @@ int PlocSupvHelper::handleAckReception(supv::TcBase& tc, uint8_t serviceId, size return 0; } -int PlocSupvHelper::handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen) { +int PlocSupvUartManager::handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, + size_t packetLen) { if (serviceId == static_cast(supv::tm::TmtcId::EXEC_ACK) or serviceId == static_cast(supv::tm::TmtcId::EXEC_NAK)) { ExecutionReport exeReport(tmReader); @@ -659,7 +660,7 @@ int PlocSupvHelper::handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, s return 0; } -ReturnValue_t PlocSupvHelper::checkReceivedTm() { +ReturnValue_t PlocSupvUartManager::checkReceivedTm() { ReturnValue_t result = tmReader.checkSize(); if (result != returnvalue::OK) { triggerEvent(SUPV_REPLY_SIZE_MISSMATCH, rememberApid); @@ -673,7 +674,7 @@ ReturnValue_t PlocSupvHelper::checkReceivedTm() { return result; } -ReturnValue_t PlocSupvHelper::calcImageCrc() { +ReturnValue_t PlocSupvUartManager::calcImageCrc() { ReturnValue_t result = returnvalue::OK; if (update.fullFileSize == 0) { return returnvalue::FAILED; @@ -719,7 +720,7 @@ ReturnValue_t PlocSupvHelper::calcImageCrc() { return result; } -ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() { +ReturnValue_t PlocSupvUartManager::handleCheckMemoryCommand() { ReturnValue_t result = returnvalue::OK; resetSpParams(); supv::CheckMemory packet(spParams); @@ -815,7 +816,7 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() { return result; } -uint32_t PlocSupvHelper::getFileSize(std::string filename) { +uint32_t PlocSupvUartManager::getFileSize(std::string filename) { std::ifstream file(filename, std::ifstream::binary); file.seekg(0, file.end); uint32_t size = file.tellg(); @@ -823,7 +824,7 @@ uint32_t PlocSupvHelper::getFileSize(std::string filename) { return size; } -ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) { +ReturnValue_t PlocSupvUartManager::handleEventBufferReception(ploc::SpTmReader& reader) { ReturnValue_t result = returnvalue::OK; // TODO: Fix //#ifdef XIPHOS_Q7S @@ -879,10 +880,10 @@ ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reade return result; } -void PlocSupvHelper::resetSpParams() { spParams.buf = cmdBuf.data(); } +void PlocSupvUartManager::resetSpParams() { spParams.buf = cmdBuf.data(); } -ReturnValue_t PlocSupvHelper::sendMessage(CookieIF* cookie, const uint8_t* sendData, - size_t sendLen) { +ReturnValue_t PlocSupvUartManager::sendMessage(CookieIF* cookie, const uint8_t* sendData, + size_t sendLen) { if (sendData == nullptr or sendLen == 0) { return FAILED; } @@ -895,13 +896,13 @@ ReturnValue_t PlocSupvHelper::sendMessage(CookieIF* cookie, const uint8_t* sendD return encodeAndSendPacket(sendData, sendLen); } -ReturnValue_t PlocSupvHelper::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; } +ReturnValue_t PlocSupvUartManager::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; } -ReturnValue_t PlocSupvHelper::requestReceiveMessage(CookieIF* cookie, size_t requestLen) { +ReturnValue_t PlocSupvUartManager::requestReceiveMessage(CookieIF* cookie, size_t requestLen) { return returnvalue::OK; } -ReturnValue_t PlocSupvHelper::handleRunningLongerRequest() { +ReturnValue_t PlocSupvUartManager::handleRunningLongerRequest() { ReturnValue_t result = OK; switch (request) { case Request::UPDATE: { @@ -949,7 +950,7 @@ ReturnValue_t PlocSupvHelper::handleRunningLongerRequest() { return false; } -ReturnValue_t PlocSupvHelper::encodeAndSendPacket(const uint8_t* sendData, size_t sendLen) { +ReturnValue_t PlocSupvUartManager::encodeAndSendPacket(const uint8_t* sendData, size_t sendLen) { size_t encodedLen = 0; hdlc_add_framing(sendData, sendLen, encodedSendBuf.data(), &encodedLen); size_t bytesWritten = write(serialPort, encodedSendBuf.data(), encodedLen); @@ -961,8 +962,8 @@ ReturnValue_t PlocSupvHelper::encodeAndSendPacket(const uint8_t* sendData, size_ return returnvalue::OK; } -ReturnValue_t PlocSupvHelper::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, - size_t* size) { +ReturnValue_t PlocSupvUartManager::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, + size_t* size) { MutexGuard mg(ipcLock); if (ipcQueue.empty()) { *size = 0; @@ -977,7 +978,7 @@ ReturnValue_t PlocSupvHelper::readReceivedMessage(CookieIF* cookie, uint8_t** bu return OK; } -ReturnValue_t PlocSupvHelper::tryHdlcParsing() { +ReturnValue_t PlocSupvUartManager::tryHdlcParsing() { size_t bytesRead = 0; ReturnValue_t result = parseRecRingBufForHdlc(bytesRead); if (result == returnvalue::OK) { @@ -1001,7 +1002,7 @@ ReturnValue_t PlocSupvHelper::tryHdlcParsing() { return result; } -ReturnValue_t PlocSupvHelper::parseRecRingBufForHdlc(size_t& readSize) { +ReturnValue_t PlocSupvUartManager::parseRecRingBufForHdlc(size_t& readSize) { size_t availableData = recRingBuf.getAvailableReadData(); if (availableData == 0) { return NO_PACKET_FOUND; @@ -1043,17 +1044,17 @@ ReturnValue_t PlocSupvHelper::parseRecRingBufForHdlc(size_t& readSize) { return NO_PACKET_FOUND; } -void PlocSupvHelper::pushIpcData(const uint8_t* data, size_t len) { +void PlocSupvUartManager::pushIpcData(const uint8_t* data, size_t len) { MutexGuard mg(ipcLock); ipcRingBuf.writeData(data, len); ipcQueue.insert(len); } -uint32_t PlocSupvHelper::buildApidServiceParam1(uint8_t apid, uint8_t serviceId) { +uint32_t PlocSupvUartManager::buildApidServiceParam1(uint8_t apid, uint8_t serviceId) { return (apid << 8) | serviceId; } -void PlocSupvHelper::performUartShutdown() { +void PlocSupvUartManager::performUartShutdown() { tcflush(serialPort, TCIOFLUSH); // Clear ring buffers recRingBuf.clear(); diff --git a/linux/devices/ploc/PlocSupvUartMan.h b/linux/devices/ploc/PlocSupvUartMan.h index 29183406..fcf49949 100644 --- a/linux/devices/ploc/PlocSupvUartMan.h +++ b/linux/devices/ploc/PlocSupvUartMan.h @@ -25,9 +25,9 @@ * the supervisor and the OBC. * @author J. Meier */ -class PlocSupvHelper : public DeviceCommunicationIF, - public SystemObject, - public ExecutableObjectIF { +class PlocSupvUartManager : public DeviceCommunicationIF, + public SystemObject, + public ExecutableObjectIF { public: static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_SUPV_HELPER; @@ -115,8 +115,8 @@ class PlocSupvHelper : public DeviceCommunicationIF, //! P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written static constexpr Event SUPV_UPDATE_PROGRESS = MAKE_EVENT(30, severity::INFO); - PlocSupvHelper(object_id_t objectId); - virtual ~PlocSupvHelper(); + PlocSupvUartManager(object_id_t objectId); + virtual ~PlocSupvUartManager(); ReturnValue_t initialize() override; ReturnValue_t performOperation(uint8_t operationCode = 0) override;