Robin Mueller
aa2bfb7d0e
All checks were successful
EIVE/eive-obsw/pipeline/pr-main This commit looks good
200 lines
8.0 KiB
C++
200 lines
8.0 KiB
C++
#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 "fsfw/objectmanager/SystemObject.h"
|
|
#include "fsfw/osal/linux/BinarySemaphore.h"
|
|
#include "fsfw/returnvalues/returnvalue.h"
|
|
#include "fsfw/tasks/ExecutableObjectIF.h"
|
|
#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
|
|
#include "fsfw/tmtcservices/SourceSequenceCounter.h"
|
|
#include "linux/payload/MpsocCommunication.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, MpsocCommunication& comInterface);
|
|
virtual ~PlocMpsocSpecialComHelper();
|
|
|
|
ReturnValue_t initialize() override;
|
|
ReturnValue_t performOperation(uint8_t operationCode = 0) override;
|
|
|
|
/**
|
|
* @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 setCommandSequenceCount(uint16_t sequenceCount_);
|
|
uint16_t getCommandSequenceCount() const;
|
|
|
|
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;
|
|
MpsocCommunication& comInterface;
|
|
// Sequence count, must be set by Ploc MPSoC Handler
|
|
// ploc::SpTmReader spReader;
|
|
uint16_t rxSequenceCount = 0;
|
|
SourceSequenceCounter txSequenceCount = 0;
|
|
|
|
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 tryReceiveNextReply();
|
|
ReturnValue_t handleAck();
|
|
ReturnValue_t handleExe();
|
|
ReturnValue_t startFlashReadOrWriteBase(std::string obcFile, std::string mpsocFile);
|
|
ReturnValue_t fileCheck(std::string obcFile);
|
|
void handleAckApidFailure(const SpacePacketReader& reader);
|
|
void handleExeFailure(const SpacePacketReader& reader);
|
|
ReturnValue_t handleTmReception();
|
|
ReturnValue_t checkReceivedTm();
|
|
};
|
|
|
|
#endif /* BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ */
|