diff --git a/linux/payload/FreshMpsocHandler.cpp b/linux/payload/FreshMpsocHandler.cpp index ba564544..9e16a339 100644 --- a/linux/payload/FreshMpsocHandler.cpp +++ b/linux/payload/FreshMpsocHandler.cpp @@ -1,15 +1,23 @@ #include "FreshMpsocHandler.h" +#include "fsfw/action/CommandActionHelper.h" #include "fsfw/devicehandlers/FreshDeviceHandlerBase.h" #include "fsfw/ipc/QueueFactory.h" #include "fsfw/returnvalues/returnvalue.h" #include "linux/payload/MpsocCommunication.h" +#include "linux/payload/plocSupvDefs.h" FreshMpsocHandler::FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface, PlocMpsocSpecialComHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch, object_id_t supervisorHandler) - : FreshDeviceHandlerBase(cfg), comInterface(comInterface) { + : FreshDeviceHandlerBase(cfg), + comInterface(comInterface), + specialComHelper(plocMPSoCHelper), + commandActionHelper(this), + uartIsolatorSwitch(uartIsolatorSwitch), + hkReport(this) { + commandActionHelperQueue = QueueFactory::instance()->createMessageQueue(10); eventQueue = QueueFactory::instance()->createMessageQueue(10); } @@ -64,11 +72,6 @@ ReturnValue_t FreshMpsocHandler::initialize() { return ObjectManagerIF::CHILD_INIT_FAILED; } - result = specialComHelper->setComIF(communicationInterface); - if (result != returnvalue::OK) { - return ObjectManagerIF::CHILD_INIT_FAILED; - } - specialComHelper->setComCookie(comCookie); specialComHelper->setSequenceCount(&sequenceCount); result = commandActionHelper.initialize(); if (result != returnvalue::OK) { @@ -78,9 +81,51 @@ ReturnValue_t FreshMpsocHandler::initialize() { } // HK manager abstract functions. -LocalPoolDataSetBase* FreshMpsocHandler::getDataSetHandle(sid_t sid) {} +LocalPoolDataSetBase* FreshMpsocHandler::getDataSetHandle(sid_t sid) { + if (sid == hkReport.getSid()) { + return &hkReport; + } + return nullptr; +} + ReturnValue_t FreshMpsocHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, LocalDataPoolManager& poolManager) { + localDataPoolMap.emplace(mpsoc::poolid::STATUS, &peStatus); + localDataPoolMap.emplace(mpsoc::poolid::MODE, &peMode); + localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_PWR_ON, &peDownlinkPwrOn); + localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_REPLY_ACTIIVE, &peDownlinkReplyActive); + localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_JESD_SYNC_STATUS, &peDownlinkJesdSyncStatus); + localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_DAC_STATUS, &peDownlinkDacStatus); + localDataPoolMap.emplace(mpsoc::poolid::CAM_STATUS, &peCameraStatus); + localDataPoolMap.emplace(mpsoc::poolid::CAM_SDI_STATUS, &peCameraSdiStatus); + localDataPoolMap.emplace(mpsoc::poolid::CAM_FPGA_TEMP, &peCameraFpgaTemp); + localDataPoolMap.emplace(mpsoc::poolid::CAM_SOC_TEMP, &peCameraSocTemp); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_TEMP, &peSysmonTemp); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCINT, &peSysmonVccInt); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCAUX, &peSysmonVccAux); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCBRAM, &peSysmonVccBram); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPAUX, &peSysmonVccPaux); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPINT, &peSysmonVccPint); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPDRO, &peSysmonVccPdro); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB12V, &peSysmonMb12V); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB3V3, &peSysmonMb3V3); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB1V8, &peSysmonMb1V8); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC12V, &peSysmonVcc12V); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC5V, &peSysmonVcc5V); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC3V3, &peSysmonVcc3V3); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC3V3VA, &peSysmonVcc3V3VA); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC2V5DDR, &peSysmonVcc2V5DDR); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC1V2DDR, &peSysmonVcc1V2DDR); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC0V9, &peSysmonVcc0V9); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC0V6VTT, &peSysmonVcc0V6VTT); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_SAFE_COTS_CUR, &peSysmonSafeCotsCur); + localDataPoolMap.emplace(mpsoc::poolid::SYSMON_NVM4_XO_CUR, &peSysmonNvm4XoCur); + localDataPoolMap.emplace(mpsoc::poolid::SEM_UNCORRECTABLE_ERRS, &peSemUncorrectableErrs); + localDataPoolMap.emplace(mpsoc::poolid::SEM_CORRECTABLE_ERRS, &peSemCorrectableErrs); + localDataPoolMap.emplace(mpsoc::poolid::SEM_STATUS, &peSemStatus); + localDataPoolMap.emplace(mpsoc::poolid::REBOOT_MPSOC_REQUIRED, &peRebootMpsocRequired); + poolManager.subscribeForRegularPeriodicPacket( + subdp::RegularHkPeriodicParams(hkReport.getSid(), false, 10.0)); return returnvalue::OK; } @@ -93,6 +138,67 @@ ReturnValue_t FreshMpsocHandler::checkModeCommand(Mode_t mode, Submode_t submode // Action override. Forward to user. ReturnValue_t FreshMpsocHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, const uint8_t* data, size_t size) { + ReturnValue_t result = returnvalue::OK; + switch (actionId) { + case mpsoc::SET_UART_TX_TRISTATE: { + uartIsolatorSwitch.pullLow(); + return EXECUTION_FINISHED; + break; + } + case mpsoc::RELEASE_UART_TX: { + uartIsolatorSwitch.pullHigh(); + return EXECUTION_FINISHED; + break; + default: + break; + } + } + + if (specialComHelperExecuting) { + return MPSoCReturnValuesIF::MPSOC_HELPER_EXECUTING; + } + + switch (actionId) { + case mpsoc::TC_FLASH_WRITE_FULL_FILE: { + mpsoc::FlashBasePusCmd flashWritePusCmd; + result = flashWritePusCmd.extractFields(data, size); + if (result != returnvalue::OK) { + return result; + } + result = specialComHelper->startFlashWrite(flashWritePusCmd.getObcFile(), + flashWritePusCmd.getMPSoCFile()); + if (result != returnvalue::OK) { + return result; + } + specialComHelperExecuting = true; + return EXECUTION_FINISHED; + } + case mpsoc::TC_FLASH_READ_FULL_FILE: { + mpsoc::FlashReadPusCmd flashReadPusCmd; + result = flashReadPusCmd.extractFields(data, size); + if (result != returnvalue::OK) { + return result; + } + result = specialComHelper->startFlashRead(flashReadPusCmd.getObcFile(), + flashReadPusCmd.getMPSoCFile(), + flashReadPusCmd.getReadSize()); + if (result != returnvalue::OK) { + return result; + } + specialComHelperExecuting = true; + return EXECUTION_FINISHED; + } + case (mpsoc::OBSW_RESET_SEQ_COUNT): { + sequenceCount = 0; + return EXECUTION_FINISHED; + } + default: + break; + } + // For longer commands, do not set these. + commandIsPending = true; + cmdCountdown.resetTimer(); + // TODO: Do all the stuff the form buildDeviceFromDevice blah did. return returnvalue::OK; } @@ -109,3 +215,96 @@ ReturnValue_t FreshMpsocHandler::performDeviceOperationPreQueueHandling(uint8_t void FreshMpsocHandler::handleTransitionToOn() {} void FreshMpsocHandler::handleTransitionToOff() {} + +MessageQueueIF* FreshMpsocHandler::getCommandQueuePtr() { return commandActionHelperQueue; } + +void FreshMpsocHandler::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) { return; } + +void FreshMpsocHandler::stepFailedReceived(ActionId_t actionId, uint8_t step, + ReturnValue_t returnCode) { + switch (actionId) { + case supv::START_MPSOC: { + sif::warning << "PlocMPSoCHandler::stepFailedReceived: Failed to start MPSoC" << std::endl; + break; + } + case supv::SHUTDOWN_MPSOC: { + triggerEvent(MPSOC_SHUTDOWN_FAILED); + sif::warning << "PlocMPSoCHandler::stepFailedReceived: Failed to shutdown MPSoC" << std::endl; + break; + } + default: + sif::debug << "PlocMPSoCHandler::stepFailedReceived: Received unexpected action reply" + << std::endl; + break; + } + powerState = PowerState::SUPV_FAILED; +} + +void FreshMpsocHandler::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) { + return; +} + +void FreshMpsocHandler::completionSuccessfulReceived(ActionId_t actionId) { + if (actionId == supv::ACK_REPORT) { + // I seriously don't know why this happens.. + // sif::warning + // << "PlocMpsocHandler::completionSuccessfulReceived: Only received ACK report. Consider + // " + // "increasing the MPSoC boot timer." + // << std::endl; + } else if (actionId != supv::EXE_REPORT) { + sif::warning << "PlocMpsocHandler::completionSuccessfulReceived: Did not expect the action " + << "ID " << actionId << std::endl; + return; + } + switch (powerState) { + case PowerState::PENDING_STARTUP: { + mpsocBootTransitionCd.resetTimer(); + powerState = PowerState::DONE; + break; + } + case PowerState::PENDING_SHUTDOWN: { + powerState = PowerState::DONE; + break; + } + default: { + break; + } + } +} + +void FreshMpsocHandler::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) { + handleActionCommandFailure(actionId); +} + +void FreshMpsocHandler::handleActionCommandFailure(ActionId_t actionId) { + switch (actionId) { + case supv::ACK_REPORT: + case supv::EXE_REPORT: + break; + default: + sif::warning << "PlocMPSoCHandler::handleActionCommandFailure: Did not expect the action ID " + << actionId << std::endl; + return; + } + switch (powerState) { + case PowerState::PENDING_STARTUP: { + sif::info << "PlocMPSoCHandler::handleActionCommandFailure: MPSoC boot command failed" + << std::endl; + // This is commonly the case when the MPSoC is already operational. Thus the power state is + // set to on here + break; + } + case PowerState::PENDING_SHUTDOWN: { + // FDIR will intercept event and switch PLOC power off + triggerEvent(MPSOC_SHUTDOWN_FAILED); + sif::warning << "PlocMPSoCHandler::handleActionCommandFailure: Failed to shutdown MPSoC" + << std::endl; + break; + } + default: + break; + } + powerState = PowerState::SUPV_FAILED; + return; +} diff --git a/linux/payload/FreshMpsocHandler.h b/linux/payload/FreshMpsocHandler.h index 7f1fba78..d1e8b68d 100644 --- a/linux/payload/FreshMpsocHandler.h +++ b/linux/payload/FreshMpsocHandler.h @@ -1,10 +1,11 @@ +#include "fsfw/action/CommandsActionsIF.h" #include "fsfw/devicehandlers/FreshDeviceHandlerBase.h" #include "fsfw/objectmanager/SystemObjectIF.h" #include "fsfw_hal/linux/gpio/Gpio.h" #include "linux/payload/MpsocCommunication.h" #include "linux/payload/PlocMpsocSpecialComHelper.h" -class FreshMpsocHandler : public FreshDeviceHandlerBase { +class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsIF { public: FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface, PlocMpsocSpecialComHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch, @@ -26,6 +27,34 @@ class FreshMpsocHandler : public FreshDeviceHandlerBase { ReturnValue_t initialize() override; private: + static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER; + + //! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet + static const Event MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW); + //! [EXPORT] : [COMMENT] PLOC receive acknowledgment failure report + //! P1: Command Id which leads the acknowledgment failure report + //! P2: The status field inserted by the MPSoC into the data field + static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW); + //! [EXPORT] : [COMMENT] PLOC receive execution failure report + //! P1: Command Id which leads the execution failure report + //! P2: The status field inserted by the MPSoC into the data field + static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW); + //! [EXPORT] : [COMMENT] PLOC reply has invalid crc + static const Event MPSOC_HANDLER_CRC_FAILURE = MAKE_EVENT(4, severity::LOW); + //! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected + //! count P1: Expected sequence count P2: Received sequence count + static const Event MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH = MAKE_EVENT(5, severity::LOW); + //! [EXPORT] : [COMMENT] Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and + //! thus also to shutdown the supervisor. + static const Event MPSOC_SHUTDOWN_FAILED = MAKE_EVENT(6, severity::HIGH); + //! [EXPORT] : [COMMENT] SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for + //! ON transition. + static constexpr Event SUPV_NOT_ON = event::makeEvent(SUBSYSTEM_ID, 7, severity::LOW); + static constexpr Event SUPV_REPLY_TIMEOUT = event::makeEvent(SUBSYSTEM_ID, 8, severity::LOW); + + enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE; + enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE }; + // HK manager abstract functions. LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override; ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, @@ -45,10 +74,71 @@ class FreshMpsocHandler : public FreshDeviceHandlerBase { void startTransition(Mode_t newMode, Submode_t submode) override; ReturnValue_t performDeviceOperationPreQueueHandling(uint8_t opCode) override; + + // CommandsActionsIF overrides. + 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; + + void handleActionCommandFailure(ActionId_t actionId); void handleTransitionToOn(); void handleTransitionToOff(); bool transitionActive = false; MpsocCommunication comInterface; MessageQueueIF* eventQueue = nullptr; + PlocMpsocSpecialComHelper* specialComHelper; + SourceSequenceCounter sequenceCount = SourceSequenceCounter(0); + MessageQueueIF* commandActionHelperQueue = nullptr; + CommandActionHelper commandActionHelper; + Gpio uartIsolatorSwitch; + + mpsoc::HkReport hkReport; + Countdown mpsocBootTransitionCd = Countdown(6500); + Countdown supvTransitionCd = Countdown(3000); + + PoolEntry peStatus = PoolEntry(); + PoolEntry peMode = PoolEntry(); + PoolEntry peDownlinkPwrOn = PoolEntry(); + PoolEntry peDownlinkReplyActive = PoolEntry(); + PoolEntry peDownlinkJesdSyncStatus = PoolEntry(); + PoolEntry peDownlinkDacStatus = PoolEntry(); + PoolEntry peCameraStatus = PoolEntry(); + PoolEntry peCameraSdiStatus = PoolEntry(); + PoolEntry peCameraFpgaTemp = PoolEntry(); + PoolEntry peCameraSocTemp = PoolEntry(); + PoolEntry peSysmonTemp = PoolEntry(); + PoolEntry peSysmonVccInt = PoolEntry(); + PoolEntry peSysmonVccAux = PoolEntry(); + PoolEntry peSysmonVccBram = PoolEntry(); + PoolEntry peSysmonVccPaux = PoolEntry(); + PoolEntry peSysmonVccPint = PoolEntry(); + PoolEntry peSysmonVccPdro = PoolEntry(); + PoolEntry peSysmonMb12V = PoolEntry(); + PoolEntry peSysmonMb3V3 = PoolEntry(); + PoolEntry peSysmonMb1V8 = PoolEntry(); + PoolEntry peSysmonVcc12V = PoolEntry(); + PoolEntry peSysmonVcc5V = PoolEntry(); + PoolEntry peSysmonVcc3V3 = PoolEntry(); + PoolEntry peSysmonVcc3V3VA = PoolEntry(); + PoolEntry peSysmonVcc2V5DDR = PoolEntry(); + PoolEntry peSysmonVcc1V2DDR = PoolEntry(); + PoolEntry peSysmonVcc0V9 = PoolEntry(); + PoolEntry peSysmonVcc0V6VTT = PoolEntry(); + PoolEntry peSysmonSafeCotsCur = PoolEntry(); + PoolEntry peSysmonNvm4XoCur = PoolEntry(); + PoolEntry peSemUncorrectableErrs = PoolEntry(); + PoolEntry peSemCorrectableErrs = PoolEntry(); + PoolEntry peSemStatus = PoolEntry(); + PoolEntry peRebootMpsocRequired = PoolEntry(); + + PowerState powerState; + bool specialComHelperExecuting = false; + + Countdown cmdCountdown = Countdown(15000); + bool commandIsPending = false; }; diff --git a/linux/payload/MpsocCommunication.cpp b/linux/payload/MpsocCommunication.cpp index cf807cbf..6239061b 100644 --- a/linux/payload/MpsocCommunication.cpp +++ b/linux/payload/MpsocCommunication.cpp @@ -45,6 +45,7 @@ ReturnValue_t MpsocCommunication::parseAndRetrieveNextPacket() { // Possibly invalid packet. We can not even trust the detected packet length. // Just clear the whole read buffer as well. readRingBuf.clear(); + return CRC_CHECK_FAILED; } readRingBuf.deleteData(spReader.getFullPacketLen()); return PACKET_RECEIVED; @@ -59,3 +60,5 @@ ReturnValue_t MpsocCommunication::readSerialInterface() { } const SpacePacketReader& MpsocCommunication::getSpReader() const { return spReader; } + +SerialCommunicationHelper& MpsocCommunication::getComHelper() { return helper; } diff --git a/linux/payload/MpsocCommunication.h b/linux/payload/MpsocCommunication.h index 789044ba..ec453b6c 100644 --- a/linux/payload/MpsocCommunication.h +++ b/linux/payload/MpsocCommunication.h @@ -14,8 +14,9 @@ class MpsocCommunication : public SystemObject { static const uint8_t CLASS_ID = CLASS_ID::PLOC_MPSOC_COM; static constexpr ReturnValue_t PACKET_RECEIVED = returnvalue::makeCode(CLASS_ID, 0); static constexpr ReturnValue_t FAULTY_PACKET_SIZE = returnvalue::makeCode(CLASS_ID, 1); + static constexpr ReturnValue_t CRC_CHECK_FAILED = returnvalue::makeCode(CLASS_ID, 2); - MpsocCommunication(object_id_t objectId, SerialCookie cfg); + MpsocCommunication(object_id_t objectId, SerialConfig cfg); ReturnValue_t initialize() override; ReturnValue_t send(const uint8_t* data, size_t dataLen); @@ -30,6 +31,8 @@ class MpsocCommunication : public SystemObject { // Can be used to read the parse packet, if one was received. const SpacePacketReader& getSpReader() const; + SerialCommunicationHelper& getComHelper(); + private: SpacePacketReader spReader; uint8_t readBuf[4096]; diff --git a/linux/payload/PlocMpsocSpecialComHelper.cpp b/linux/payload/PlocMpsocSpecialComHelper.cpp index 91bf5834..d82ab4c5 100644 --- a/linux/payload/PlocMpsocSpecialComHelper.cpp +++ b/linux/payload/PlocMpsocSpecialComHelper.cpp @@ -16,8 +16,9 @@ using namespace ploc; -PlocMpsocSpecialComHelper::PlocMpsocSpecialComHelper(object_id_t objectId) - : SystemObject(objectId) { +PlocMpsocSpecialComHelper::PlocMpsocSpecialComHelper(object_id_t objectId, + MpsocCommunication& comInterface) + : SystemObject(objectId), comInterface(comInterface) { spParams.buf = commandBuffer; spParams.maxSize = sizeof(commandBuffer); } @@ -73,11 +74,6 @@ ReturnValue_t PlocMpsocSpecialComHelper::performOperation(uint8_t operationCode) } } -ReturnValue_t PlocMpsocSpecialComHelper::setComIF(MpsocCommunication& communication) { - comInterface = communication; - return returnvalue::OK; -} - void PlocMpsocSpecialComHelper::setSequenceCount(SourceSequenceCounter* sequenceCount_) { sequenceCount = sequenceCount_; } @@ -112,7 +108,8 @@ ReturnValue_t PlocMpsocSpecialComHelper::startFlashRead(std::string obcFile, std void PlocMpsocSpecialComHelper::resetHelper() { spParams.buf = commandBuffer; terminate = false; - uartComIF->flushUartRxBuffer(comCookie); + auto& helper = comInterface.getComHelper(); + helper.flushUartRxBuffer(); } void PlocMpsocSpecialComHelper::stopProcess() { terminate = true; } @@ -306,8 +303,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionNoReply(ploc::S } ReturnValue_t PlocMpsocSpecialComHelper::sendCommand(ploc::SpTcBase& tc) { - ReturnValue_t result = returnvalue::OK; - result = uartComIF->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen()); + ReturnValue_t result = comInterface.send(tc.getFullPacket(), tc.getFullPacketLen()); if (result != returnvalue::OK) { sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl; triggerEvent(MPSOC_SENDING_COMMAND_FAILED, result, static_cast(internalState)); @@ -499,12 +495,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::checkReceivedTm() { triggerEvent(MPSOC_TM_SIZE_ERROR); return result; } - result = spReader.checkCrc(); - if (result != returnvalue::OK) { - sif::warning << "PLOC MPSoC: CRC check failed" << std::endl; - triggerEvent(MPSOC_TM_CRC_MISSMATCH, *sequenceCount); - return result; - } + // No CRC check, this is already done by the communication interface.. uint16_t recvSeqCnt = spReader.getSequenceCount(); if (recvSeqCnt != *sequenceCount) { triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt); @@ -518,22 +509,17 @@ ReturnValue_t PlocMpsocSpecialComHelper::checkReceivedTm() { ReturnValue_t PlocMpsocSpecialComHelper::receive(uint8_t* data, size_t requestBytes, size_t* readBytes) { ReturnValue_t result = returnvalue::OK; - uint8_t* buffer = nullptr; - result = uartComIF->requestReceiveMessage(comCookie, requestBytes); + result = comInterface.readSerialInterface(); if (result != returnvalue::OK) { - sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl; triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result, static_cast(static_cast(internalState))); return returnvalue::FAILED; } - result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes); - if (result != returnvalue::OK) { - sif::warning << "PlocMPSoCHelper::receive: Failed to read received message" << std::endl; - triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast(internalState)); - return returnvalue::FAILED; - } - if (*readBytes > 0) { - std::memcpy(data, buffer, *readBytes); + result = comInterface.parseAndRetrieveNextPacket(); + if (result == MpsocCommunication::PACKET_RECEIVED) { + auto& spReader = comInterface.getSpReader(); + // Maybe unnecessary copy, but the easiest way to get this done for now.. + std::memcpy(data, spReader.getFullData(), spReader.getFullPacketLen()); } return result; } diff --git a/linux/payload/PlocMpsocSpecialComHelper.h b/linux/payload/PlocMpsocSpecialComHelper.h index a8b9f34c..18071e8d 100644 --- a/linux/payload/PlocMpsocSpecialComHelper.h +++ b/linux/payload/PlocMpsocSpecialComHelper.h @@ -84,15 +84,12 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF FLASH_READ_READLEN_ERROR = 2 }; - PlocMpsocSpecialComHelper(object_id_t objectId); + PlocMpsocSpecialComHelper(object_id_t objectId, MpsocCommunication& comInterface); virtual ~PlocMpsocSpecialComHelper(); ReturnValue_t initialize() override; ReturnValue_t performOperation(uint8_t operationCode = 0) override; - ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_); - void setComCookie(CookieIF* comCookie_); - /** * @brief Starts flash write sequence * diff --git a/linux/payload/SerialCommunicationHelper.h b/linux/payload/SerialCommunicationHelper.h index 6eac1743..79431894 100644 --- a/linux/payload/SerialCommunicationHelper.h +++ b/linux/payload/SerialCommunicationHelper.h @@ -19,7 +19,7 @@ */ class SerialCommunicationHelper { public: - SerialCommunicationHelper(SerialCookie serialCfg); + SerialCommunicationHelper(SerialConfig serialCfg); ReturnValue_t send(const uint8_t* data, size_t dataLen); @@ -43,7 +43,7 @@ class SerialCommunicationHelper { ReturnValue_t flushUartTxAndRxBuf(); private: - SerialCookie cfg; + SerialConfig cfg; int fd = 0; /**