eive-obsw/bsp_q7s/devices/startracker/StrHelper.h

#ifndef BSP_Q7S_DEVICES_STRHELPER_H_
#define BSP_Q7S_DEVICES_STRHELPER_H_

#include <string>
#include "ArcsecDatalinkLayer.h"
#include "fsfw/osal/linux/BinarySemaphore.h"
#include "bsp_q7s/memory/SdCardManager.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
#include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw_hal/linux/uart/UartComIF.h"
#include "fsfw/devicehandlers/CookieIF.h"

extern "C" {
    #include "thirdparty/arcsec_star_tracker/common/generated/tmtcstructs.h"
    #include "thirdparty/arcsec_star_tracker/client/generated/actionreq.h"
}

/**
 * @brief   Helper class for the star tracker handler to accelerate large data transfers.
 */
class StrHelper: public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
public:

    static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HELPER;

    //! [EXPORT] : [COMMENT] Image upload failed
    static const Event IMAGE_UPLOAD_FAILED = MAKE_EVENT(0, severity::LOW);
    //! [EXPORT] : [COMMENT] Image download failed
    static const Event IMAGE_DOWNLOAD_FAILED = MAKE_EVENT(1, severity::LOW);
    //! [EXPORT] : [COMMENT] Uploading image to star tracker was successfulop
    static const Event IMAGE_UPLOAD_SUCCESSFUL = MAKE_EVENT(2, severity::LOW);
    //! [EXPORT] : [COMMENT] Image download was successful
    static const Event IMAGE_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(3, severity::LOW);
    //! [EXPORT] : [COMMENT] Finished flash write procedure successfully
    static const Event FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(4, severity::LOW);
    //! [EXPORT] : [COMMENT] Finished flash read procedure successfully
    static const Event FLASH_READ_SUCCESSFUL = MAKE_EVENT(5, severity::LOW);
    //! [EXPORT] : [COMMENT] Flash write procedure failed
    static const Event FLASH_WRITE_FAILED = MAKE_EVENT(6, severity::LOW);
    //! [EXPORT] : [COMMENT] Flash read procedure failed
    static const Event FLASH_READ_FAILED = MAKE_EVENT(7, severity::LOW);
    //! [EXPORT] : [COMMENT] Download of FPGA image successful
    static const Event FPGA_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(8, severity::LOW);
    //! [EXPORT] : [COMMENT] Download of FPGA image failed
    static const Event FPGA_DOWNLOAD_FAILED = MAKE_EVENT(9, severity::LOW);
    //! [EXPORT] : [COMMENT] Upload of FPGA image successful
    static const Event FPGA_UPLOAD_SUCCESSFUL = MAKE_EVENT(10, severity::LOW);
    //! [EXPORT] : [COMMENT] Upload of FPGA image failed
    static const Event FPGA_UPLOAD_FAILED = MAKE_EVENT(11, severity::LOW);
    //! [EXPORT] : [COMMENT] Failed to read communication interface reply data
    //!P1: Return code of failed communication interface read call
    //!P1: Upload/download position for which the read call failed
    static const Event STR_HELPER_READING_REPLY_FAILED = MAKE_EVENT(12, severity::LOW);
    //! [EXPORT] : [COMMENT] Unexpected stop of decoding sequence
    //!P1: Return code of failed communication interface read call
    //!P1: Upload/download position for which the read call failed
    static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(13, severity::LOW);
    //! [EXPORT] : [COMMENT] Star tracker did not send replies (maybe device is powered off)
    //!P1: Position of upload or download packet for which no reply was sent
    static const Event STR_HELPER_NO_REPLY = MAKE_EVENT(14, severity::LOW);
    //! [EXPORT] : [COMMENT] Error during decoding of received reply occurred
    //P1: Return value of decoding function
    //P2: Position of upload/download packet, or address of flash write/read request
    static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(15, severity::LOW);
    //! [EXPORT] : [COMMENT] Position mismatch
    //! P1: The expected position and thus the position for which the image upload/download failed
    static const Event POSITION_MISMATCH = MAKE_EVENT(16, severity::LOW);
    //! [EXPORT] : [COMMENT] Specified file does not exist
    //!P1: Internal state of str helper
    static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(17, severity::LOW);
    //! [EXPORT] : [COMMENT] Sending packet to star tracker failed
    //!P1: Return code of communication interface sendMessage function
    //!P2: Position of upload/download packet, or address of flash write/read request for which sending failed
    static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(18, severity::LOW);
    //! [EXPORT] : [COMMENT] Communication interface requesting reply failed
    //!P1: Return code of failed request
    //!P1: Upload/download position, or address of flash write/read request for which transmission failed
    static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(19, severity::LOW);

    StrHelper(object_id_t objectId);
    virtual ~StrHelper();

    ReturnValue_t initialize() override;
    ReturnValue_t performOperation(uint8_t operationCode = 0) override;

    ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_);
    void setComCookie(CookieIF* comCookie_);

    /**
     * @brief   Starts sequence to upload image to star tracker
     *
     * @param uploadImage_  Name including absolute path of the image to upload. Must be previously
     *                      transferred to the OBC with the CFDP protocol.
     */
    ReturnValue_t startImageUpload(std::string uploadImage_);

    /**
     * @brief   Calling this function initiates the download of an image from the star tracker.
     *
     * @param path  Path where downloaded image will be stored
     */
    ReturnValue_t startImageDownload(std::string path);

    /**
     * @brief   Starts the flash write procedure
     *
     * @param fullname             Full name including absolute path of file to write to flash
     * @param region               Region ID of flash region to write to
     * @param address              Start address of flash write procedure
     */
    ReturnValue_t startFlashWrite(std::string fullname, uint8_t region, uint32_t address);

    /**
     * @brief   Starts the flash read procedure
     *
     * @param path                 Path where file with read flash data will be created
     * @param region               Region ID of flash region to read from
     * @param address    Start address of flash section to read
     * @param length               Number of bytes to read from flash
     */
    ReturnValue_t startFlashRead(std::string path, uint8_t region, uint32_t address,
            uint32_t length);

    /**
     * @brief   Starts the download of the FPGA image
     *
     * @param path          The path where the file with the downloaded data will be created
     * @param startPosition Offset in fpga image to read from
     * @param length        Number of bytes to dwonload from the FPGA image
     *
     */
    ReturnValue_t startFpgaDownload(std::string path, uint32_t startPosition, uint32_t length);

    /**
     * @brief   Starts upload of new image to FPGA
     *
     * @param uploadFile      Full name of file containing FPGA image data
     */
    ReturnValue_t startFpgaUpload(std::string uploadFile);

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

    /**
     * @brief   Changes the dafault name of downloaded images
     */
    void setDownloadImageName(std::string filename);

    /**
     * @brief   Sets the name of the file which will be created to store the data read from flash
     */
    void setFlashReadFilename(std::string filename);

    /**
     * @brief   Set download FPGA image name
     */
    void setDownloadFpgaImage(std::string filename);

private:

    static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER;

    //! [EXPORT] : [COMMENT] SD card specified in path string not mounted
    static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0xA0);
    //! [EXPORT] : [COMMENT] Specified file does not exist on filesystem
    static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xA1);
    //! [EXPORT] : [COMMENT] Specified path does not exist
    static const ReturnValue_t PATH_NOT_EXISTS = MAKE_RETURN_CODE(0xA2);
    //! [EXPORT] : [COMMENT] Failed to create download image or read flash file
    static const ReturnValue_t FILE_CREATION_FAILED = MAKE_RETURN_CODE(0xA3);
    //! [EXPORT] : [COMMENT] Region in flash write/read reply does not match expected region
    static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(0xA4);
    //! [EXPORT] : [COMMENT] Address in flash write/read reply does not match expected address
    static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xA5);
    //! [EXPORT] : [COMMENT] Length in flash write/read reply does not match expected length
    static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(0xA6);
    //! [EXPORT] : [COMMENT] Status field in reply signals error
    static const ReturnValue_t STATUS_ERROR = MAKE_RETURN_CODE(0xA7);
    //! [EXPORT] : [COMMENT] Reply has invalid type ID (should be of action reply type)
    static const ReturnValue_t INVALID_TYPE_ID = MAKE_RETURN_CODE(0xA8);

    // Size of one image part which can be sent per action request
    static const size_t SIZE_IMAGE_PART = 1024;

    class ImageDownload {
    public:
        static const uint32_t LAST_POSITION = 4095;
    };

    class FpgaDownload {
    public:
        static const uint16_t MAX_DATA = 1024;
        static const uint8_t DATA_OFFSET = 10;
        // Start position of fpga image part to download
        uint32_t startPosition = 0;
        // Length of image part to download
        uint32_t length = 0;
        // Path where downloaded FPGA image will be stored
        std::string path;
        // Name of file containing downloaded FPGA image
        std::string fileName = "fpgaimage.bin";
    };
    FpgaDownload fpgaDownload;

    class FpgaUpload {
    public:
        static const uint32_t MAX_DATA = 1024;
        // Full name of file to upload
        std::string uploadFile;
    };
    FpgaUpload fpgaUpload;

    static const uint32_t MAX_POLLS = 10000;

    static const uint8_t ACTION_DATA_OFFSET = 2;
    static const uint8_t POS_OFFSET = 2;
    static const uint8_t IMAGE_DATA_OFFSET = 5;
    static const uint8_t FLASH_READ_DATA_OFFSET = 8;
    static const uint8_t REGION_OFFSET = 2;
    static const uint8_t ADDRESS_OFFSET = 3;
    static const uint8_t LENGTH_OFFSET = 7;
    static const size_t IMAGE_DATA_SIZE = 1024;
    static const size_t MAX_FLASH_DATA = 1024;
    static const size_t CONFIG_MAX_DOWNLOAD_RETRIES = 3;

    enum class InternalState {
        IDLE,
        UPLOAD_IMAGE,
        DOWNLOAD_IMAGE,
        FLASH_WRITE,
        FLASH_READ,
        DOWNLOAD_FPGA_IMAGE,
        UPLOAD_FPGA_IMAGE
    };

    InternalState internalState = InternalState::IDLE;

    ArcsecDatalinkLayer datalinkLayer;

    BinarySemaphore semaphore;

    class UploadImage {
    public:
        // Name including absolute path of image to upload
        std::string uploadFile;
    };
    UploadImage uploadImage;

    class DownloadImage {
    public:
        // Path where the downloaded image will be stored
        std::string path;
        // Default name of downloaded image, can be changed via command
        std::string filename = "image.bin";
    };
    DownloadImage downloadImage;

    class FlashWrite {
    public:
        // File which contains data to write when executing the flash write command
        std::string fullname;
        // Will be set with the flash write command
        uint8_t region = 0;
        // Will be set with the flash write command and specifies the start address where to write the
        // flash data to
        uint32_t address = 0;
    };
    FlashWrite flashWrite;

    class FlashRead {
    public:
        // Path where the file containing the read data will be stored
        std::string path = "";
        // Default name of file containing the data read from flash, can be changed via command
        std::string filename = "flashread.bin";
        // Will be set with the flash read command
        uint8_t region = 0;
        // Will be set with the flash read command and specifies the start address of the flash section
        // to read
        uint32_t address = 0;
        // Number of bytes to read from flash
        uint32_t size = 0;
    };
    FlashRead flashRead;

    SdCardManager* sdcMan = nullptr;

    uint8_t commandBuffer[StarTracker::MAX_FRAME_SIZE];

    bool terminate = false;

    /**
     * UART communication object responsible for low level access of star tracker
     * Must be set by star tracker handler
     */
    UartComIF* uartComIF = nullptr;
    // Communication cookie. Must be set by the star tracker handler
    CookieIF* comCookie = nullptr;

    // Queue id of raw data receiver
    MessageQueueId_t rawDataReceiver = MessageQueueIF::NO_QUEUE;

    /**
     * @brief   Performs image uploading
     */
    ReturnValue_t performImageUpload();

    /**
     * @brief   Performs download of last taken image from the star tracker.
     *
     * @details Download is split over multiple packets transporting each a maximum of 1024 bytes.
     *          In case the download of one position fails, the same packet will be again
     *          requested. If the download of the packet fails CONFIG_MAX_DOWNLOAD_RETRIES times,
     *          the download will be stopped.
     */
    ReturnValue_t performImageDownload();

    /**
     * @brief   Handles flash write procedure
     *
     * @return RETURN_OK if successful, otherwise RETURN_FAILED
     */
    ReturnValue_t performFlashWrite();

    /**
     * @brief   Sends a sequence of commands to the star tracker to read larger parts from the
     *          flash memory.
     */
    ReturnValue_t performFlashRead();

    /**
     * @brief   Performs the download of the FPGA image which requires to be slip over multiple
     *          action requests.
     */
    ReturnValue_t performFpgaDownload();

    /**
     * @brief   Performs upload of new FPGA image. Upload sequence split over multiple commands
     *          because one command can only transport 1024 bytes of image data.
     */
    ReturnValue_t performFpgaUpload();

    /**
     * @brief   Sends packet to the star tracker and reads reply by using the communication
     *          interface
     *
     * @param size        Size of data beforehand written to the commandBuffer
     * @param parameter   Parameter 2 of trigger event function
     *
     * @return  RETURN_OK if successful, otherwise RETURN_FAILED
     */
    ReturnValue_t sendAndRead(size_t size, uint32_t parameter);

    /**
     * @brief   Checks the header (type id and status fields) of the action reply
     *
     * @return  RETURN_OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED
     */
    ReturnValue_t checkActionReply();

    /**
     * @brief   Checks the position field in a star tracker upload/download reply.
     *
     * @param expectedPosition  Value of expected position
     *
     * @return RETURN_OK if received position matches expected position, otherwise RETURN_FAILED
     */
    ReturnValue_t checkReplyPosition(uint32_t expectedPosition);

    /**
     * @brief   Checks the region, address and length value of a flash write or read reply.
     *
     * @return  RETURN_OK if values match expected values, otherwise appropriate error return
     *          value.
     */
    ReturnValue_t checkFlashActionReply(uint8_t region_, uint32_t address_, uint16_t length_);

    /**
     * @brief   Checks the reply to the fpga download and upload request
     *
     * @param expectedPosition  The expected position value in the reply
     * @param expectedLength    The expected length field in the reply
     */
    ReturnValue_t checkFpgaActionReply(uint32_t expectedPosition, uint32_t expectedLength);

    /**
     * @brief   Checks if a path points to an sd card and whether the SD card is monuted.
     *
     * @return  SD_NOT_MOUNTED id SD card is not mounted, otherwise RETURN_OK
     */
    ReturnValue_t checkPath(std::string name);
};

#endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */