#ifndef MISSION_DEVICES_PLOCMPSOCHANDLER_H_ #define MISSION_DEVICES_PLOCMPSOCHANDLER_H_ #include #include #include /** * @brief This is the device handler for the MPSoC which is programmed by the ILH of the * university of stuttgart. * * @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 PlocMPSoCHandler : public DeviceHandlerBase { public: PlocMPSoCHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie); virtual ~PlocMPSoCHandler(); /** * @brief Sets mode to MODE_NORMAL. Can be used for debugging. */ void setModeNormal(); 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_MPSOC_HANDLER; //! Space Packet received from PLOC has invalid CRC static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0); //! Received ACK failure reply from PLOC static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1); //! Received execution failure reply from PLOC static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2); //! Received space packet with invalid APID from PLOC static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3); static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER; //! PLOC crc failure in telemetry packet static const Event MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW); //! PLOC receive acknowledgment failure report static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW); //! PLOC receive execution failure report static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW); //! PLOC reply has invalid crc static const Event 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_MPSOC::MAX_COMMAND_SIZE]; /** * @brief This object is incremented each time a packet is sent or received. By checking the * packet sequence count of a received packet, no packets can be lost without noticing * it. Only the least significant 14 bits represent the packet sequence count in a * space packet. Thus the maximum value amounts to 16383 (0x3FFF). * @note Normally this should never happen because the PLOC replies are always sent in a * fixed order. However, the PLOC software checks this value and will return an ACK * failure report in case the sequence count is not incremented with each transferred * space packet. */ uint16_t packetSequenceCount = 0x3FFF; /** * 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_MPSOC::NONE; /** * @brief This function fills the commandBuffer to initiate the write memory command. * * @param commandData Pointer to action command data. * @param commanDataLen Size of command data in bytes. * * @return RETURN_OK if successful, else RETURN_FAILURE. */ ReturnValue_t prepareTcMemWriteCommand(const uint8_t* commandData, size_t commandDataLen); /** * @brief This function fills the commandBuffer to initiate the write reads command. * * @param commandData Pointer to action command data. * @param commanDataLen Size of command data in bytes. * * @return RETURN_OK if successful, else RETURN_FAILURE. */ ReturnValue_t prepareTcMemReadCommand(const uint8_t* commandData, size_t commandDataLen); /** * @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(); /** * @brief This function checks and increments the packet sequence count of a received space * packet. * * @param data Pointer to a space packet. * * @return RETURN_OK if successful * * @details There should be never a case in which a wrong packet sequence count is received * because the communication scheme between PLOC and OBC always follows a strict * procedure. Thus this function mainly serves for debugging purposes to detected an * invalid handling of the packet sequence count. */ ReturnValue_t checkPacketSequenceCount(const uint8_t* data); }; #endif /* MISSION_DEVICES_PLOCMPSOCHANDLER_H_ */