enough of this for today

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;
+}

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<uint32_t> peStatus = PoolEntry<uint32_t>();
+  PoolEntry<uint8_t> peMode = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkPwrOn = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkReplyActive = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkJesdSyncStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkDacStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peCameraStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peCameraSdiStatus = PoolEntry<uint8_t>();
+  PoolEntry<float> peCameraFpgaTemp = PoolEntry<float>();
+  PoolEntry<float> peCameraSocTemp = PoolEntry<float>();
+  PoolEntry<float> peSysmonTemp = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccInt = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccAux = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccBram = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPaux = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPint = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPdro = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb12V = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb3V3 = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb1V8 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc12V = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc5V = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc3V3 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc3V3VA = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc2V5DDR = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc1V2DDR = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc0V9 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc0V6VTT = PoolEntry<float>();
+  PoolEntry<float> peSysmonSafeCotsCur = PoolEntry<float>();
+  PoolEntry<float> peSysmonNvm4XoCur = PoolEntry<float>();
+  PoolEntry<uint16_t> peSemUncorrectableErrs = PoolEntry<uint16_t>();
+  PoolEntry<uint16_t> peSemCorrectableErrs = PoolEntry<uint16_t>();
+  PoolEntry<uint8_t> peSemStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peRebootMpsocRequired = PoolEntry<uint8_t>();
+
+  PowerState powerState;
+  bool specialComHelperExecuting = false;
+
+  Countdown cmdCountdown = Countdown(15000);
+  bool commandIsPending = false;
 };

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; }

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];

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<uint32_t>(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<uint32_t>(static_cast<uint32_t>(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<uint32_t>(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;
 }

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
    *

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;
 
   /**