#ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ #define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ #include #include #include #include "OBSWConfig.h" #include "devices/powerSwitcherList.h" #include "fsfw/devicehandlers/DeviceHandlerBase.h" #include "fsfw/timemanager/Countdown.h" #include "fsfw_hal/linux/gpio/Gpio.h" #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h" #include "fsfw_hal/linux/serial/SerialComIF.h" #ifdef XIPHOS_Q7S #include "bsp_q7s/fs/SdCardManager.h" #endif using supv::ExecutionReport; using supv::TcBase; static constexpr bool DEBUG_PLOC_SUPV = true; /** * @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. On 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, CookieIF* comCookie, Gpio uartIsolatorSwitch, power::Switch_t powerSwitch, PlocSupvUartManager& supvHelper); virtual ~PlocSupervisorHandler(); virtual ReturnValue_t initialize() override; void performOperationHook() override; ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, const uint8_t* data, size_t size) 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; 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; void doOffActivity() override; private: 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] Unhandled event. P1: APID, P2: Service ID static constexpr Event SUPV_UNKNOWN_TM = MAKE_EVENT(2, severity::LOW); static constexpr Event SUPV_UNINIMPLEMENTED_TM = MAKE_EVENT(3, severity::LOW); //! [EXPORT] : [COMMENT] PLOC supervisor received acknowledgment failure report static const Event SUPV_ACK_FAILURE = MAKE_EVENT(4, severity::LOW); //! [EXPORT] : [COMMENT] PLOC received execution failure report //! P1: ID of command for which the execution failed //! P2: Status code sent by the supervisor handler static const Event SUPV_EXE_FAILURE = MAKE_EVENT(5, severity::LOW); //! [EXPORT] : [COMMENT] PLOC supervisor reply has invalid crc static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(6, severity::LOW); //! [EXPORT] : [COMMENT] Supervisor helper currently executing a command static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(7, severity::LOW); //! [EXPORT] : [COMMENT] Failed to build the command to shutdown the MPSoC static const Event SUPV_MPSOC_SHUTDOWN_BUILD_FAILED = MAKE_EVENT(8, severity::LOW); static const uint16_t APID_MASK = 0x7FF; static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF; static const uint8_t EXE_STATUS_OFFSET = 10; static const uint8_t SIZE_NULL_TERMINATOR = 1; // 5 s static const uint32_t EXECUTION_DEFAULT_TIMEOUT = 5000; // 70 S static const uint32_t ACKNOWLEDGE_DEFAULT_TIMEOUT = 70000; // 60 s static const uint32_t MRAM_DUMP_EXECUTION_TIMEOUT = 60000; // 70 s static const uint32_t COPY_ADC_TO_MRAM_TIMEOUT = 70000; // 60 s static const uint32_t MRAM_DUMP_TIMEOUT = 60000; // 4 s static const uint32_t BOOT_TIMEOUT = 4000; enum class StartupState : uint8_t { OFF, BOOTING, SET_TIME, WAIT_FOR_TIME_REPLY, TIME_WAS_SET, ON }; static constexpr bool SET_TIME_DURING_BOOT = true; StartupState startupState = StartupState::OFF; uint8_t commandBuffer[supv::MAX_COMMAND_SIZE]; SpacePacketCreator creator; supv::TcParams spParams = supv::TcParams(creator); /** * 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 = supv::NONE; SerialComIF* uartComIf = nullptr; LinuxLibgpioIF* gpioComIF = nullptr; Gpio uartIsolatorSwitch; bool shutdownCmdSent = false; supv::HkSet hkset; supv::BootStatusReport bootStatusReport; supv::LatchupStatusReport latchupStatusReport; supv::LoggingReport loggingReport; supv::AdcReport adcReport; const power::Switch_t powerSwitch = power::NO_SWITCH; supv::TmBase tmReader; PlocSupvUartManager& uartManager; MessageQueueIF* eventQueue = nullptr; /** 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; /** This buffer is used to concatenate space packets received in two different read steps */ uint8_t spacePacketBuffer[supv::MAX_PACKET_SIZE]; #ifdef XIPHOS_Q7S SdCardManager* sdcMan = nullptr; #endif // Path to supervisor specific files on SD card std::string supervisorFilePath = "ploc/supervisor"; std::string activeMramFile; Countdown executionReportTimeout = Countdown(EXECUTION_DEFAULT_TIMEOUT, false); Countdown acknowledgementReportTimeout = Countdown(ACKNOWLEDGE_DEFAULT_TIMEOUT, false); // Vorago nees some time to boot properly Countdown bootTimeout = Countdown(BOOT_TIMEOUT); Countdown mramDumpTimeout = Countdown(MRAM_DUMP_TIMEOUT); PoolEntry fmcStateEntry = PoolEntry(1); PoolEntry bootStateEntry = PoolEntry(1); PoolEntry bootCyclesEntry = PoolEntry(1); PoolEntry tempSupEntry = PoolEntry(1); /** * @brief Adjusts the timeout of the execution report dependent on command */ void setExecutionTimeout(DeviceCommandId_t command); void handlePacketPrint(); /** * @brief Handles event messages received from the supervisor helper */ void handleEvent(EventMessage* eventMessage); ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches); /** * @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 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 returnvalue::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); void handleBadApidServiceCombination(Event result, unsigned int apid, unsigned int serviceId); ReturnValue_t handleAdcReport(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. */ ReturnValue_t prepareEmptyCmd(uint16_t apid, uint8_t serviceId); /** * @brief This function initializes the space packet to select the boot image of the MPSoC. */ ReturnValue_t prepareSelBootImageCmd(const uint8_t* commandData); ReturnValue_t 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. */ ReturnValue_t prepareSetBootTimeoutCmd(const uint8_t* commandData); ReturnValue_t prepareRestartTriesCmd(const uint8_t* commandData); ReturnValue_t prepareFactoryResetCmd(const uint8_t* commandData, size_t len); /** * @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 prepareSetAlertLimitCmd(const uint8_t* commandData); ReturnValue_t prepareSetAdcEnabledChannelsCmd(const uint8_t* commandData); ReturnValue_t prepareSetAdcWindowAndStrideCmd(const uint8_t* commandData); ReturnValue_t prepareSetAdcThresholdCmd(const uint8_t* commandData); ReturnValue_t prepareRunAutoEmTest(const uint8_t* commandData); ReturnValue_t prepareWipeMramCmd(const uint8_t* commandData); ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData); ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData); /** * @brief Copies the content of a space packet to the command buffer. */ void finishTcPrep(TcBase& tc); /** * @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(); void disableReply(DeviceCommandId_t replyId); /** * @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 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 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); ReturnValue_t prepareSetShutdownTimeoutCmd(const uint8_t* commandData); ReturnValue_t extractUpdateCommand(const uint8_t* commandData, size_t size, supv::UpdateParams& params); ReturnValue_t extractBaseParams(const uint8_t** commandData, size_t& remSize, supv::UpdateParams& params); ReturnValue_t eventSubscription(); ReturnValue_t handleExecutionSuccessReport(ExecutionReport& report); void handleExecutionFailureReport(ExecutionReport& report); void printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId); pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER); ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode, uint32_t* msToReachTheMode) override; }; #endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */