eive-obsw/linux/devices/ploc/PlocMPSoCHandler.h

#ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
#define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_

#include <string>
#include "fsfw/devicehandlers/DeviceHandlerBase.h"
#include "fsfw_hal/linux/uart/UartComIF.h"
#include "fsfw/ipc/QueueFactory.h"
#include "fsfw/tmtcservices/SourceSequenceCounter.h"
#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
#include "PlocMPSoCHelper.h"
#include "linux/devices/devicedefinitions/MPSoCReturnValuesIF.h"

/**
 * @brief	This is the device handler for the MPSoC of the payload computer.
 *
 * @details The PLOC uses the space packet protocol for communication. On each command the PLOC
 *          answers with at least one acknowledgment and one execution report.
 *          Flight manual: https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_MPSoC
 *          ICD: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_TAS-ILH-IRS/ICD-PLOC/ILH&fileid=1030263
 *
 * @note The sequence count in the space packets must be incremented with each received and sent
 *       packet.
 *
 * @author	J. Meier
 */
class PlocMPSoCHandler: public DeviceHandlerBase {
public:

    PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF * comCookie,
            PlocMPSoCHelper* plocMPSoCHelper);
	virtual ~PlocMPSoCHandler();
	virtual ReturnValue_t initialize() override;
	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
            const uint8_t* data, size_t size) override;
	void performOperationHook() override;

protected:
	void doStartUp() override;
	void doShutDown() override;
	ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override;
	ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) override;
	void fillCommandAndReplyMap() override;
	ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
				const uint8_t * commandData,size_t commandDataLen) override;
	ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
			DeviceCommandId_t *foundId, size_t *foundLen) override;
	ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
			const uint8_t *packet) override;
	void setNormalDatapoolEntriesInvalid() override;
	uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
	ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
            LocalDataPoolManager& poolManager) override;
	ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator command,
	            uint8_t expectedReplies = 1, bool useAlternateId = false,
	            DeviceCommandId_t alternateReplyID = 0) override;
	size_t getNextReplyLength(DeviceCommandId_t deviceCommand) 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
    static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW);
    //! [EXPORT] : [COMMENT] PLOC receive execution failure report
    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_SEQ_CNT_MISMATCH = MAKE_EVENT(5, severity::LOW);

    //! [EXPORT] : [COMMENT] Received command has file string with invalid length
    static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xD0);

    static const uint16_t APID_MASK = 0x7FF;
    static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
    static const uint8_t STATUS_OFFSET = 10;

    MessageQueueIF* eventQueue = nullptr;

    SourceSequenceCounter sequenceCount;

    uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];

    /**
     * This variable is used to store the id of the next reply to receive. This is necessary
     * because the PLOC sends as reply to each command at least one acknowledgment and execution
     * report.
     */
    DeviceCommandId_t nextReplyId = mpsoc::NONE;

    UartComIF* uartComIf = nullptr;

    PlocMPSoCHelper* plocMPSoCHelper = nullptr;

    // Used to block incoming commands when MPSoC helper class is currently executing a command
    bool plocMPSoCHelperExecuting = false;

    class TmMemReadReport {
    public:
        static const uint8_t FIX_SIZE = 14;
        size_t rememberRequestedSize = 0;
    };

    TmMemReadReport tmMemReadReport;

    /**
     * @brief   Handles events received from the PLOC MPSoC helper
     */
    void handleEvent(EventMessage* eventMessage);

    ReturnValue_t prepareTcMemWrite(const uint8_t * commandData, size_t commandDataLen);
    ReturnValue_t prepareTcMemRead(const uint8_t * commandData, size_t commandDataLen);
    ReturnValue_t prepareTcFlashDelete(const uint8_t * commandData, size_t commandDataLen);
    ReturnValue_t prepareTcReplayStart(const uint8_t * commandData, size_t commandDataLen);
    ReturnValue_t prepareTcReplayStop();
    ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t * commandData, size_t commandDataLen);
    ReturnValue_t prepareTcDownlinkPwrOff();
    ReturnValue_t prepareTcReplayWriteSequence(const uint8_t * commandData, size_t commandDataLen);

    /**
     * @brief   Copies space packet into command buffer
     */
    void copyToCommandBuffer(mpsoc::TcBase* tc);

	/**
	 * @brief   This function checks the crc of the received PLOC reply.
	 *
	 * @param start Pointer to the first byte of the reply.
	 * @param foundLen  Pointer to the length of the whole packet.
	 *
	 * @return  RETURN_OK if CRC is ok, otherwise CRC_FAILURE.
	 */
	ReturnValue_t verifyPacket(const uint8_t* start, size_t foundLen);

	/**
	 * @brief   This function handles the acknowledgment report.
	 *
	 * @param data  Pointer to the data holding the acknowledgment report.
	 *
	 * @return  RETURN_OK if successful, otherwise an error code.
	 */
	ReturnValue_t handleAckReport(const uint8_t* data);

	/**
	 * @brief   This function handles the data of a execution report.
	 *
	 * @param data  Pointer to the received data packet.
	 *
	 * @return  RETURN_OK if successful, otherwise an error code.
	 */
	ReturnValue_t handleExecutionReport(const uint8_t* data);

	/**
	 * @brief   This function handles the memory read report.
	 *
	 * @param data  Pointer to the data buffer holding the memory read report.
	 *
	 * @return  RETURN_OK if successful, otherwise an error code.
	 */
	ReturnValue_t handleMemoryReadReport(const uint8_t* data);

	/**
     * @brief   Depending on the current active command, this function sets the reply id of the
     *          next reply after a successful acknowledgment report has been received. This is
     *          required by the function getNextReplyLength() to identify the length of the next
     *          reply to read.
	 */
	void setNextReplyId();

	/**
	 * @brief   This function handles action message replies in case the telemetry has been
	 *          requested by another object.
	 *
	 * @param data  Pointer to the telemetry data.
	 * @param dataSize  Size of telemetry in bytes.
	 * @param replyId   Id of the reply. This will be added to the ActionMessage.
	 */
	void handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);

	/**
	 * @brief   In case an acknowledgment failure reply has been received this function disables
	 *          all previously enabled commands and resets the exepected replies variable of an
	 *          active command.
	 */
	void disableAllReplies();

	/**
	 * @brief   This function sends a failure report if the active action was commanded by an other
	 *          object.
	 *
	 * @param replyId   The id of the reply which signals a failure.
	 * @param status    A status byte which gives information about the failure type.
	 */
	void sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status);

	/**
	 * @brief   This function disables the execution report reply. Within this function also the
	 *          the variable expectedReplies of an active command will be set to 0.
	 */
	void disableExeReportReply();

	void printStatus(const uint8_t* data);

	ReturnValue_t prepareTcModeReplay();
};

#endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */