eive-obsw/linux/devices/ploc/PlocSupervisorHandler.h

377 lines
15 KiB
C
Raw Normal View History

#ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
#define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
2021-03-29 14:37:52 +02:00
2022-03-28 13:54:46 +02:00
#include "OBSWConfig.h"
2022-04-30 16:21:59 +02:00
#include "PlocSupvHelper.h"
2022-03-27 14:42:20 +02:00
#include "bsp_q7s/memory/SdCardManager.h"
2022-03-28 13:54:46 +02:00
#include "devices/powerSwitcherList.h"
2022-03-27 14:42:20 +02:00
#include "fsfw/devicehandlers/DeviceHandlerBase.h"
2022-04-30 16:21:59 +02:00
#include "fsfw/timemanager/Countdown.h"
2022-03-28 09:08:11 +02:00
#include "fsfw_hal/linux/gpio/Gpio.h"
2022-03-28 13:54:46 +02:00
#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
#include "fsfw_hal/linux/uart/UartComIF.h"
2022-03-28 09:08:11 +02:00
#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
2022-04-10 18:46:39 +02:00
#include "linux/devices/devicedefinitions/SupvReturnValuesIF.h"
2021-03-29 14:37:52 +02:00
/**
* @brief This is the device handler for the supervisor of the PLOC which is programmed by
* Thales.
*
2022-04-10 18:46:39 +02:00
* @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
2021-03-29 14:37:52 +02:00
* @author J. Meier
*/
2022-03-27 13:07:18 +02:00
class PlocSupervisorHandler : public DeviceHandlerBase {
public:
2022-03-27 14:42:20 +02:00
PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
2022-04-10 18:46:39 +02:00
Gpio uartIsolatorSwitch, power::Switch_t powerSwitch,
PlocSupvHelper* supvHelper);
2022-03-27 13:07:18 +02:00
virtual ~PlocSupervisorHandler();
virtual ReturnValue_t initialize() override;
2022-04-10 18:46:39 +02:00
void performOperationHook() override;
ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
const uint8_t* data, size_t size) override;
2022-03-27 13:07:18 +02:00
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;
void doOffActivity() override;
2022-03-27 13:07:18 +02:00
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] PLOC supervisor received acknowledgment failure report
static const Event SUPV_ACK_FAILURE = MAKE_EVENT(2, 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
2022-03-27 13:07:18 +02:00
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);
2022-04-10 18:46:39 +02:00
//! [EXPORT] : [COMMENT] Supervisor helper currently executing a command
static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(5, severity::LOW);
//! [EXPORT] : [COMMENT] Failed to build the command to shutdown the MPSoC
static const Event SUPV_MPSOC_SHUWDOWN_BUILD_FAILED = MAKE_EVENT(5, severity::LOW);
2022-03-27 13:07:18 +02:00
static const uint16_t APID_MASK = 0x7FF;
static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
2022-04-06 17:27:44 +02:00
static const uint8_t EXE_STATUS_OFFSET = 10;
2022-04-10 18:46:39 +02:00
static const uint8_t SIZE_NULL_TERMINATOR = 1;
2022-04-27 16:08:17 +02:00
// 5 s
static const uint32_t EXECUTION_DEFAULT_TIMEOUT = 5000;
2022-05-23 12:05:42 +02:00
// 70 S
static const uint32_t ACKNOWLEDGE_DEFAULT_TIMEOUT = 70000;
2022-05-06 19:34:12 +02:00
// 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;
2022-05-03 14:59:23 +02:00
// 2 s
static const uint32_t BOOT_TIMEOUT = 2000;
2022-05-06 19:53:33 +02:00
enum class StartupState : uint8_t { OFF, BOOTING, SET_TIME, SET_TIME_EXECUTING, ON };
2022-05-03 14:59:23 +02:00
2022-06-03 18:03:25 +02:00
bool setTimeDuringStartup = false;
2022-05-03 14:59:23 +02:00
StartupState startupState = StartupState::OFF;
2022-03-27 13:07:18 +02:00
2022-03-30 09:19:30 +02:00
uint8_t commandBuffer[supv::MAX_COMMAND_SIZE];
2022-03-27 13:07:18 +02:00
/**
* 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.
*/
2022-03-30 09:19:30 +02:00
DeviceCommandId_t nextReplyId = supv::NONE;
2022-03-27 13:07:18 +02:00
UartComIF* uartComIf = nullptr;
2022-03-27 14:42:20 +02:00
LinuxLibgpioIF* gpioComIF = nullptr;
2022-03-28 09:08:11 +02:00
Gpio uartIsolatorSwitch;
2022-03-27 13:07:18 +02:00
2022-03-30 09:19:30 +02:00
supv::HkSet hkset;
supv::BootStatusReport bootStatusReport;
supv::LatchupStatusReport latchupStatusReport;
2022-04-13 11:56:37 +02:00
supv::LoggingReport loggingReport;
2022-04-21 16:30:23 +02:00
supv::AdcReport adcReport;
2022-03-27 13:07:18 +02:00
2022-03-30 09:19:30 +02:00
const power::Switch_t powerSwitch = power::NO_SWITCH;
2022-04-10 18:46:39 +02:00
PlocSupvHelper* supvHelper = nullptr;
MessageQueueIF* eventQueue = nullptr;
2022-03-27 13:07:18 +02:00
/** 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 */
2022-03-30 09:19:30 +02:00
uint8_t spacePacketBuffer[supv::MAX_PACKET_SIZE];
2022-04-10 18:46:39 +02:00
#ifndef TE0720_1CFA
2022-03-27 13:07:18 +02:00
SdCardManager* sdcMan = nullptr;
#endif /* BOARD_TE0720 == 0 */
2021-08-08 15:02:59 +02:00
2022-05-05 08:55:45 +02:00
// Path to supervisor specific files on SD card
std::string supervisorFilePath = "ploc/supervisor";
2022-03-27 13:07:18 +02:00
std::string activeMramFile;
2022-04-10 18:46:39 +02:00
// Supervisor helper class currently executing a command
bool plocSupvHelperExecuting = false;
2022-05-23 12:05:42 +02:00
Countdown executionReportTimeout = Countdown(EXECUTION_DEFAULT_TIMEOUT, false);
Countdown acknowledgementReportTimeout = Countdown(ACKNOWLEDGE_DEFAULT_TIMEOUT, false);
2022-05-03 14:59:23 +02:00
// Vorago nees some time to boot properly
Countdown bootTimeout = Countdown(BOOT_TIMEOUT);
Countdown mramDumpTimeout = Countdown(MRAM_DUMP_TIMEOUT);
2022-04-27 16:08:17 +02:00
/**
* @brief Adjusts the timeout of the execution report dependent on command
*/
void setExecutionTimeout(DeviceCommandId_t command);
2022-04-10 18:46:39 +02:00
/**
* @brief Handles event messages received from the supervisor helper
*/
void handleEvent(EventMessage* eventMessage);
2022-03-28 13:54:46 +02:00
ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches);
2022-03-27 13:07:18 +02:00
/**
* @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);
2022-04-13 11:56:37 +02:00
ReturnValue_t handleLoggingReport(const uint8_t* data);
2022-04-21 16:30:23 +02:00
ReturnValue_t handleAdcReport(const uint8_t* data);
2022-03-27 13:07:18 +02:00
/**
* @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 prepareSetAlertLimitCmd(const uint8_t* commandData);
void prepareSetAdcEnabledChannelsCmd(const uint8_t* commandData);
void prepareSetAdcWindowAndStrideCmd(const uint8_t* commandData);
void prepareSetAdcThresholdCmd(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 prepareSetGpioCmd(const uint8_t* commandData);
void prepareReadGpioCmd(const uint8_t* commandData);
2022-04-13 11:56:37 +02:00
ReturnValue_t prepareLoggingRequest(const uint8_t* commandData, size_t commandDataLen);
2022-05-05 19:18:39 +02:00
ReturnValue_t prepareEnableNvmsCommand(const uint8_t* commandData);
2022-03-27 13:07:18 +02:00
/**
* @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();
void disableReply(DeviceCommandId_t replyId);
2022-03-27 13:07:18 +02:00
/**
* @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);
2022-04-06 07:10:20 +02:00
void prepareSetShutdownTimeoutCmd(const uint8_t* commandData);
2022-04-10 18:46:39 +02:00
ReturnValue_t extractUpdateCommand(const uint8_t* commandData, size_t size, std::string* file,
uint8_t* memoryId, uint32_t* startAddress);
ReturnValue_t eventSubscription();
2022-04-29 08:34:23 +02:00
2022-05-03 14:59:23 +02:00
void handleExecutionSuccessReport(const uint8_t* data);
void handleExecutionFailureReport(uint16_t statusCode);
2021-03-29 14:37:52 +02:00
};
#endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */