eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 120 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 +171 -228
5 changed files with 171 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit e46bb42266 - Show all commits

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

@ -33,6 +33,8 @@ typedef struct {
uint8_t tm_year; // years since 1900 uint8_t tm_year; // years since 1900
} tas_time_t; } tas_time_t;
static constexpr uint16_t DEFAULT_SEQ_COUNT = 0;
/** Command IDs */ /** Command IDs */
static const DeviceCommandId_t NONE = 0; static const DeviceCommandId_t NONE = 0;
static const DeviceCommandId_t GET_HK_REPORT = 1; static const DeviceCommandId_t GET_HK_REPORT = 1;
@ -122,14 +124,16 @@ 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;
static constexpr uint16_t APID_TMTC_MAN = 0x00; enum Apids {
static constexpr uint16_t APID_HK = 0x01; TMTC_MAN = 0x00,
static constexpr uint16_t APID_BOOT_MAN = 0x02; HK = 0x01,
static constexpr uint16_t APID_LATCHUP_MON = 0x03; BOOT_MAN = 0x02,
static constexpr uint16_t APID_ADC_MON = 0x04; LATCHUP_MON = 0x03,
static constexpr uint16_t APID_MEM_MAN = 0x05; ADC_MON = 0x04,
static constexpr uint16_t APID_DATA_LOGGER = 0x06; MEM_MAN = 0x05,
static constexpr uint16_t APID_WDOG_MAN = 0x07; DATA_LOGGER = 0x06,
WDOG_MAN = 0x07
};
enum class HkServiceIds : uint8_t { enum class HkServiceIds : uint8_t {
ENABLE = 0x01, ENABLE = 0x01,
@ -170,7 +174,13 @@ 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 AdcMonServiceIds : uint8_t {
SET_SWEEP_PERIOD = 0x01,
SET_ENABLED_CHANNELS = 0x02,
SET_WINDOW_STRIDE = 0x03,
SET_ADC_THRESHOLD = 0x04,
COPY_ADC_DATA_TO_MRAM = 0x05
};
enum class DataLoggerServiceIds : uint8_t { FACTORY_RESET = 0x07 }; enum class DataLoggerServiceIds : uint8_t { FACTORY_RESET = 0x07 };
@ -178,49 +188,9 @@ enum class DataLoggerServiceIds : uint8_t { FACTORY_RESET = 0x07 };
// 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 WdogManServiceIds : uint8_t {};
static const uint16_t APID_START_MPSOC = 0xA1;
static const uint16_t APID_SHUTWOWN_MPSOC = 0xA2;
static const uint16_t APID_SEL_MPSOC_BOOT_IMAGE = 0xA3;
static const uint16_t APID_SET_BOOT_TIMEOUT = 0xA4;
static const uint16_t APID_SET_MAX_RESTART_TRIES = 0xA5;
static const uint16_t APID_RESET_MPSOC = 0xA6;
static const uint16_t APID_RESET_PL = 0xA7;
static const uint16_t APID_GET_BOOT_STATUS_RPT = 0xA8;
static const uint16_t APID_PREPARE_UPDATE = 0xA9;
static const uint16_t APID_START_MPSOC_QUIET = 0xAA;
static const uint16_t APID_SET_SHUTDOWN_TIMEOUT = 0xAB;
static const uint16_t APID_FACTORY_FLASH = 0xAC;
static const uint16_t APID_ERASE_MEMORY = 0xB0;
static const uint16_t APID_WRITE_MEMORY = 0xB1;
static const uint16_t APID_CHECK_MEMORY = 0xB2;
static const uint16_t APID_SET_TIME_REF = 0xC2;
static const uint16_t APID_DISABLE_HK = 0xC3;
static const uint16_t APID_AUTO_TM = 0xC5;
static const uint16_t APID_ENABLE_LATCHUP_ALERT = 0xD0;
static const uint16_t APID_DISABLE_LATCHUP_ALERT = 0xD1;
static const uint16_t APID_SET_ALERT_LIMIT = 0xD3;
static const uint16_t APID_SET_ADC_ENABLED_CHANNELS = 0xE1;
static const uint16_t APID_SET_ADC_WINDOW_AND_STRIDE = 0xE2;
static const uint16_t APID_SET_ADC_THRESHOLD = 0xE3;
static const uint16_t APID_GET_LATCHUP_STATUS_REPORT = 0xD9;
static const uint16_t APID_COPY_ADC_DATA_TO_MRAM = 0xDA;
static const uint16_t APID_REQUEST_ADC_REPORT = 0xDB;
static const uint16_t APID_ENABLE_NVMS = 0xF0;
static const uint16_t APID_RUN_AUTO_EM_TESTS = 0xF2;
static const uint16_t APID_WIPE_MRAM = 0xF3;
static const uint16_t APID_DUMP_MRAM = 0xF4;
static const uint16_t APID_SET_GPIO = 0xF9;
static const uint16_t APID_READ_GPIO = 0xFA;
static const uint16_t APID_RESTART_SUPERVISOR = 0xFB;
static const uint16_t APID_FACTORY_RESET = 0xFC;
static const uint16_t APID_REQUEST_LOGGING_DATA = 0xFD;
static const uint16_t APID_GET_HK_REPORT = 0xC6;
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;
static constexpr uint16_t DEFAULT_SEQUENCE_COUNT = 1;
static const uint8_t HK_SET_ENTRIES = 13; static const uint8_t HK_SET_ENTRIES = 13;
static const uint8_t BOOT_REPORT_SET_ENTRIES = 10; static const uint8_t BOOT_REPORT_SET_ENTRIES = 10;
static const uint8_t LATCHUP_RPT_SET_ENTRIES = 16; static const uint8_t LATCHUP_RPT_SET_ENTRIES = 16;
@ -369,29 +339,43 @@ struct TcParams : public ploc::SpTcParams {
class TcBase : public ploc::SpTcBase { class TcBase : public ploc::SpTcBase {
public: public:
TcBase(TcParams params) : ploc::SpTcBase(params) { setup(); } TcBase(TcParams params) : TcBase(params, 0x00, 0x00, MIN_PAYLOAD_LEN) {}
TcBase(TcParams params, uint16_t apid, uint8_t serviceId, uint16_t seqCount) TcBase(TcParams params, uint16_t apid) : TcBase(params, apid, 0x00, MIN_PAYLOAD_LEN) {}
: ploc::SpTcBase(params, apid, seqCount), serviceId(serviceId) {
if (setup() == OK and params.buf != nullptr) { TcBase(TcParams params, uint16_t apid, uint8_t service, size_t payloadLen)
params.buf[supv::PAYLOAD_OFFSET] = serviceId; : TcBase(params, apid, service, payloadLen, DEFAULT_SEQ_COUNT) {}
TcBase(TcParams params, uint16_t apid, uint8_t serviceId, size_t payloadLen, uint16_t seqCount)
: ploc::SpTcBase(params, apid, fullSpDataLenFromPayloadLen(payloadLen), seqCount) {
setup(serviceId);
} }
void setServiceId(uint8_t id) {
if (spParams.maxSize < MIN_PAYLOAD_LEN) {
return;
}
payloadStart[supv::PAYLOAD_OFFSET] = id;
}
static size_t fullSpDataLenFromPayloadLen(size_t payloadLen) {
return SECONDARY_HEADER_LEN + payloadLen + CRC_LEN;
} }
void setLenFromPayloadLen(size_t payloadLen) { void setLenFromPayloadLen(size_t payloadLen) {
spParams.setFullPayloadLen(ccsds::HEADER_LEN + SECONDARY_HEADER_LEN + payloadLen + CRC_LEN); spParams.setFullPayloadLen(fullSpDataLenFromPayloadLen(payloadLen));
updateLenFromParams();
} }
private: private:
uint8_t serviceId = 0; ReturnValue_t setup(uint8_t serviceId) {
ReturnValue_t setup() {
if (spParams.maxSize < MIN_PAYLOAD_LEN) { if (spParams.maxSize < MIN_PAYLOAD_LEN) {
sif::error << "SupvTcBase::SupvTcBase: Passed buffer is too small" << std::endl; sif::error << "SupvTcBase::SupvTcBase: Passed buffer is too small" << std::endl;
return returnvalue::FAILED; return returnvalue::FAILED;
} }
std::memset(spParams.buf + ccsds::HEADER_LEN, 0, TIMESTAMP_LEN); std::memset(spParams.buf + ccsds::HEADER_LEN, 0, TIMESTAMP_LEN);
payloadStart = spParams.buf + SECONDARY_HEADER_LEN; payloadStart = spParams.buf + ccsds::HEADER_LEN + SECONDARY_HEADER_LEN;
payloadStart[supv::PAYLOAD_OFFSET] = serviceId;
return returnvalue::OK; return returnvalue::OK;
} }
}; };
@ -402,7 +386,8 @@ class NoPayloadPacket : public TcBase {
: NoPayloadPacket(params, apid, serviceId, 0) {} : NoPayloadPacket(params, apid, serviceId, 0) {}
NoPayloadPacket(TcParams params, uint16_t apid, uint8_t serviceId, uint16_t seqId) NoPayloadPacket(TcParams params, uint16_t apid, uint8_t serviceId, uint16_t seqId)
: TcBase(params, apid, serviceId, seqId) {} : TcBase(params, apid, serviceId, MIN_PAYLOAD_LEN, seqId) {}
ReturnValue_t buildPacket() { ReturnValue_t buildPacket() {
ReturnValue_t result = checkSizeAndSerializeHeader(); ReturnValue_t result = checkSizeAndSerializeHeader();
if (result != OK) { if (result != OK) {
@ -433,11 +418,8 @@ class MPSoCBootSelect : public TcBase {
* *
* @note Selection of partitions is currently not supported. * @note Selection of partitions is currently not supported.
*/ */
MPSoCBootSelect(TcParams params) : TcBase(params) { MPSoCBootSelect(TcParams params)
params.setLenFromPayloadLen(4); : TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::SELECT_IMAGE), 4) {}
spParams.creator.setApid(APID_SEL_MPSOC_BOOT_IMAGE);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
}
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();
@ -449,16 +431,11 @@ class MPSoCBootSelect : public TcBase {
} }
private: private:
static const uint8_t MEM_OFFSET = 0;
static const uint8_t BP0_OFFSET = 1;
static const uint8_t BP1_OFFSET = 2;
static const uint8_t BP2_OFFSET = 3;
void initPacket(uint8_t mem = 0, uint8_t bp0 = 0, uint8_t bp1 = 0, uint8_t bp2 = 0) { void initPacket(uint8_t mem = 0, uint8_t bp0 = 0, uint8_t bp1 = 0, uint8_t bp2 = 0) {
payloadStart[0] = mem; payloadStart[0] = mem;
std::memcpy(payloadStart + BP0_OFFSET, &bp0, sizeof(bp0)); payloadStart[1] = bp0;
std::memcpy(payloadStart + BP1_OFFSET, &bp1, sizeof(bp1)); payloadStart[2] = bp1;
std::memcpy(payloadStart + BP2_OFFSET, &bp2, sizeof(bp2)); payloadStart[3] = bp2;
} }
}; };
@ -466,51 +443,49 @@ class MPSoCBootSelect : public TcBase {
* @brief This class creates the command to enable or disable the NVMs connected to the * @brief This class creates the command to enable or disable the NVMs connected to the
* supervisor. * supervisor.
*/ */
class EnableNvms : public ploc::SpTcBase { // class EnableNvms : public ploc::SpTcBase {
public: // public:
/** // /**
* @brief Constructor // * @brief Constructor
* // *
* @param mem The memory to boot from: NVM0 (0), NVM1 (1) // * @param mem The memory to boot from: NVM0 (0), NVM1 (1)
* @param bp0 Partition pin 0 // * @param bp0 Partition pin 0
* @param bp1 Partition pin 1 // * @param bp1 Partition pin 1
* @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.setFullPayloadLen(DATA_FIELD_LENGTH); // spParams.setFullPayloadLen(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);
} // }
//
ReturnValue_t buildPacket(uint8_t nvm01, uint8_t nvm3) { // ReturnValue_t buildPacket(uint8_t nvm01, uint8_t nvm3) {
auto res = checkSizeAndSerializeHeader(); // auto res = checkSizeAndSerializeHeader();
if (res != returnvalue::OK) { // if (res != returnvalue::OK) {
return res; // return res;
} // }
initPacket(nvm01, nvm3); // initPacket(nvm01, nvm3);
return calcAndSetCrc(); // return calcAndSetCrc();
} // }
//
private: // private:
static const uint8_t DATA_FIELD_LENGTH = 4; // static const uint8_t DATA_FIELD_LENGTH = 4;
static const uint8_t CRC_OFFSET = 2; // static const uint8_t CRC_OFFSET = 2;
//
void initPacket(uint8_t nvm01, uint8_t nvm3) { // void initPacket(uint8_t nvm01, uint8_t nvm3) {
payloadStart[0] = nvm01; // payloadStart[0] = nvm01;
payloadStart[1] = nvm3; // payloadStart[1] = nvm3;
} // }
}; // };
/** /**
* @brief This class generates the space packet to update the time of the PLOC supervisor. * @brief This class generates the space packet to update the time of the PLOC supervisor.
*/ */
class SetTimeRef : public ploc::SpTcBase { class SetTimeRef : public TcBase {
public: public:
SetTimeRef(ploc::SpTcParams params) : ploc::SpTcBase(params) { static constexpr size_t PAYLOAD_LEN = 8;
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); SetTimeRef(TcParams params)
spParams.creator.setApid(APID_SET_TIME_REF); : TcBase(params, Apids::TMTC_MAN, static_cast<uint8_t>(TmtcServiceIds::TIME_REF), 8) {}
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
}
ReturnValue_t buildPacket(Clock::TimeOfDay_t* time) { ReturnValue_t buildPacket(Clock::TimeOfDay_t* time) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -525,8 +500,6 @@ class SetTimeRef : public ploc::SpTcBase {
} }
private: private:
static const uint16_t DATA_FIELD_LENGTH = 10;
static const uint16_t CRC_OFFSET = DATA_FIELD_LENGTH - 2;
static const uint16_t SYNC = 0x8000; static const uint16_t SYNC = 0x8000;
ReturnValue_t initPacket(Clock::TimeOfDay_t* time) { ReturnValue_t initPacket(Clock::TimeOfDay_t* time) {
@ -578,18 +551,17 @@ class SetTimeRef : public ploc::SpTcBase {
/** /**
* @brief This class can be used to generate the set boot timout command. * @brief This class can be used to generate the set boot timout command.
*/ */
class SetBootTimeout : public ploc::SpTcBase { class SetBootTimeout : public TcBase {
public: public:
static constexpr size_t PAYLOAD_LEN = 4;
/** /**
* @brief Constructor * @brief Constructor
* *
* @param timeout The boot timeout in milliseconds. * @param timeout The boot timeout in milliseconds.
*/ */
SetBootTimeout(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetBootTimeout(TcParams params)
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); : TcBase(params, Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::SET_BOOT_TIMEOUT),
spParams.creator.setApid(APID_SET_BOOT_TIMEOUT); PAYLOAD_LEN) {}
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
}
ReturnValue_t buildPacket(uint32_t timeout) { ReturnValue_t buildPacket(uint32_t timeout) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -601,9 +573,6 @@ class SetBootTimeout : public ploc::SpTcBase {
} }
private: private:
/** boot timeout value (uint32_t) and crc (uint16_t) */
static const uint16_t DATA_FIELD_LENGTH = 6;
void initPacket(uint32_t timeout) { void initPacket(uint32_t timeout) {
size_t serializedSize = 0; size_t serializedSize = 0;
uint8_t* dataFieldPtr = payloadStart; uint8_t* dataFieldPtr = payloadStart;
@ -615,18 +584,16 @@ class SetBootTimeout : public ploc::SpTcBase {
/** /**
* @brief This class can be used to generate the space packet to set the maximum boot tries. * @brief This class can be used to generate the space packet to set the maximum boot tries.
*/ */
class SetRestartTries : public ploc::SpTcBase { class SetRestartTries : public TcBase {
public: public:
/** /**
* @brief Constructor * @brief Constructor
* *
* @param restartTries Maximum restart tries to set. * @param restartTries Maximum restart tries to set.
*/ */
SetRestartTries(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetRestartTries(TcParams params)
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); : TcBase(params, Apids::BOOT_MAN,
spParams.creator.setApid(APID_SET_MAX_RESTART_TRIES); static_cast<uint8_t>(BootManServiceIds::SET_MAX_REBOOT_TRIES), 1) {}
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
}
ReturnValue_t buildPacket(uint8_t restartTries) { ReturnValue_t buildPacket(uint8_t restartTries) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -640,9 +607,6 @@ class SetRestartTries : public ploc::SpTcBase {
private: private:
uint8_t restartTries = 0; uint8_t restartTries = 0;
/** Restart tries value (uint8_t) and crc (uint16_t) */
static const uint16_t DATA_FIELD_LENGTH = 3;
void initPacket(uint8_t restartTries) { payloadStart[0] = restartTries; } void initPacket(uint8_t restartTries) { payloadStart[0] = restartTries; }
}; };
@ -651,16 +615,13 @@ class SetRestartTries : public ploc::SpTcBase {
* of housekeeping data. Normally, this will be disabled by default. However, adding this * of housekeeping data. Normally, this will be disabled by default. However, adding this
* command can be useful for debugging. * command can be useful for debugging.
*/ */
class DisablePeriodicHkTransmission : public ploc::SpTcBase { class DisablePeriodicHkTransmission : public TcBase {
public: public:
/** /**
* @brief Constructor * @brief Constructor
*/ */
DisablePeriodicHkTransmission(ploc::SpTcParams params) : ploc::SpTcBase(params) { DisablePeriodicHkTransmission(TcParams params)
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); : TcBase(params, Apids::HK, static_cast<uint8_t>(HkServiceIds::ENABLE), 1) {}
spParams.creator.setApid(APID_DISABLE_HK);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
}
ReturnValue_t buildPacket() { ReturnValue_t buildPacket() {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -672,9 +633,6 @@ class DisablePeriodicHkTransmission : public ploc::SpTcBase {
} }
private: private:
/** Restart tries value (uint8_t) and crc (uint16_t) */
static const uint16_t DATA_FIELD_LENGTH = 3;
void initPacket() { payloadStart[0] = false; } void initPacket() { payloadStart[0] = false; }
}; };
@ -683,7 +641,7 @@ class DisablePeriodicHkTransmission : public ploc::SpTcBase {
* *
* @details There are 7 different latchup alerts. * @details There are 7 different latchup alerts.
*/ */
class LatchupAlert : public ploc::SpTcBase { class LatchupAlert : public TcBase {
public: public:
/** /**
* @brief Constructor * @brief Constructor
@ -692,16 +650,13 @@ class LatchupAlert : public ploc::SpTcBase {
* @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(ploc::SpTcParams params) : ploc::SpTcBase(params) { LatchupAlert(TcParams params) : TcBase(params, Apids::LATCHUP_MON) { setLenFromPayloadLen(1); }
spParams.setFullPayloadLen(DATA_FIELD_LENGTH);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
}
ReturnValue_t buildPacket(bool state, uint8_t latchupId) { ReturnValue_t buildPacket(bool state, uint8_t latchupId) {
if (state) { if (state) {
spParams.creator.setApid(APID_ENABLE_LATCHUP_ALERT); setServiceId(static_cast<uint8_t>(LatchupMonServiceIds::ENABLE));
} else { } else {
spParams.creator.setApid(APID_DISABLE_LATCHUP_ALERT); setServiceId(static_cast<uint8_t>(LatchupMonServiceIds::DISABLE));
} }
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
if (res != returnvalue::OK) { if (res != returnvalue::OK) {
@ -712,16 +667,12 @@ class LatchupAlert : public ploc::SpTcBase {
} }
private: private:
static const uint16_t DATA_FIELD_LENGTH = 3;
static const uint16_t CRC_OFFSET = DATA_FIELD_LENGTH - 2;
uint8_t latchupId = 0; uint8_t latchupId = 0;
void initPacket(uint8_t latchupId) { payloadStart[0] = latchupId; } void initPacket(uint8_t latchupId) { payloadStart[0] = latchupId; }
}; };
class SetAlertlimit : public ploc::SpTcBase { class SetAlertlimit : public TcBase {
public: public:
/** /**
* @brief Constructor * @brief Constructor
@ -730,11 +681,9 @@ class SetAlertlimit : public ploc::SpTcBase {
* 3 - 3.3V, 4 - NVM_4XO, 5 - MISSION, 6 - SAFECOTS) * 3 - 3.3V, 4 - NVM_4XO, 5 - MISSION, 6 - SAFECOTS)
* @param dutycycle * @param dutycycle
*/ */
SetAlertlimit(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetAlertlimit(TcParams params)
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); : TcBase(params, Apids::LATCHUP_MON,
spParams.creator.setApid(APID_SET_ALERT_LIMIT); static_cast<uint8_t>(LatchupMonServiceIds::SET_ALERT_LIMIT), 5) {}
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
}
ReturnValue_t buildPacket(uint8_t latchupId, uint32_t dutycycle) { ReturnValue_t buildPacket(uint8_t latchupId, uint32_t dutycycle) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -749,9 +698,6 @@ class SetAlertlimit : public ploc::SpTcBase {
} }
private: private:
static const uint16_t DATA_FIELD_LENGTH = 7;
static const uint16_t CRC_OFFSET = DATA_FIELD_LENGTH - 2;
uint8_t latchupId = 0; uint8_t latchupId = 0;
uint32_t dutycycle = 0; uint32_t dutycycle = 0;
@ -766,18 +712,16 @@ class SetAlertlimit : public ploc::SpTcBase {
/** /**
* @brief This class packages the space packet to enable or disable ADC channels. * @brief This class packages the space packet to enable or disable ADC channels.
*/ */
class SetAdcEnabledChannels : public ploc::SpTcBase { class SetAdcEnabledChannels : public TcBase {
public: public:
/** /**
* @brief Constructor * @brief Constructor
* *
* @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(TcParams params)
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); : TcBase(params, Apids::ADC_MON, static_cast<uint8_t>(AdcMonServiceIds::SET_ENABLED_CHANNELS),
spParams.creator.setApid(APID_SET_ADC_ENABLED_CHANNELS); 2) {}
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
}
ReturnValue_t buildPacket(uint16_t ch) { ReturnValue_t buildPacket(uint16_t ch) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
@ -789,10 +733,6 @@ class SetAdcEnabledChannels : public ploc::SpTcBase {
} }
private: private:
static const uint16_t DATA_FIELD_LENGTH = 4;
static const uint16_t CRC_OFFSET = DATA_FIELD_LENGTH - 2;
void initPacket(uint16_t ch) { void initPacket(uint16_t ch) {
size_t serializedSize = 0; size_t serializedSize = 0;
SerializeAdapter::serialize(&ch, &payloadStart, &serializedSize, sizeof(ch), SerializeAdapter::serialize(&ch, &payloadStart, &serializedSize, sizeof(ch),
@ -814,8 +754,8 @@ class SetAdcWindowAndStride : public ploc::SpTcBase {
*/ */
SetAdcWindowAndStride(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetAdcWindowAndStride(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); spParams.setFullPayloadLen(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);
} }
ReturnValue_t buildPacket(uint16_t windowSize, uint16_t stridingStepSize) { ReturnValue_t buildPacket(uint16_t windowSize, uint16_t stridingStepSize) {
@ -854,7 +794,7 @@ class SetAdcThreshold : public ploc::SpTcBase {
*/ */
SetAdcThreshold(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetAdcThreshold(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); spParams.setFullPayloadLen(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);
} }
@ -892,7 +832,7 @@ class RunAutoEmTests : public ploc::SpTcBase {
*/ */
RunAutoEmTests(ploc::SpTcParams params) : ploc::SpTcBase(params) { RunAutoEmTests(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); spParams.setFullPayloadLen(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);
} }
@ -934,14 +874,14 @@ class MramCmd : public ploc::SpTcBase {
*/ */
MramCmd(ploc::SpTcParams params) : ploc::SpTcBase(params) { MramCmd(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); spParams.setFullPayloadLen(DATA_FIELD_LENGTH);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); // spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
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) {
spParams.creator.setApid(APID_WIPE_MRAM); // spParams.creator.setApid(APID_WIPE_MRAM);
} else if (action == MramAction::DUMP) { } else if (action == MramAction::DUMP) {
spParams.creator.setApid(APID_DUMP_MRAM); // spParams.creator.setApid(APID_DUMP_MRAM);
} else { } else {
sif::debug << "WipeMram: Invalid action specified"; sif::debug << "WipeMram: Invalid action specified";
} }
@ -988,7 +928,7 @@ class SetGpio : public ploc::SpTcBase {
*/ */
SetGpio(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetGpio(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); spParams.setFullPayloadLen(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);
} }
@ -1032,7 +972,7 @@ class ReadGpio : public ploc::SpTcBase {
*/ */
ReadGpio(ploc::SpTcParams params) : ploc::SpTcBase(params) { ReadGpio(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(DATA_FIELD_LENGTH); spParams.setFullPayloadLen(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);
} }
@ -1078,7 +1018,7 @@ class FactoryReset : public ploc::SpTcBase {
* @param op * @param op
*/ */
FactoryReset(ploc::SpTcParams params) : ploc::SpTcBase(params) { FactoryReset(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.creator.setApid(APID_FACTORY_RESET); // spParams.creator.setApid(APID_FACTORY_RESET);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
@ -1116,8 +1056,8 @@ class SetShutdownTimeout : public ploc::SpTcBase {
public: public:
SetShutdownTimeout(ploc::SpTcParams params) : ploc::SpTcBase(params) { SetShutdownTimeout(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(PAYLOAD_LEN + 2); spParams.setFullPayloadLen(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);
} }
ReturnValue_t buildPacket(uint32_t timeout) { ReturnValue_t buildPacket(uint32_t timeout) {
@ -1155,8 +1095,8 @@ class CheckMemory : public ploc::SpTcBase {
*/ */
CheckMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) { CheckMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(PAYLOAD_LENGTH + 2); spParams.setFullPayloadLen(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);
} }
ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) { ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) {
@ -1202,8 +1142,8 @@ class WriteMemory : public ploc::SpTcBase {
* @param updateData Pointer to buffer containing update data * @param updateData Pointer to buffer containing update data
*/ */
WriteMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) { WriteMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.creator.setApid(APID_WRITE_MEMORY); // spParams.creator.setApid(APID_WRITE_MEMORY);
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); // spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
ReturnValue_t buildPacket(ccsds::SequenceFlags seqFlags, uint16_t sequenceCount, uint8_t memoryId, ReturnValue_t buildPacket(ccsds::SequenceFlags seqFlags, uint16_t sequenceCount, uint8_t memoryId,
@ -1268,8 +1208,8 @@ class EraseMemory : public ploc::SpTcBase {
public: public:
EraseMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) { EraseMemory(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(PAYLOAD_LENGTH + 2); spParams.setFullPayloadLen(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);
} }
ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) { ReturnValue_t buildPacket(uint8_t memoryId, uint32_t startAddress, uint32_t length) {
@ -1310,8 +1250,8 @@ class EnableAutoTm : public ploc::SpTcBase {
public: public:
EnableAutoTm(ploc::SpTcParams params) : ploc::SpTcBase(params) { EnableAutoTm(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(PAYLOAD_LENGTH + 2); spParams.setFullPayloadLen(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);
} }
ReturnValue_t buildPacket() { ReturnValue_t buildPacket() {
@ -1335,8 +1275,8 @@ class DisableAutoTm : public ploc::SpTcBase {
public: public:
DisableAutoTm(ploc::SpTcParams params) : ploc::SpTcBase(params) { DisableAutoTm(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(PAYLOAD_LENGTH + 2); spParams.setFullPayloadLen(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);
} }
ReturnValue_t buildPacket() { ReturnValue_t buildPacket() {
@ -1370,8 +1310,8 @@ class RequestLoggingData : public ploc::SpTcBase {
RequestLoggingData(ploc::SpTcParams params) : ploc::SpTcBase(params) { RequestLoggingData(ploc::SpTcParams params) : ploc::SpTcBase(params) {
spParams.setFullPayloadLen(PAYLOAD_LENGTH + 2); spParams.setFullPayloadLen(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);
} }
/** /**

48
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(APID_HK, static_cast<uint8_t>(HkServiceIds::GET_REPORT)); prepareEmptyCmd(Apids::HK, static_cast<uint8_t>(HkServiceIds::GET_REPORT));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
case START_MPSOC: { case START_MPSOC: {
prepareEmptyCmd(APID_BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::START_MPSOC)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::START_MPSOC));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
case SHUTDOWN_MPSOC: { case SHUTDOWN_MPSOC: {
prepareEmptyCmd(APID_BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::SHUTDOWN_MPSOC)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::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(APID_BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::RESET_MPSOC)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::RESET_MPSOC));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -265,7 +265,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case GET_BOOT_STATUS_REPORT: { case GET_BOOT_STATUS_REPORT: {
prepareEmptyCmd(APID_BOOT_MAN, prepareEmptyCmd(Apids::BOOT_MAN,
static_cast<uint8_t>(BootManServiceIds::GET_BOOT_STATUS_REPORT)); static_cast<uint8_t>(BootManServiceIds::GET_BOOT_STATUS_REPORT));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
@ -298,7 +298,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case GET_LATCHUP_STATUS_REPORT: { case GET_LATCHUP_STATUS_REPORT: {
prepareEmptyCmd(APID_LATCHUP_MON, prepareEmptyCmd(Apids::LATCHUP_MON,
static_cast<uint8_t>(LatchupMonServiceIds::GET_STATUS_REPORT)); static_cast<uint8_t>(LatchupMonServiceIds::GET_STATUS_REPORT));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
@ -380,7 +380,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case FACTORY_FLASH: { case FACTORY_FLASH: {
prepareEmptyCmd(APID_BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::FACTORY_FLASH)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::FACTORY_FLASH));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
@ -434,14 +434,14 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
break; break;
} }
case RESET_PL: { case RESET_PL: {
prepareEmptyCmd(APID_BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::RESET_PL)); prepareEmptyCmd(Apids::BOOT_MAN, static_cast<uint8_t>(BootManServiceIds::RESET_PL));
result = returnvalue::OK; result = returnvalue::OK;
break; break;
} }
case ENABLE_NVMS: { // case ENABLE_NVMS: {
result = prepareEnableNvmsCommand(commandData); // result = prepareEnableNvmsCommand(commandData);
break; // break;
} // }
default: default:
sif::debug << "PlocSupervisorHandler::buildCommandFromCommand: Command not implemented" sif::debug << "PlocSupervisorHandler::buildCommandFromCommand: Command not implemented"
<< std::endl; << std::endl;
@ -1701,18 +1701,18 @@ ReturnValue_t PlocSupervisorHandler::prepareLoggingRequest(const uint8_t* comman
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t PlocSupervisorHandler::prepareEnableNvmsCommand(const uint8_t* commandData) { // ReturnValue_t PlocSupervisorHandler::prepareEnableNvmsCommand(const uint8_t* commandData) {
using namespace supv; // using namespace supv;
uint8_t nvm01 = *(commandData); // uint8_t nvm01 = *(commandData);
uint8_t nvm3 = *(commandData + 1); // uint8_t nvm3 = *(commandData + 1);
EnableNvms packet(spParams); // EnableNvms packet(spParams);
ReturnValue_t result = packet.buildPacket(nvm01, nvm3); // ReturnValue_t result = packet.buildPacket(nvm01, nvm3);
if (result != returnvalue::OK) { // if (result != returnvalue::OK) {
return result; // return result;
} // }
finishTcPrep(packet.getFullPacketLen()); // finishTcPrep(packet.getFullPacketLen());
return returnvalue::OK; // return returnvalue::OK;
} // }
void PlocSupervisorHandler::disableAllReplies() { void PlocSupervisorHandler::disableAllReplies() {
using namespace supv; using namespace supv;

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

@ -283,7 +283,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData); ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData);
ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData); ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData);
ReturnValue_t prepareLoggingRequest(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t prepareLoggingRequest(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareEnableNvmsCommand(const uint8_t* commandData); // ReturnValue_t prepareEnableNvmsCommand(const uint8_t* commandData);
/** /**
* @brief Copies the content of a space packet to the command buffer. * @brief Copies the content of a space packet to the command buffer.

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

@ -499,7 +499,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, supv::APID_BOOT_MAN, supv::NoPayloadPacket packet(spParams, Apids::BOOT_MAN,
static_cast<uint8_t>(BootManServiceIds::PREPARE_UPDATE)); static_cast<uint8_t>(BootManServiceIds::PREPARE_UPDATE));
result = packet.buildPacket(); result = packet.buildPacket();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {

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

@ -24,23 +24,26 @@ struct SpTcParams {
class SpTcBase { class SpTcBase {
public: public:
SpTcBase(SpTcParams params) : spParams(params) { SpTcBase(SpTcParams params) : SpTcBase(params, 0x00, 1, 0) {}
payloadStart = spParams.buf + ccsds::HEADER_LEN;
updateSpFields();
}
SpTcBase(SpTcParams params, uint16_t apid, uint16_t seqCount) : spParams(params) { SpTcBase(SpTcParams params, uint16_t apid, size_t payloadLen)
: SpTcBase(params, apid, payloadLen, 0) {}
SpTcBase(SpTcParams params, uint16_t apid, size_t payloadLen, uint16_t seqCount)
: spParams(params) {
spParams.creator.setApid(apid); spParams.creator.setApid(apid);
spParams.creator.setSeqCount(seqCount); spParams.creator.setSeqCount(seqCount);
payloadStart = spParams.buf + ccsds::HEADER_LEN; payloadStart = spParams.buf + ccsds::HEADER_LEN;
spParams.fullPayloadLen = payloadLen;
updateSpFields(); updateSpFields();
} }
void updateSpFields() { void updateSpFields() {
spParams.creator.setDataLenField(spParams.fullPayloadLen - 1); updateLenFromParams();
spParams.creator.setPacketType(ccsds::PacketType::TC); spParams.creator.setPacketType(ccsds::PacketType::TC);
} }
void updateLenFromParams() { spParams.creator.setDataLenField(spParams.fullPayloadLen - 1); }
const uint8_t* getFullPacket() const { return spParams.buf; } const uint8_t* getFullPacket() const { return spParams.buf; }
size_t getFullPacketLen() const { return spParams.creator.getFullPacketLen(); } size_t getFullPacketLen() const { return spParams.creator.getFullPacketLen(); }