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

continue refactoring
All checks were successful
EIVE/eive-obsw/pipeline/pr-develop This commit looks good
Details

Browse Source
This commit is contained in:
Robin Müller 2022-11-08 14:26:52 +01:00
parent cfe7599f62
commit 9d02322cd7
No known key found for this signature in database
GPG Key ID: 71B58F8A3CDFA9AC
4 changed files with 347 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -142,20 +142,20 @@ static const uint16_t SIZE_ADC_REPORT = 72;
/** /**
* SpacePacket apids of telemetry packets * SpacePacket apids of telemetry packets
*/ */
static const uint16_t APID_ACK_SUCCESS = 0x200; // static const uint16_t APID_ACK_SUCCESS = 0x200;
static const uint16_t APID_ACK_FAILURE = 0x201; // static const uint16_t APID_ACK_FAILURE = 0x201;
static const uint16_t APID_EXE_SUCCESS = 0x202; // static const uint16_t APID_EXE_SUCCESS = 0x202;
static const uint16_t APID_EXE_FAILURE = 0x203; // static const uint16_t APID_EXE_FAILURE = 0x203;
static const uint16_t APID_HK_REPORT = 0x204; // static const uint16_t APID_HK_REPORT = 0x204;
static const uint16_t APID_BOOT_STATUS_REPORT = 0x205; // static const uint16_t APID_BOOT_STATUS_REPORT = 0x205;
static const uint16_t APID_UPDATE_STATUS_REPORT = 0x206; // static const uint16_t APID_UPDATE_STATUS_REPORT = 0x206;
static const uint16_t APID_ADC_REPORT = 0x207; // static const uint16_t APID_ADC_REPORT = 0x207;
static const uint16_t APID_LATCHUP_STATUS_REPORT = 0x208; // static const uint16_t APID_LATCHUP_STATUS_REPORT = 0x208;
static const uint16_t APID_SOC_SYSMON = 0x209; // static const uint16_t APID_SOC_SYSMON = 0x209;
static const uint16_t APID_MRAM_DUMP_TM = 0x20A; // static const uint16_t APID_MRAM_DUMP_TM = 0x20A;
static const uint16_t APID_SRAM = 0x20B; // static const uint16_t APID_SRAM = 0x20B;
static const uint16_t APID_NOR_DATA = 0x20C; // static const uint16_t APID_NOR_DATA = 0x20C;
static const uint16_t APID_DATA_LOGGER_DATA = 0x20D; // static const uint16_t APID_DATA_LOGGER_DATA = 0x20D;
/** /**
* APIDs of telecommand packets * APIDs of telecommand packets
@ -163,7 +163,7 @@ static const uint16_t APID_DATA_LOGGER_DATA = 0x20D;
// 2 bits APID SRC, 00 for OBC, 2 bits APID DEST, 01 for SUPV, 7 bits CMD ID -> Mask 0x080 // 2 bits APID SRC, 00 for OBC, 2 bits APID DEST, 01 for SUPV, 7 bits CMD ID -> Mask 0x080
static constexpr uint16_t APID_TC_SUPV_MASK = 0x080; static constexpr uint16_t APID_TC_SUPV_MASK = 0x080;
enum Apids { enum Apid {
TMTC_MAN = 0x00, TMTC_MAN = 0x00,
HK = 0x01, HK = 0x01,
BOOT_MAN = 0x02, BOOT_MAN = 0x02,
@ -445,6 +445,8 @@ class TcBase : public ploc::SpTcBase {
class TmBase : public ploc::SpTmReader { class TmBase : public ploc::SpTmReader {
public: public:
TmBase() = default;
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;
@ -507,7 +509,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>(tc::BootManId::SELECT_IMAGE), 4) {} : TcBase(params, Apid::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();
@ -534,7 +536,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>(tc::TmtcId::TIME_REF), 8) {} : TcBase(params, Apid::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();
@ -609,7 +611,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>(tc::BootManId::SET_BOOT_TIMEOUT), : TcBase(params, Apid::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) {
@ -641,7 +643,7 @@ 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, static_cast<uint8_t>(tc::BootManId::SET_MAX_REBOOT_TRIES), : TcBase(params, Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SET_MAX_REBOOT_TRIES),
1) {} 1) {}
ReturnValue_t buildPacket(uint8_t restartTries) { ReturnValue_t buildPacket(uint8_t restartTries) {
@ -670,7 +672,7 @@ class DisablePeriodicHkTransmission : public TcBase {
* @brief Constructor * @brief Constructor
*/ */
DisablePeriodicHkTransmission(TcParams params) DisablePeriodicHkTransmission(TcParams params)
: TcBase(params, Apids::HK, static_cast<uint8_t>(tc::HkId::ENABLE), 1) {} : TcBase(params, Apid::HK, static_cast<uint8_t>(tc::HkId::ENABLE), 1) {}
ReturnValue_t buildPacket() { ReturnValue_t buildPacket() {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -699,7 +701,7 @@ class LatchupAlert : public TcBase {
* @param latchupId Identifies the latchup to enable/disable (0 - 0.85V, 1 - 1.8V, 2 - MISC, * @param latchupId Identifies the latchup to enable/disable (0 - 0.85V, 1 - 1.8V, 2 - MISC,
* 3 - 3.3V, 4 - NVM_4XO, 5 - MISSION, 6 - SAFECOTS) * 3 - 3.3V, 4 - NVM_4XO, 5 - MISSION, 6 - SAFECOTS)
*/ */
LatchupAlert(TcParams params) : TcBase(params, Apids::LATCHUP_MON) { setLenFromPayloadLen(1); } LatchupAlert(TcParams params) : TcBase(params, Apid::LATCHUP_MON) { setLenFromPayloadLen(1); }
ReturnValue_t buildPacket(bool state, uint8_t latchupId) { ReturnValue_t buildPacket(bool state, uint8_t latchupId) {
if (state) { if (state) {
@ -731,7 +733,7 @@ class SetAlertlimit : public TcBase {
* @param dutycycle * @param dutycycle
*/ */
SetAlertlimit(TcParams params) SetAlertlimit(TcParams params)
: TcBase(params, Apids::LATCHUP_MON, static_cast<uint8_t>(tc::LatchupMonId::SET_ALERT_LIMIT), : TcBase(params, Apid::LATCHUP_MON, static_cast<uint8_t>(tc::LatchupMonId::SET_ALERT_LIMIT),
5) {} 5) {}
ReturnValue_t buildPacket(uint8_t latchupId, uint32_t dutycycle) { ReturnValue_t buildPacket(uint8_t latchupId, uint32_t dutycycle) {
@ -771,7 +773,7 @@ class SetAdcWindowAndStride : public TcBase {
* @param stridingStepSize * @param stridingStepSize
*/ */
SetAdcWindowAndStride(TcParams params) SetAdcWindowAndStride(TcParams params)
: TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::SET_WINDOW_STRIDE), 4) {} : TcBase(params, Apid::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::SET_WINDOW_STRIDE), 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();
@ -804,7 +806,7 @@ class SetAdcThreshold : public TcBase {
* @param threshold * @param threshold
*/ */
SetAdcThreshold(TcParams params) SetAdcThreshold(TcParams params)
: TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::SET_ADC_THRESHOLD), 4) {} : TcBase(params, Apid::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::SET_ADC_THRESHOLD), 4) {}
ReturnValue_t buildPacket(uint32_t threshold) { ReturnValue_t buildPacket(uint32_t threshold) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -834,7 +836,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>(tc::TmtcId::RUN_AUTO_EM_TEST), 1) {} : TcBase(params, Apid::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();
@ -865,7 +867,7 @@ class SetGpio : public TcBase {
* @param val * @param val
*/ */
SetGpio(TcParams params) SetGpio(TcParams params)
: TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(tc::TmtcId::SET_GPIO), 3) {} : TcBase(params, Apid::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();
@ -901,7 +903,7 @@ class ReadGpio : public TcBase {
* @param pin * @param pin
*/ */
ReadGpio(TcParams params) ReadGpio(TcParams params)
: TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(tc::TmtcId::READ_GPIO), 2) {} : TcBase(params, Apid::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();
@ -925,7 +927,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>(tc::BootManId::SHUTDOWN_TIMEOUT), 4) {} : TcBase(params, Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SHUTDOWN_TIMEOUT), 4) {}
ReturnValue_t buildPacket(uint32_t timeout) { ReturnValue_t buildPacket(uint32_t timeout) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -957,7 +959,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>(tc::MemManId::CHECK), 10) {} : TcBase(params, Apid::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();
@ -997,7 +999,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>(tc::MemManId::WRITE), 1) {} : TcBase(params, Apid::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) {
@ -1060,7 +1062,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>(tc::MemManId::ERASE), PAYLOAD_LENGTH) {} : TcBase(params, Apid::MEM_MAN, static_cast<uint8_t>(tc::MemManId::ERASE), 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();
@ -1100,7 +1102,7 @@ class VerificationReport {
if (not readerBase.crcIsOk()) { if (not readerBase.crcIsOk()) {
return result::CRC_FAILURE; return result::CRC_FAILURE;
} }
if (readerBase.getApid() != Apids::TMTC_MAN) { if (readerBase.getApid() != Apid::TMTC_MAN) {
return result::INVALID_APID; return result::INVALID_APID;
} }
if (readerBase.getBufSize() < MIN_PAYLOAD_LEN + 8) { if (readerBase.getBufSize() < MIN_PAYLOAD_LEN + 8) {
@ -1823,7 +1825,7 @@ class FactoryReset : public TcBase {
* *
* @param op * @param op
*/ */
FactoryReset(TcParams params) : TcBase(params, Apids::TMTC_MAN, 0x11, 1) {} FactoryReset(TcParams params) : TcBase(params, Apid::TMTC_MAN, 0x11, 1) {}
ReturnValue_t buildPacket(Op op) { ReturnValue_t buildPacket(Op op) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -1867,7 +1869,7 @@ class EnableNvms : public TcBase {
* @param bp1 Partition pin 1 * @param bp1 Partition pin 1
* @param bp2 Partition pin 2 * @param bp2 Partition pin 2
*/ */
EnableNvms(TcParams params) : TcBase(params, Apids::TMTC_MAN, 0x06, 2) {} EnableNvms(TcParams params) : TcBase(params, Apid::TMTC_MAN, 0x06, 2) {}
ReturnValue_t buildPacket(uint8_t nvm01, uint8_t nvm3) { ReturnValue_t buildPacket(uint8_t nvm01, uint8_t nvm3) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -1901,7 +1903,7 @@ class MramCmd : public TcBase {
* *
* @note The content at the stop address is excluded from the dump or wipe operation. * @note The content at the stop address is excluded from the dump or wipe operation.
*/ */
MramCmd(TcParams params) : TcBase(params, Apids::DATA_LOGGER) { setLenFromPayloadLen(6); } MramCmd(TcParams params) : TcBase(params, Apid::DATA_LOGGER) { setLenFromPayloadLen(6); }
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) {
@ -1996,8 +1998,8 @@ 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>(tc::AdcMonId::SET_ENABLED_CHANNELS), : TcBase(params, Apid::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) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();

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

@ -223,17 +223,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>(tc::HkId::GET_REPORT)); prepareEmptyCmd(Apid::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>(tc::BootManId::START_MPSOC)); prepareEmptyCmd(Apid::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>(tc::BootManId::SHUTDOWN_MPSOC)); prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SHUTDOWN_MPSOC));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -243,7 +243,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case RESET_MPSOC: { case RESET_MPSOC: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_MPSOC)); prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_MPSOC));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -267,7 +267,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case GET_BOOT_STATUS_REPORT: { case GET_BOOT_STATUS_REPORT: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::GET_BOOT_STATUS_REPORT)); prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::GET_BOOT_STATUS_REPORT));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -299,8 +299,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
// break; // break;
// } // }
case GET_LATCHUP_STATUS_REPORT: { case GET_LATCHUP_STATUS_REPORT: {
prepareEmptyCmd(Apids::LATCHUP_MON, prepareEmptyCmd(Apid::LATCHUP_MON, static_cast<uint8_t>(tc::LatchupMonId::GET_STATUS_REPORT));
static_cast<uint8_t>(tc::LatchupMonId::GET_STATUS_REPORT));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -381,7 +380,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case FACTORY_FLASH: { case FACTORY_FLASH: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::FACTORY_FLASH)); prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::FACTORY_FLASH));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -435,7 +434,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
// break; // break;
// } // }
case RESET_PL: { case RESET_PL: {
prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_PL)); prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_PL));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -654,73 +653,66 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t remainingSize, ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t remainingSize,
DeviceCommandId_t* foundId, size_t* foundLen) { DeviceCommandId_t* foundId, size_t* foundLen) {
using namespace supv; using namespace supv;
if (nextReplyId == FIRST_MRAM_DUMP) { // TODO: Is this still required?
*foundId = FIRST_MRAM_DUMP; // if (nextReplyId == FIRST_MRAM_DUMP) {
return parseMramPackets(start, remainingSize, foundLen); // *foundId = FIRST_MRAM_DUMP;
} else if (nextReplyId == CONSECUTIVE_MRAM_DUMP) { // return parseMramPackets(start, remainingSize, foundLen);
*foundId = CONSECUTIVE_MRAM_DUMP; // } else if (nextReplyId == CONSECUTIVE_MRAM_DUMP) {
return parseMramPackets(start, remainingSize, foundLen); // *foundId = CONSECUTIVE_MRAM_DUMP;
} // return parseMramPackets(start, remainingSize, foundLen);
// }
ReturnValue_t result = returnvalue::OK; tmReader.setData(start, remainingSize);
uint16_t apid = tmReader.getApid(); //(*(start) << 8 | *(start + 1)) & APID_MASK;
uint16_t apid = (*(start) << 8 | *(start + 1)) & APID_MASK;
switch (apid) { switch (apid) {
case (APID_ACK_SUCCESS): case (Apid::TMTC_MAN): {
switch (tmReader.getServiceId()) {
case (static_cast<uint8_t>(supv::tm::TmtcId::ACK)):
case (static_cast<uint8_t>(supv::tm::TmtcId::NAK)): {
*foundLen = SIZE_ACK_REPORT; *foundLen = SIZE_ACK_REPORT;
*foundId = ACK_REPORT; *foundId = ACK_REPORT;
return OK;
}
case (static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)):
case (static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)): {
*foundLen = SIZE_EXE_REPORT;
*foundId = EXE_REPORT;
return OK;
}
}
break; break;
case (APID_ACK_FAILURE): }
*foundLen = SIZE_ACK_REPORT; case (Apid::HK): {
*foundId = ACK_REPORT; if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::HkId::REPORT)) {
break;
case (APID_HK_REPORT):
*foundLen = SIZE_HK_REPORT; *foundLen = SIZE_HK_REPORT;
*foundId = HK_REPORT; *foundId = HK_REPORT;
return OK;
} else if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::HkId::HARDFAULTS)) {
handleBadApidServiceCombination(SUPV_UNINIMPLEMENTED_TM, apid, tmReader.getServiceId());
return INVALID_DATA;
}
break; break;
case (APID_BOOT_STATUS_REPORT): }
case (Apid::BOOT_MAN): {
if (tmReader.getServiceId() ==
static_cast<uint8_t>(supv::tm::BootManId::BOOT_STATUS_REPORT)) {
*foundLen = SIZE_BOOT_STATUS_REPORT; *foundLen = SIZE_BOOT_STATUS_REPORT;
*foundId = BOOT_STATUS_REPORT; *foundId = BOOT_STATUS_REPORT;
return OK;
}
break; break;
case (APID_LATCHUP_STATUS_REPORT): }
*foundLen = SIZE_LATCHUP_STATUS_REPORT; case (Apid::MEM_MAN): {
*foundId = LATCHUP_REPORT; if (tmReader.getServiceId() ==
break; static_cast<uint8_t>(supv::tm::MemManId::UPDATE_STATUS_REPORT)) {
case (APID_DATA_LOGGER_DATA): // TODO: I think this will be handled by the uart manager
*foundLen = SIZE_LOGGING_REPORT; }
*foundId = LOGGING_REPORT; }
break; }
case (APID_ADC_REPORT): handleBadApidServiceCombination(SUPV_UNKNOWN_TM, apid, tmReader.getServiceId());
*foundLen = SIZE_ADC_REPORT;
*foundId = ADC_REPORT;
break;
case (APID_EXE_SUCCESS):
*foundLen = SIZE_EXE_REPORT;
*foundId = EXE_REPORT;
break;
case (APID_EXE_FAILURE):
*foundLen = SIZE_EXE_REPORT;
*foundId = EXE_REPORT;
break;
default: {
sif::debug << "PlocSupervisorHandler::scanForReply: Reply has invalid apid" << std::endl;
*foundLen = remainingSize; *foundLen = remainingSize;
return result::INVALID_APID; return INVALID_DATA;
}
}
return result;
}
ReturnValue_t PlocSupervisorHandler::getSwitches(const uint8_t** switches,
uint8_t* numberOfSwitches) {
if (powerSwitch == power::NO_SWITCH) {
return DeviceHandlerBase::NO_SWITCH;
}
*numberOfSwitches = 1;
*switches = &powerSwitch;
return returnvalue::OK;
} }
ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id, ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
@ -771,6 +763,16 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
return result; return result;
} }
ReturnValue_t PlocSupervisorHandler::getSwitches(const uint8_t** switches,
uint8_t* numberOfSwitches) {
if (powerSwitch == power::NO_SWITCH) {
return DeviceHandlerBase::NO_SWITCH;
}
*numberOfSwitches = 1;
*switches = &powerSwitch;
return returnvalue::OK;
}
void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid() {} void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid() {}
uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
@ -932,6 +934,7 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
// TODO: Fix // TODO: Fix
// AcknowledgmentReport ack(data, SIZE_ACK_REPORT); // AcknowledgmentReport ack(data, SIZE_ACK_REPORT);
// result = ack.checkSize(); // result = ack.checkSize();
// if (result != returnvalue::OK) { // if (result != returnvalue::OK) {
@ -1806,39 +1809,40 @@ void PlocSupervisorHandler::disableExeReportReply() {
info->command->second.expectedReplies = 1; info->command->second.expectedReplies = 1;
} }
ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t* packet, size_t remainingSize, // ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t* packet, size_t
size_t* foundLen) { // remainingSize,
ReturnValue_t result = IGNORE_FULL_PACKET; // size_t* foundLen) {
uint16_t packetLen = 0; // ReturnValue_t result = IGNORE_FULL_PACKET;
*foundLen = 0; // uint16_t packetLen = 0;
// *foundLen = 0;
for (size_t idx = 0; idx < remainingSize; idx++) { //
std::memcpy(spacePacketBuffer + bufferTop, packet + idx, 1); // for (size_t idx = 0; idx < remainingSize; idx++) {
bufferTop += 1; // std::memcpy(spacePacketBuffer + bufferTop, packet + idx, 1);
*foundLen += 1; // bufferTop += 1;
if (bufferTop >= ccsds::HEADER_LEN) { // *foundLen += 1;
packetLen = readSpacePacketLength(spacePacketBuffer); // if (bufferTop >= ccsds::HEADER_LEN) {
} // packetLen = readSpacePacketLength(spacePacketBuffer);
// }
if (bufferTop == ccsds::HEADER_LEN + packetLen + 1) { //
packetInBuffer = true; // if (bufferTop == ccsds::HEADER_LEN + packetLen + 1) {
bufferTop = 0; // packetInBuffer = true;
return checkMramPacketApid(); // bufferTop = 0;
} // return checkMramPacketApid();
// }
if (bufferTop == supv::MAX_PACKET_SIZE) { //
*foundLen = remainingSize; // if (bufferTop == supv::MAX_PACKET_SIZE) {
disableAllReplies(); // *foundLen = remainingSize;
bufferTop = 0; // disableAllReplies();
sif::info << "PlocSupervisorHandler::parseMramPackets: Can not find MRAM packet in space " // bufferTop = 0;
"packet buffer" // sif::info << "PlocSupervisorHandler::parseMramPackets: Can not find MRAM packet in space "
<< std::endl; // "packet buffer"
return result::MRAM_PACKET_PARSING_FAILURE; // << std::endl;
} // return result::MRAM_PACKET_PARSING_FAILURE;
} // }
// }
return result; //
} // return result;
// }
ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id) { ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id) {
ReturnValue_t result = returnvalue::FAILED; ReturnValue_t result = returnvalue::FAILED;
@ -1916,13 +1920,14 @@ void PlocSupervisorHandler::increaseExpectedMramReplies(DeviceCommandId_t id) {
return; return;
} }
ReturnValue_t PlocSupervisorHandler::checkMramPacketApid() { // ReturnValue_t PlocSupervisorHandler::checkMramPacketApid() {
uint16_t apid = (spacePacketBuffer[0] << 8 | spacePacketBuffer[1]) & supv::APID_MASK; // uint16_t apid = (spacePacketBuffer[0] << 8 | spacePacketBuffer[1]) & supv::APID_MASK;
if (apid != supv::APID_MRAM_DUMP_TM) { // TODO: Fix
return result::NO_MRAM_PACKET; // if (apid != supv::APID_MRAM_DUMP_TM) {
} // return result::NO_MRAM_PACKET;
return APERIODIC_REPLY; // }
} // return APERIODIC_REPLY;
//}
ReturnValue_t PlocSupervisorHandler::handleMramDumpFile(DeviceCommandId_t id) { ReturnValue_t PlocSupervisorHandler::handleMramDumpFile(DeviceCommandId_t id) {
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
@ -2164,6 +2169,19 @@ void PlocSupervisorHandler::handleExecutionFailureReport(uint16_t statusCode) {
disableExeReportReply(); disableExeReportReply();
} }
void PlocSupervisorHandler::handleBadApidServiceCombination(Event event, unsigned int apid,
unsigned int serviceId) {
const char* printString = "";
if (event == SUPV_UNKNOWN_TM) {
printString = "Unknown";
} else if (event == SUPV_UNINIMPLEMENTED_TM) {
printString = "Unimplemented";
}
triggerEvent(event, apid, tmReader.getServiceId());
sif::error << printString << " APID service combination 0x" << std::setw(2) << std::setfill('0')
<< std::hex << apid << ", " << std::setw(2) << serviceId << std::endl;
}
void PlocSupervisorHandler::printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId) { void PlocSupervisorHandler::printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId) {
sif::warning << "PlocSupervisorHandler: Received Ack failure report with status code: 0x" sif::warning << "PlocSupervisorHandler: Received Ack failure report with status code: 0x"
<< std::hex << statusCode << std::endl; << std::hex << statusCode << std::endl;

19
linux/devices/ploc/PlocSupervisorHandler.h
View File

@ -64,18 +64,21 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
//! [EXPORT] : [COMMENT] PLOC supervisor crc failure in telemetry packet //! [EXPORT] : [COMMENT] PLOC supervisor crc failure in telemetry packet
static const Event SUPV_MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW); static const Event SUPV_MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
//! [EXPORT] : [COMMENT] Unhandled event. P1: APID, P2: Service ID
static constexpr Event SUPV_UNKNOWN_TM = MAKE_EVENT(2, severity::LOW);
static constexpr Event SUPV_UNINIMPLEMENTED_TM = MAKE_EVENT(3, severity::LOW);
//! [EXPORT] : [COMMENT] PLOC supervisor received acknowledgment failure report //! [EXPORT] : [COMMENT] PLOC supervisor received acknowledgment failure report
static const Event SUPV_ACK_FAILURE = MAKE_EVENT(2, severity::LOW); static const Event SUPV_ACK_FAILURE = MAKE_EVENT(4, severity::LOW);
//! [EXPORT] : [COMMENT] PLOC received execution failure report //! [EXPORT] : [COMMENT] PLOC received execution failure report
//! P1: ID of command for which the execution failed //! P1: ID of command for which the execution failed
//! P2: Status code sent by the supervisor handler //! P2: Status code sent by the supervisor handler
static const Event SUPV_EXE_FAILURE = MAKE_EVENT(3, severity::LOW); static const Event SUPV_EXE_FAILURE = MAKE_EVENT(5, severity::LOW);
//! [EXPORT] : [COMMENT] PLOC supervisor reply has invalid crc //! [EXPORT] : [COMMENT] PLOC supervisor reply has invalid crc
static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(4, severity::LOW); static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(6, severity::LOW);
//! [EXPORT] : [COMMENT] Supervisor helper currently executing a command //! [EXPORT] : [COMMENT] Supervisor helper currently executing a command
static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(5, severity::LOW); static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(7, severity::LOW);
//! [EXPORT] : [COMMENT] Failed to build the command to shutdown the MPSoC //! [EXPORT] : [COMMENT] Failed to build the command to shutdown the MPSoC
static const Event SUPV_MPSOC_SHUWDOWN_BUILD_FAILED = MAKE_EVENT(5, severity::LOW); static const Event SUPV_MPSOC_SHUWDOWN_BUILD_FAILED = MAKE_EVENT(8, severity::LOW);
static const uint16_t APID_MASK = 0x7FF; static const uint16_t APID_MASK = 0x7FF;
static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF; static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
@ -121,6 +124,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
supv::AdcReport adcReport; supv::AdcReport adcReport;
const power::Switch_t powerSwitch = power::NO_SWITCH; const power::Switch_t powerSwitch = power::NO_SWITCH;
supv::TmBase tmReader;
PlocSupvHelper* supvHelper = nullptr; PlocSupvHelper* supvHelper = nullptr;
MessageQueueIF* eventQueue = nullptr; MessageQueueIF* eventQueue = nullptr;
@ -210,6 +214,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
ReturnValue_t handleBootStatusReport(const uint8_t* data); ReturnValue_t handleBootStatusReport(const uint8_t* data);
ReturnValue_t handleLatchupStatusReport(const uint8_t* data); ReturnValue_t handleLatchupStatusReport(const uint8_t* data);
void handleBadApidServiceCombination(Event result, unsigned int apid, unsigned int serviceId);
// ReturnValue_t handleLoggingReport(const uint8_t* data); // ReturnValue_t handleLoggingReport(const uint8_t* data);
ReturnValue_t handleAdcReport(const uint8_t* data); ReturnValue_t handleAdcReport(const uint8_t* data);
@ -317,7 +322,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
* @brief Function is called in scanForReply and fills the spacePacketBuffer with the read * @brief Function is called in scanForReply and fills the spacePacketBuffer with the read
* data until a full packet has been received. * data until a full packet has been received.
*/ */
ReturnValue_t parseMramPackets(const uint8_t* packet, size_t remainingSize, size_t* foundlen); // ReturnValue_t parseMramPackets(const uint8_t* packet, size_t remainingSize, size_t* foundlen);
/** /**
* @brief This function generates the Service 8 packets for the MRAM dump data. * @brief This function generates the Service 8 packets for the MRAM dump data.
@ -335,7 +340,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
* @brief Function checks if the packet written to the space packet buffer is really a * @brief Function checks if the packet written to the space packet buffer is really a
* MRAM dump packet. * MRAM dump packet.
*/ */
ReturnValue_t checkMramPacketApid(); // ReturnValue_t checkMramPacketApid();
/** /**
* @brief Writes the data of the MRAM dump to a file. The file will be created when receiving * @brief Writes the data of the MRAM dump to a file. The file will be created when receiving

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

@ -500,7 +500,7 @@ ReturnValue_t PlocSupvHelper::selectMemory() {
ReturnValue_t PlocSupvHelper::prepareUpdate() { 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, Apid::BOOT_MAN,
static_cast<uint8_t>(tc::BootManId::PREPARE_UPDATE)); static_cast<uint8_t>(tc::BootManId::PREPARE_UPDATE));
result = packet.buildPacket(); result = packet.buildPacket();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -584,7 +584,7 @@ ReturnValue_t PlocSupvHelper::handleAck() {
// } // }
// return result; // return result;
// } // }
return returnvalue::OK; return result;
} }
ReturnValue_t PlocSupvHelper::handleExe(uint32_t timeout) { ReturnValue_t PlocSupvHelper::handleExe(uint32_t timeout) {
@ -735,74 +735,76 @@ ReturnValue_t PlocSupvHelper::calcImageCrc() {
ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() { ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
resetSpParams(); // TODO: Fix
// Will hold status report for later processing // resetSpParams();
std::array<uint8_t, 32> statusReportBuf{}; // // Will hold status report for later processing
supv::UpdateStatusReport updateStatusReport(tmBuf.data(), tmBuf.size()); // std::array<uint8_t, 32> statusReportBuf{};
// Verification of update write procedure // supv::UpdateStatusReport updateStatusReport(tmBuf.data(), tmBuf.size());
supv::CheckMemory packet(spParams); // // Verification of update write procedure
result = packet.buildPacket(update.memoryId, update.startAddress, update.fullFileSize); // supv::CheckMemory packet(spParams);
if (result != returnvalue::OK) { // result = packet.buildPacket(update.memoryId, update.startAddress, update.fullFileSize);
return result; // if (result != returnvalue::OK) {
} // return result;
result = sendCommand(packet); // }
if (result != returnvalue::OK) { // result = sendCommand(packet);
return result; // if (result != returnvalue::OK) {
} // return result;
result = handleAck(); // }
if (result != returnvalue::OK) { // result = handleAck();
return result; // if (result != returnvalue::OK) {
} // return result;
// }
bool exeAlreadyHandled = false; //
uint32_t timeout = std::max(CRC_EXECUTION_TIMEOUT, supv::timeout::UPDATE_STATUS_REPORT); // bool exeAlreadyHandled = false;
result = handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), timeout); // uint32_t timeout = std::max(CRC_EXECUTION_TIMEOUT, supv::timeout::UPDATE_STATUS_REPORT);
ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size()); // result = handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), timeout);
if (spReader.getApid() == supv::APID_EXE_FAILURE) { // ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size());
exeAlreadyHandled = true; // if (spReader.getApid() == supv::APID_EXE_FAILURE) {
result = handleRemainingExeReport(spReader); // exeAlreadyHandled = true;
} else if (spReader.getApid() == supv::APID_UPDATE_STATUS_REPORT) { // result = handleRemainingExeReport(spReader);
size_t remBytes = spReader.getPacketDataLen() + 1; // } else if (spReader.getApid() == supv::APID_UPDATE_STATUS_REPORT) {
result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN, // size_t remBytes = spReader.getPacketDataLen() + 1;
supv::timeout::UPDATE_STATUS_REPORT); // result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN,
if (result != returnvalue::OK) { // supv::timeout::UPDATE_STATUS_REPORT);
sif::warning // if (result != returnvalue::OK) {
<< "PlocSupvHelper::handleCheckMemoryCommand: Failed to receive update status report" // sif::warning
<< std::endl; // << "PlocSupvHelper::handleCheckMemoryCommand: Failed to receive update status report"
return result; // << std::endl;
} // return result;
result = updateStatusReport.checkCrc(); // }
if (result != returnvalue::OK) { // result = updateStatusReport.checkCrc();
sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: CRC check failed" << std::endl; // if (result != returnvalue::OK) {
return result; // sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: CRC check failed" << std::endl;
} // return result;
// Copy into other buffer because data will be overwritten when reading execution report // }
std::memcpy(statusReportBuf.data(), tmBuf.data(), updateStatusReport.getNominalSize()); // // Copy into other buffer because data will be overwritten when reading execution report
} // std::memcpy(statusReportBuf.data(), tmBuf.data(), updateStatusReport.getNominalSize());
// }
if (not exeAlreadyHandled) { //
result = handleExe(CRC_EXECUTION_TIMEOUT); // if (not exeAlreadyHandled) {
if (result != returnvalue::OK) { // result = handleExe(CRC_EXECUTION_TIMEOUT);
return result; // if (result != returnvalue::OK) {
} // return result;
} // }
// }
// Now process the status report //
updateStatusReport.setData(statusReportBuf.data(), statusReportBuf.size()); // // Now process the status report
result = updateStatusReport.parseDataField(); // updateStatusReport.setData(statusReportBuf.data(), statusReportBuf.size());
if (result != returnvalue::OK) { // result = updateStatusReport.parseDataField();
return result; // if (result != returnvalue::OK) {
} // return result;
if (update.crcShouldBeChecked) { // }
result = updateStatusReport.verifycrc(update.crc); // if (update.crcShouldBeChecked) {
if (result != returnvalue::OK) { // result = updateStatusReport.verifycrc(update.crc);
sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: CRC failure. Expected CRC 0x" // if (result != returnvalue::OK) {
<< std::setfill('0') << std::hex << std::setw(4) // sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: CRC failure. Expected CRC 0x"
<< static_cast<uint16_t>(update.crc) << " but received CRC 0x" << std::setw(4) // << std::setfill('0') << std::hex << std::setw(4)
<< updateStatusReport.getCrc() << std::dec << std::endl; // << static_cast<uint16_t>(update.crc) << " but received CRC 0x" <<
return result; // std::setw(4)
} // << updateStatusReport.getCrc() << std::dec << std::endl;
} // return result;
// }
// }
return result; return result;
} }
@ -816,55 +818,57 @@ uint32_t PlocSupvHelper::getFileSize(std::string filename) {
ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) { ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
#ifdef XIPHOS_Q7S
if (not sdcMan->getActiveSdCard()) {
return HasFileSystemIF::FILESYSTEM_INACTIVE;
}
#endif
std::string filename = Filenaming::generateAbsoluteFilename(
eventBufferReq.path, eventBufferReq.filename, timestamping);
std::ofstream file(filename, std::ios_base::app | std::ios_base::out);
uint32_t packetsRead = 0;
size_t requestLen = 0;
bool firstPacket = true;
for (packetsRead = 0; packetsRead < NUM_EVENT_BUFFER_PACKETS; packetsRead++) {
if (terminate) {
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_TERMINATED, packetsRead - 1);
file.close();
return PROCESS_TERMINATED;
}
if (packetsRead == NUM_EVENT_BUFFER_PACKETS - 1) {
requestLen = SIZE_EVENT_BUFFER_LAST_PACKET;
} else {
requestLen = SIZE_EVENT_BUFFER_FULL_PACKET;
}
if (firstPacket) {
firstPacket = false;
requestLen -= 6;
}
result = handleTmReception(requestLen);
if (result != returnvalue::OK) {
sif::debug << "PlocSupvHelper::handleEventBufferReception: Failed while trying to read packet"
<< " " << packetsRead + 1 << std::endl;
file.close();
return result;
}
ReturnValue_t result = reader.checkCrc();
if (result != returnvalue::OK) {
triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
return result;
}
uint16_t apid = reader.getApid();
if (apid != supv::APID_MRAM_DUMP_TM) {
sif::warning << "PlocSupvHelper::handleEventBufferReception: Did not expect space packet "
<< "with APID 0x" << std::hex << apid << std::endl;
file.close();
return EVENT_BUFFER_REPLY_INVALID_APID;
}
// TODO: Fix // TODO: Fix
// file.write(reinterpret_cast<const char*>(reader.getPacketData()), //#ifdef XIPHOS_Q7S
// reader.getPayloadDataLength()); // if (not sdcMan->getActiveSdCard()) {
} // return HasFileSystemIF::FILESYSTEM_INACTIVE;
// }
//#endif
// std::string filename = Filenaming::generateAbsoluteFilename(
// eventBufferReq.path, eventBufferReq.filename, timestamping);
// std::ofstream file(filename, std::ios_base::app | std::ios_base::out);
// uint32_t packetsRead = 0;
// size_t requestLen = 0;
// bool firstPacket = true;
// for (packetsRead = 0; packetsRead < NUM_EVENT_BUFFER_PACKETS; packetsRead++) {
// if (terminate) {
// triggerEvent(SUPV_EVENT_BUFFER_REQUEST_TERMINATED, packetsRead - 1);
// file.close();
// return PROCESS_TERMINATED;
// }
// if (packetsRead == NUM_EVENT_BUFFER_PACKETS - 1) {
// requestLen = SIZE_EVENT_BUFFER_LAST_PACKET;
// } else {
// requestLen = SIZE_EVENT_BUFFER_FULL_PACKET;
// }
// if (firstPacket) {
// firstPacket = false;
// requestLen -= 6;
// }
// result = handleTmReception(requestLen);
// if (result != returnvalue::OK) {
// sif::debug << "PlocSupvHelper::handleEventBufferReception: Failed while trying to read
// packet"
// << " " << packetsRead + 1 << std::endl;
// file.close();
// return result;
// }
// ReturnValue_t result = reader.checkCrc();
// if (result != returnvalue::OK) {
// triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
// return result;
// }
// uint16_t apid = reader.getApid();
// if (apid != supv::APID_MRAM_DUMP_TM) {
// sif::warning << "PlocSupvHelper::handleEventBufferReception: Did not expect space packet "
// << "with APID 0x" << std::hex << apid << std::endl;
// file.close();
// return EVENT_BUFFER_REPLY_INVALID_APID;
// }
// // TODO: Fix
// // file.write(reinterpret_cast<const char*>(reader.getPacketData()),
// // reader.getPayloadDataLength());
// }
return result; return result;
} }