Robin Mueller
876bde16e2
All checks were successful
EIVE/eive-obsw/pipeline/pr-main This commit looks good
410 lines
16 KiB
C++
410 lines
16 KiB
C++
#ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
|
|
#define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
|
|
|
|
#include <linux/payload/PlocSupvUartMan.h>
|
|
#include <linux/payload/plocSupvDefs.h>
|
|
#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
|
|
|
|
#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;
|
|
static constexpr bool REDUCE_NORMAL_MODE_PRINTOUT = 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 = 5000;
|
|
// 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;
|
|
|
|
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;
|
|
// Yeah, I am using an extra variable because I once again don't know
|
|
// what the hell the base class is doing and I don't care anymore.
|
|
bool normalCommandIsPending = false;
|
|
// True men implement their reply timeout handling themselves!
|
|
Countdown normalCmdCd = Countdown(2000);
|
|
bool commandIsPending = false;
|
|
Countdown cmdCd = Countdown(2000);
|
|
|
|
supv::HkSet hkset;
|
|
supv::BootStatusReport bootStatusReport;
|
|
supv::LatchupStatusReport latchupStatusReport;
|
|
supv::CountersReport countersReport;
|
|
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(supv::BOOT_TIMEOUT_MS);
|
|
Countdown mramDumpTimeout = Countdown(MRAM_DUMP_TIMEOUT);
|
|
|
|
PoolEntry<uint16_t> adcRawEntry = PoolEntry<uint16_t>(16);
|
|
PoolEntry<uint16_t> adcEngEntry = PoolEntry<uint16_t>(16);
|
|
PoolEntry<uint32_t> latchupCounters = PoolEntry<uint32_t>(7);
|
|
PoolEntry<uint8_t> fmcStateEntry = PoolEntry<uint8_t>(1);
|
|
PoolEntry<uint8_t> bootStateEntry = PoolEntry<uint8_t>(1);
|
|
PoolEntry<uint8_t> bootCyclesEntry = PoolEntry<uint8_t>(1);
|
|
PoolEntry<uint32_t> tempSupEntry = PoolEntry<uint32_t>(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);
|
|
ReturnValue_t handleCounterReport(const uint8_t* data);
|
|
void handleBadApidServiceCombination(Event result, unsigned int apid, unsigned int serviceId);
|
|
ReturnValue_t handleAdcReport(const uint8_t* data);
|
|
ReturnValue_t genericHandleTm(const char* contextString, const uint8_t* data,
|
|
LocalPoolDataSetBase& set);
|
|
|
|
void disableCommand(DeviceCommandId_t cmd);
|
|
|
|
/**
|
|
* @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, size_t commandDataLen);
|
|
ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData, size_t commandDataLen);
|
|
|
|
/**
|
|
* @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_ */
|