#ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ #define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ #include #include #include #include #include #include #include "fsfw/action/CommandActionHelper.h" #include "fsfw/action/CommandsActionsIF.h" #include "fsfw/devicehandlers/DeviceHandlerBase.h" #include "fsfw/ipc/QueueFactory.h" #include "fsfw/tmtcservices/SourceSequenceCounter.h" #include "fsfw_hal/linux/gpio/Gpio.h" #include "fsfw_hal/linux/serial/SerialComIF.h" static constexpr bool DEBUG_MPSOC_COMMUNICATION = false; /** * @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. * * NOTE: This is not an example for a good device handler, DO NOT USE THIS AS A REFERENCE HANDLER. * @author J. Meier, R. Mueller */ 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, PlocMpsocSpecialComHelper* 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; ReturnValue_t doSendReadHook() override; LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override; bool dontCheckQueue() 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); //! [EXPORT] : [COMMENT] SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for //! ON transition. static constexpr Event SUPV_NOT_ON = event::makeEvent(SUBSYSTEM_ID, 7, severity::LOW); static constexpr Event SUPV_REPLY_TIMEOUT = event::makeEvent(SUBSYSTEM_ID, 8, severity::LOW); static const uint16_t APID_MASK = 0x7FF; static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF; mpsoc::HkReport hkReport; Countdown mpsocBootTransitionCd = Countdown(6500); Countdown supvTransitionCd = Countdown(3000); MessageQueueIF* eventQueue = nullptr; MessageQueueIF* commandActionHelperQueue = nullptr; SourceSequenceCounter sequenceCount = SourceSequenceCounter(0); uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE]; SpacePacketCreator creator; ploc::SpTcParams spParams = ploc::SpTcParams(creator); PoolEntry peStatus = PoolEntry(); PoolEntry peMode = PoolEntry(); PoolEntry peDownlinkPwrOn = PoolEntry(); PoolEntry peDownlinkReplyActive = PoolEntry(); PoolEntry peDownlinkJesdSyncStatus = PoolEntry(); PoolEntry peDownlinkDacStatus = PoolEntry(); PoolEntry peCameraStatus = PoolEntry(); PoolEntry peCameraSdiStatus = PoolEntry(); PoolEntry peCameraFpgaTemp = PoolEntry(); PoolEntry peCameraSocTemp = PoolEntry(); PoolEntry peSysmonTemp = PoolEntry(); PoolEntry peSysmonVccInt = PoolEntry(); PoolEntry peSysmonVccAux = PoolEntry(); PoolEntry peSysmonVccBram = PoolEntry(); PoolEntry peSysmonVccPaux = PoolEntry(); PoolEntry peSysmonVccPint = PoolEntry(); PoolEntry peSysmonVccPdro = PoolEntry(); PoolEntry peSysmonMb12V = PoolEntry(); PoolEntry peSysmonMb3V3 = PoolEntry(); PoolEntry peSysmonMb1V8 = PoolEntry(); PoolEntry peSysmonVcc12V = PoolEntry(); PoolEntry peSysmonVcc5V = PoolEntry(); PoolEntry peSysmonVcc3V3 = PoolEntry(); PoolEntry peSysmonVcc3V3VA = PoolEntry(); PoolEntry peSysmonVcc2V5DDR = PoolEntry(); PoolEntry peSysmonVcc1V2DDR = PoolEntry(); PoolEntry peSysmonVcc0V9 = PoolEntry(); PoolEntry peSysmonVcc0V6VTT = PoolEntry(); PoolEntry peSysmonSafeCotsCur = PoolEntry(); PoolEntry peSysmonNvm4XoCur = PoolEntry(); PoolEntry peSemUncorrectableErrs = PoolEntry(); PoolEntry peSemCorrectableErrs = PoolEntry(); PoolEntry peSemStatus = PoolEntry(); PoolEntry peRebootMpsocRequired = PoolEntry(); /** * 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; SerialComIF* uartComIf = nullptr; PlocMpsocSpecialComHelper* specialComHelper = 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 specialComHelperExecuting = false; bool commandIsPending = false; struct TmMemReadReport { static const uint8_t FIX_SIZE = 14; size_t rememberRequestedSize = 0; }; TmMemReadReport tmMemReadReport; Countdown cmdCountdown = Countdown(10000); struct TelemetryBuffer { uint16_t length = 0; uint8_t buffer[mpsoc::SP_MAX_SIZE]; }; size_t foundPacketLen = 0; TelemetryBuffer tmBuffer; enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE; enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE }; PowerState powerState = PowerState::IDLE; uint8_t skipSupvCommandingToOn = false; /** * @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 prepareTcGetHkReport(); ReturnValue_t prepareTcGetDirContent(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t prepareTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t prepareTcModeIdle(); ReturnValue_t prepareTcCamTakePic(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t prepareTcSimplexSendFile(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t prepareTcDownlinkDataModulate(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t prepareTcModeSnapshot(); ReturnValue_t finishTcPrep(mpsoc::TcBase& tcBase); /** * @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 returnvalue::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 returnvalue::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 returnvalue::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 returnvalue::OK if successful, otherwise an error code. */ ReturnValue_t handleMemoryReadReport(const uint8_t* data); ReturnValue_t handleGetHkReport(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(); ReturnValue_t prepareTcModeReplay(); void cmdDoneHandler(bool success, ReturnValue_t result); bool handleHwStartup(); bool handleHwShutdown(); void stopSpecialComHelper(); void handleActionCommandFailure(ActionId_t actionId); pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER); ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode, uint32_t* msToReachTheMode) override; ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues, uint16_t startAtIndex) override; }; #endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */