eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 121 Wiki Activity

v1.17.0 #327

Merged
muellerr merged 131 commits from develop into main 2022-11-28 18:29:31 +01:00
Conversation 0 Commits 131 Files Changed 69 +329 -263
5 changed files with 329 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 4515703efa - Show all commits

2
fsfw

@ -1 +1 @@
Subproject commit 672fca5169b017387e58e2ff864913d932c59aa1 Subproject commit 0e8f5ddd26d586dd40e69f52aef1a63c0d5a9da6

260
linux/devices/devicedefinitions/PlocSupervisorDefinitions.h
View File

@ -17,6 +17,12 @@ using namespace returnvalue;
namespace supv { 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 { typedef struct {
// The most significant bit of msec value is set to 0x80 to indicate that full // 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 // time and data information is transmitted, when the time has been synced with
@ -135,14 +141,16 @@ enum Apids {
WDOG_MAN = 0x07 WDOG_MAN = 0x07
}; };
enum class HkServiceIds : uint8_t { namespace tc {
enum class HkId : uint8_t {
ENABLE = 0x01, ENABLE = 0x01,
SET_PERIOD = 0x02, SET_PERIOD = 0x02,
GET_REPORT = 0x03, GET_REPORT = 0x03,
GET_HARDFAULTS_REPORT = 0x04, GET_HARDFAULTS_REPORT = 0x04,
}; };
enum class TmtcServiceIds : uint8_t { enum class TmtcId : uint8_t {
TIME_REF = 0x03, TIME_REF = 0x03,
GET_SUPV_VERSION = 0x05, GET_SUPV_VERSION = 0x05,
RUN_AUTO_EM_TEST = 0x08, RUN_AUTO_EM_TEST = 0x08,
@ -151,7 +159,7 @@ enum class TmtcServiceIds : uint8_t {
GET_MPSOC_POWER_INFO = 0x10 GET_MPSOC_POWER_INFO = 0x10
}; };
enum class BootManServiceIds : uint8_t { enum class BootManId : uint8_t {
START_MPSOC = 0x01, START_MPSOC = 0x01,
SHUTDOWN_MPSOC = 0x02, SHUTDOWN_MPSOC = 0x02,
SELECT_IMAGE = 0x03, SELECT_IMAGE = 0x03,
@ -165,7 +173,7 @@ enum class BootManServiceIds : uint8_t {
FACTORY_FLASH = 0x0C FACTORY_FLASH = 0x0C
}; };
enum class LatchupMonServiceIds : uint8_t { enum class LatchupMonId : uint8_t {
ENABLE = 0x01, ENABLE = 0x01,
DISABLE = 0x02, DISABLE = 0x02,
SET_ALERT_LIMIT = 0x04, 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 // Right now, none of the commands seem to be implemented, but still
// keep the enum here in case some are added // keep the enum here in case some are added
enum class AdcMonServiceIds : uint8_t { enum class AdcMonId : uint8_t {
SET_SWEEP_PERIOD = 0x01, SET_SWEEP_PERIOD = 0x01,
SET_ENABLED_CHANNELS = 0x02, SET_ENABLED_CHANNELS = 0x02,
SET_WINDOW_STRIDE = 0x03, SET_WINDOW_STRIDE = 0x03,
@ -182,9 +190,9 @@ enum class AdcMonServiceIds : uint8_t {
COPY_ADC_DATA_TO_MRAM = 0x05 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, WIPE_MRAM = 0x05,
DUMP_MRAM = 0x06, DUMP_MRAM = 0x06,
FACTORY_RESET = 0x07 FACTORY_RESET = 0x07
@ -192,7 +200,23 @@ enum class DataLoggerServiceIds : uint8_t {
// Right now, none of the commands seem to be implemented, but still // Right now, none of the commands seem to be implemented, but still
// keep the enum here in case some are added // 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 APID_MASK = 0x3FF;
static const uint16_t SEQUENCE_COUNT_MASK = 0xFFF; 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 LOGGING_RPT_ID = LOGGING_REPORT;
static const uint32_t ADC_REPORT_SET_ID = ADC_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 // Erase memory can require up to 60 seconds for execution
static const uint32_t ERASE_MEMORY = 60000; static const uint32_t ERASE_MEMORY = 60000;
static const uint32_t UPDATE_STATUS_REPORT = 70000; static const uint32_t UPDATE_STATUS_REPORT = 70000;
} // namespace recv_timeout } // namespace timeout
static constexpr size_t TIMESTAMP_LEN = 7; static constexpr size_t TIMESTAMP_LEN = 7;
static constexpr size_t SECONDARY_HEADER_LEN = TIMESTAMP_LEN + 1; static constexpr size_t SECONDARY_HEADER_LEN = TIMESTAMP_LEN + 1;
@ -386,23 +410,29 @@ class TcBase : public ploc::SpTcBase {
} }
}; };
class TmBase: public ploc::SpTmReader { class TmBase : public ploc::SpTmReader {
public: public:
TmBase(const uint8_t* data, size_t maxSize): ploc::SpTmReader(data, maxSize) { TmBase(const uint8_t* data, size_t maxSize) : ploc::SpTmReader(data, maxSize) {
if(maxSize < MIN_TMTC_LEN) { if (maxSize < MIN_TMTC_LEN) {
sif::error << "SupvTcBase::SupvTcBase: Passed buffer is too small" << std::endl; sif::error << "SupvTcBase::SupvTcBase: Passed buffer is too small" << std::endl;
} }
} }
uint8_t getServiceId() { bool verifyCrc() {
return getPacketData()[TIMESTAMP_LEN]; if (checkCrc() == returnvalue::OK) {
crcOk = true;
}
return crcOk;
} }
const uint8_t* getPayloadStart() { bool crcIsOk() const { return crcOk; }
return getPacketData() + SECONDARY_HEADER_LEN;
}
private:
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 { class NoPayloadPacket : public TcBase {
@ -444,7 +474,7 @@ class MPSoCBootSelect : public TcBase {
* @note Selection of partitions is currently not supported. * @note Selection of partitions is currently not supported.
*/ */
MPSoCBootSelect(TcParams params) MPSoCBootSelect(TcParams params)
: TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::SELECT_IMAGE), 4) {} : TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SELECT_IMAGE), 4) {}
ReturnValue_t buildPacket(uint8_t mem = 0, uint8_t bp0 = 0, uint8_t bp1 = 0, uint8_t bp2 = 0) { ReturnValue_t buildPacket(uint8_t mem = 0, uint8_t bp0 = 0, uint8_t bp1 = 0, uint8_t bp2 = 0) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -471,7 +501,7 @@ class SetTimeRef : public TcBase {
public: public:
static constexpr size_t PAYLOAD_LEN = 8; static constexpr size_t PAYLOAD_LEN = 8;
SetTimeRef(TcParams params) SetTimeRef(TcParams params)
: TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(TmtcServiceIds::TIME_REF), 8) {} : TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(tc::TmtcId::TIME_REF), 8) {}
ReturnValue_t buildPacket(Clock::TimeOfDay_t* time) { ReturnValue_t buildPacket(Clock::TimeOfDay_t* time) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -546,7 +576,7 @@ class SetBootTimeout : public TcBase {
* @param timeout The boot timeout in milliseconds. * @param timeout The boot timeout in milliseconds.
*/ */
SetBootTimeout(TcParams params) SetBootTimeout(TcParams params)
: TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::SET_BOOT_TIMEOUT), : TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SET_BOOT_TIMEOUT),
PAYLOAD_LEN) {} PAYLOAD_LEN) {}
ReturnValue_t buildPacket(uint32_t timeout) { ReturnValue_t buildPacket(uint32_t timeout) {
@ -578,8 +608,8 @@ class SetRestartTries : public TcBase {
* @param restartTries Maximum restart tries to set. * @param restartTries Maximum restart tries to set.
*/ */
SetRestartTries(TcParams params) SetRestartTries(TcParams params)
: TcBase(params, Apids::BOOT_MAN, : TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SET_MAX_REBOOT_TRIES),
static_cast<uint8_t>(BootManServiceIds::SET_MAX_REBOOT_TRIES), 1) {} 1) {}
ReturnValue_t buildPacket(uint8_t restartTries) { ReturnValue_t buildPacket(uint8_t restartTries) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -607,7 +637,7 @@ class DisablePeriodicHkTransmission : public TcBase {
* @brief Constructor * @brief Constructor
*/ */
DisablePeriodicHkTransmission(TcParams params) DisablePeriodicHkTransmission(TcParams params)
: TcBase(params, Apids::HK, static_cast<uint8_t>(HkServiceIds::ENABLE), 1) {} : TcBase(params, Apids::HK, static_cast<uint8_t>(tc::HkId::ENABLE), 1) {}
ReturnValue_t buildPacket() { ReturnValue_t buildPacket() {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -640,9 +670,9 @@ class LatchupAlert : public TcBase {
ReturnValue_t buildPacket(bool state, uint8_t latchupId) { ReturnValue_t buildPacket(bool state, uint8_t latchupId) {
if (state) { if (state) {
setServiceId(static_cast<uint8_t>(LatchupMonServiceIds::ENABLE)); setServiceId(static_cast<uint8_t>(tc::LatchupMonId::ENABLE));
} else { } else {
setServiceId(static_cast<uint8_t>(LatchupMonServiceIds::DISABLE)); setServiceId(static_cast<uint8_t>(tc::LatchupMonId::DISABLE));
} }
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
if (res != returnvalue::OK) { if (res != returnvalue::OK) {
@ -668,8 +698,8 @@ class SetAlertlimit : public TcBase {
* @param dutycycle * @param dutycycle
*/ */
SetAlertlimit(TcParams params) SetAlertlimit(TcParams params)
: TcBase(params, Apids::LATCHUP_MON, : TcBase(params, Apids::LATCHUP_MON, static_cast<uint8_t>(tc::LatchupMonId::SET_ALERT_LIMIT),
static_cast<uint8_t>(LatchupMonServiceIds::SET_ALERT_LIMIT), 5) {} 5) {}
ReturnValue_t buildPacket(uint8_t latchupId, uint32_t dutycycle) { ReturnValue_t buildPacket(uint8_t latchupId, uint32_t dutycycle) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -708,8 +738,7 @@ class SetAdcWindowAndStride : public TcBase {
* @param stridingStepSize * @param stridingStepSize
*/ */
SetAdcWindowAndStride(TcParams params) SetAdcWindowAndStride(TcParams params)
: TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(AdcMonServiceIds::SET_WINDOW_STRIDE), : TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::SET_WINDOW_STRIDE), 4) {}
4) {}
ReturnValue_t buildPacket(uint16_t windowSize, uint16_t stridingStepSize) { ReturnValue_t buildPacket(uint16_t windowSize, uint16_t stridingStepSize) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -742,8 +771,7 @@ class SetAdcThreshold : public TcBase {
* @param threshold * @param threshold
*/ */
SetAdcThreshold(TcParams params) SetAdcThreshold(TcParams params)
: TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(AdcMonServiceIds::SET_ADC_THRESHOLD), : TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::SET_ADC_THRESHOLD), 4) {}
4) {}
ReturnValue_t buildPacket(uint32_t threshold) { ReturnValue_t buildPacket(uint32_t threshold) {
auto res = checkSizeAndSerializeHeader(); 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) * @param test 1 - complete EM test, 2 - Short test (only memory readback NVM0,1,3)
*/ */
RunAutoEmTests(TcParams params) RunAutoEmTests(TcParams params)
: TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(TmtcServiceIds::RUN_AUTO_EM_TEST), 1) { : TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(tc::TmtcId::RUN_AUTO_EM_TEST), 1) {}
}
ReturnValue_t buildPacket(uint8_t test) { ReturnValue_t buildPacket(uint8_t test) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -805,7 +832,7 @@ class SetGpio : public TcBase {
* @param val * @param val
*/ */
SetGpio(TcParams params) SetGpio(TcParams params)
: TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(TmtcServiceIds::SET_GPIO), 3) {} : TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(tc::TmtcId::SET_GPIO), 3) {}
ReturnValue_t buildPacket(uint8_t port, uint8_t pin, uint8_t val) { ReturnValue_t buildPacket(uint8_t port, uint8_t pin, uint8_t val) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -841,7 +868,7 @@ class ReadGpio : public TcBase {
* @param pin * @param pin
*/ */
ReadGpio(TcParams params) ReadGpio(TcParams params)
: TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(TmtcServiceIds::READ_GPIO), 2) {} : TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(tc::TmtcId::READ_GPIO), 2) {}
ReturnValue_t buildPacket(uint8_t port, uint8_t pin) { ReturnValue_t buildPacket(uint8_t port, uint8_t pin) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -865,8 +892,7 @@ class ReadGpio : public TcBase {
class SetShutdownTimeout : public TcBase { class SetShutdownTimeout : public TcBase {
public: public:
SetShutdownTimeout(TcParams params) SetShutdownTimeout(TcParams params)
: TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::SHUTDOWN_TIMEOUT), : TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SHUTDOWN_TIMEOUT), 4) {}
4) {}
ReturnValue_t buildPacket(uint32_t timeout) { ReturnValue_t buildPacket(uint32_t timeout) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -898,7 +924,7 @@ class CheckMemory : public TcBase {
* @param length Length in bytes of memory region * @param length Length in bytes of memory region
*/ */
CheckMemory(TcParams params) CheckMemory(TcParams params)
: TcBase(params, Apids::MEM_MAN, static_cast<uint8_t>(MemManServiceIds::CHECK), 10) {} : TcBase(params, Apids::MEM_MAN, static_cast<uint8_t>(tc::MemManId::CHECK), 10) {}
ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) { ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -938,7 +964,7 @@ class WriteMemory : public TcBase {
* @param updateData Pointer to buffer containing update data * @param updateData Pointer to buffer containing update data
*/ */
WriteMemory(TcParams params) WriteMemory(TcParams params)
: TcBase(params, Apids::MEM_MAN, static_cast<uint8_t>(MemManServiceIds::WRITE), 1) {} : TcBase(params, Apids::MEM_MAN, static_cast<uint8_t>(tc::MemManId::WRITE), 1) {}
ReturnValue_t buildPacket(ccsds::SequenceFlags seqFlags, uint16_t sequenceCount, uint8_t memoryId, ReturnValue_t buildPacket(ccsds::SequenceFlags seqFlags, uint16_t sequenceCount, uint8_t memoryId,
uint32_t startAddress, uint16_t length, uint8_t* updateData) { uint32_t startAddress, uint16_t length, uint8_t* updateData) {
@ -1001,8 +1027,7 @@ class WriteMemory : public TcBase {
class EraseMemory : public TcBase { class EraseMemory : public TcBase {
public: public:
EraseMemory(TcParams params) EraseMemory(TcParams params)
: TcBase(params, Apids::MEM_MAN, static_cast<uint8_t>(MemManServiceIds::ERASE), : TcBase(params, Apids::MEM_MAN, static_cast<uint8_t>(tc::MemManId::ERASE), PAYLOAD_LENGTH) {}
PAYLOAD_LENGTH) {}
ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) { ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -1032,61 +1057,95 @@ class EraseMemory : public TcBase {
} }
}; };
class VerificationReport : public ploc::SpTmReader { class VerificationReport {
public: 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. * @brief Gets the APID of command which caused the transmission of this verification report.
*/ */
uint16_t getRefApid() { uint8_t getRefApid() const { return refApid; }
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;
}
uint16_t getStatusCode() { uint8_t getRefServiceId() const { return refServiceId; }
uint16_t statusCode = 0;
size_t size = 0; uint16_t getRefSequenceCount() const { return refSeqCount; }
const uint8_t* statusCodePtr = this->getPacketData() + OFFSET_STATUS_CODE;
ReturnValue_t result = SerializeAdapter::deSerialize(&statusCode, statusCodePtr, &size, uint32_t getStatusCode() const { return statusCode; }
SerializeIF::Endianness::BIG);
if (result != returnvalue::OK) {
sif::debug << "ExecutionReport: Failed to deserialize status code field" << std::endl;
return result;
}
return statusCode;
}
virtual ReturnValue_t checkApid() { return returnvalue::FAILED; } virtual ReturnValue_t checkApid() { return returnvalue::FAILED; }
private: 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 { class AcknowledgmentReport : public VerificationReport {
public: public:
AcknowledgmentReport(const uint8_t* buf, size_t maxSize) : VerificationReport(buf, maxSize) {} AcknowledgmentReport(TmBase& readerBase) : VerificationReport(readerBase) {}
ReturnValue_t checkApid() { virtual ReturnValue_t parse() override {
uint16_t apid = this->getApid(); // if (readerBase.getServiceId() != )
if (apid == APID_ACK_SUCCESS) { // uint16_t apid = this->getApid();
return returnvalue::OK; // if (apid == APID_ACK_SUCCESS) {
} else if (apid == APID_ACK_FAILURE) { // return returnvalue::OK;
printStatusInformation(); // } else if (apid == APID_ACK_FAILURE) {
return SupvReturnValuesIF::RECEIVED_ACK_FAILURE; // printStatusInformation();
} else { // return SupvReturnValuesIF::RECEIVED_ACK_FAILURE;
sif::warning << "AcknowledgmentReport::checkApid: Invalid apid: 0x" << std::hex << apid // } else {
<< std::endl; // sif::warning << "AcknowledgmentReport::checkApid: Invalid apid: 0x" << std::hex << apid
return SupvReturnValuesIF::INVALID_APID; // << std::endl;
} // return SupvReturnValuesIF::INVALID_APID;
// }
return OK;
} }
void printStatusInformation() { void printStatusInformation() {
@ -1147,20 +1206,21 @@ class AcknowledgmentReport : public VerificationReport {
class ExecutionReport : public VerificationReport { class ExecutionReport : public VerificationReport {
public: public:
ExecutionReport(const uint8_t* buf, size_t maxSize) : VerificationReport(buf, maxSize) {} ExecutionReport(TmBase& readerBase) : VerificationReport(readerBase) {}
ReturnValue_t checkApid() { ReturnValue_t parse() override {
uint16_t apid = this->getApid(); /* uint16_t apid = this->getApid();
if (apid == APID_EXE_SUCCESS) { if (apid == APID_EXE_SUCCESS) {
return returnvalue::OK; return returnvalue::OK;
} else if (apid == APID_EXE_FAILURE) { } else if (apid == APID_EXE_FAILURE) {
printStatusInformation(); printStatusInformation();
return SupvReturnValuesIF::RECEIVED_EXE_FAILURE; return SupvReturnValuesIF::RECEIVED_EXE_FAILURE;
} else { } else {
sif::warning << "ExecutionReport::checkApid: Invalid apid: 0x" << std::hex << apid sif::warning << "ExecutionReport::checkApid: Invalid apid: 0x" << std::hex << apid
<< std::endl; << std::endl;
return SupvReturnValuesIF::INVALID_APID; return SupvReturnValuesIF::INVALID_APID;
} }*/
return OK;
} }
private: private:
@ -1808,9 +1868,9 @@ class MramCmd : public TcBase {
ReturnValue_t buildPacket(uint32_t start, uint32_t stop, MramAction action) { ReturnValue_t buildPacket(uint32_t start, uint32_t stop, MramAction action) {
if (action == MramAction::WIPE) { if (action == MramAction::WIPE) {
setServiceId(static_cast<uint8_t>(DataLoggerServiceIds::WIPE_MRAM)); setServiceId(static_cast<uint8_t>(tc::DataLoggerServiceId::WIPE_MRAM));
} else if (action == MramAction::DUMP) { } else if (action == MramAction::DUMP) {
setServiceId(static_cast<uint8_t>(DataLoggerServiceIds::DUMP_MRAM)); setServiceId(static_cast<uint8_t>(tc::DataLoggerServiceId::DUMP_MRAM));
} else { } else {
sif::debug << "WipeMram: Invalid action specified"; sif::debug << "WipeMram: Invalid action specified";
} }
@ -1899,7 +1959,7 @@ class SetAdcEnabledChannels : public TcBase {
* @param ch Defines channels to be enabled or disabled. * @param ch Defines channels to be enabled or disabled.
*/ */
SetAdcEnabledChannels(TcParams params) SetAdcEnabledChannels(TcParams params)
: TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(AdcMonServiceIds::SET_ENABLED_CHANNELS), : TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::SET_ENABLED_CHANNELS),
2) {} 2) {}
ReturnValue_t buildPacket(uint16_t ch) { ReturnValue_t buildPacket(uint16_t ch) {

240
linux/devices/ploc/PlocSupervisorHandler.cpp
View File

@ -221,17 +221,17 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
spParams.buf = commandBuffer; spParams.buf = commandBuffer;
switch (deviceCommand) { switch (deviceCommand) {
case GET_HK_REPORT: { case GET_HK_REPORT: {
prepareEmptyCmd(Apids::HK, static_cast<uint8_t>(HkServiceIds::GET_REPORT)); prepareEmptyCmd(Apids::HK, static_cast<uint8_t>(tc::HkId::GET_REPORT));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
case START_MPSOC: { case START_MPSOC: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::START_MPSOC)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::START_MPSOC));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
case SHUTDOWN_MPSOC: { case SHUTDOWN_MPSOC: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::SHUTDOWN_MPSOC)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SHUTDOWN_MPSOC));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -241,7 +241,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case RESET_MPSOC: { case RESET_MPSOC: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::RESET_MPSOC)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_MPSOC));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -265,8 +265,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case GET_BOOT_STATUS_REPORT: { case GET_BOOT_STATUS_REPORT: {
prepareEmptyCmd(Apids::BOOT_MAN, prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::GET_BOOT_STATUS_REPORT));
static_cast<uint8_t>(BootManServiceIds::GET_BOOT_STATUS_REPORT));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -299,7 +298,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
// } // }
case GET_LATCHUP_STATUS_REPORT: { case GET_LATCHUP_STATUS_REPORT: {
prepareEmptyCmd(Apids::LATCHUP_MON, prepareEmptyCmd(Apids::LATCHUP_MON,
static_cast<uint8_t>(LatchupMonServiceIds::GET_STATUS_REPORT)); static_cast<uint8_t>(tc::LatchupMonId::GET_STATUS_REPORT));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -380,7 +379,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case FACTORY_FLASH: { case FACTORY_FLASH: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::FACTORY_FLASH)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::FACTORY_FLASH));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -434,7 +433,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
// break; // break;
// } // }
case RESET_PL: { case RESET_PL: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::RESET_PL)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_PL));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -930,56 +929,57 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
using namespace supv; using namespace supv;
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
AcknowledgmentReport ack(data, SIZE_ACK_REPORT); // TODO: Fix
result = ack.checkSize(); // AcknowledgmentReport ack(data, SIZE_ACK_REPORT);
if (result != returnvalue::OK) { // result = ack.checkSize();
return result; // if (result != returnvalue::OK) {
} // return result;
// }
result = ack.checkCrc(); //
if (result != returnvalue::OK) { // result = ack.checkCrc();
sif::error << "PlocSupervisorHandler::handleAckReport: CRC failure" << std::endl; // if (result != returnvalue::OK) {
nextReplyId = supv::NONE; // sif::error << "PlocSupervisorHandler::handleAckReport: CRC failure" << std::endl;
replyRawReplyIfnotWiretapped(data, supv::SIZE_ACK_REPORT); // nextReplyId = supv::NONE;
triggerEvent(SUPV_CRC_FAILURE_EVENT); // replyRawReplyIfnotWiretapped(data, supv::SIZE_ACK_REPORT);
sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::CRC_FAILURE); // triggerEvent(SUPV_CRC_FAILURE_EVENT);
disableAllReplies(); // sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::CRC_FAILURE);
return returnvalue::OK; // disableAllReplies();
} // return returnvalue::OK;
// }
result = ack.checkApid(); //
// result = ack.checkApid();
switch (result) { //
case SupvReturnValuesIF::RECEIVED_ACK_FAILURE: { // switch (result) {
DeviceCommandId_t commandId = getPendingCommand(); // case SupvReturnValuesIF::RECEIVED_ACK_FAILURE: {
if (commandId != DeviceHandlerIF::NO_COMMAND_ID) { // DeviceCommandId_t commandId = getPendingCommand();
triggerEvent(SUPV_ACK_FAILURE, commandId, static_cast<uint32_t>(ack.getStatusCode())); // if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
} // triggerEvent(SUPV_ACK_FAILURE, commandId, static_cast<uint32_t>(ack.getStatusCode()));
printAckFailureInfo(ack.getStatusCode(), commandId); // }
sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::RECEIVED_ACK_FAILURE); // printAckFailureInfo(ack.getStatusCode(), commandId);
disableAllReplies(); // sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::RECEIVED_ACK_FAILURE);
nextReplyId = supv::NONE; // disableAllReplies();
result = IGNORE_REPLY_DATA; // nextReplyId = supv::NONE;
break; // result = IGNORE_REPLY_DATA;
} // break;
case returnvalue::OK: { // }
setNextReplyId(); // case returnvalue::OK: {
break; // setNextReplyId();
} // break;
case SupvReturnValuesIF::INVALID_APID: // }
sif::warning << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report" // case SupvReturnValuesIF::INVALID_APID:
<< std::endl; // sif::warning << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report"
sendFailureReport(supv::ACK_REPORT, result); // << std::endl;
disableAllReplies(); // sendFailureReport(supv::ACK_REPORT, result);
nextReplyId = supv::NONE; // disableAllReplies();
result = IGNORE_REPLY_DATA; // nextReplyId = supv::NONE;
break; // result = IGNORE_REPLY_DATA;
default: { // break;
sif::error << "PlocSupervisorHandler::handleAckReport: APID parsing failed" << std::endl; // default: {
result = returnvalue::FAILED; // sif::error << "PlocSupervisorHandler::handleAckReport: APID parsing failed" << std::endl;
break; // result = returnvalue::FAILED;
} // break;
} // }
// }
return result; return result;
} }
@ -987,38 +987,39 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
using namespace supv; using namespace supv;
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
ExecutionReport exe(data, SIZE_EXE_REPORT); // TODO: Fix
result = exe.checkSize(); // ExecutionReport exe(data, SIZE_EXE_REPORT);
if (result != returnvalue::OK) { // result = exe.checkSize();
return result; // if (result != returnvalue::OK) {
} // return result;
// }
result = exe.checkCrc(); //
if (result != returnvalue::OK) { // result = exe.checkCrc();
sif::error << "PlocSupervisorHandler::handleExecutionReport: CRC failure" << std::endl; // if (result != returnvalue::OK) {
nextReplyId = supv::NONE; // sif::error << "PlocSupervisorHandler::handleExecutionReport: CRC failure" << std::endl;
return result; // nextReplyId = supv::NONE;
} // return result;
// }
result = exe.checkApid(); //
// result = exe.checkApid();
switch (result) { //
case (returnvalue::OK): { // switch (result) {
handleExecutionSuccessReport(data); // case (returnvalue::OK): {
break; // handleExecutionSuccessReport(data);
} // break;
case (SupvReturnValuesIF::RECEIVED_EXE_FAILURE): { // }
handleExecutionFailureReport(exe.getStatusCode()); // case (SupvReturnValuesIF::RECEIVED_EXE_FAILURE): {
result = returnvalue::OK; // handleExecutionFailureReport(exe.getStatusCode());
break; // result = returnvalue::OK;
} // break;
default: { // }
sif::error << "PlocSupervisorHandler::handleExecutionReport: Unknown APID" << std::endl; // default: {
result = returnvalue::FAILED; // sif::error << "PlocSupervisorHandler::handleExecutionReport: Unknown APID" << std::endl;
break; // result = returnvalue::FAILED;
} // break;
} // }
nextReplyId = supv::NONE; // }
// nextReplyId = supv::NONE;
return result; return result;
} }
@ -2107,33 +2108,36 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(const uint8_t*
DeviceCommandId_t commandId = getPendingCommand(); DeviceCommandId_t commandId = getPendingCommand();
switch (commandId) { switch (commandId) {
case supv::READ_GPIO: { case supv::READ_GPIO: {
supv::ExecutionReport exe(data, supv::SIZE_EXE_REPORT); // TODO: Fix
if (exe.isNull()) { // supv::ExecutionReport exe(data, supv::SIZE_EXE_REPORT);
return returnvalue::FAILED; // if (exe.isNull()) {
} // return returnvalue::FAILED;
ReturnValue_t result = exe.checkSize(); // }
if (result != returnvalue::OK) { // ReturnValue_t result = exe.checkSize();
return result; // if (result != returnvalue::OK) {
} // return result;
uint16_t gpioState = exe.getStatusCode(); // }
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1 // uint16_t gpioState = exe.getStatusCode();
sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl; //#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */ // sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl;
DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId); //#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
if (iter->second.sendReplyTo == NO_COMMAND_ID) { // DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId);
return returnvalue::OK; // if (iter->second.sendReplyTo == NO_COMMAND_ID) {
} // return returnvalue::OK;
uint8_t data[sizeof(gpioState)]; // }
size_t size = 0; // uint8_t data[sizeof(gpioState)];
result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState), // size_t size = 0;
SerializeIF::Endianness::BIG); // result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState),
if (result != returnvalue::OK) { // SerializeIF::Endianness::BIG);
sif::debug << "PlocSupervisorHandler: Failed to deserialize GPIO state" << std::endl; // if (result != returnvalue::OK) {
} // sif::debug << "PlocSupervisorHandler: Failed to deserialize GPIO state" <<
result = actionHelper.reportData(iter->second.sendReplyTo, commandId, data, sizeof(data)); // std::endl;
if (result != returnvalue::OK) { // }
sif::warning << "PlocSupervisorHandler: Read GPIO, failed to report data" << 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; break;
} }
case supv::SET_TIME_REF: { case supv::SET_TIME_REF: {

88
linux/devices/ploc/PlocSupvUartMan.cpp
View File

@ -501,7 +501,7 @@ ReturnValue_t PlocSupvHelper::prepareUpdate() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
resetSpParams(); resetSpParams();
supv::NoPayloadPacket packet(spParams, Apids::BOOT_MAN, supv::NoPayloadPacket packet(spParams, Apids::BOOT_MAN,
static_cast<uint8_t>(BootManServiceIds::PREPARE_UPDATE)); static_cast<uint8_t>(tc::BootManId::PREPARE_UPDATE));
result = packet.buildPacket(); result = packet.buildPacket();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -522,7 +522,7 @@ ReturnValue_t PlocSupvHelper::eraseMemory() {
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
result = handlePacketTransmission(eraseMemory, supv::recv_timeout::ERASE_MEMORY); result = handlePacketTransmission(eraseMemory, supv::timeout::ERASE_MEMORY);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
@ -562,27 +562,28 @@ ReturnValue_t PlocSupvHelper::sendCommand(ploc::SpTcBase& packet) {
ReturnValue_t PlocSupvHelper::handleAck() { ReturnValue_t PlocSupvHelper::handleAck() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
result = handleTmReception(supv::SIZE_ACK_REPORT); // TODO: Fix
if (result != returnvalue::OK) { // result = handleTmReception(supv::SIZE_ACK_REPORT);
triggerEvent(ACK_RECEPTION_FAILURE, result, static_cast<uint32_t>(rememberApid)); // if (result != returnvalue::OK) {
sif::warning << "PlocSupvHelper::handleAck: Error in reception of acknowledgment report" // triggerEvent(ACK_RECEPTION_FAILURE, result, static_cast<uint32_t>(rememberApid));
<< std::endl; // sif::warning << "PlocSupvHelper::handleAck: Error in reception of acknowledgment report"
return result; // << std::endl;
} // return result;
supv::AcknowledgmentReport ackReport(tmBuf.data(), tmBuf.size()); // }
result = checkReceivedTm(ackReport); // supv::AcknowledgmentReport ackReport(tmBuf.data(), tmBuf.size());
if (result != returnvalue::OK) { // result = checkReceivedTm(ackReport);
return result; // if (result != returnvalue::OK) {
} // return result;
result = ackReport.checkApid(); // }
if (result != returnvalue::OK) { // result = ackReport.checkApid();
if (result == SupvReturnValuesIF::RECEIVED_ACK_FAILURE) { // if (result != returnvalue::OK) {
triggerEvent(SUPV_ACK_FAILURE_REPORT, static_cast<uint32_t>(ackReport.getRefApid())); // if (result == SupvReturnValuesIF::RECEIVED_ACK_FAILURE) {
} else if (result == SupvReturnValuesIF::INVALID_APID) { // triggerEvent(SUPV_ACK_FAILURE_REPORT, static_cast<uint32_t>(ackReport.getRefApid()));
triggerEvent(SUPV_ACK_INVALID_APID, static_cast<uint32_t>(rememberApid)); // } else if (result == SupvReturnValuesIF::INVALID_APID) {
} // triggerEvent(SUPV_ACK_INVALID_APID, static_cast<uint32_t>(rememberApid));
return result; // }
} // return result;
// }
return returnvalue::OK; return returnvalue::OK;
} }
@ -601,22 +602,23 @@ ReturnValue_t PlocSupvHelper::handleExe(uint32_t timeout) {
} }
ReturnValue_t PlocSupvHelper::exeReportHandling() { ReturnValue_t PlocSupvHelper::exeReportHandling() {
supv::ExecutionReport exeReport(tmBuf.data(), tmBuf.size()); // TODO: Fix
// supv::ExecutionReport exeReport(tmBuf.data(), tmBuf.size());
ReturnValue_t result = checkReceivedTm(exeReport); //
if (result != returnvalue::OK) { // ReturnValue_t result = checkReceivedTm(exeReport);
return result; // if (result != returnvalue::OK) {
} // return result;
result = exeReport.checkApid(); // }
if (result != returnvalue::OK) { // result = exeReport.checkApid();
if (result == SupvReturnValuesIF::RECEIVED_EXE_FAILURE) { // if (result != returnvalue::OK) {
triggerEvent(SUPV_EXE_FAILURE_REPORT, static_cast<uint32_t>(exeReport.getRefApid())); // if (result == SupvReturnValuesIF::RECEIVED_EXE_FAILURE) {
} else if (result == SupvReturnValuesIF::INVALID_APID) { // triggerEvent(SUPV_EXE_FAILURE_REPORT, static_cast<uint32_t>(exeReport.getRefApid()));
triggerEvent(SUPV_EXE_INVALID_APID, static_cast<uint32_t>(rememberApid)); // } else if (result == SupvReturnValuesIF::INVALID_APID) {
} // triggerEvent(SUPV_EXE_INVALID_APID, static_cast<uint32_t>(rememberApid));
return result; // }
} // return result;
return result; // }
return OK;
} }
ReturnValue_t PlocSupvHelper::handleTmReception(size_t remainingBytes, uint8_t* readBuf, ReturnValue_t PlocSupvHelper::handleTmReception(size_t remainingBytes, uint8_t* readBuf,
@ -753,7 +755,7 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
} }
bool exeAlreadyHandled = false; 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); result = handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), timeout);
ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size()); ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size());
if (spReader.getApid() == supv::APID_EXE_FAILURE) { if (spReader.getApid() == supv::APID_EXE_FAILURE) {
@ -762,7 +764,7 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
} else if (spReader.getApid() == supv::APID_UPDATE_STATUS_REPORT) { } else if (spReader.getApid() == supv::APID_UPDATE_STATUS_REPORT) {
size_t remBytes = spReader.getPacketDataLen() + 1; size_t remBytes = spReader.getPacketDataLen() + 1;
result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN, result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN,
supv::recv_timeout::UPDATE_STATUS_REPORT); supv::timeout::UPDATE_STATUS_REPORT);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sif::warning sif::warning
<< "PlocSupvHelper::handleCheckMemoryCommand: Failed to receive update status report" << "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; return EVENT_BUFFER_REPLY_INVALID_APID;
} }
// TODO: Fix // TODO: Fix
// file.write(reinterpret_cast<const char*>(reader.getPacketData()), // file.write(reinterpret_cast<const char*>(reader.getPacketData()),
// reader.getPayloadDataLength()); // reader.getPayloadDataLength());
} }
return result; return result;
} }

2
mission/devices/devicedefinitions/SpBase.h
View File

@ -102,7 +102,7 @@ class SpTmReader : public SpacePacketReader {
return setReadOnlyData(buf, maxSize); return setReadOnlyData(buf, maxSize);
} }
ReturnValue_t checkCrc() { ReturnValue_t checkCrc() const {
if (CRC::crc16ccitt(getFullData(), getFullPacketLen()) != 0) { if (CRC::crc16ccitt(getFullData(), getFullPacketLen()) != 0) {
return returnvalue::FAILED; return returnvalue::FAILED;
} }