#ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ #define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ #include #include "PlocMPSoCHelper.h" #include "fsfw/action/CommandActionHelper.h" #include "fsfw/action/CommandsActionsIF.h" #include "fsfw/devicehandlers/DeviceHandlerBase.h" #include "fsfw/ipc/QueueFactory.h" #include "fsfw/tmtcpacket/SpacePacket.h" #include "fsfw/tmtcservices/SourceSequenceCounter.h" #include "fsfw_hal/linux/gpio/Gpio.h" #include "fsfw_hal/linux/uart/UartComIF.h" #include "linux/devices/devicedefinitions/MPSoCReturnValuesIF.h" #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h" #include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h" /** * @brief This is the device handler for the MPSoC of the payload computer. * * @details The PLOC uses the space packet protocol for communication. Each command will be * answered 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 otherwise the MPSoC will reply with an acknowledgment failure report. * * @author J. Meier */ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF { public: /** * @brief Constructor * * @param ojectId Object ID of the MPSoC handler * @param uartcomIFid Object ID of the UART communication interface * @param comCookie UART communication cookie * @param plocMPSoCHelper Pointer to MPSoC helper object * @param uartIsolatorSwitch Gpio object representing the GPIO connected to the UART isolator * module in the programmable logic * @param supervisorHandler Object ID of the supervisor handler */ PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie, PlocMPSoCHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch, object_id_t supervisorHandler); 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; MessageQueueIF* getCommandQueuePtr() override; void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) override; void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) override; void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) override; void completionSuccessfulReceived(ActionId_t actionId) override; void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) 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; virtual ReturnValue_t doSendReadHook() 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 //! P1: Command Id which leads the acknowledgment failure report //! P2: The status field inserted by the MPSoC into the data field static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW); //! [EXPORT] : [COMMENT] PLOC receive execution failure report //! P1: Command Id which leads the execution failure report //! P2: The status field inserted by the MPSoC into the data field 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_SEQUENCE_COUNT_MISMATCH = MAKE_EVENT(5, severity::LOW); //! [EXPORT] : [COMMENT] Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and //! thus also to shutdown the supervisor. static const Event MPSOC_SHUTDOWN_FAILED = MAKE_EVENT(6, severity::HIGH); 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; MessageQueueIF* commandActionHelperQueue = nullptr; // Initiate the sequence count with the maximum value. It is incremented before // a packet is sent, so the first value will be 0 accordingly using // the wrap around of the counter. SourceSequenceCounter sequenceCount = SourceSequenceCounter(SpacePacketBase::LIMIT_SEQUENCE_COUNT - 1); 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; Gpio uartIsolatorSwitch; object_id_t supervisorHandler = 0; CommandActionHelper commandActionHelper; // Used to block incoming commands when MPSoC helper class is currently executing a command bool plocMPSoCHelperExecuting = false; struct TmMemReadReport { static const uint8_t FIX_SIZE = 14; size_t rememberRequestedSize = 0; }; TmMemReadReport tmMemReadReport; struct TmCamCmdRpt { size_t rememberSpacePacketSize = 0; }; TmCamCmdRpt tmCamCmdRpt; struct TelemetryBuffer { uint16_t length = 0; uint8_t buffer[SpacePacket::PACKET_MAX_SIZE]; }; TelemetryBuffer tmBuffer; enum class PowerState { OFF, BOOTING, SHUTDOWN, ON }; PowerState powerState = PowerState::OFF; /** * @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); ReturnValue_t prepareTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t prepareTcModeIdle(); /** * @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); ReturnValue_t handleCamCmdRpt(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(); uint16_t getStatus(const uint8_t* data); void handleActionCommandFailure(ActionId_t actionId); }; #endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */