diff --git a/fsfw b/fsfw index 672fca51..0e8f5ddd 160000 --- a/fsfw +++ b/fsfw @@ -1 +1 @@ -Subproject commit 672fca5169b017387e58e2ff864913d932c59aa1 +Subproject commit 0e8f5ddd26d586dd40e69f52aef1a63c0d5a9da6 diff --git a/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h b/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h index 4d8dbb46..c564b6e4 100644 --- a/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h +++ b/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h @@ -17,6 +17,12 @@ using namespace returnvalue; namespace supv { +static const uint8_t CLASS_ID = CLASS_ID::PLOC_SUPERVISOR_HANDLER; + +static constexpr ReturnValue_t CRC_MISSMATCH = makeCode(CLASS_ID, 1); +static constexpr ReturnValue_t APID_MISSMATCH = makeCode(CLASS_ID, 2); +static constexpr ReturnValue_t BUF_TOO_SMALL = makeCode(CLASS_ID, 3); + typedef struct { // The most significant bit of msec value is set to 0x80 to indicate that full // time and data information is transmitted, when the time has been synced with @@ -135,14 +141,16 @@ enum Apids { WDOG_MAN = 0x07 }; -enum class HkServiceIds : uint8_t { +namespace tc { + +enum class HkId : uint8_t { ENABLE = 0x01, SET_PERIOD = 0x02, GET_REPORT = 0x03, GET_HARDFAULTS_REPORT = 0x04, }; -enum class TmtcServiceIds : uint8_t { +enum class TmtcId : uint8_t { TIME_REF = 0x03, GET_SUPV_VERSION = 0x05, RUN_AUTO_EM_TEST = 0x08, @@ -151,7 +159,7 @@ enum class TmtcServiceIds : uint8_t { GET_MPSOC_POWER_INFO = 0x10 }; -enum class BootManServiceIds : uint8_t { +enum class BootManId : uint8_t { START_MPSOC = 0x01, SHUTDOWN_MPSOC = 0x02, SELECT_IMAGE = 0x03, @@ -165,7 +173,7 @@ enum class BootManServiceIds : uint8_t { FACTORY_FLASH = 0x0C }; -enum class LatchupMonServiceIds : uint8_t { +enum class LatchupMonId : uint8_t { ENABLE = 0x01, DISABLE = 0x02, SET_ALERT_LIMIT = 0x04, @@ -174,7 +182,7 @@ enum class LatchupMonServiceIds : uint8_t { // Right now, none of the commands seem to be implemented, but still // keep the enum here in case some are added -enum class AdcMonServiceIds : uint8_t { +enum class AdcMonId : uint8_t { SET_SWEEP_PERIOD = 0x01, SET_ENABLED_CHANNELS = 0x02, SET_WINDOW_STRIDE = 0x03, @@ -182,9 +190,9 @@ enum class AdcMonServiceIds : uint8_t { COPY_ADC_DATA_TO_MRAM = 0x05 }; -enum class MemManServiceIds : uint8_t { ERASE = 0x01, WRITE = 0x02, CHECK = 0x03 }; +enum class MemManId : uint8_t { ERASE = 0x01, WRITE = 0x02, CHECK = 0x03 }; -enum class DataLoggerServiceIds : uint8_t { +enum class DataLoggerServiceId : uint8_t { WIPE_MRAM = 0x05, DUMP_MRAM = 0x06, FACTORY_RESET = 0x07 @@ -192,7 +200,23 @@ enum class DataLoggerServiceIds : uint8_t { // Right now, none of the commands seem to be implemented, but still // keep the enum here in case some are added -enum class WdogManServiceIds : uint8_t {}; +enum class WdogManServiceId : uint8_t {}; + +} // namespace tc + +namespace tm { + +enum class TmtcId : uint8_t { ACK = 0x01, NAK = 0x02, EXEC_ACK = 0x03, EXEC_NAK = 0x04 }; + +enum class HkId : uint8_t { REPORT = 0x01, HARDFAULTS = 0x02 }; + +enum class BootManId : uint8_t { BOOT_STATUS_REPORT = 0x01 }; + +enum class MemManId : uint8_t { UPDATE_STATUS_REPORT = 0x01 }; + +enum class LatchupMonId : uint8_t { LATCHUP_STATUS_REPORT = 0x01 }; + +} // namespace tm static const uint16_t APID_MASK = 0x3FF; static const uint16_t SEQUENCE_COUNT_MASK = 0xFFF; @@ -209,11 +233,11 @@ static const uint32_t LATCHUP_RPT_ID = LATCHUP_REPORT; static const uint32_t LOGGING_RPT_ID = LOGGING_REPORT; static const uint32_t ADC_REPORT_SET_ID = ADC_REPORT; -namespace recv_timeout { +namespace timeout { // Erase memory can require up to 60 seconds for execution static const uint32_t ERASE_MEMORY = 60000; static const uint32_t UPDATE_STATUS_REPORT = 70000; -} // namespace recv_timeout +} // namespace timeout static constexpr size_t TIMESTAMP_LEN = 7; static constexpr size_t SECONDARY_HEADER_LEN = TIMESTAMP_LEN + 1; @@ -386,23 +410,29 @@ class TcBase : public ploc::SpTcBase { } }; -class TmBase: public ploc::SpTmReader { -public: - TmBase(const uint8_t* data, size_t maxSize): ploc::SpTmReader(data, maxSize) { - if(maxSize < MIN_TMTC_LEN) { +class TmBase : public ploc::SpTmReader { + public: + TmBase(const uint8_t* data, size_t maxSize) : ploc::SpTmReader(data, maxSize) { + if (maxSize < MIN_TMTC_LEN) { sif::error << "SupvTcBase::SupvTcBase: Passed buffer is too small" << std::endl; } } - uint8_t getServiceId() { - return getPacketData()[TIMESTAMP_LEN]; + bool verifyCrc() { + if (checkCrc() == returnvalue::OK) { + crcOk = true; + } + return crcOk; } - const uint8_t* getPayloadStart() { - return getPacketData() + SECONDARY_HEADER_LEN; - } -private: + bool crcIsOk() const { return crcOk; } + uint8_t getServiceId() const { return getPacketData()[TIMESTAMP_LEN]; } + + const uint8_t* getPayloadStart() const { return getPacketData() + SECONDARY_HEADER_LEN; } + + private: + bool crcOk = false; }; class NoPayloadPacket : public TcBase { @@ -444,7 +474,7 @@ class MPSoCBootSelect : public TcBase { * @note Selection of partitions is currently not supported. */ MPSoCBootSelect(TcParams params) - : TcBase(params, Apids::BOOT_MAN, static_cast(BootManServiceIds::SELECT_IMAGE), 4) {} + : TcBase(params, Apids::BOOT_MAN, static_cast(tc::BootManId::SELECT_IMAGE), 4) {} ReturnValue_t buildPacket(uint8_t mem = 0, uint8_t bp0 = 0, uint8_t bp1 = 0, uint8_t bp2 = 0) { auto res = checkSizeAndSerializeHeader(); @@ -471,7 +501,7 @@ class SetTimeRef : public TcBase { public: static constexpr size_t PAYLOAD_LEN = 8; SetTimeRef(TcParams params) - : TcBase(params, Apids::TMTC_MAN, static_cast(TmtcServiceIds::TIME_REF), 8) {} + : TcBase(params, Apids::TMTC_MAN, static_cast(tc::TmtcId::TIME_REF), 8) {} ReturnValue_t buildPacket(Clock::TimeOfDay_t* time) { auto res = checkSizeAndSerializeHeader(); @@ -546,7 +576,7 @@ class SetBootTimeout : public TcBase { * @param timeout The boot timeout in milliseconds. */ SetBootTimeout(TcParams params) - : TcBase(params, Apids::BOOT_MAN, static_cast(BootManServiceIds::SET_BOOT_TIMEOUT), + : TcBase(params, Apids::BOOT_MAN, static_cast(tc::BootManId::SET_BOOT_TIMEOUT), PAYLOAD_LEN) {} ReturnValue_t buildPacket(uint32_t timeout) { @@ -578,8 +608,8 @@ class SetRestartTries : public TcBase { * @param restartTries Maximum restart tries to set. */ SetRestartTries(TcParams params) - : TcBase(params, Apids::BOOT_MAN, - static_cast(BootManServiceIds::SET_MAX_REBOOT_TRIES), 1) {} + : TcBase(params, Apids::BOOT_MAN, static_cast(tc::BootManId::SET_MAX_REBOOT_TRIES), + 1) {} ReturnValue_t buildPacket(uint8_t restartTries) { auto res = checkSizeAndSerializeHeader(); @@ -607,7 +637,7 @@ class DisablePeriodicHkTransmission : public TcBase { * @brief Constructor */ DisablePeriodicHkTransmission(TcParams params) - : TcBase(params, Apids::HK, static_cast(HkServiceIds::ENABLE), 1) {} + : TcBase(params, Apids::HK, static_cast(tc::HkId::ENABLE), 1) {} ReturnValue_t buildPacket() { auto res = checkSizeAndSerializeHeader(); @@ -640,9 +670,9 @@ class LatchupAlert : public TcBase { ReturnValue_t buildPacket(bool state, uint8_t latchupId) { if (state) { - setServiceId(static_cast(LatchupMonServiceIds::ENABLE)); + setServiceId(static_cast(tc::LatchupMonId::ENABLE)); } else { - setServiceId(static_cast(LatchupMonServiceIds::DISABLE)); + setServiceId(static_cast(tc::LatchupMonId::DISABLE)); } auto res = checkSizeAndSerializeHeader(); if (res != returnvalue::OK) { @@ -668,8 +698,8 @@ class SetAlertlimit : public TcBase { * @param dutycycle */ SetAlertlimit(TcParams params) - : TcBase(params, Apids::LATCHUP_MON, - static_cast(LatchupMonServiceIds::SET_ALERT_LIMIT), 5) {} + : TcBase(params, Apids::LATCHUP_MON, static_cast(tc::LatchupMonId::SET_ALERT_LIMIT), + 5) {} ReturnValue_t buildPacket(uint8_t latchupId, uint32_t dutycycle) { auto res = checkSizeAndSerializeHeader(); @@ -708,8 +738,7 @@ class SetAdcWindowAndStride : public TcBase { * @param stridingStepSize */ SetAdcWindowAndStride(TcParams params) - : TcBase(params, Apids::ADC_MON, static_cast(AdcMonServiceIds::SET_WINDOW_STRIDE), - 4) {} + : TcBase(params, Apids::ADC_MON, static_cast(tc::AdcMonId::SET_WINDOW_STRIDE), 4) {} ReturnValue_t buildPacket(uint16_t windowSize, uint16_t stridingStepSize) { auto res = checkSizeAndSerializeHeader(); @@ -742,8 +771,7 @@ class SetAdcThreshold : public TcBase { * @param threshold */ SetAdcThreshold(TcParams params) - : TcBase(params, Apids::ADC_MON, static_cast(AdcMonServiceIds::SET_ADC_THRESHOLD), - 4) {} + : TcBase(params, Apids::ADC_MON, static_cast(tc::AdcMonId::SET_ADC_THRESHOLD), 4) {} ReturnValue_t buildPacket(uint32_t threshold) { auto res = checkSizeAndSerializeHeader(); @@ -773,8 +801,7 @@ class RunAutoEmTests : public TcBase { * @param test 1 - complete EM test, 2 - Short test (only memory readback NVM0,1,3) */ RunAutoEmTests(TcParams params) - : TcBase(params, Apids::TMTC_MAN, static_cast(TmtcServiceIds::RUN_AUTO_EM_TEST), 1) { - } + : TcBase(params, Apids::TMTC_MAN, static_cast(tc::TmtcId::RUN_AUTO_EM_TEST), 1) {} ReturnValue_t buildPacket(uint8_t test) { auto res = checkSizeAndSerializeHeader(); @@ -805,7 +832,7 @@ class SetGpio : public TcBase { * @param val */ SetGpio(TcParams params) - : TcBase(params, Apids::TMTC_MAN, static_cast(TmtcServiceIds::SET_GPIO), 3) {} + : TcBase(params, Apids::TMTC_MAN, static_cast(tc::TmtcId::SET_GPIO), 3) {} ReturnValue_t buildPacket(uint8_t port, uint8_t pin, uint8_t val) { auto res = checkSizeAndSerializeHeader(); @@ -841,7 +868,7 @@ class ReadGpio : public TcBase { * @param pin */ ReadGpio(TcParams params) - : TcBase(params, Apids::TMTC_MAN, static_cast(TmtcServiceIds::READ_GPIO), 2) {} + : TcBase(params, Apids::TMTC_MAN, static_cast(tc::TmtcId::READ_GPIO), 2) {} ReturnValue_t buildPacket(uint8_t port, uint8_t pin) { auto res = checkSizeAndSerializeHeader(); @@ -865,8 +892,7 @@ class ReadGpio : public TcBase { class SetShutdownTimeout : public TcBase { public: SetShutdownTimeout(TcParams params) - : TcBase(params, Apids::BOOT_MAN, static_cast(BootManServiceIds::SHUTDOWN_TIMEOUT), - 4) {} + : TcBase(params, Apids::BOOT_MAN, static_cast(tc::BootManId::SHUTDOWN_TIMEOUT), 4) {} ReturnValue_t buildPacket(uint32_t timeout) { auto res = checkSizeAndSerializeHeader(); @@ -898,7 +924,7 @@ class CheckMemory : public TcBase { * @param length Length in bytes of memory region */ CheckMemory(TcParams params) - : TcBase(params, Apids::MEM_MAN, static_cast(MemManServiceIds::CHECK), 10) {} + : TcBase(params, Apids::MEM_MAN, static_cast(tc::MemManId::CHECK), 10) {} ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) { auto res = checkSizeAndSerializeHeader(); @@ -938,7 +964,7 @@ class WriteMemory : public TcBase { * @param updateData Pointer to buffer containing update data */ WriteMemory(TcParams params) - : TcBase(params, Apids::MEM_MAN, static_cast(MemManServiceIds::WRITE), 1) {} + : TcBase(params, Apids::MEM_MAN, static_cast(tc::MemManId::WRITE), 1) {} ReturnValue_t buildPacket(ccsds::SequenceFlags seqFlags, uint16_t sequenceCount, uint8_t memoryId, uint32_t startAddress, uint16_t length, uint8_t* updateData) { @@ -1001,8 +1027,7 @@ class WriteMemory : public TcBase { class EraseMemory : public TcBase { public: EraseMemory(TcParams params) - : TcBase(params, Apids::MEM_MAN, static_cast(MemManServiceIds::ERASE), - PAYLOAD_LENGTH) {} + : TcBase(params, Apids::MEM_MAN, static_cast(tc::MemManId::ERASE), PAYLOAD_LENGTH) {} ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) { auto res = checkSizeAndSerializeHeader(); @@ -1032,61 +1057,95 @@ class EraseMemory : public TcBase { } }; -class VerificationReport : public ploc::SpTmReader { +class VerificationReport { public: - VerificationReport(const uint8_t* buf, size_t maxSize) : ploc::SpTmReader(buf, maxSize) {} + VerificationReport(TmBase& readerBase) : readerBase(readerBase) {} + + virtual ~VerificationReport() = default; + + virtual ReturnValue_t parse() { + if (not readerBase.crcIsOk()) { + return CRC_MISSMATCH; + } + if (readerBase.getApid() != Apids::TMTC_MAN) { + return APID_MISSMATCH; + } + if (readerBase.getBufSize() < MIN_PAYLOAD_LEN + 8) { + sif::error << "VerificationReport: Invalid verification report, payload too small" + << std::endl; + return BUF_TOO_SMALL; + } + const uint8_t* payloadStart = readerBase.getPayloadStart(); + size_t remLen = PAYLOAD_LEN; + ReturnValue_t result = SerializeAdapter::deSerialize(&refApid, &payloadStart, &remLen, + SerializeIF::Endianness::BIG); + if (result != returnvalue::OK) { + sif::debug << "VerificationReport: Failed to deserialize reference APID field" << std::endl; + return result; + } + result = SerializeAdapter::deSerialize(&refServiceId, &payloadStart, &remLen, + SerializeIF::Endianness::BIG); + if (result != returnvalue::OK) { + sif::debug << "VerificationReport: Failed to deserialize reference Service ID field" + << std::endl; + return result; + } + result = SerializeAdapter::deSerialize(&refSeqCount, &payloadStart, &remLen, + SerializeIF::Endianness::BIG); + if (result != returnvalue::OK) { + sif::debug << "VerificationReport: Failed to deserialize reference sequence count field" + << std::endl; + return result; + } + result = SerializeAdapter::deSerialize(&statusCode, &payloadStart, &remLen, + SerializeIF::Endianness::BIG); + if (result != returnvalue::OK) { + sif::debug << "VerificationReport: Failed to deserialize status code field" << std::endl; + return result; + } + return returnvalue::OK; + } /** * @brief Gets the APID of command which caused the transmission of this verification report. */ - uint16_t getRefApid() { - uint16_t refApid = 0; - size_t size = 0; - const uint8_t* refApidPtr = this->getPacketData(); - ReturnValue_t result = - SerializeAdapter::deSerialize(&refApid, refApidPtr, &size, SerializeIF::Endianness::BIG); - if (result != returnvalue::OK) { - sif::debug << "ExecutionReport: Failed to deserialize reference APID field" << std::endl; - return result; - } - return refApid; - } + uint8_t getRefApid() const { return refApid; } - uint16_t getStatusCode() { - uint16_t statusCode = 0; - size_t size = 0; - const uint8_t* statusCodePtr = this->getPacketData() + OFFSET_STATUS_CODE; - ReturnValue_t result = SerializeAdapter::deSerialize(&statusCode, statusCodePtr, &size, - SerializeIF::Endianness::BIG); - if (result != returnvalue::OK) { - sif::debug << "ExecutionReport: Failed to deserialize status code field" << std::endl; - return result; - } - return statusCode; - } + uint8_t getRefServiceId() const { return refServiceId; } + + uint16_t getRefSequenceCount() const { return refSeqCount; } + + uint32_t getStatusCode() const { return statusCode; } virtual ReturnValue_t checkApid() { return returnvalue::FAILED; } private: - static const uint8_t OFFSET_STATUS_CODE = 4; + TmBase& readerBase; + uint8_t refApid = 0; + uint8_t refServiceId = 0; + uint16_t refSeqCount = 0; + uint32_t statusCode = 0; + static const size_t PAYLOAD_LEN = 8; }; class AcknowledgmentReport : public VerificationReport { public: - AcknowledgmentReport(const uint8_t* buf, size_t maxSize) : VerificationReport(buf, maxSize) {} + AcknowledgmentReport(TmBase& readerBase) : VerificationReport(readerBase) {} - ReturnValue_t checkApid() { - uint16_t apid = this->getApid(); - if (apid == APID_ACK_SUCCESS) { - return returnvalue::OK; - } else if (apid == APID_ACK_FAILURE) { - printStatusInformation(); - return SupvReturnValuesIF::RECEIVED_ACK_FAILURE; - } else { - sif::warning << "AcknowledgmentReport::checkApid: Invalid apid: 0x" << std::hex << apid - << std::endl; - return SupvReturnValuesIF::INVALID_APID; - } + virtual ReturnValue_t parse() override { + // if (readerBase.getServiceId() != ) + // uint16_t apid = this->getApid(); + // if (apid == APID_ACK_SUCCESS) { + // return returnvalue::OK; + // } else if (apid == APID_ACK_FAILURE) { + // printStatusInformation(); + // return SupvReturnValuesIF::RECEIVED_ACK_FAILURE; + // } else { + // sif::warning << "AcknowledgmentReport::checkApid: Invalid apid: 0x" << std::hex << apid + // << std::endl; + // return SupvReturnValuesIF::INVALID_APID; + // } + return OK; } void printStatusInformation() { @@ -1147,20 +1206,21 @@ class AcknowledgmentReport : public VerificationReport { class ExecutionReport : public VerificationReport { public: - ExecutionReport(const uint8_t* buf, size_t maxSize) : VerificationReport(buf, maxSize) {} + ExecutionReport(TmBase& readerBase) : VerificationReport(readerBase) {} - ReturnValue_t checkApid() { - uint16_t apid = this->getApid(); - if (apid == APID_EXE_SUCCESS) { - return returnvalue::OK; - } else if (apid == APID_EXE_FAILURE) { - printStatusInformation(); - return SupvReturnValuesIF::RECEIVED_EXE_FAILURE; - } else { - sif::warning << "ExecutionReport::checkApid: Invalid apid: 0x" << std::hex << apid - << std::endl; - return SupvReturnValuesIF::INVALID_APID; - } + ReturnValue_t parse() override { + /* uint16_t apid = this->getApid(); + if (apid == APID_EXE_SUCCESS) { + return returnvalue::OK; + } else if (apid == APID_EXE_FAILURE) { + printStatusInformation(); + return SupvReturnValuesIF::RECEIVED_EXE_FAILURE; + } else { + sif::warning << "ExecutionReport::checkApid: Invalid apid: 0x" << std::hex << apid + << std::endl; + return SupvReturnValuesIF::INVALID_APID; + }*/ + return OK; } private: @@ -1808,9 +1868,9 @@ class MramCmd : public TcBase { ReturnValue_t buildPacket(uint32_t start, uint32_t stop, MramAction action) { if (action == MramAction::WIPE) { - setServiceId(static_cast(DataLoggerServiceIds::WIPE_MRAM)); + setServiceId(static_cast(tc::DataLoggerServiceId::WIPE_MRAM)); } else if (action == MramAction::DUMP) { - setServiceId(static_cast(DataLoggerServiceIds::DUMP_MRAM)); + setServiceId(static_cast(tc::DataLoggerServiceId::DUMP_MRAM)); } else { sif::debug << "WipeMram: Invalid action specified"; } @@ -1899,7 +1959,7 @@ class SetAdcEnabledChannels : public TcBase { * @param ch Defines channels to be enabled or disabled. */ SetAdcEnabledChannels(TcParams params) - : TcBase(params, Apids::ADC_MON, static_cast(AdcMonServiceIds::SET_ENABLED_CHANNELS), + : TcBase(params, Apids::ADC_MON, static_cast(tc::AdcMonId::SET_ENABLED_CHANNELS), 2) {} ReturnValue_t buildPacket(uint16_t ch) { diff --git a/linux/devices/ploc/PlocSupervisorHandler.cpp b/linux/devices/ploc/PlocSupervisorHandler.cpp index cf63bea3..f26012a7 100644 --- a/linux/devices/ploc/PlocSupervisorHandler.cpp +++ b/linux/devices/ploc/PlocSupervisorHandler.cpp @@ -221,17 +221,17 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d spParams.buf = commandBuffer; switch (deviceCommand) { case GET_HK_REPORT: { - prepareEmptyCmd(Apids::HK, static_cast(HkServiceIds::GET_REPORT)); + prepareEmptyCmd(Apids::HK, static_cast(tc::HkId::GET_REPORT)); result = returnvalue::OK; break; } case START_MPSOC: { - prepareEmptyCmd(Apids::BOOT_MAN, static_cast(BootManServiceIds::START_MPSOC)); + prepareEmptyCmd(Apids::BOOT_MAN, static_cast(tc::BootManId::START_MPSOC)); result = returnvalue::OK; break; } case SHUTDOWN_MPSOC: { - prepareEmptyCmd(Apids::BOOT_MAN, static_cast(BootManServiceIds::SHUTDOWN_MPSOC)); + prepareEmptyCmd(Apids::BOOT_MAN, static_cast(tc::BootManId::SHUTDOWN_MPSOC)); result = returnvalue::OK; break; } @@ -241,7 +241,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d break; } case RESET_MPSOC: { - prepareEmptyCmd(Apids::BOOT_MAN, static_cast(BootManServiceIds::RESET_MPSOC)); + prepareEmptyCmd(Apids::BOOT_MAN, static_cast(tc::BootManId::RESET_MPSOC)); result = returnvalue::OK; break; } @@ -265,8 +265,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d break; } case GET_BOOT_STATUS_REPORT: { - prepareEmptyCmd(Apids::BOOT_MAN, - static_cast(BootManServiceIds::GET_BOOT_STATUS_REPORT)); + prepareEmptyCmd(Apids::BOOT_MAN, static_cast(tc::BootManId::GET_BOOT_STATUS_REPORT)); result = returnvalue::OK; break; } @@ -299,7 +298,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d // } case GET_LATCHUP_STATUS_REPORT: { prepareEmptyCmd(Apids::LATCHUP_MON, - static_cast(LatchupMonServiceIds::GET_STATUS_REPORT)); + static_cast(tc::LatchupMonId::GET_STATUS_REPORT)); result = returnvalue::OK; break; } @@ -380,7 +379,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d break; } case FACTORY_FLASH: { - prepareEmptyCmd(Apids::BOOT_MAN, static_cast(BootManServiceIds::FACTORY_FLASH)); + prepareEmptyCmd(Apids::BOOT_MAN, static_cast(tc::BootManId::FACTORY_FLASH)); result = returnvalue::OK; break; } @@ -434,7 +433,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d // break; // } case RESET_PL: { - prepareEmptyCmd(Apids::BOOT_MAN, static_cast(BootManServiceIds::RESET_PL)); + prepareEmptyCmd(Apids::BOOT_MAN, static_cast(tc::BootManId::RESET_PL)); result = returnvalue::OK; break; } @@ -930,56 +929,57 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) { using namespace supv; ReturnValue_t result = returnvalue::OK; - AcknowledgmentReport ack(data, SIZE_ACK_REPORT); - result = ack.checkSize(); - if (result != returnvalue::OK) { - return result; - } - - result = ack.checkCrc(); - if (result != returnvalue::OK) { - sif::error << "PlocSupervisorHandler::handleAckReport: CRC failure" << std::endl; - nextReplyId = supv::NONE; - replyRawReplyIfnotWiretapped(data, supv::SIZE_ACK_REPORT); - triggerEvent(SUPV_CRC_FAILURE_EVENT); - sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::CRC_FAILURE); - disableAllReplies(); - return returnvalue::OK; - } - - result = ack.checkApid(); - - switch (result) { - case SupvReturnValuesIF::RECEIVED_ACK_FAILURE: { - DeviceCommandId_t commandId = getPendingCommand(); - if (commandId != DeviceHandlerIF::NO_COMMAND_ID) { - triggerEvent(SUPV_ACK_FAILURE, commandId, static_cast(ack.getStatusCode())); - } - printAckFailureInfo(ack.getStatusCode(), commandId); - sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::RECEIVED_ACK_FAILURE); - disableAllReplies(); - nextReplyId = supv::NONE; - result = IGNORE_REPLY_DATA; - break; - } - case returnvalue::OK: { - setNextReplyId(); - break; - } - case SupvReturnValuesIF::INVALID_APID: - sif::warning << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report" - << std::endl; - sendFailureReport(supv::ACK_REPORT, result); - disableAllReplies(); - nextReplyId = supv::NONE; - result = IGNORE_REPLY_DATA; - break; - default: { - sif::error << "PlocSupervisorHandler::handleAckReport: APID parsing failed" << std::endl; - result = returnvalue::FAILED; - break; - } - } + // TODO: Fix + // AcknowledgmentReport ack(data, SIZE_ACK_REPORT); + // result = ack.checkSize(); + // if (result != returnvalue::OK) { + // return result; + // } + // + // result = ack.checkCrc(); + // if (result != returnvalue::OK) { + // sif::error << "PlocSupervisorHandler::handleAckReport: CRC failure" << std::endl; + // nextReplyId = supv::NONE; + // replyRawReplyIfnotWiretapped(data, supv::SIZE_ACK_REPORT); + // triggerEvent(SUPV_CRC_FAILURE_EVENT); + // sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::CRC_FAILURE); + // disableAllReplies(); + // return returnvalue::OK; + // } + // + // result = ack.checkApid(); + // + // switch (result) { + // case SupvReturnValuesIF::RECEIVED_ACK_FAILURE: { + // DeviceCommandId_t commandId = getPendingCommand(); + // if (commandId != DeviceHandlerIF::NO_COMMAND_ID) { + // triggerEvent(SUPV_ACK_FAILURE, commandId, static_cast(ack.getStatusCode())); + // } + // printAckFailureInfo(ack.getStatusCode(), commandId); + // sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::RECEIVED_ACK_FAILURE); + // disableAllReplies(); + // nextReplyId = supv::NONE; + // result = IGNORE_REPLY_DATA; + // break; + // } + // case returnvalue::OK: { + // setNextReplyId(); + // break; + // } + // case SupvReturnValuesIF::INVALID_APID: + // sif::warning << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report" + // << std::endl; + // sendFailureReport(supv::ACK_REPORT, result); + // disableAllReplies(); + // nextReplyId = supv::NONE; + // result = IGNORE_REPLY_DATA; + // break; + // default: { + // sif::error << "PlocSupervisorHandler::handleAckReport: APID parsing failed" << std::endl; + // result = returnvalue::FAILED; + // break; + // } + // } return result; } @@ -987,38 +987,39 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data) using namespace supv; ReturnValue_t result = returnvalue::OK; - ExecutionReport exe(data, SIZE_EXE_REPORT); - result = exe.checkSize(); - if (result != returnvalue::OK) { - return result; - } - - result = exe.checkCrc(); - if (result != returnvalue::OK) { - sif::error << "PlocSupervisorHandler::handleExecutionReport: CRC failure" << std::endl; - nextReplyId = supv::NONE; - return result; - } - - result = exe.checkApid(); - - switch (result) { - case (returnvalue::OK): { - handleExecutionSuccessReport(data); - break; - } - case (SupvReturnValuesIF::RECEIVED_EXE_FAILURE): { - handleExecutionFailureReport(exe.getStatusCode()); - result = returnvalue::OK; - break; - } - default: { - sif::error << "PlocSupervisorHandler::handleExecutionReport: Unknown APID" << std::endl; - result = returnvalue::FAILED; - break; - } - } - nextReplyId = supv::NONE; + // TODO: Fix + // ExecutionReport exe(data, SIZE_EXE_REPORT); + // result = exe.checkSize(); + // if (result != returnvalue::OK) { + // return result; + // } + // + // result = exe.checkCrc(); + // if (result != returnvalue::OK) { + // sif::error << "PlocSupervisorHandler::handleExecutionReport: CRC failure" << std::endl; + // nextReplyId = supv::NONE; + // return result; + // } + // + // result = exe.checkApid(); + // + // switch (result) { + // case (returnvalue::OK): { + // handleExecutionSuccessReport(data); + // break; + // } + // case (SupvReturnValuesIF::RECEIVED_EXE_FAILURE): { + // handleExecutionFailureReport(exe.getStatusCode()); + // result = returnvalue::OK; + // break; + // } + // default: { + // sif::error << "PlocSupervisorHandler::handleExecutionReport: Unknown APID" << std::endl; + // result = returnvalue::FAILED; + // break; + // } + // } + // nextReplyId = supv::NONE; return result; } @@ -2107,33 +2108,36 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(const uint8_t* DeviceCommandId_t commandId = getPendingCommand(); switch (commandId) { case supv::READ_GPIO: { - supv::ExecutionReport exe(data, supv::SIZE_EXE_REPORT); - if (exe.isNull()) { - return returnvalue::FAILED; - } - ReturnValue_t result = exe.checkSize(); - if (result != returnvalue::OK) { - return result; - } - uint16_t gpioState = exe.getStatusCode(); -#if OBSW_DEBUG_PLOC_SUPERVISOR == 1 - sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl; -#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */ - DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId); - if (iter->second.sendReplyTo == NO_COMMAND_ID) { - return returnvalue::OK; - } - uint8_t data[sizeof(gpioState)]; - size_t size = 0; - result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState), - SerializeIF::Endianness::BIG); - if (result != returnvalue::OK) { - sif::debug << "PlocSupervisorHandler: Failed to deserialize GPIO state" << std::endl; - } - result = actionHelper.reportData(iter->second.sendReplyTo, commandId, data, sizeof(data)); - if (result != returnvalue::OK) { - sif::warning << "PlocSupervisorHandler: Read GPIO, failed to report data" << std::endl; - } + // TODO: Fix + // supv::ExecutionReport exe(data, supv::SIZE_EXE_REPORT); + // if (exe.isNull()) { + // return returnvalue::FAILED; + // } + // ReturnValue_t result = exe.checkSize(); + // if (result != returnvalue::OK) { + // return result; + // } + // uint16_t gpioState = exe.getStatusCode(); + //#if OBSW_DEBUG_PLOC_SUPERVISOR == 1 + // sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl; + //#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */ + // DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId); + // if (iter->second.sendReplyTo == NO_COMMAND_ID) { + // return returnvalue::OK; + // } + // uint8_t data[sizeof(gpioState)]; + // size_t size = 0; + // result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState), + // SerializeIF::Endianness::BIG); + // if (result != returnvalue::OK) { + // sif::debug << "PlocSupervisorHandler: Failed to deserialize GPIO state" << + // std::endl; + // } + // result = actionHelper.reportData(iter->second.sendReplyTo, commandId, data, + // sizeof(data)); if (result != returnvalue::OK) { + // sif::warning << "PlocSupervisorHandler: Read GPIO, failed to report data" << + // std::endl; + // } break; } case supv::SET_TIME_REF: { diff --git a/linux/devices/ploc/PlocSupvUartMan.cpp b/linux/devices/ploc/PlocSupvUartMan.cpp index 604a6c5e..53488ce2 100644 --- a/linux/devices/ploc/PlocSupvUartMan.cpp +++ b/linux/devices/ploc/PlocSupvUartMan.cpp @@ -501,7 +501,7 @@ ReturnValue_t PlocSupvHelper::prepareUpdate() { ReturnValue_t result = returnvalue::OK; resetSpParams(); supv::NoPayloadPacket packet(spParams, Apids::BOOT_MAN, - static_cast(BootManServiceIds::PREPARE_UPDATE)); + static_cast(tc::BootManId::PREPARE_UPDATE)); result = packet.buildPacket(); if (result != returnvalue::OK) { return result; @@ -522,7 +522,7 @@ ReturnValue_t PlocSupvHelper::eraseMemory() { if (result != returnvalue::OK) { return result; } - result = handlePacketTransmission(eraseMemory, supv::recv_timeout::ERASE_MEMORY); + result = handlePacketTransmission(eraseMemory, supv::timeout::ERASE_MEMORY); if (result != returnvalue::OK) { return result; } @@ -562,27 +562,28 @@ ReturnValue_t PlocSupvHelper::sendCommand(ploc::SpTcBase& packet) { ReturnValue_t PlocSupvHelper::handleAck() { ReturnValue_t result = returnvalue::OK; - result = handleTmReception(supv::SIZE_ACK_REPORT); - if (result != returnvalue::OK) { - triggerEvent(ACK_RECEPTION_FAILURE, result, static_cast(rememberApid)); - sif::warning << "PlocSupvHelper::handleAck: Error in reception of acknowledgment report" - << std::endl; - return result; - } - supv::AcknowledgmentReport ackReport(tmBuf.data(), tmBuf.size()); - result = checkReceivedTm(ackReport); - if (result != returnvalue::OK) { - return result; - } - result = ackReport.checkApid(); - if (result != returnvalue::OK) { - if (result == SupvReturnValuesIF::RECEIVED_ACK_FAILURE) { - triggerEvent(SUPV_ACK_FAILURE_REPORT, static_cast(ackReport.getRefApid())); - } else if (result == SupvReturnValuesIF::INVALID_APID) { - triggerEvent(SUPV_ACK_INVALID_APID, static_cast(rememberApid)); - } - return result; - } + // TODO: Fix + // result = handleTmReception(supv::SIZE_ACK_REPORT); + // if (result != returnvalue::OK) { + // triggerEvent(ACK_RECEPTION_FAILURE, result, static_cast(rememberApid)); + // sif::warning << "PlocSupvHelper::handleAck: Error in reception of acknowledgment report" + // << std::endl; + // return result; + // } + // supv::AcknowledgmentReport ackReport(tmBuf.data(), tmBuf.size()); + // result = checkReceivedTm(ackReport); + // if (result != returnvalue::OK) { + // return result; + // } + // result = ackReport.checkApid(); + // if (result != returnvalue::OK) { + // if (result == SupvReturnValuesIF::RECEIVED_ACK_FAILURE) { + // triggerEvent(SUPV_ACK_FAILURE_REPORT, static_cast(ackReport.getRefApid())); + // } else if (result == SupvReturnValuesIF::INVALID_APID) { + // triggerEvent(SUPV_ACK_INVALID_APID, static_cast(rememberApid)); + // } + // return result; + // } return returnvalue::OK; } @@ -601,22 +602,23 @@ ReturnValue_t PlocSupvHelper::handleExe(uint32_t timeout) { } ReturnValue_t PlocSupvHelper::exeReportHandling() { - supv::ExecutionReport exeReport(tmBuf.data(), tmBuf.size()); - - ReturnValue_t result = checkReceivedTm(exeReport); - if (result != returnvalue::OK) { - return result; - } - result = exeReport.checkApid(); - if (result != returnvalue::OK) { - if (result == SupvReturnValuesIF::RECEIVED_EXE_FAILURE) { - triggerEvent(SUPV_EXE_FAILURE_REPORT, static_cast(exeReport.getRefApid())); - } else if (result == SupvReturnValuesIF::INVALID_APID) { - triggerEvent(SUPV_EXE_INVALID_APID, static_cast(rememberApid)); - } - return result; - } - return result; + // TODO: Fix + // supv::ExecutionReport exeReport(tmBuf.data(), tmBuf.size()); + // + // ReturnValue_t result = checkReceivedTm(exeReport); + // if (result != returnvalue::OK) { + // return result; + // } + // result = exeReport.checkApid(); + // if (result != returnvalue::OK) { + // if (result == SupvReturnValuesIF::RECEIVED_EXE_FAILURE) { + // triggerEvent(SUPV_EXE_FAILURE_REPORT, static_cast(exeReport.getRefApid())); + // } else if (result == SupvReturnValuesIF::INVALID_APID) { + // triggerEvent(SUPV_EXE_INVALID_APID, static_cast(rememberApid)); + // } + // return result; + // } + return OK; } ReturnValue_t PlocSupvHelper::handleTmReception(size_t remainingBytes, uint8_t* readBuf, @@ -753,7 +755,7 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() { } bool exeAlreadyHandled = false; - uint32_t timeout = std::max(CRC_EXECUTION_TIMEOUT, supv::recv_timeout::UPDATE_STATUS_REPORT); + uint32_t timeout = std::max(CRC_EXECUTION_TIMEOUT, supv::timeout::UPDATE_STATUS_REPORT); result = handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), timeout); ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size()); if (spReader.getApid() == supv::APID_EXE_FAILURE) { @@ -762,7 +764,7 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() { } else if (spReader.getApid() == supv::APID_UPDATE_STATUS_REPORT) { size_t remBytes = spReader.getPacketDataLen() + 1; result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN, - supv::recv_timeout::UPDATE_STATUS_REPORT); + supv::timeout::UPDATE_STATUS_REPORT); if (result != returnvalue::OK) { sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: Failed to receive update status report" @@ -860,8 +862,8 @@ ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reade return EVENT_BUFFER_REPLY_INVALID_APID; } // TODO: Fix -// file.write(reinterpret_cast(reader.getPacketData()), -// reader.getPayloadDataLength()); + // file.write(reinterpret_cast(reader.getPacketData()), + // reader.getPayloadDataLength()); } return result; } diff --git a/mission/devices/devicedefinitions/SpBase.h b/mission/devices/devicedefinitions/SpBase.h index 6cd4a803..f34e921a 100644 --- a/mission/devices/devicedefinitions/SpBase.h +++ b/mission/devices/devicedefinitions/SpBase.h @@ -102,7 +102,7 @@ class SpTmReader : public SpacePacketReader { return setReadOnlyData(buf, maxSize); } - ReturnValue_t checkCrc() { + ReturnValue_t checkCrc() const { if (CRC::crc16ccitt(getFullData(), getFullPacketLen()) != 0) { return returnvalue::FAILED; }