#ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ #define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ #include "OBSWconfig.h" #include #include #include #include /** * @brief This is the device handler for the supervisor of the PLOC which is programmed by * Thales. * * @details The PLOC uses the space packet protocol for communication. To 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_Commands * ILH ICD: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/ * Arbeitsdaten/08_Used%20Components/PLOC&fileid=940960 * @author J. Meier */ class PlocSupervisorHandler: public DeviceHandlerBase { public: PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF * comCookie); virtual ~PlocSupervisorHandler(); virtual ReturnValue_t initialize() 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 INTERFACE_ID = CLASS_ID::PLOC_SUPERVISOR_HANDLER; //! [EXPORT] : [COMMENT] Space Packet received from PLOC supervisor has invalid CRC static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0); //! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC supervisor static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1); //! [EXPORT] : [COMMENT] Received execution failure reply from PLOC supervisor static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2); //! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC supervisor static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3); //! [EXPORT] : [COMMENT] Failed to read current system time static const ReturnValue_t GET_TIME_FAILURE = MAKE_RETURN_CODE(0xA4); //! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT static const ReturnValue_t INVALID_WATCHDOG = MAKE_RETURN_CODE(0xA5); //! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms. static const ReturnValue_t INVALID_WATCHDOG_TIMEOUT = MAKE_RETURN_CODE(0xA6); //! [EXPORT] : [COMMENT] Received latchup config command with invalid latchup ID static const ReturnValue_t INVALID_LATCHUP_ID = MAKE_RETURN_CODE(0xA7); //! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be larger than 21. static const ReturnValue_t SWEEP_PERIOD_TOO_SMALL = MAKE_RETURN_CODE(0xA8); //! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1 and 2. static const ReturnValue_t INVALID_TEST_PARAM = MAKE_RETURN_CODE(0xA9); //! [EXPORT] : [COMMENT] Returned when scanning for MRAM dump packets failed. static const ReturnValue_t MRAM_PACKET_PARSING_FAILURE = MAKE_RETURN_CODE(0xAA); //! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM wipe commands are invalid (e.g. start address bigger than stop address) static const ReturnValue_t INVALID_MRAM_ADDRESSES = MAKE_RETURN_CODE(0xAB); //! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with other apid. static const ReturnValue_t NO_MRAM_PACKET = MAKE_RETURN_CODE(0xAC); //! [EXPORT] : [COMMENT] Path to PLOC directory on SD card does not exist static const ReturnValue_t PATH_DOES_NOT_EXIST = MAKE_RETURN_CODE(0xAD); //! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet. static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAE); static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER; //! [EXPORT] : [COMMENT] PLOC supervisor crc failure in telemetry packet static const Event SUPV_MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW); //! [EXPORT] : [COMMENT] PLOC supervisor received acknowledgment failure report static const Event SUPV_ACK_FAILURE = MAKE_EVENT(2, severity::LOW); //! [EXPORT] : [COMMENT] PLOC received execution failure report static const Event SUPV_EXE_FAILURE = MAKE_EVENT(3, severity::LOW); //! [EXPORT] : [COMMENT] PLOC supervisor reply has invalid crc static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(4, severity::LOW); static const uint16_t APID_MASK = 0x7FF; static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF; uint8_t commandBuffer[PLOC_SPV::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 = PLOC_SPV::NONE; UartComIF* uartComIf = nullptr; PLOC_SPV::HkSet hkset; PLOC_SPV::BootStatusReport bootStatusReport; PLOC_SPV::LatchupStatusReport latchupStatusReport; /** Number of expected replies following the MRAM dump command */ uint32_t expectedMramDumpPackets = 0; uint32_t receivedMramDumpPackets = 0; /** Set to true as soon as a complete space packet is present in the spacePacketBuffer */ bool packetInBuffer = false; /** Points to the next free position in the space packet buffer */ uint16_t bufferTop = 0; /** This buffer is used to concatenate space packets received in two different read steps */ uint8_t spacePacketBuffer[PLOC_SPV::MAX_PACKET_SIZE]; #if BOARD_TE0720 == 0 SdCardManager* sdcMan = nullptr; #endif /* BOARD_TE0720 == 0 */ /** Path to PLOC specific files on SD card */ std::string plocFilePath = "ploc"; std::string activeMramFile; /** Setting this variable to true will enable direct downlink of MRAM packets */ bool downlinkMramDump = false; /** * @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 housekeeping report. This means verifying the CRC of the * reply and filling the appropriate dataset. * * @param data Pointer to the data buffer holding the housekeeping read report. * * @return RETURN_OK if successful, otherwise an error code. */ ReturnValue_t handleHkReport(const uint8_t* data); /** * @brief This function calls the function to check the CRC of the received boot status report * and fills the associated dataset with the boot status information. */ ReturnValue_t handleBootStatusReport(const uint8_t* data); ReturnValue_t handleLatchupStatusReport(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 This function prepares a space packet which does not transport any data in the * packet data field apart from the crc. */ void prepareEmptyCmd(uint16_t apid); /** * @brief This function initializes the space packet to select the boot image of the MPSoC. */ void prepareSelBootImageCmd(const uint8_t * commandData); void prepareDisableHk(); /** * @brief This function fills the commandBuffer with the data to update the time of the * PLOC supervisor. */ ReturnValue_t prepareSetTimeRefCmd(); /** * @brief This function fills the commandBuffer with the data to change the boot timeout * value in the PLOC supervisor. */ void prepareSetBootTimeoutCmd(const uint8_t * commandData); void prepareRestartTriesCmd(const uint8_t * commandData); /** * @brief This function fills the command buffer with the packet to enable or disable the * watchdogs on the PLOC. */ void prepareWatchdogsEnableCmd(const uint8_t * commandData); /** * @brief This function fills the command buffer with the packet to set the watchdog timer * of one of the three watchdogs (PS, PL, INT). */ ReturnValue_t prepareWatchdogsConfigTimeoutCmd(const uint8_t * commandData); ReturnValue_t prepareLatchupConfigCmd(const uint8_t* commandData, DeviceCommandId_t deviceCommand); ReturnValue_t prepareAutoCalibrateAlertCmd(const uint8_t* commandData); ReturnValue_t prepareSetAlertLimitCmd(const uint8_t* commandData); ReturnValue_t prepareSetAlertIrqFilterCmd(const uint8_t* commandData); ReturnValue_t prepareSetAdcSweetPeriodCmd(const uint8_t* commandData); void prepareSetAdcEnabledChannelsCmd(const uint8_t* commandData); void prepareSetAdcWindowAndStrideCmd(const uint8_t* commandData); void prepareSetAdcThresholdCmd(const uint8_t* commandData); void prepareEnableNvmsCmd(const uint8_t* commandData); void prepareSelectNvmCmd(const uint8_t* commandData); ReturnValue_t prepareRunAutoEmTest(const uint8_t* commandData); ReturnValue_t prepareWipeMramCmd(const uint8_t* commandData); ReturnValue_t prepareDumpMramCmd(const uint8_t* commandData); void preparePrintCpuStatsCmd(const uint8_t* commandData); void prepareSetDbgVerbosityCmd(const uint8_t* commandData); void prepareSetGpioCmd(const uint8_t* commandData); void prepareReadGpioCmd(const uint8_t* commandData); /** * @brief Copies the content of a space packet to the command buffer. */ void packetToOutBuffer(uint8_t* packetData, size_t fullSize); /** * @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(); /** * @brief Function is called in scanForReply and fills the spacePacketBuffer with the read * data until a full packet has been received. */ ReturnValue_t parseMramPackets(const uint8_t *packet, size_t remainingSize, size_t* foundlen); /** * @brief This function generates the Service 8 packets for the MRAM dump data. */ ReturnValue_t handleMramDumpPacket(DeviceCommandId_t id); /** * @brief With this function the number of expected replies following an MRAM dump command * will be increased. This is necessary to release the command in case not all replies * have been received. */ void increaseExpectedMramReplies(DeviceCommandId_t id); /** * @brief Function checks if the packet written to the space packet buffer is really a * MRAM dump packet. */ ReturnValue_t checkMramPacketApid(); /** * @brief Writes the data of the MRAM dump to a file. The file will be created when receiving * the first packet. */ ReturnValue_t handleMramDumpFile(DeviceCommandId_t id); /** * @brief Extracts the length field of a spacePacket referenced by the spacePacket pointer. * * @param spacePacket Pointer to the buffer holding the space packet. * * @return The value stored in the length field of the data field. */ uint16_t readSpacePacketLength(uint8_t* spacePacket); /** * @brief Extracts the sequence flags from a space packet referenced by the spacePacket * pointer. * * @param spacePacket Pointer to the buffer holding the space packet. * * @return uint8_t where the two least significant bits hold the sequence flags. */ uint8_t readSequenceFlags(uint8_t* spacePacket); ReturnValue_t createMramDumpFile(); ReturnValue_t getTimeStampString(std::string& timeStamp); }; #endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */