#ifndef BSP_Q7S_DEVICES_STRHELPER_H_ #define BSP_Q7S_DEVICES_STRHELPER_H_ #include #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] 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; /** * @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); }; #endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */