#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ #define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ #include #include #include #include "eive/eventSubsystemIds.h" #include "eive/resultClassIds.h" #include "fsfw/action/HasActionsIF.h" #include "fsfw/events/Event.h" #include "fsfw/returnvalues/returnvalue.h" #include "fsfw/serialize/SerializeAdapter.h" #include "fsfw/serialize/SerializeIF.h" namespace mpsoc { static constexpr bool MPSOC_TX_WIRETAPPING = false; static constexpr bool MPSOC_RX_WIRETAPPING = false; static constexpr size_t CRC_SIZE = 2; /** * @brief Abstract base class for TC space packet of MPSoC. */ class TcBase : public ploc::SpTcBase { public: virtual ~TcBase() = default; // Initial length field of space packet. Will always be updated when packet is created. static const uint16_t INIT_LENGTH = CRC_SIZE; /** * @brief Constructor * * @param sequenceCount Sequence count of space packet which will be incremented with each * sent and received packets. */ TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount) : ploc::SpTcBase(params, apid, 0, sequenceCount) { payloadStart = spParams.buf + ccsds::HEADER_LEN; spParams.setFullPayloadLen(INIT_LENGTH); } /** * @brief Function to finsh and write the space packet. It is expected that the user has * set the payload fields in the child class* * @return returnvalue::OK if packet creation was successful, otherwise error return value */ ReturnValue_t finishPacket() { updateSpFields(); ReturnValue_t res = checkSizeAndSerializeHeader(); if (res != returnvalue::OK) { return res; } return calcAndSetCrc(); } }; void printRxPacket(const SpacePacketReader& spReader); void printTxPacket(const ploc::SpTcBase& tcBase); static constexpr uint32_t DEFAULT_CMD_TIMEOUT_MS = 5000; static constexpr uint32_t CMD_TIMEOUT_MKFS = 15000; enum FlashId : uint8_t { FLASH_0 = 0, FLASH_1 = 1 }; static const uint8_t INTERFACE_ID = CLASS_ID::MPSOC_RETURN_VALUES_IF; //! [EXPORT] : [COMMENT] Space Packet received from PLOC has invalid CRC static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0); //! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1); //! [EXPORT] : [COMMENT] Received execution failure reply from PLOC static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2); //! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3); //! [EXPORT] : [COMMENT] Received command with invalid length static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xA4); //! [EXPORT] : [COMMENT] Filename of file in OBC filesystem is too long static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA5); //! [EXPORT] : [COMMENT] MPSoC helper is currently executing a command static const ReturnValue_t MPSOC_HELPER_EXECUTING = MAKE_RETURN_CODE(0xA6); //! [EXPORT] : [COMMENT] Filename of MPSoC file is to long (max. 256 bytes) static const ReturnValue_t MPSOC_FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA7); //! [EXPORT] : [COMMENT] Command has invalid parameter static const ReturnValue_t INVALID_PARAMETER = MAKE_RETURN_CODE(0xA8); //! [EXPORT] : [COMMENT] Received command has file string with invalid length static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xA9); //! [EXPORT] : [COMMENT] Command has timed out. static const ReturnValue_t COMMAND_TIMEOUT = MAKE_RETURN_CODE(0x10); 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); //! [EXPORT] : [COMMENT] Camera must be commanded on first. static constexpr Event CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE = event::makeEvent(SUBSYSTEM_ID, 9, severity::LOW); enum ParamId : uint8_t { SKIP_SUPV_ON_COMMANDING = 0x01 }; enum FileAccessModes : uint8_t { // Opens a file, fails if the file does not exist. OPEN_EXISTING = 0x00, READ = 0x01, WRITE = 0x02, // Creates a new file, fails if it already exists. CREATE_NEW = 0x04, // Creates a new file, existing file is truncated and overwritten. CREATE_ALWAYS = 0x08, // Opens the file if it is existing. If not, a new file is created. OPEN_ALWAYS = 0x10, OPEN_APPEND = 0x30 }; static constexpr uint32_t HK_SET_ID = 0; static constexpr uint32_t DEADBEEF_ADDR = 0x40000004; static constexpr uint32_t DEADBEEF_VALUE = 0xdeadbeef; namespace poolid { enum { STATUS = 0, MODE = 1, DOWNLINK_PWR_ON = 2, DOWNLINK_REPLY_ACTIIVE = 3, DOWNLINK_JESD_SYNC_STATUS = 4, DOWNLINK_DAC_STATUS = 5, CAM_STATUS = 6, CAM_SDI_STATUS = 7, CAM_FPGA_TEMP = 8, CAM_SOC_TEMP = 9, SYSMON_TEMP = 10, SYSMON_VCCINT = 11, SYSMON_VCCAUX = 12, SYSMON_VCCBRAM = 13, SYSMON_VCCPAUX = 14, SYSMON_VCCPINT = 15, SYSMON_VCCPDRO = 16, SYSMON_MB12V = 17, SYSMON_MB3V3 = 18, SYSMON_MB1V8 = 19, SYSMON_VCC12V = 20, SYSMON_VCC5V = 21, SYSMON_VCC3V3 = 22, SYSMON_VCC3V3VA = 23, SYSMON_VCC2V5DDR = 24, SYSMON_VCC1V2DDR = 25, SYSMON_VCC0V9 = 26, SYSMON_VCC0V6VTT = 27, SYSMON_SAFE_COTS_CUR = 28, SYSMON_NVM4_XO_CUR = 29, SEM_UNCORRECTABLE_ERRS = 30, SEM_CORRECTABLE_ERRS = 31, SEM_STATUS = 32, REBOOT_MPSOC_REQUIRED = 33, }; } static const DeviceCommandId_t NONE = 0; static const DeviceCommandId_t TC_MEM_WRITE = 1; static const DeviceCommandId_t TC_MEM_READ = 2; static const DeviceCommandId_t ACK_REPORT = 3; static const DeviceCommandId_t EXE_REPORT = 5; static const DeviceCommandId_t TM_MEMORY_READ_REPORT = 6; static const DeviceCommandId_t TC_FLASHFOPEN = 7; static const DeviceCommandId_t TC_FLASHFCLOSE = 8; static const DeviceCommandId_t TC_FLASH_WRITE_FULL_FILE = 9; static const DeviceCommandId_t TC_FLASHDELETE = 10; static const DeviceCommandId_t TC_REPLAY_START = 11; static const DeviceCommandId_t TC_REPLAY_STOP = 12; static const DeviceCommandId_t TC_REPLAY_WRITE_SEQUENCE = 13; static const DeviceCommandId_t TC_DOWNLINK_PWR_ON = 14; static const DeviceCommandId_t TC_DOWNLINK_PWR_OFF = 15; static const DeviceCommandId_t TC_MODE_REPLAY = 16; static const DeviceCommandId_t TC_CAM_CMD_SEND = 17; static const DeviceCommandId_t TC_MODE_IDLE = 18; static const DeviceCommandId_t TM_CAM_CMD_RPT = 19; static const DeviceCommandId_t SET_UART_TX_TRISTATE = 20; static const DeviceCommandId_t RELEASE_UART_TX = 21; static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22; // Stream file down using E-Band component directly. static const DeviceCommandId_t TC_SIMPLEX_STREAM_FILE = 23; static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24; static const DeviceCommandId_t TC_MODE_SNAPSHOT = 25; static const DeviceCommandId_t TC_GET_HK_REPORT = 26; static const DeviceCommandId_t TM_GET_HK_REPORT = 27; static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28; static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29; static constexpr DeviceCommandId_t TC_FLASH_READ_FULL_FILE = 30; // Store file on MPSoC. static const DeviceCommandId_t TC_SIMPLEX_STORE_FILE = 31; static const DeviceCommandId_t TC_VERIFY_BOOT = 32; static const DeviceCommandId_t TC_ENABLE_TC_EXECTION = 33; static const DeviceCommandId_t TC_FLASH_MKFS = 34; // Will reset the sequence count of the OBSW. Not required anymore after MPSoC update. static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT_LEGACY = 50; static const uint16_t SIZE_ACK_REPORT = 14; static const uint16_t SIZE_EXE_REPORT = 14; static constexpr size_t SIZE_TM_HK_REPORT = 369; enum Submode : uint8_t { IDLE_OR_NONE = 0, REPLAY = 1, SNAPSHOT = 2 }; // Setting the internal mode value to the actual telecommand ID /* enum InternalMode { OFF = HasModesIF::MODE_OFF, IDLE = , REPLAY = TC_MODE_REPLAY, SNAPSHOT = TC_MODE_SNAPSHOT }; */ /** * SpacePacket apids of PLOC telecommands and telemetry. */ namespace apid { static const uint16_t TC_REPLAY_START = 0x110; static const uint16_t TC_REPLAY_STOP = 0x111; static const uint16_t TC_REPLAY_WRITE_SEQUENCE = 0x112; static const uint16_t TC_DOWNLINK_PWR_ON = 0x113; static const uint16_t TC_MEM_WRITE = 0x114; static const uint16_t TC_MEM_READ = 0x115; static const uint16_t TC_CAM_TAKE_PIC = 0x116; static constexpr uint16_t TC_FLASHWRITE = 0x117; static constexpr uint16_t TC_FLASHREAD = 0x118; static const uint16_t TC_FLASHFOPEN = 0x119; static const uint16_t TC_FLASHFCLOSE = 0x11A; static constexpr uint16_t TC_FLASH_GET_DIRECTORY_CONTENT = 0x11B; static const uint16_t TC_FLASHDELETE = 0x11C; static constexpr uint16_t TC_FLASH_CREATE_DIR = 0x11D; static const uint16_t TC_MODE_IDLE = 0x11E; static const uint16_t TC_MODE_REPLAY = 0x11F; static const uint16_t TC_MODE_SNAPSHOT = 0x120; static const uint16_t TC_DOWNLINK_DATA_MODULATE = 0x121; static constexpr uint16_t TC_HK_GET_REPORT = 0x123; static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124; static constexpr uint16_t TC_ENABLE_TC_EXECUTION = 0x129; static constexpr uint16_t TC_FLASH_MKFS = 0x12A; static const uint16_t TC_CAM_CMD_SEND = 0x12C; static constexpr uint16_t TC_FLASH_COPY_FILE = 0x12E; static const uint16_t TC_SIMPLEX_SEND_FILE = 0x130; static const uint16_t ACK_SUCCESS = 0x400; static const uint16_t ACK_FAILURE = 0x401; static const uint16_t EXE_SUCCESS = 0x402; static const uint16_t EXE_FAILURE = 0x403; static const uint16_t TM_MEMORY_READ_REPORT = 0x404; static const uint16_t TM_FLASH_READ_REPORT = 0x405; static constexpr uint16_t TM_FLASH_DIRECTORY_CONTENT = 0x406; static const uint16_t TM_CAM_CMD_RPT = 0x407; static constexpr uint16_t TM_HK_GET_REPORT = 0x408; } // namespace apid /** Offset from first byte in space packet to first byte of data field */ static const uint8_t DATA_FIELD_OFFSET = 6; static const size_t MEM_READ_RPT_LEN_OFFSET = 10; static const char NULL_TERMINATOR = '\0'; static const uint8_t MIN_SPACE_PACKET_LENGTH = 7; static const uint8_t SPACE_PACKET_HEADER_SIZE = 6; static const uint8_t STATUS_OFFSET = 10; /** * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service * 8. */ static const uint8_t SIZE_MEM_READ_RPT_FIX = 6; static const size_t FILENAME_FIELD_SIZE = 256; // Subtract size of NULL terminator. static const size_t MAX_FILENAME_SIZE = FILENAME_FIELD_SIZE - 1; /** * PLOC space packet length for fixed size packets. This is the size of the whole packet data * field. For the length field in the space packet this size will be substracted by one. */ static const uint16_t LENGTH_TC_MEM_WRITE = 12; static const uint16_t LENGTH_TC_MEM_READ = 8; /** * Maximum SP packet size as specified in the TAS Supversior ICD. * https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_TAS-ILH-IRS/ICD-PLOC/TAS&fileid=942896 * at sheet README */ static constexpr size_t SP_MAX_SIZE = 1024; static constexpr size_t MAX_REPLY_SIZE = SP_MAX_SIZE * 3; static constexpr size_t MAX_COMMAND_SIZE = SP_MAX_SIZE; // 1016 bytes. static constexpr size_t SP_MAX_DATA_SIZE = SP_MAX_SIZE - ccsds::HEADER_LEN - CRC_SIZE; static constexpr size_t FLASH_READ_MIN_OVERHEAD = 16; // 1000 bytes. static const size_t MAX_FLASH_READ_DATA_SIZE = SP_MAX_DATA_SIZE - FLASH_READ_MIN_OVERHEAD; // 1012 bytes, 4 bytes for the write length. static constexpr size_t MAX_FLASH_WRITE_DATA_SIZE = SP_MAX_DATA_SIZE - sizeof(uint32_t); /** * The replay write sequence command has a maximum delay for the execution report which amounts to * 30 seconds. (80 cycles * 0.5 seconds = 40 seconds). */ static const uint16_t TC_WRITE_SEQ_EXECUTION_DELAY = 80; // Requires approx. 2 seconds for execution. 8 => 4 seconds static const uint16_t TC_DOWNLINK_PWR_ON_EXECUTION_DELAY = 8; static const uint16_t TC_CAM_TAKE_PIC_EXECUTION_DELAY = 20; static const uint16_t TC_SIMPLEX_SEND_FILE_DELAY = 80; namespace statusCode { static const uint16_t DEFAULT_ERROR_CODE = 0x1; static constexpr uint16_t FLASH_DRIVE_ERROR = 0xb; static const uint16_t UNKNOWN_APID = 0x5DD; static const uint16_t INCORRECT_LENGTH = 0x5DE; static const uint16_t INCORRECT_CRC = 0x5DF; static const uint16_t INCORRECT_PKT_SEQ_CNT = 0x5E0; static const uint16_t TC_NOT_ALLOWED_IN_MODE = 0x5E1; static const uint16_t TC_EXEUTION_DISABLED = 0x5E2; static const uint16_t FLASH_MOUNT_FAILED = 0x5E3; static const uint16_t FLASH_FILE_ALREADY_CLOSED = 0x5E4; static const uint16_t FLASH_FILE_OPEN_FAILED = 0x5E5; static const uint16_t FLASH_FILE_ALREADY_OPEN = 0x5E6; static const uint16_t FLASH_FILE_NOT_OPEN = 0x5E7; static const uint16_t FLASH_UNMOUNT_FAILED = 0x5E8; static const uint16_t HEAP_ALLOCATION_FAILED = 0x5E9; static const uint16_t INVALID_PARAMETER = 0x5EA; static const uint16_t NOT_INITIALIZED = 0x5EB; static const uint16_t REBOOT_IMMINENT = 0x5EC; static const uint16_t CORRUPT_DATA = 0x5ED; static const uint16_t FLASH_CORRECTABLE_MISMATCH = 0x5EE; static const uint16_t FLASH_UNCORRECTABLE_MISMATCH = 0x5EF; static const uint16_t RESERVED_0 = 0x5F0; static const uint16_t RESERVED_1 = 0x5F1; static const uint16_t RESERVED_2 = 0x5F2; static const uint16_t RESERVED_3 = 0x5F3; static const uint16_t RESERVED_4 = 0x5F4; } // namespace statusCode /** * @brief This class helps to build the memory read command for the PLOC. */ class TcMemRead : public mpsoc::TcBase { public: /** * @brief Constructor */ TcMemRead(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_MEM_READ, sequenceCount) { spParams.setFullPayloadLen(COMMAND_LENGTH + CRC_SIZE); } uint16_t getMemLen() const { return memLen; } ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { ReturnValue_t result = returnvalue::OK; result = lengthCheck(commandDataLen); if (result != returnvalue::OK) { return result; } std::memcpy(payloadStart, commandData, MEM_ADDRESS_SIZE); std::memcpy(payloadStart + MEM_ADDRESS_SIZE, commandData + MEM_ADDRESS_SIZE, MEM_LEN_SIZE); size_t size = sizeof(memLen); const uint8_t* memLenPtr = commandData + MEM_ADDRESS_SIZE; result = SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size, SerializeIF::Endianness::BIG); if (result != returnvalue::OK) { return result; } return result; } private: static const size_t COMMAND_LENGTH = 6; static const size_t MEM_ADDRESS_SIZE = 4; static const size_t MEM_LEN_SIZE = 2; static const uint16_t PACKET_LENGTH = 7; uint16_t memLen = 0; ReturnValue_t lengthCheck(size_t commandDataLen) { if (commandDataLen != COMMAND_LENGTH or checkPayloadLen() != returnvalue::OK) { return INVALID_LENGTH; } return returnvalue::OK; } }; /** * @brief This class helps to generate the space packet to write data to a memory address within * the PLOC. */ class TcMemWrite : public mpsoc::TcBase { public: /** * @brief Constructor */ TcMemWrite(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_MEM_WRITE, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { ReturnValue_t result = returnvalue::OK; result = lengthCheck(commandDataLen); if (result != returnvalue::OK) { return result; } uint16_t memLen = *(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1); spParams.setFullPayloadLen(MIN_FIXED_PAYLOAD_LENGTH + memLen * 4 + CRC_SIZE); result = checkPayloadLen(); if (result != returnvalue::OK) { return result; } std::memcpy(payloadStart, commandData, commandDataLen); return result; } private: // 4 byte address, 2 byte mem length field static const size_t MEM_ADDRESS_SIZE = 4; static const size_t MIN_FIXED_PAYLOAD_LENGTH = MEM_ADDRESS_SIZE + 2; // Min length consists of 4 byte address, 2 byte mem length field, 4 byte data (1 word) static const size_t MIN_COMMAND_DATA_LENGTH = MIN_FIXED_PAYLOAD_LENGTH + 4; ReturnValue_t lengthCheck(size_t commandDataLen) { if (commandDataLen < MIN_COMMAND_DATA_LENGTH) { sif::warning << "TcMemWrite: Length " << commandDataLen << " smaller than minimum " << MIN_COMMAND_DATA_LENGTH << std::endl; return INVALID_LENGTH; } if (commandDataLen + CRC_SIZE > spParams.maxSize) { sif::warning << "TcMemWrite: Length " << commandDataLen << " larger than allowed " << spParams.maxSize - CRC_SIZE << std::endl; return INVALID_LENGTH; } return returnvalue::OK; } }; /** * @brief Class to help creation of flash fopen command. */ class TcFlashFopen : public mpsoc::TcBase { public: TcFlashFopen(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_FLASHFOPEN, sequenceCount) {} ReturnValue_t setPayload(std::string filename, uint8_t mode) { accessMode = mode; ReturnValue_t result = checkPayloadLen(); if (result != returnvalue::OK) { return result; } std::memset(payloadStart, 0, FILENAME_FIELD_SIZE); std::memcpy(payloadStart, filename.c_str(), filename.size()); payloadStart[FILENAME_FIELD_SIZE] = accessMode; spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + 1 + CRC_SIZE); return returnvalue::OK; } private: uint8_t accessMode = FileAccessModes::OPEN_EXISTING; }; /** * @brief Class to help creation of flash fclose command. */ class TcFlashFclose : public TcBase { public: TcFlashFclose(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_FLASHFCLOSE, sequenceCount) { spParams.setFullPayloadLen(CRC_SIZE); } }; class TcEnableTcExec : public TcBase { public: TcEnableTcExec(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_ENABLE_TC_EXECUTION, sequenceCount) { spParams.setFullPayloadLen(CRC_SIZE); } ReturnValue_t setPayload(const uint8_t* cmdData, size_t cmdDataLen) { if (cmdDataLen != 2) { return HasActionsIF::INVALID_PARAMETERS; } std::memcpy(payloadStart, cmdData, 2); spParams.setFullPayloadLen(2 + CRC_SIZE); return returnvalue::OK; } }; class TcFlashMkfs : public TcBase { public: TcFlashMkfs(ploc::SpTcParams params, uint16_t sequenceCount, FlashId flashId) : TcBase(params, apid::TC_FLASH_MKFS, sequenceCount) { const char* flashIdStr = "0:\\"; if (flashId == FlashId::FLASH_1) { flashIdStr = "1:\\"; } std::memcpy(payloadStart, flashIdStr, 3); // Null terminator payloadStart[3] = 0; spParams.setFullPayloadLen(4 + CRC_SIZE); } }; /** * @brief Class to build flash write space packet. */ class TcFlashWrite : public TcBase { public: TcFlashWrite(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_FLASHWRITE, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* writeData, uint32_t writeLen_) { writeLen = writeLen_; if (writeLen > MAX_FLASH_WRITE_DATA_SIZE) { sif::error << "TcFlashWrite: Command data too big" << std::endl; return returnvalue::FAILED; } spParams.setFullPayloadLen(sizeof(uint32_t) + static_cast(writeLen) + CRC_SIZE); ReturnValue_t result = checkPayloadLen(); if (result != returnvalue::OK) { return result; } size_t serializedSize = ccsds::HEADER_LEN; result = SerializeAdapter::serialize(&writeLen, payloadStart, &serializedSize, spParams.maxSize, SerializeIF::Endianness::BIG); if (result != returnvalue::OK) { return result; } std::memcpy(payloadStart + sizeof(uint32_t), writeData, writeLen); updateSpFields(); result = checkSizeAndSerializeHeader(); if (result != returnvalue::OK) { return result; } return calcAndSetCrc(); } private: uint32_t writeLen = 0; }; class TcFlashRead : public TcBase { public: TcFlashRead(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_FLASHREAD, sequenceCount) {} ReturnValue_t setPayload(uint32_t readLen) { if (readLen > MAX_FLASH_READ_DATA_SIZE) { sif::error << "TcFlashRead: Read length " << readLen << " too large" << std::endl; return returnvalue::FAILED; } spParams.setFullPayloadLen(sizeof(uint32_t) + CRC_SIZE); ReturnValue_t result = checkPayloadLen(); if (result != returnvalue::OK) { return result; } size_t serializedSize = ccsds::HEADER_LEN; result = SerializeAdapter::serialize(&readLen, payloadStart, &serializedSize, spParams.maxSize, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } readSize = readLen; return result; } uint32_t readSize = 0; }; /** * @brief Class to help creation of flash delete command. */ class TcFlashDelete : public TcBase { public: TcFlashDelete(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_FLASHDELETE, sequenceCount) {} ReturnValue_t setPayload(std::string filename) { size_t nameSize = filename.size(); spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE); auto res = checkPayloadLen(); if (res != returnvalue::OK) { return res; } std::memcpy(payloadStart, filename.c_str(), nameSize); *(payloadStart + nameSize) = NULL_TERMINATOR; return returnvalue::OK; } }; /** * @brief Class to build replay stop space packet. */ class TcReplayStop : public TcBase { public: TcReplayStop(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_REPLAY_STOP, sequenceCount) {} }; /** * @brief This class helps to build the replay start command. */ class TcReplayStart : public TcBase { public: /** * @brief Constructor */ TcReplayStart(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_REPLAY_START, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { ReturnValue_t result = returnvalue::OK; spParams.setFullPayloadLen(commandDataLen + CRC_SIZE); result = lengthCheck(commandDataLen); if (result != returnvalue::OK) { return result; } result = checkData(*commandData); if (result != returnvalue::OK) { return result; } std::memcpy(payloadStart, commandData, commandDataLen); return result; } private: static const size_t COMMAND_DATA_LENGTH = 1; static const uint8_t REPEATING = 0; static const uint8_t ONCE = 1; ReturnValue_t lengthCheck(size_t commandDataLen) { if (commandDataLen != COMMAND_DATA_LENGTH or checkPayloadLen() != returnvalue::OK) { sif::warning << "TcReplayStart: Command has invalid length " << commandDataLen << std::endl; return INVALID_LENGTH; } return returnvalue::OK; } ReturnValue_t checkData(uint8_t replay) { if (replay != REPEATING && replay != ONCE) { sif::warning << "TcReplayStart::checkData: Invalid replay value" << std::endl; return INVALID_PARAMETER; } return returnvalue::OK; } }; /** * @brief This class helps to build downlink power on command. */ class TcDownlinkPwrOn : public TcBase { public: /** * @brief Constructor */ TcDownlinkPwrOn(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_DOWNLINK_PWR_ON, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { ReturnValue_t result = returnvalue::OK; result = lengthCheck(commandDataLen); if (result != returnvalue::OK) { return result; } result = modeCheck(*commandData); if (result != returnvalue::OK) { return result; } result = laneRateCheck(*(commandData + 1)); if (result != returnvalue::OK) { return result; } spParams.setFullPayloadLen(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE); result = checkPayloadLen(); if (result != returnvalue::OK) { return result; } std::memcpy(payloadStart, commandData, commandDataLen); std::memcpy(payloadStart + commandDataLen, &MAX_AMPLITUDE, sizeof(MAX_AMPLITUDE)); return result; } private: static const uint8_t INTERFACE_ID = CLASS_ID::DWLPWRON_CMD; //! [EXPORT] : [COMMENT] Received command has invalid JESD mode (valid modes are 0 - 5) static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0xE0); //! [EXPORT] : [COMMENT] Received command has invalid lane rate (valid lane rate are 0 - 9) static const ReturnValue_t INVALID_LANE_RATE = MAKE_RETURN_CODE(0xE1); static const size_t COMMAND_DATA_LENGTH = 2; static const uint8_t MAX_MODE = 5; static const uint8_t MAX_LANE_RATE = 9; static const uint16_t MAX_AMPLITUDE = 0; ReturnValue_t lengthCheck(size_t commandDataLen) { if (commandDataLen != COMMAND_DATA_LENGTH) { sif::warning << "TcDownlinkPwrOn: Command has invalid length " << commandDataLen << std::endl; return INVALID_LENGTH; } return returnvalue::OK; } ReturnValue_t modeCheck(uint8_t mode) { if (mode > MAX_MODE) { sif::warning << "TcDwonlinkPwrOn::modeCheck: Invalid JESD mode" << std::endl; return INVALID_MODE; } return returnvalue::OK; } ReturnValue_t laneRateCheck(uint8_t laneRate) { if (laneRate > MAX_LANE_RATE) { sif::warning << "TcReplayStart::laneRateCheck: Invalid lane rate" << std::endl; return INVALID_LANE_RATE; } return returnvalue::OK; } }; class TcGetHkReport : public TcBase { public: TcGetHkReport(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_HK_GET_REPORT, sequenceCount) {} }; class TcGetDirContent : public TcBase { public: TcGetDirContent(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_FLASH_GET_DIRECTORY_CONTENT, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { ReturnValue_t result = returnvalue::OK; // Yeah it needs to be 256.. even if the path is shorter. spParams.setFullPayloadLen(256 + CRC_SIZE); if (result != returnvalue::OK) { return result; } std::memset(payloadStart, 0, 256); std::memcpy(payloadStart, commandData, commandDataLen); payloadStart[255] = 0; return result; } }; /** * @brief Class to build replay stop space packet. */ class TcDownlinkPwrOff : public TcBase { public: TcDownlinkPwrOff(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_DOWNLINK_PWR_OFF, sequenceCount) {} }; /** * @brief This class helps to build the replay start command. */ class TcReplayWriteSeq : public TcBase { public: /** * @brief Constructor */ TcReplayWriteSeq(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { ReturnValue_t result = returnvalue::OK; spParams.setFullPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE); result = lengthCheck(commandDataLen); if (result != returnvalue::OK) { return result; } std::memcpy(payloadStart, commandData, commandDataLen); *(payloadStart + commandDataLen) = NULL_TERMINATOR; return result; } private: static const size_t USE_DECODING_LENGTH = 1; ReturnValue_t lengthCheck(size_t commandDataLen) { if (commandDataLen > USE_DECODING_LENGTH + FILENAME_FIELD_SIZE or checkPayloadLen() != returnvalue::OK) { sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen << std::endl; return INVALID_LENGTH; } return returnvalue::OK; } }; /** * @brief Helps to extract the fields of the flash write command from the PUS packet. */ class FlashBasePusCmd { public: FlashBasePusCmd() = default; virtual ~FlashBasePusCmd() = default; virtual ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) { if (commandDataLen > FILENAME_FIELD_SIZE) { return INVALID_LENGTH; } size_t fileLen = strnlen(reinterpret_cast(commandData), commandDataLen); if (fileLen > MAX_FILENAME_SIZE) { return FILENAME_TOO_LONG; } obcFile = std::string(reinterpret_cast(commandData), fileLen); fileLen = strnlen(reinterpret_cast(commandData + obcFile.size() + SIZE_NULL_TERMINATOR), commandDataLen - obcFile.size() - 1); if (fileLen > FILENAME_FIELD_SIZE) { return MPSOC_FILENAME_TOO_LONG; } mpsocFile = std::string( reinterpret_cast(commandData + obcFile.size() + SIZE_NULL_TERMINATOR), fileLen); return returnvalue::OK; } const std::string& getObcFile() const { return obcFile; } const std::string& getMpsocFile() const { return mpsocFile; } protected: size_t getParsedSize() const { return getObcFile().size() + getMpsocFile().size() + 2 * SIZE_NULL_TERMINATOR; } static const size_t SIZE_NULL_TERMINATOR = 1; private: std::string obcFile; std::string mpsocFile; }; class FlashReadPusCmd : public FlashBasePusCmd { public: FlashReadPusCmd(){}; ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) override { ReturnValue_t result = FlashBasePusCmd::extractFields(commandData, commandDataLen); if (result != returnvalue::OK) { return result; } if (commandDataLen < (getParsedSize() + 4)) { return returnvalue::FAILED; } size_t deserDummy = 4; return SerializeAdapter::deSerialize(&readSize, commandData + getParsedSize(), &deserDummy, SerializeIF::Endianness::NETWORK); } size_t getReadSize() const { return readSize; } private: size_t readSize = 0; }; /** * @brief Class to build replay stop space packet. */ class TcModeReplay : public TcBase { public: TcModeReplay(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_MODE_REPLAY, sequenceCount) {} }; /** * @brief Class to build mode idle command */ class TcModeIdle : public TcBase { public: TcModeIdle(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_MODE_IDLE, sequenceCount) {} }; /** * @brief Class to build mode idle command */ class TcModeSnapshot : public TcBase { public: TcModeSnapshot(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_MODE_SNAPSHOT, sequenceCount) {} }; /** * @brief Class to build camera take picture command */ class TcCamTakePic : public TcBase { public: TcCamTakePic(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_CAM_TAKE_PIC, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { const uint8_t** dataPtr = &commandData; if (commandDataLen > FULL_PAYLOAD_SIZE) { return INVALID_LENGTH; } size_t deserLen = commandDataLen; size_t serLen = 0; fileName = reinterpret_cast(commandData); if (fileName.size() > MAX_FILENAME_SIZE) { return FILENAME_TOO_LONG; } deserLen -= fileName.length() + 1; *dataPtr += fileName.length() + 1; uint8_t** payloadPtr = &payloadStart; memcpy(payloadStart, fileName.data(), fileName.size()); *payloadPtr += FILENAME_FIELD_SIZE; serLen += FILENAME_FIELD_SIZE; ReturnValue_t result = SerializeAdapter::deSerialize(&encoderSettingY, dataPtr, &deserLen, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::serialize(&encoderSettingY, payloadPtr, &serLen, FULL_PAYLOAD_SIZE, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::deSerialize(&quantizationY, dataPtr, &deserLen, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::serialize(&quantizationY, payloadPtr, &serLen, FULL_PAYLOAD_SIZE, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::deSerialize(&encoderSettingsCb, dataPtr, &deserLen, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::serialize(&encoderSettingsCb, payloadPtr, &serLen, FULL_PAYLOAD_SIZE, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::deSerialize(&quantizationCb, dataPtr, &deserLen, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::serialize(&quantizationCb, payloadPtr, &serLen, FULL_PAYLOAD_SIZE, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::deSerialize(&encoderSettingsCr, dataPtr, &deserLen, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::serialize(&encoderSettingsCr, payloadPtr, &serLen, FULL_PAYLOAD_SIZE, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::deSerialize(&quantizationCr, dataPtr, &deserLen, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::serialize(&quantizationCr, payloadPtr, &serLen, FULL_PAYLOAD_SIZE, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::deSerialize(&bypassCompressor, dataPtr, &deserLen, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } result = SerializeAdapter::serialize(&bypassCompressor, payloadPtr, &serLen, FULL_PAYLOAD_SIZE, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } spParams.setFullPayloadLen(FULL_PAYLOAD_SIZE + CRC_SIZE); return returnvalue::OK; } std::string fileName; uint8_t encoderSettingY = 7; uint64_t quantizationY = 0; uint8_t encoderSettingsCb = 7; uint64_t quantizationCb = 0; uint8_t encoderSettingsCr = 7; uint64_t quantizationCr = 0; uint8_t bypassCompressor = 0; private: static const size_t PARAMETER_SIZE = 28; static constexpr size_t FULL_PAYLOAD_SIZE = FILENAME_FIELD_SIZE + PARAMETER_SIZE; }; /** * @brief Class to build simplex send file command */ class TcSimplexStreamFile : public TcBase { public: TcSimplexStreamFile(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { if (commandDataLen > MAX_FILENAME_SIZE) { return INVALID_LENGTH; } std::string fileName(reinterpret_cast(commandData)); if (fileName.size() > MAX_FILENAME_SIZE) { return FILENAME_TOO_LONG; } std::memset(payloadStart, 0, FILENAME_FIELD_SIZE); std::memcpy(payloadStart, fileName.data(), fileName.length()); payloadStart[fileName.length()] = 0; spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE); ; return returnvalue::OK; } private: }; /** * @brief Class to build simplex send file command */ class TcSimplexStoreFile : public TcBase { public: TcSimplexStoreFile(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { if (commandDataLen < MIN_DATA_LENGTH) { return INVALID_LENGTH; } if (commandDataLen > MAX_DATA_LENGTH) { return INVALID_LENGTH; } const uint8_t** dataPtr = &commandData; ReturnValue_t result = SerializeAdapter::deSerialize(&chunkParameter, dataPtr, &commandDataLen, SerializeIF::Endianness::NETWORK); if (result != returnvalue::OK) { return result; } /// No chunks makes no sense, and DIV str can not be longer than whats representable with 3 /// decimal digits. if (chunkParameter == 0 or chunkParameter > 999) { return INVALID_PARAMETER; } std::string fileName(reinterpret_cast(*dataPtr)); if (fileName.size() > MAX_FILENAME_SIZE) { return FILENAME_TOO_LONG; } char divStr[16]{}; sprintf(divStr, "DIV%03u", chunkParameter); std::memcpy(payloadStart, divStr, DIV_STR_LEN); payloadStart[DIV_STR_LEN] = 0; std::memset(payloadStart + DIV_STR_LEN + 1, 0, FILENAME_FIELD_SIZE - DIV_STR_LEN - 1); std::memcpy(payloadStart + DIV_STR_LEN + 1, fileName.data(), fileName.length()); spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE); return returnvalue::OK; } private: uint32_t chunkParameter = 0; static constexpr size_t MIN_DATA_LENGTH = 4; static constexpr size_t DIV_STR_LEN = 6; static constexpr size_t MAX_DATA_LENGTH = 4 + MAX_FILENAME_SIZE; }; /** * @brief Class to build downlink data modulate command */ class TcDownlinkDataModulate : public TcBase { public: TcDownlinkDataModulate(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_DOWNLINK_DATA_MODULATE, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { if (commandDataLen > MAX_DATA_LENGTH) { return INVALID_LENGTH; } spParams.setFullPayloadLen(commandDataLen + CRC_SIZE); std::memcpy(payloadStart, commandData, commandDataLen); return returnvalue::OK; } private: static const size_t MAX_DATA_LENGTH = 11; }; class TcCamcmdSend : public TcBase { public: TcCamcmdSend(ploc::SpTcParams params, uint16_t sequenceCount) : TcBase(params, apid::TC_CAM_CMD_SEND, sequenceCount) {} ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) { if (commandDataLen > MAX_DATA_LENGTH) { return INVALID_LENGTH; } uint16_t dataLen = static_cast(commandDataLen + sizeof(CARRIAGE_RETURN)); spParams.setFullPayloadLen(sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN) + CRC_SIZE); auto res = checkPayloadLen(); if (res != returnvalue::OK) { return res; } size_t size = ccsds::HEADER_LEN; SerializeAdapter::serialize(&dataLen, payloadStart, &size, spParams.maxSize, SerializeIF::Endianness::BIG); std::memcpy(payloadStart + sizeof(dataLen), commandData, commandDataLen); *(payloadStart + sizeof(dataLen) + commandDataLen) = CARRIAGE_RETURN; return returnvalue::OK; } private: static const uint8_t MAX_DATA_LENGTH = 10; static const uint8_t CARRIAGE_RETURN = 0xD; }; class HkReport : public StaticLocalDataSet<36> { public: HkReport(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, HK_SET_ID) {} HkReport(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, HK_SET_ID)) {} lp_var_t status = lp_var_t(sid.objectId, mpsoc::poolid::STATUS, this); lp_var_t mode = lp_var_t(sid.objectId, mpsoc::poolid::MODE, this); lp_var_t downlinkPwrOn = lp_var_t(sid.objectId, mpsoc::poolid::DOWNLINK_PWR_ON, this); lp_var_t downlinkReplyActive = lp_var_t(sid.objectId, mpsoc::poolid::DOWNLINK_REPLY_ACTIIVE, this); lp_var_t downlinkJesdSyncStatus = lp_var_t(sid.objectId, mpsoc::poolid::DOWNLINK_JESD_SYNC_STATUS, this); lp_var_t downlinkDacStatus = lp_var_t(sid.objectId, mpsoc::poolid::DOWNLINK_DAC_STATUS, this); lp_var_t camStatus = lp_var_t(sid.objectId, mpsoc::poolid::CAM_STATUS, this); lp_var_t camSdiStatus = lp_var_t(sid.objectId, mpsoc::poolid::CAM_SDI_STATUS, this); lp_var_t camFpgaTemp = lp_var_t(sid.objectId, mpsoc::poolid::CAM_FPGA_TEMP, this); lp_var_t camSocTemp = lp_var_t(sid.objectId, mpsoc::poolid::CAM_SOC_TEMP, this); lp_var_t sysmonTemp = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_TEMP, this); lp_var_t sysmonVccInt = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCCINT, this); lp_var_t sysmonVccAux = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCCAUX, this); lp_var_t sysmonVccBram = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCCBRAM, this); lp_var_t sysmonVccPaux = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCCPAUX, this); lp_var_t sysmonVccPint = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCCPINT, this); lp_var_t sysmonVccPdro = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCCPDRO, this); lp_var_t sysmonMb12V = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_MB12V, this); lp_var_t sysmonMb3V3 = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_MB3V3, this); lp_var_t sysmonMb1V8 = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_MB1V8, this); lp_var_t sysmonVcc12V = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCC12V, this); lp_var_t sysmonVcc5V = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCC5V, this); lp_var_t sysmonVcc3V3 = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCC3V3, this); lp_var_t sysmonVcc3V3VA = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCC3V3VA, this); lp_var_t sysmonVcc2V5DDR = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCC2V5DDR, this); lp_var_t sysmonVcc1V2DDR = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCC1V2DDR, this); lp_var_t sysmonVcc0V9 = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCC0V9, this); lp_var_t sysmonVcc0V6VTT = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_VCC0V6VTT, this); lp_var_t sysmonSafeCotsCur = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_SAFE_COTS_CUR, this); lp_var_t sysmonNvm4XoCur = lp_var_t(sid.objectId, mpsoc::poolid::SYSMON_NVM4_XO_CUR, this); lp_var_t semUncorrectableErrs = lp_var_t(sid.objectId, mpsoc::poolid::SEM_UNCORRECTABLE_ERRS, this); lp_var_t semCorrectableErrs = lp_var_t(sid.objectId, mpsoc::poolid::SEM_CORRECTABLE_ERRS, this); lp_var_t semStatus = lp_var_t(sid.objectId, mpsoc::poolid::SEM_STATUS, this); lp_var_t rebootMpsocRequired = lp_var_t(sid.objectId, mpsoc::poolid::REBOOT_MPSOC_REQUIRED, this); }; uint16_t getStatusFromRawData(const uint8_t* data); std::string getStatusString(uint16_t status); } // namespace mpsoc #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */