eive-obsw/linux/payload/PlocMpsocSpecialComHelper.h

#ifndef BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
#define BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_

#include <linux/payload/plocMpsocHelpers.h>
#include <mission/utility/trace.h>

#include <string>

#include "OBSWConfig.h"
#include "fsfw/devicehandlers/CookieIF.h"
#include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/osal/linux/BinarySemaphore.h"
#include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw/tmtcservices/SourceSequenceCounter.h"
#include "fsfw_hal/linux/serial/SerialComIF.h"
#ifdef XIPHOS_Q7S
#include "bsp_q7s/fs/SdCardManager.h"
#endif

/**
 * @brief   Helper class for MPSoC of PLOC intended to accelerate large data transfers between
 *          MPSoC and OBC.
 * @author  J. Meier
 */
class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF {
 public:
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HELPER;

  //! [EXPORT] : [COMMENT] Flash write fails
  static const Event MPSOC_FLASH_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
  //! [EXPORT] : [COMMENT] Flash write successful
  static const Event MPSOC_FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(1, severity::INFO);
  //! [EXPORT] : [COMMENT] Communication interface returned failure when trying to send the command
  //! to the MPSoC
  //! P1: Return value returned by the communication interface sendMessage function
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_SENDING_COMMAND_FAILED = MAKE_EVENT(2, severity::LOW);
  //! [EXPORT] : [COMMENT] Request receive message of communication interface failed
  //! P1: Return value returned by the communication interface requestReceiveMessage function
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_HELPER_REQUESTING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW);
  //! [EXPORT] : [COMMENT] Reading receive message of communication interface failed
  //! P1: Return value returned by the communication interface readingReceivedMessage function
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_HELPER_READING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
  //! [EXPORT] : [COMMENT] Did not receive acknowledgment report
  //! P1: Number of bytes missing
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_MISSING_ACK = MAKE_EVENT(5, severity::LOW);
  //! [EXPORT] : [COMMENT] Did not receive execution report
  //! P1: Number of bytes missing
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_MISSING_EXE = MAKE_EVENT(6, severity::LOW);
  //! [EXPORT] : [COMMENT] Received acknowledgment failure report
  //! P1: Internal state of MPSoC
  static const Event MPSOC_ACK_FAILURE_REPORT = MAKE_EVENT(7, severity::LOW);
  //! [EXPORT] : [COMMENT] Received execution failure report
  //! P1: Internal state of MPSoC
  static const Event MPSOC_EXE_FAILURE_REPORT = MAKE_EVENT(8, severity::LOW);
  //! [EXPORT] : [COMMENT] Expected acknowledgment report but received space packet with other apid
  //! P1: Apid of received space packet
  //! P2: Internal state of MPSoC
  static const Event MPSOC_ACK_INVALID_APID = MAKE_EVENT(9, severity::LOW);
  //! [EXPORT] : [COMMENT] Expected execution report but received space packet with other apid
  //! P1: Apid of received space packet
  //! P2: Internal state of MPSoC
  static const Event MPSOC_EXE_INVALID_APID = MAKE_EVENT(10, severity::LOW);
  //! [EXPORT] : [COMMENT] Received sequence count does not match expected sequence count
  //! P1: Expected sequence count
  //! P2: Received sequence count
  static const Event MPSOC_HELPER_SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW);
  static const Event MPSOC_TM_SIZE_ERROR = MAKE_EVENT(12, severity::LOW);
  static const Event MPSOC_TM_CRC_MISSMATCH = MAKE_EVENT(13, severity::LOW);
  static const Event MPSOC_FLASH_READ_PACKET_ERROR = MAKE_EVENT(14, severity::LOW);
  static const Event MPSOC_FLASH_READ_FAILED = MAKE_EVENT(15, severity::LOW);
  static const Event MPSOC_FLASH_READ_SUCCESSFUL = MAKE_EVENT(16, severity::INFO);
  static const Event MPSOC_READ_TIMEOUT = MAKE_EVENT(17, severity::LOW);

  enum FlashReadErrorType : uint32_t {
    FLASH_READ_APID_ERROR = 0,
    FLASH_READ_FILENAME_ERROR = 1,
    FLASH_READ_READLEN_ERROR = 2
  };

  PlocMpsocSpecialComHelper(object_id_t objectId);
  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
   *
   * @param obcFile   File where to read from the data
   * @param mpsocFile The file of the MPSoC where should be written to
   *
   * @return  returnvalue::OK if successful, otherwise error return value
   */
  ReturnValue_t startFlashWrite(std::string obcFile, std::string mpsocFile);
  /**
   *
   * @param obcFile Full target file name on OBC
   * @param mpsocFile The file on the MPSoC which should be copied ot the OBC
   * @param readFileSize The size of the file on the MPSoC.
   * @return
   */
  ReturnValue_t startFlashRead(std::string obcFile, std::string mpsocFile, size_t readFileSize);

  /**
   * @brief   Can be used to interrupt a running data transfer.
   */
  void stopProcess();

  /**
   * @brief   Sets the sequence count object responsible for the sequence count handling
   */
  void setSequenceCount(SourceSequenceCounter* sequenceCount_);

 private:
  static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER;

  //! [EXPORT] : [COMMENT] File error occured for file transfers from OBC to the MPSoC.
  static const ReturnValue_t FILE_WRITE_ERROR = MAKE_RETURN_CODE(0xA0);
  //! [EXPORT] : [COMMENT] File error occured for file transfers from MPSoC to OBC.
  static const ReturnValue_t FILE_READ_ERROR = MAKE_RETURN_CODE(0xA1);

  // Maximum number of times the communication interface retries polling data from the reply
  // buffer
  static const int RETRIES = 10000;

  struct FlashInfo {
    std::string obcFile;
    std::string mpsocFile;
  };

  struct FlashRead : public FlashInfo {
    size_t totalReadSize = 0;
  };

  struct FlashRead flashReadAndWrite;
#if OBSW_THREAD_TRACING == 1
  uint32_t opCounter = 0;
#endif

  enum class InternalState { IDLE, FLASH_WRITE, FLASH_READ };

  InternalState internalState = InternalState::IDLE;

  BinarySemaphore semaphore;
#ifdef XIPHOS_Q7S
  SdCardManager* sdcMan = nullptr;
#endif
  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
  SpacePacketCreator creator;
  ploc::SpTcParams spParams = ploc::SpTcParams(creator);

  Countdown tmCountdown = Countdown(5000);

  std::array<uint8_t, mpsoc::SP_MAX_DATA_SIZE> fileBuf{};
  std::array<uint8_t, mpsoc::MAX_REPLY_SIZE> tmBuf{};

  bool terminate = false;

  /**
   * Communication interface of MPSoC responsible for low level access. Must be set by the
   * MPSoC Handler.
   */
  SerialComIF* uartComIF = nullptr;
  // Communication cookie. Must be set by the MPSoC Handler
  CookieIF* comCookie = nullptr;
  // Sequence count, must be set by Ploc MPSoC Handler
  SourceSequenceCounter* sequenceCount = nullptr;
  ploc::SpTmReader spReader;

  void resetHelper();
  ReturnValue_t performFlashWrite();
  ReturnValue_t performFlashRead();
  ReturnValue_t flashfopen(uint8_t accessMode);
  ReturnValue_t flashfclose();
  ReturnValue_t handlePacketTransmissionNoReply(ploc::SpTcBase& tc);
  ReturnValue_t handlePacketTransmissionFlashRead(mpsoc::TcFlashRead& tc, std::ofstream& ofile,
                                                  size_t expectedReadLen);
  ReturnValue_t handleFlashReadReply(std::ofstream& ofile, size_t expectedReadLen);
  ReturnValue_t sendCommand(ploc::SpTcBase& tc);
  ReturnValue_t receive(uint8_t* data, size_t requestBytes, size_t* readBytes);
  ReturnValue_t handleAck();
  ReturnValue_t handleExe();
  ReturnValue_t startFlashReadOrWriteBase(std::string obcFile, std::string mpsocFile);
  ReturnValue_t fileCheck(std::string obcFile);
  void handleAckApidFailure(const ploc::SpTmReader& reader);
  void handleExeFailure();
  ReturnValue_t handleTmReception();
  ReturnValue_t checkReceivedTm();
};

#endif /* BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ */