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

important fix and clarification
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-04 14:19:58 +01:00
parent dc024e5385
commit 2b9afbedff
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
4 changed files with 68 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
linux/devices/devicedefinitions/PlocMPSoCDefinitions.h
View File

@ -153,7 +153,7 @@ class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
*/ */
TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount) TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
: ploc::SpTcBase(params, apid, sequenceCount) { : ploc::SpTcBase(params, apid, sequenceCount) {
spParams.setDataFieldLen(INIT_LENGTH); spParams.setFullPacketLen(INIT_LENGTH);
} }
ReturnValue_t buildPacket() { return buildPacket(nullptr, 0); } ReturnValue_t buildPacket() { return buildPacket(nullptr, 0); }
@ -206,7 +206,7 @@ class TcMemRead : public TcBase {
*/ */
TcMemRead(ploc::SpTcParams params, uint16_t sequenceCount) TcMemRead(ploc::SpTcParams params, uint16_t sequenceCount)
: TcBase(params, apid::TC_MEM_READ, sequenceCount) { : TcBase(params, apid::TC_MEM_READ, sequenceCount) {
spParams.setPayloadLen(COMMAND_LENGTH); spParams.setFullPacketLen(COMMAND_LENGTH + CRC_SIZE);
} }
uint16_t getMemLen() const { return memLen; } uint16_t getMemLen() const { return memLen; }
@ -267,7 +267,7 @@ class TcMemWrite : public TcBase {
} }
uint16_t memLen = uint16_t memLen =
*(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1); *(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1);
spParams.setPayloadLen(MIN_FIXED_PAYLOAD_LENGTH + memLen * 4); spParams.setFullPacketLen(MIN_FIXED_PAYLOAD_LENGTH + memLen * 4 + CRC_SIZE);
result = checkPayloadLen(); result = checkPayloadLen();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -313,7 +313,7 @@ class FlashFopen : public ploc::SpTcBase {
ReturnValue_t createPacket(std::string filename, char accessMode_) { ReturnValue_t createPacket(std::string filename, char accessMode_) {
accessMode = accessMode_; accessMode = accessMode_;
size_t nameSize = filename.size(); size_t nameSize = filename.size();
spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode)); spParams.setFullPacketLen(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode) + CRC_SIZE);
ReturnValue_t result = checkPayloadLen(); ReturnValue_t result = checkPayloadLen();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -339,7 +339,7 @@ class FlashFclose : public ploc::SpTcBase {
ReturnValue_t createPacket(std::string filename) { ReturnValue_t createPacket(std::string filename) {
size_t nameSize = filename.size(); size_t nameSize = filename.size();
spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR)); spParams.setFullPacketLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
ReturnValue_t result = checkPayloadLen(); ReturnValue_t result = checkPayloadLen();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -365,7 +365,7 @@ class TcFlashWrite : public ploc::SpTcBase {
sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl; sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl;
return returnvalue::FAILED; return returnvalue::FAILED;
} }
spParams.setPayloadLen(static_cast<uint16_t>(writeLen) + 4); spParams.setFullPacketLen(static_cast<uint16_t>(writeLen) + 4 + CRC_SIZE);
result = checkPayloadLen(); result = checkPayloadLen();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -399,7 +399,7 @@ class TcFlashDelete : public ploc::SpTcBase {
ReturnValue_t buildPacket(std::string filename) { ReturnValue_t buildPacket(std::string filename) {
size_t nameSize = filename.size(); size_t nameSize = filename.size();
spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR)); spParams.setFullPacketLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
auto res = checkPayloadLen(); auto res = checkPayloadLen();
if (res != returnvalue::OK) { if (res != returnvalue::OK) {
return res; return res;
@ -439,7 +439,7 @@ class TcReplayStart : public TcBase {
protected: protected:
ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override { ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
spParams.setPayloadLen(commandDataLen); spParams.setFullPacketLen(commandDataLen + CRC_SIZE);
result = lengthCheck(commandDataLen); result = lengthCheck(commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -500,7 +500,7 @@ class TcDownlinkPwrOn : public TcBase {
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
spParams.setPayloadLen(commandDataLen + sizeof(MAX_AMPLITUDE)); spParams.setFullPacketLen(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE);
result = checkPayloadLen(); result = checkPayloadLen();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -571,7 +571,7 @@ class TcReplayWriteSeq : public TcBase {
protected: protected:
ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override { ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
spParams.setPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR)); spParams.setFullPacketLen(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE);
result = lengthCheck(commandDataLen); result = lengthCheck(commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -657,7 +657,8 @@ class TcCamcmdSend : public TcBase {
return INVALID_LENGTH; return INVALID_LENGTH;
} }
uint16_t dataLen = static_cast<uint16_t>(commandDataLen + sizeof(CARRIAGE_RETURN)); uint16_t dataLen = static_cast<uint16_t>(commandDataLen + sizeof(CARRIAGE_RETURN));
spParams.setPayloadLen(sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN)); spParams.setFullPacketLen(sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN) +
CRC_SIZE);
auto res = checkPayloadLen(); auto res = checkPayloadLen();
if (res != returnvalue::OK) { if (res != returnvalue::OK) {
return res; return res;

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

@ -161,8 +161,6 @@ static const size_t MAX_DATA_CAPACITY = 1016;
/** This is the maximum size of a space packet for the supervisor */ /** This is the maximum size of a space packet for the supervisor */
static const size_t MAX_PACKET_SIZE = 1024; static const size_t MAX_PACKET_SIZE = 1024;
static const uint8_t SPACE_PACKET_HEADER_LENGTH = 6;
struct UpdateParams { struct UpdateParams {
std::string file; std::string file;
uint8_t memId; uint8_t memId;
@ -284,6 +282,29 @@ 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 recv_timeout
static constexpr size_t TIMESTAMP_LEN = 7;
static constexpr size_t SECONDARY_HEADER_LEN = TIMESTAMP_LEN + 1;
static constexpr size_t CRC_LEN = 2;
struct SupvTcParams : public ploc::SpTcParams {
public:
SupvTcParams(SpacePacketCreator& creator) : ploc::SpTcParams(creator) {}
SupvTcParams(SpacePacketCreator& creator, uint8_t* buf, size_t maxSize)
: ploc::SpTcParams(creator, buf, maxSize) {}
void setLenFromPayloadLen(size_t payloadLen) {
setFullPacketLen(ccsds::HEADER_LEN + SECONDARY_HEADER_LEN + payloadLen + CRC_LEN);
}
};
class SupvTcBase : public ploc::SpTcBase {
public:
SupvTcBase(SupvTcParams params) : ploc::SpTcBase(params) {}
private:
};
/** /**
* @brief This class creates a space packet containing only the header data and the CRC. * @brief This class creates a space packet containing only the header data and the CRC.
*/ */
@ -297,7 +318,7 @@ class ApidOnlyPacket : public ploc::SpTcBase {
* @note Sequence count of empty packet is always 1. * @note Sequence count of empty packet is always 1.
*/ */
ApidOnlyPacket(ploc::SpTcParams params, uint16_t apid) : ploc::SpTcBase(params) { ApidOnlyPacket(ploc::SpTcParams params, uint16_t apid) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(LENGTH_EMPTY_TC); spParams.setFullPacketLen(LENGTH_EMPTY_TC);
spParams.creator.setApid(apid); spParams.creator.setApid(apid);
} }
@ -332,7 +353,7 @@ class MPSoCBootSelect : public ploc::SpTcBase {
* @note Selection of partitions is currently not supported. * @note Selection of partitions is currently not supported.
*/ */
MPSoCBootSelect(ploc::SpTcParams params) : ploc::SpTcBase(params) { MPSoCBootSelect(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SEL_MPSOC_BOOT_IMAGE); spParams.creator.setApid(APID_SEL_MPSOC_BOOT_IMAGE);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -378,7 +399,7 @@ class EnableNvms : public ploc::SpTcBase {
* @param bp2 Partition pin 2 * @param bp2 Partition pin 2
*/ */
EnableNvms(ploc::SpTcParams params) : ploc::SpTcBase(params) { EnableNvms(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_ENABLE_NVMS); spParams.creator.setApid(APID_ENABLE_NVMS);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -408,7 +429,7 @@ class EnableNvms : public ploc::SpTcBase {
class SetTimeRef : public ploc::SpTcBase { class SetTimeRef : public ploc::SpTcBase {
public: public:
SetTimeRef(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetTimeRef(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SET_TIME_REF); spParams.creator.setApid(APID_SET_TIME_REF);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -487,7 +508,7 @@ class SetBootTimeout : public ploc::SpTcBase {
* @param timeout The boot timeout in milliseconds. * @param timeout The boot timeout in milliseconds.
*/ */
SetBootTimeout(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetBootTimeout(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SET_BOOT_TIMEOUT); spParams.creator.setApid(APID_SET_BOOT_TIMEOUT);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -524,7 +545,7 @@ class SetRestartTries : public ploc::SpTcBase {
* @param restartTries Maximum restart tries to set. * @param restartTries Maximum restart tries to set.
*/ */
SetRestartTries(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetRestartTries(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SET_MAX_RESTART_TRIES); spParams.creator.setApid(APID_SET_MAX_RESTART_TRIES);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -558,7 +579,7 @@ class DisablePeriodicHkTransmission : public ploc::SpTcBase {
* @brief Constructor * @brief Constructor
*/ */
DisablePeriodicHkTransmission(ploc::SpTcParams params) : ploc::SpTcBase(params) { DisablePeriodicHkTransmission(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_DISABLE_HK); spParams.creator.setApid(APID_DISABLE_HK);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -594,7 +615,7 @@ class LatchupAlert : public ploc::SpTcBase {
* 3 - 3.3V, 4 - NVM_4XO, 5 - MISSION, 6 - SAFECOTS) * 3 - 3.3V, 4 - NVM_4XO, 5 - MISSION, 6 - SAFECOTS)
*/ */
LatchupAlert(ploc::SpTcParams params) : ploc::SpTcBase(params) { LatchupAlert(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -632,7 +653,7 @@ class SetAlertlimit : public ploc::SpTcBase {
* @param dutycycle * @param dutycycle
*/ */
SetAlertlimit(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetAlertlimit(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SET_ALERT_LIMIT); spParams.creator.setApid(APID_SET_ALERT_LIMIT);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -675,7 +696,7 @@ class SetAdcEnabledChannels : public ploc::SpTcBase {
* @param ch Defines channels to be enabled or disabled. * @param ch Defines channels to be enabled or disabled.
*/ */
SetAdcEnabledChannels(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetAdcEnabledChannels(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SET_ADC_ENABLED_CHANNELS); spParams.creator.setApid(APID_SET_ADC_ENABLED_CHANNELS);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -714,7 +735,7 @@ class SetAdcWindowAndStride : public ploc::SpTcBase {
* @param stridingStepSize * @param stridingStepSize
*/ */
SetAdcWindowAndStride(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetAdcWindowAndStride(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SET_ADC_WINDOW_AND_STRIDE); spParams.creator.setApid(APID_SET_ADC_WINDOW_AND_STRIDE);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -754,7 +775,7 @@ class SetAdcThreshold : public ploc::SpTcBase {
* @param threshold * @param threshold
*/ */
SetAdcThreshold(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetAdcThreshold(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SET_ADC_THRESHOLD); spParams.creator.setApid(APID_SET_ADC_THRESHOLD);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -792,7 +813,7 @@ class RunAutoEmTests : public ploc::SpTcBase {
* @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(ploc::SpTcParams params) : ploc::SpTcBase(params) { RunAutoEmTests(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_RUN_AUTO_EM_TESTS); spParams.creator.setApid(APID_RUN_AUTO_EM_TESTS);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -834,7 +855,7 @@ class MramCmd : public ploc::SpTcBase {
* @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(ploc::SpTcParams params) : ploc::SpTcBase(params) { MramCmd(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -888,7 +909,7 @@ class SetGpio : public ploc::SpTcBase {
* @param val * @param val
*/ */
SetGpio(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetGpio(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_SET_GPIO); spParams.creator.setApid(APID_SET_GPIO);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -932,7 +953,7 @@ class ReadGpio : public ploc::SpTcBase {
* @param pin * @param pin
*/ */
ReadGpio(ploc::SpTcParams params) : ploc::SpTcBase(params) { ReadGpio(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setDataFieldLen(DATA_FIELD_LENGTH); spParams.setFullPacketLen(DATA_FIELD_LENGTH);
spParams.creator.setApid(APID_READ_GPIO); spParams.creator.setApid(APID_READ_GPIO);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -1009,14 +1030,14 @@ class FactoryReset : public ploc::SpTcBase {
default: default:
break; break;
} }
spParams.setDataFieldLen(packetDataLen); spParams.setFullPacketLen(packetDataLen);
} }
}; };
class SetShutdownTimeout : public ploc::SpTcBase { class SetShutdownTimeout : public ploc::SpTcBase {
public: public:
SetShutdownTimeout(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetShutdownTimeout(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setPayloadLen(PAYLOAD_LEN); spParams.setFullPacketLen(PAYLOAD_LEN + 2);
spParams.creator.setApid(APID_SET_SHUTDOWN_TIMEOUT); spParams.creator.setApid(APID_SET_SHUTDOWN_TIMEOUT);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -1055,7 +1076,7 @@ class CheckMemory : public ploc::SpTcBase {
* @param length Length in bytes of memory region * @param length Length in bytes of memory region
*/ */
CheckMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) { CheckMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setPayloadLen(PAYLOAD_LENGTH); spParams.setFullPacketLen(PAYLOAD_LENGTH + 2);
spParams.creator.setApid(APID_CHECK_MEMORY); spParams.creator.setApid(APID_CHECK_MEMORY);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -1134,9 +1155,9 @@ class WriteMemory : public ploc::SpTcBase {
uint8_t* updateData) { uint8_t* updateData) {
uint8_t* data = payloadStart; uint8_t* data = payloadStart;
if (updateDataLen % 2 != 0) { if (updateDataLen % 2 != 0) {
spParams.setPayloadLen(META_DATA_LENGTH + updateDataLen + 1); spParams.setFullPacketLen(META_DATA_LENGTH + updateDataLen + 1 + 2);
} else { } else {
spParams.setPayloadLen(META_DATA_LENGTH + updateDataLen); spParams.setFullPacketLen(META_DATA_LENGTH + updateDataLen + 2);
} }
// To avoid crashes in this unexpected case // To avoid crashes in this unexpected case
ReturnValue_t result = checkPayloadLen(); ReturnValue_t result = checkPayloadLen();
@ -1168,7 +1189,7 @@ class WriteMemory : public ploc::SpTcBase {
class EraseMemory : public ploc::SpTcBase { class EraseMemory : public ploc::SpTcBase {
public: public:
EraseMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) { EraseMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setPayloadLen(PAYLOAD_LENGTH); spParams.setFullPacketLen(PAYLOAD_LENGTH + 2);
spParams.creator.setApid(APID_ERASE_MEMORY); spParams.creator.setApid(APID_ERASE_MEMORY);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -1210,7 +1231,7 @@ class EraseMemory : public ploc::SpTcBase {
class EnableAutoTm : public ploc::SpTcBase { class EnableAutoTm : public ploc::SpTcBase {
public: public:
EnableAutoTm(ploc::SpTcParams params) : ploc::SpTcBase(params) { EnableAutoTm(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setPayloadLen(PAYLOAD_LENGTH); spParams.setFullPacketLen(PAYLOAD_LENGTH + 2);
spParams.creator.setApid(APID_AUTO_TM); spParams.creator.setApid(APID_AUTO_TM);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -1235,7 +1256,7 @@ class EnableAutoTm : public ploc::SpTcBase {
class DisableAutoTm : public ploc::SpTcBase { class DisableAutoTm : public ploc::SpTcBase {
public: public:
DisableAutoTm(ploc::SpTcParams params) : ploc::SpTcBase(params) { DisableAutoTm(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setPayloadLen(PAYLOAD_LENGTH); spParams.setFullPacketLen(PAYLOAD_LENGTH + 2);
spParams.creator.setApid(APID_AUTO_TM); spParams.creator.setApid(APID_AUTO_TM);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -1270,7 +1291,7 @@ class RequestLoggingData : public ploc::SpTcBase {
}; };
RequestLoggingData(ploc::SpTcParams params) : ploc::SpTcBase(params) { RequestLoggingData(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setPayloadLen(PAYLOAD_LENGTH); spParams.setFullPacketLen(PAYLOAD_LENGTH + 2);
spParams.creator.setApid(APID_REQUEST_LOGGING_DATA); spParams.creator.setApid(APID_REQUEST_LOGGING_DATA);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }

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

@ -1808,11 +1808,11 @@ ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t* packet, siz
std::memcpy(spacePacketBuffer + bufferTop, packet + idx, 1); std::memcpy(spacePacketBuffer + bufferTop, packet + idx, 1);
bufferTop += 1; bufferTop += 1;
*foundLen += 1; *foundLen += 1;
if (bufferTop >= supv::SPACE_PACKET_HEADER_LENGTH) { if (bufferTop >= ccsds::HEADER_LEN) {
packetLen = readSpacePacketLength(spacePacketBuffer); packetLen = readSpacePacketLength(spacePacketBuffer);
} }
if (bufferTop == supv::SPACE_PACKET_HEADER_LENGTH + packetLen + 1) { if (bufferTop == ccsds::HEADER_LEN + packetLen + 1) {
packetInBuffer = true; packetInBuffer = true;
bufferTop = 0; bufferTop = 0;
return checkMramPacketApid(); return checkMramPacketApid();
@ -1838,7 +1838,7 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id)
// Prepare packet for downlink // Prepare packet for downlink
if (packetInBuffer) { if (packetInBuffer) {
uint16_t packetLen = readSpacePacketLength(spacePacketBuffer); uint16_t packetLen = readSpacePacketLength(spacePacketBuffer);
result = verifyPacket(spacePacketBuffer, supv::SPACE_PACKET_HEADER_LENGTH + packetLen + 1); result = verifyPacket(spacePacketBuffer, ccsds::HEADER_LEN + packetLen + 1);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sif::warning << "PlocSupervisorHandler::handleMramDumpPacket: CRC failure" << std::endl; sif::warning << "PlocSupervisorHandler::handleMramDumpPacket: CRC failure" << std::endl;
return result; return result;
@ -1940,8 +1940,7 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpFile(DeviceCommandId_t id) {
return SupvReturnValuesIF::MRAM_FILE_NOT_EXISTS; return SupvReturnValuesIF::MRAM_FILE_NOT_EXISTS;
} }
std::ofstream file(activeMramFile, std::ios_base::app | std::ios_base::out); std::ofstream file(activeMramFile, std::ios_base::app | std::ios_base::out);
file.write(reinterpret_cast<const char*>(spacePacketBuffer + supv::SPACE_PACKET_HEADER_LENGTH), file.write(reinterpret_cast<const char*>(spacePacketBuffer + ccsds::HEADER_LEN), packetLen - 1);
packetLen - 1);
file.close(); file.close();
return returnvalue::OK; return returnvalue::OK;
} }

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

@ -14,14 +14,12 @@ struct SpTcParams {
SpTcParams(SpacePacketCreator& creator, uint8_t* buf, size_t maxSize) SpTcParams(SpacePacketCreator& creator, uint8_t* buf, size_t maxSize)
: creator(creator), buf(buf), maxSize(maxSize) {} : creator(creator), buf(buf), maxSize(maxSize) {}
void setPayloadLen(size_t payloadLen_) { dataFieldLen = payloadLen_ + 2; } void setFullPacketLen(size_t fullPacketLen_) { fullPacketLen = fullPacketLen_; }
void setDataFieldLen(size_t dataFieldLen_) { dataFieldLen = dataFieldLen_; }
SpacePacketCreator& creator; SpacePacketCreator& creator;
uint8_t* buf = nullptr; uint8_t* buf = nullptr;
size_t maxSize = 0; size_t maxSize = 0;
size_t dataFieldLen = 0; size_t fullPacketLen = 0;
}; };
class SpTcBase { class SpTcBase {
@ -39,7 +37,7 @@ class SpTcBase {
} }
void updateSpFields() { void updateSpFields() {
spParams.creator.setDataLenField(spParams.dataFieldLen - 1); spParams.creator.setDataLenField(spParams.fullPacketLen - 1);
spParams.creator.setPacketType(ccsds::PacketType::TC); spParams.creator.setPacketType(ccsds::PacketType::TC);
} }
@ -50,7 +48,7 @@ class SpTcBase {
uint16_t getApid() const { return spParams.creator.getApid(); } uint16_t getApid() const { return spParams.creator.getApid(); }
ReturnValue_t checkPayloadLen() { ReturnValue_t checkPayloadLen() {
if (ccsds::HEADER_LEN + spParams.dataFieldLen > spParams.maxSize) { if (ccsds::HEADER_LEN + spParams.fullPacketLen > spParams.maxSize) {
return SerializeIF::BUFFER_TOO_SHORT; return SerializeIF::BUFFER_TOO_SHORT;
} }