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

ploc update
Some checks failed
EIVE/eive-obsw/pipeline/head There was a failure building this commit
Details

Browse Source
This commit is contained in:
Jakob Meier
2022-04-10 18:46:39 +02:00
parent dbe4f70d8e
commit b440fc3df6
27 changed files with 1533 additions and 1817 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,6 +7,7 @@
#include <fsfw/serialize/SerializeAdapter.h>
#include <fsfw/timemanager/Clock.h>
#include <fsfw/tmtcpacket/SpacePacket.h>
#include "linux/devices/devicedefinitions/SupvReturnValuesIF.h"
namespace supv {
@ -24,7 +25,6 @@ static const DeviceCommandId_t SET_TIME_REF = 9;
static const DeviceCommandId_t DISABLE_PERIOIC_HK_TRANSMISSION = 10;
static const DeviceCommandId_t GET_BOOT_STATUS_REPORT = 11;
/** Notifies the supervisor that a new update is available for the MPSoC */
static const DeviceCommandId_t UPDATE_AVAILABLE = 12;
static const DeviceCommandId_t WATCHDOGS_ENABLE = 13;
static const DeviceCommandId_t WATCHDOGS_CONFIG_TIMEOUT = 14;
static const DeviceCommandId_t ENABLE_LATCHUP_ALERT = 15;
@ -51,15 +51,15 @@ static const DeviceCommandId_t READ_GPIO = 35;
static const DeviceCommandId_t RESTART_SUPERVISOR = 36;
static const DeviceCommandId_t FACTORY_RESET_CLEAR_ALL = 37;
static const DeviceCommandId_t REQUEST_LOGGING_DATA = 38;
static const DeviceCommandId_t UPDATE_IMAGE_DATA = 39;
static const DeviceCommandId_t FACTORY_RESET_CLEAR_MIRROR = 40;
static const DeviceCommandId_t FACTORY_RESET_CLEAR_CIRCULAR = 41;
static const DeviceCommandId_t UPDATE_VERIFY = 42;
static const DeviceCommandId_t CONSECUTIVE_MRAM_DUMP = 43;
static const DeviceCommandId_t PREPARE_UPDATE = 44;
static const DeviceCommandId_t START_MPSOC_QUIET = 45;
static const DeviceCommandId_t SET_SHUTDOWN_TIMEOUT = 46;
static const DeviceCommandId_t FACTORY_FLASH = 47;
static const DeviceCommandId_t PERFORM_UPDATE = 48;
static const DeviceCommandId_t TERMINATE_SUPV_HELPER = 49;
/** Reply IDs */
static const DeviceCommandId_t ACK_REPORT = 50;
@ -70,7 +70,7 @@ static const DeviceCommandId_t LATCHUP_REPORT = 54;
static const uint16_t SIZE_ACK_REPORT = 14;
static const uint16_t SIZE_EXE_REPORT = 14;
//static const uint16_t SIZE_HK_REPORT = 52;
// static const uint16_t SIZE_HK_REPORT = 52;
static const uint16_t SIZE_HK_REPORT = 56;
static const uint16_t SIZE_BOOT_STATUS_REPORT = 24;
static const uint16_t SIZE_LATCHUP_STATUS_REPORT = 31;
@ -108,9 +108,9 @@ 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_UPDATE_AVAILABLE = 0xB0;
static const uint16_t APID_UPDATE_IMAGE_DATA = 0xB1;
static const uint16_t APID_UPDATE_VERIFY = 0xB2;
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_WTD_ENABLE = 0xC0;
static const uint16_t APID_WTD_CONFIG_TIMEOUT = 0xC1;
static const uint16_t APID_SET_TIME_REF = 0xC2;
@ -221,9 +221,9 @@ static const uint32_t BOOT_REPORT_SET_ID = BOOT_STATUS_REPORT;
static const uint32_t LATCHUP_RPT_ID = LATCHUP_REPORT;
/**
* @brief With this class a space packet can be created which does not contain any data.
* @brief This class creates a space packet containing only the header data and the CRC.
*/
class EmptyPacket : public SpacePacket {
class ApidOnlyPacket : public SpacePacket {
public:
/**
* @brief Constructor
@ -232,7 +232,7 @@ class EmptyPacket : public SpacePacket {
*
* @note Sequence count of empty packet is always 1.
*/
EmptyPacket(uint16_t apid) : SpacePacket(LENGTH_EMPTY_TC - 1, true, apid, 1) { calcCrc(); }
ApidOnlyPacket(uint16_t apid) : SpacePacket(LENGTH_EMPTY_TC - 1, true, apid, 1) { calcCrc(); }
private:
/**
@ -324,39 +324,39 @@ class SetTimeRef : public SpacePacket {
void initPacket(Clock::TimeOfDay_t* time) {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
uint8_t* dataFieldPtr = this->localData.fields.buffer;
uint16_t milliseconds = static_cast<uint16_t>(time->usecond / 1000) | SYNC;
SerializeAdapter::serialize<uint16_t>(&milliseconds, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint16_t>(&milliseconds, &dataFieldPtr, &serializedSize,
sizeof(milliseconds), SerializeIF::Endianness::BIG);
uint8_t second = static_cast<uint8_t>(time->second);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&second, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint8_t>(&second, &dataFieldPtr, &serializedSize,
sizeof(time->second), SerializeIF::Endianness::BIG);
uint8_t minute = static_cast<uint8_t>(time->minute);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&minute, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint8_t>(&minute, &dataFieldPtr, &serializedSize,
sizeof(time->minute), SerializeIF::Endianness::BIG);
uint8_t hour = static_cast<uint8_t>(time->hour);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&hour, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint8_t>(&hour, &dataFieldPtr, &serializedSize,
sizeof(time->hour), SerializeIF::Endianness::BIG);
uint8_t day = static_cast<uint8_t>(time->day);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&day, &data_field_ptr, &serializedSize, sizeof(time->day),
SerializeAdapter::serialize<uint8_t>(&day, &dataFieldPtr, &serializedSize, sizeof(time->day),
SerializeIF::Endianness::BIG);
uint8_t month = static_cast<uint8_t>(time->month);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&month, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint8_t>(&month, &dataFieldPtr, &serializedSize,
sizeof(time->month), SerializeIF::Endianness::BIG);
uint8_t year = static_cast<uint8_t>(time->year - 1900);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&year, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint8_t>(&year, &dataFieldPtr, &serializedSize,
sizeof(time->year), SerializeIF::Endianness::BIG);
serializedSize = 0;
/* Calculate crc */
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
sizeof(CCSDSPrimaryHeader) + DATA_FIELD_LENGTH - 2);
SerializeAdapter::serialize<uint16_t>(&crc, &data_field_ptr, &serializedSize, sizeof(crc),
SerializeAdapter::serialize<uint16_t>(&crc, &dataFieldPtr, &serializedSize, sizeof(crc),
SerializeIF::Endianness::BIG);
}
};
@ -384,15 +384,15 @@ class SetBootTimeout : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint32_t>(&timeout, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint32_t>(&timeout, &dataFieldPtr, &serializedSize,
sizeof(timeout), SerializeIF::Endianness::BIG);
/* Calculate crc */
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
sizeof(CCSDSPrimaryHeader) + DATA_FIELD_LENGTH - 2);
/* Add crc to packet data field of space packet */
serializedSize = 0;
SerializeAdapter::serialize<uint16_t>(&crc, &data_field_ptr, &serializedSize, sizeof(crc),
SerializeAdapter::serialize<uint16_t>(&crc, &dataFieldPtr, &serializedSize, sizeof(crc),
SerializeIF::Endianness::BIG);
}
};
@ -420,81 +420,17 @@ class SetRestartTries : public SpacePacket {
static const uint16_t DATA_FIELD_LENGTH = 3;
void initPacket() {
uint8_t* data_field_ptr = this->localData.fields.buffer;
*data_field_ptr = restartTries;
uint8_t* dataFieldPtr = this->localData.fields.buffer;
*dataFieldPtr = restartTries;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
sizeof(CCSDSPrimaryHeader) + DATA_FIELD_LENGTH - 2);
size_t serializedSize = 0;
uint8_t* crcPtr = data_field_ptr + 1;
uint8_t* crcPtr = dataFieldPtr + 1;
SerializeAdapter::serialize<uint16_t>(&crc, &crcPtr, &serializedSize, sizeof(crc),
SerializeIF::Endianness::BIG);
}
};
/**
* @brief This class packages the command to notify the supervisor that a new update for the
* MPSoC is available.
*/
class UpdateAvailable : public SpacePacket {
public:
/**
* @brief Constructor
*
* @param imageSelect
* @param imagePartition
* @param imageSize
* @param imageCrc
* @param numberOfPackets
*/
UpdateAvailable(uint8_t imageSelect, uint8_t imagePartition, uint32_t imageSize,
uint32_t imageCrc, uint32_t numberOfPackets)
: SpacePacket(DATA_FIELD_LENGTH - 1, true, APID_UPDATE_AVAILABLE, DEFAULT_SEQUENCE_COUNT),
imageSelect(imageSelect),
imagePartition(imagePartition),
imageSize(imageSize),
imageCrc(imageCrc),
numberOfPackets(numberOfPackets) {
initPacket();
}
private:
static const uint16_t DATA_FIELD_LENGTH = 16;
static const uint16_t DEFAULT_SEQUENCE_COUNT = 1;
static const uint16_t CRC_OFFSET = DATA_FIELD_LENGTH - 2;
uint8_t imageSelect = 0;
uint8_t imagePartition = 0;
uint32_t imageSize = 0;
uint32_t imageCrc = 0;
uint32_t numberOfPackets = 0;
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&imageSelect, &data_field_ptr, &serializedSize,
sizeof(imageSelect), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&imagePartition, &data_field_ptr, &serializedSize,
sizeof(imagePartition), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&imageSize, &data_field_ptr, &serializedSize,
sizeof(imageSize), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&imageCrc, &data_field_ptr, &serializedSize,
sizeof(imageCrc), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&numberOfPackets, &data_field_ptr, &serializedSize,
sizeof(numberOfPackets), SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
sizeof(CCSDSPrimaryHeader) + DATA_FIELD_LENGTH - 2);
uint8_t* crcPos = this->localData.fields.buffer + CRC_OFFSET;
SerializeAdapter::serialize<uint16_t>(&crc, &crcPos, &serializedSize, sizeof(crc),
SerializeIF::Endianness::BIG);
}
};
/**
* @brief With this class the space packet can be generated to disable to periodic transmission
* of housekeeping data. Normally, this will be disabled by default. However, adding this
@ -516,12 +452,12 @@ class DisablePeriodicHkTransmission : public SpacePacket {
static const uint16_t DATA_FIELD_LENGTH = 3;
void initPacket() {
uint8_t* data_field_ptr = this->localData.fields.buffer;
*data_field_ptr = disableHk;
uint8_t* dataFieldPtr = this->localData.fields.buffer;
*dataFieldPtr = disableHk;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
sizeof(CCSDSPrimaryHeader) + DATA_FIELD_LENGTH - 2);
size_t serializedSize = 0;
uint8_t* crcPtr = data_field_ptr + 1;
uint8_t* crcPtr = dataFieldPtr + 1;
SerializeAdapter::serialize<uint16_t>(&crc, &crcPtr, &serializedSize, sizeof(crc),
SerializeIF::Endianness::BIG);
}
@ -559,14 +495,14 @@ class WatchdogsEnable : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&watchdogPs, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&watchdogPs, &dataFieldPtr, &serializedSize,
sizeof(watchdogPs), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&watchdogPl, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint8_t>(&watchdogPl, &dataFieldPtr, &serializedSize,
sizeof(watchdogPl), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&watchdogInt, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint8_t>(&watchdogInt, &dataFieldPtr, &serializedSize,
sizeof(watchdogInt), SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -607,11 +543,11 @@ class WatchdogsConfigTimeout : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&watchdog, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&watchdog, &dataFieldPtr, &serializedSize,
sizeof(watchdog), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&timeout, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint32_t>(&timeout, &dataFieldPtr, &serializedSize,
sizeof(timeout), SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -657,8 +593,8 @@ class LatchupAlert : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&latchupId, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&latchupId, &dataFieldPtr, &serializedSize,
sizeof(latchupId), SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -699,11 +635,11 @@ class AutoCalibrateAlert : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&latchupId, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&latchupId, &dataFieldPtr, &serializedSize,
sizeof(latchupId), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&mg, &data_field_ptr, &serializedSize, sizeof(mg),
SerializeAdapter::serialize<uint32_t>(&mg, &dataFieldPtr, &serializedSize, sizeof(mg),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -741,11 +677,11 @@ class SetAlertlimit : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&latchupId, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&latchupId, &dataFieldPtr, &serializedSize,
sizeof(latchupId), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&dutycycle, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint32_t>(&dutycycle, &dataFieldPtr, &serializedSize,
sizeof(dutycycle), SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -785,14 +721,14 @@ class SetAlertIrqFilter : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&latchupId, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&latchupId, &dataFieldPtr, &serializedSize,
sizeof(latchupId), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&tp, &data_field_ptr, &serializedSize, sizeof(tp),
SerializeAdapter::serialize<uint8_t>(&tp, &dataFieldPtr, &serializedSize, sizeof(tp),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&div, &data_field_ptr, &serializedSize, sizeof(div),
SerializeAdapter::serialize<uint8_t>(&div, &dataFieldPtr, &serializedSize, sizeof(div),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -829,8 +765,8 @@ class SetAdcSweepPeriod : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint32_t>(&sweepPeriod, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint32_t>(&sweepPeriod, &dataFieldPtr, &serializedSize,
sizeof(sweepPeriod), SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -868,8 +804,8 @@ class SetAdcEnabledChannels : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint16_t>(&ch, &data_field_ptr, &serializedSize, sizeof(ch),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint16_t>(&ch, &dataFieldPtr, &serializedSize, sizeof(ch),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -911,11 +847,11 @@ class SetAdcWindowAndStride : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint16_t>(&windowSize, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint16_t>(&windowSize, &dataFieldPtr, &serializedSize,
sizeof(windowSize), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint16_t>(&stridingStepSize, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint16_t>(&stridingStepSize, &dataFieldPtr, &serializedSize,
sizeof(stridingStepSize), SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -952,8 +888,8 @@ class SetAdcThreshold : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint32_t>(&threshold, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint32_t>(&threshold, &dataFieldPtr, &serializedSize,
sizeof(threshold), SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -990,8 +926,8 @@ class SelectNvm : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&mem, &data_field_ptr, &serializedSize, sizeof(mem),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&mem, &dataFieldPtr, &serializedSize, sizeof(mem),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -1031,11 +967,11 @@ class EnableNvms : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&n01, &data_field_ptr, &serializedSize, sizeof(n01),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&n01, &dataFieldPtr, &serializedSize, sizeof(n01),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&n3, &data_field_ptr, &serializedSize, sizeof(n3),
SerializeAdapter::serialize<uint8_t>(&n3, &dataFieldPtr, &serializedSize, sizeof(n3),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -1072,8 +1008,8 @@ class RunAutoEmTests : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&test, &data_field_ptr, &serializedSize, sizeof(test),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&test, &dataFieldPtr, &serializedSize, sizeof(test),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -1111,8 +1047,8 @@ class PrintCpuStats : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&en, &data_field_ptr, &serializedSize, sizeof(en),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&en, &dataFieldPtr, &serializedSize, sizeof(en),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -1150,8 +1086,8 @@ class SetDbgVerbosity : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&vb, &data_field_ptr, &serializedSize, sizeof(vb),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&vb, &dataFieldPtr, &serializedSize, sizeof(vb),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -1209,8 +1145,8 @@ class MramCmd : public SpacePacket {
concatBuffer[3] = static_cast<uint8_t>(stop >> 16);
concatBuffer[4] = static_cast<uint8_t>(stop >> 8);
concatBuffer[5] = static_cast<uint8_t>(stop);
uint8_t* data_field_ptr = this->localData.fields.buffer;
std::memcpy(data_field_ptr, concatBuffer, sizeof(concatBuffer));
uint8_t* dataFieldPtr = this->localData.fields.buffer;
std::memcpy(dataFieldPtr, concatBuffer, sizeof(concatBuffer));
size_t serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
sizeof(CCSDSPrimaryHeader) + DATA_FIELD_LENGTH - 2);
@ -1253,14 +1189,14 @@ class SetGpio : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&port, &data_field_ptr, &serializedSize, sizeof(port),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&port, &dataFieldPtr, &serializedSize, sizeof(port),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&pin, &data_field_ptr, &serializedSize, sizeof(pin),
SerializeAdapter::serialize<uint8_t>(&pin, &dataFieldPtr, &serializedSize, sizeof(pin),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&val, &data_field_ptr, &serializedSize, sizeof(val),
SerializeAdapter::serialize<uint8_t>(&val, &dataFieldPtr, &serializedSize, sizeof(val),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -1301,11 +1237,11 @@ class ReadGpio : public SpacePacket {
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&port, &data_field_ptr, &serializedSize, sizeof(port),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&port, &dataFieldPtr, &serializedSize, sizeof(port),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&pin, &data_field_ptr, &serializedSize, sizeof(pin),
SerializeAdapter::serialize<uint8_t>(&pin, &dataFieldPtr, &serializedSize, sizeof(pin),
SerializeIF::Endianness::BIG);
serializedSize = 0;
uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
@ -1346,16 +1282,16 @@ class FactoryReset : public SpacePacket {
Op op = Op::CLEAR_ALL;
void initPacket() {
uint8_t* data_field_ptr = this->localData.fields.buffer;
uint8_t* dataFieldPtr = this->localData.fields.buffer;
switch (op) {
case Op::MIRROR_ENTRIES:
*data_field_ptr = 1;
*dataFieldPtr = 1;
packetLen = 2;
crcOffset = 1;
break;
case Op::CIRCULAR_ENTRIES:
*data_field_ptr = 2;
*dataFieldPtr = 2;
packetLen = 2;
crcOffset = 1;
break;
@ -1374,7 +1310,6 @@ class FactoryReset : public SpacePacket {
class SetShutdownTimeout : public SpacePacket {
public:
SetShutdownTimeout(uint32_t timeout)
: SpacePacket(0, true, APID_SET_SHUTDOWN_TIMEOUT, DEFAULT_SEQUENCE_COUNT), timeout(timeout) {
initPacket();
@ -1388,9 +1323,9 @@ class SetShutdownTimeout : public SpacePacket {
uint8_t crcOffset = 0;
void initPacket() {
uint8_t* data_field_ptr = this->localData.fields.buffer;
uint8_t* dataFieldPtr = this->localData.fields.buffer;
size_t serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&timeout, data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint32_t>(&timeout, dataFieldPtr, &serializedSize,
sizeof(timeout), SerializeIF::Endianness::BIG);
this->setPacketDataLength(PACKET_LEN);
serializedSize = 0;
@ -1426,110 +1361,141 @@ class SupvTcSpacePacket : public SpacePacket {
};
/**
* @brief This class can be used to package the update available or update verify command.
* @brief Command to request CRC over memory region of the supervisor.
*/
class UpdateInfo : public SupvTcSpacePacket {
class CheckMemory : public SupvTcSpacePacket {
public:
/**
* @brief Constructor
*
* @param apid Packet can be used to generate the update available and the update verify
* packet. Thus the APID must be specified here.
* @param image The image to update on a NVM (A - 0, B - 1)
* @param partition The partition to update. uboot - 1, bitstream - 2, linux - 3,
* application - 4
* @param imageSize The size of the update image
* param numPackets The number of space packets required to transfer all data.
* @param memoryId
* @param startAddress Start address of CRC calculation
* @param length Length in bytes of memory region
*/
UpdateInfo(uint16_t apid, uint8_t image, uint8_t partition, uint32_t imageSize, uint32_t imageCrc,
uint32_t numPackets)
: SupvTcSpacePacket(PAYLOAD_LENGTH, apid),
image(image),
partition(partition),
imageSize(imageSize),
imageCrc(imageCrc),
numPackets(numPackets) {
CheckMemory(uint8_t memoryId, uint32_t startAddress, uint32_t length)
: SupvTcSpacePacket(PAYLOAD_LENGTH, APID_CHECK_MEMORY),
memoryId(memoryId),
startAddress(startAddress),
length(length) {
initPacket();
makeCrc();
}
private:
static const uint16_t PAYLOAD_LENGTH = 14; // length without CRC field
static const uint16_t PAYLOAD_LENGTH = 10; // length without CRC field
uint8_t image = 0;
uint8_t partition = 0;
uint32_t imageSize = 0;
uint32_t imageCrc = 0;
uint32_t numPackets = 0;
uint8_t memoryId = 0;
uint8_t n = 1;
uint32_t startAddress = 0;
uint32_t length = 0;
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&image, &data_field_ptr, &serializedSize, sizeof(image),
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&memoryId, &dataFieldPtr, &serializedSize, sizeof(memoryId),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&partition, &data_field_ptr, &serializedSize,
sizeof(partition), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize<uint8_t>(&n, &dataFieldPtr, &serializedSize, sizeof(n),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&imageSize, &data_field_ptr, &serializedSize,
sizeof(imageSize), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize<uint32_t>(&startAddress, &dataFieldPtr, &serializedSize,
sizeof(startAddress), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&imageCrc, &data_field_ptr, &serializedSize,
sizeof(imageCrc), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&numPackets, &data_field_ptr, &serializedSize,
sizeof(numPackets), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize<uint32_t>(&length, &dataFieldPtr, &serializedSize,
sizeof(length), SerializeIF::Endianness::BIG);
}
};
/**
* @brief This class packages the space packet transporting a part of an MPSoC update.
*/
class UpdatePacket : public SupvTcSpacePacket {
class WriteMemory : public SupvTcSpacePacket {
public:
/**
* @brief Constrcutor
*
* @param updateData Pointer to buffer containing update data
*/
UpdatePacket(uint8_t memoryId, uint32_t startAddress, uint16_t length, uint8_t* updateData)
: SupvTcSpacePacket(META_DATA_LENGTH + length, apid),
/**
* @brief Constructor
*
* @param seqFlags Sequence flags
* @param sequenceCount Sequence count (first update packet expects 1 as sequence count)
* @param updateData Pointer to buffer containing update data
*/
WriteMemory(SequenceFlags seqFlags, uint16_t sequenceCount, uint8_t memoryId,
uint32_t startAddress, uint16_t length, uint8_t* updateData)
: SupvTcSpacePacket(META_DATA_LENGTH + length, APID_WRITE_MEMORY),
memoryId(memoryId),
startAddress(startAddress),
length(length) {
if (this->length > CHUNK_MAX) {
sif::error << "WriteMemory::WriteMemory: Invalid length" << std::endl;
}
initPacket(updateData);
this->setSequenceFlags(static_cast<uint8_t>(seqFlags));
this->setPacketSequenceCount(sequenceCount);
makeCrc();
}
static const uint16_t MAX_UPDATE_DATA = 1010;
// Although the space packet has space left for 1010 bytes of data to supervisor can only process
// update packets with maximum 512 bytes of update data.
static const uint16_t CHUNK_MAX = 512;
private:
static const uint16_t META_DATA_LENGTH = 8;
uint8_t memoryId =0;
uint8_t memoryId = 0;
uint8_t n = 1;
uint32_t startAddress = 0;
uint16_t length = 0;
void initPacket(uint8_t* updateData) {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&memoryId, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&memoryId, &dataFieldPtr, &serializedSize,
sizeof(memoryId), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&n, &data_field_ptr, &serializedSize,
sizeof(n), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize<uint8_t>(&n, &dataFieldPtr, &serializedSize, sizeof(n),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&startAddress, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint32_t>(&startAddress, &dataFieldPtr, &serializedSize,
sizeof(startAddress), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint16_t>(&length, &data_field_ptr, &serializedSize,
sizeof(length), SerializeIF::Endianness::BIG);
std::memcpy(data_field_ptr, updateData, length);
SerializeAdapter::serialize<uint16_t>(&length, &dataFieldPtr, &serializedSize, sizeof(length),
SerializeIF::Endianness::BIG);
std::memcpy(dataFieldPtr, updateData, length);
if (length % 2 != 0) {
this->setPacketDataLength(this->getFullSize() + 1);
// The data field must be two bytes aligned. Thus, in case the number of bytes to write is odd
// a value of zero is added here
*(dataFieldPtr + length + 1) = 0;
}
}
};
/**
* @brief This dataset stores the boot status report of the supervisor.
*/
class BootStatusReport : public StaticLocalDataSet<BOOT_REPORT_SET_ENTRIES> {
public:
BootStatusReport(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, BOOT_REPORT_SET_ID) {}
BootStatusReport(object_id_t objectId)
: StaticLocalDataSet(sid_t(objectId, BOOT_REPORT_SET_ID)) {}
/** Information about boot status of MPSoC */
lp_var_t<uint8_t> bootSignal = lp_var_t<uint8_t>(sid.objectId, PoolIds::BOOT_SIGNAL, this);
lp_var_t<uint8_t> resetCounter = lp_var_t<uint8_t>(sid.objectId, PoolIds::RESET_COUNTER, this);
/** Time the MPSoC needs for last boot */
lp_var_t<uint32_t> bootAfterMs = lp_var_t<uint32_t>(sid.objectId, PoolIds::BOOT_AFTER_MS, this);
/** The currently set boot timeout */
lp_var_t<uint32_t> bootTimeoutMs =
lp_var_t<uint32_t>(sid.objectId, PoolIds::BOOT_TIMEOUT_MS, this);
lp_var_t<uint8_t> activeNvm = lp_var_t<uint8_t>(sid.objectId, PoolIds::ACTIVE_NVM, this);
/** States of the boot partition pins */
lp_var_t<uint8_t> bp0State = lp_var_t<uint8_t>(sid.objectId, PoolIds::BP0_STATE, this);
lp_var_t<uint8_t> bp1State = lp_var_t<uint8_t>(sid.objectId, PoolIds::BP1_STATE, this);
lp_var_t<uint8_t> bp2State = lp_var_t<uint8_t>(sid.objectId, PoolIds::BP2_STATE, this);
lp_var_t<uint8_t> bootState = lp_var_t<uint8_t>(sid.objectId, PoolIds::BOOT_STATE, this);
lp_var_t<uint8_t> bootCycles = lp_var_t<uint8_t>(sid.objectId, PoolIds::BOOT_CYCLES, this);
};
/**
* @brief This dataset stores the housekeeping data of the supervisor.
*/
@ -1587,7 +1553,7 @@ class LatchupStatusReport : public StaticLocalDataSet<LATCHUP_RPT_SET_ENTRIES> {
/**
* @brief Class for handling tm replies of the supervisor.
*/
class TmPacket : public SpacePacket, public MPSoCReturnValuesIF {
class TmPacket : public SpacePacket {
public:
/**
* @brief Constructor creates idle packet and sets length field to maximum allowed size.
@ -1600,7 +1566,7 @@ class TmPacket : public SpacePacket, public MPSoCReturnValuesIF {
uint16_t recalculatedCrc =
CRC::crc16ccitt(this->localData.byteStream, this->getFullSize() - CRC_SIZE);
if (recalculatedCrc != receivedCrc) {
return CRC_FAILURE;
return SupvReturnValuesIF::CRC_FAILURE;
}
return HasReturnvaluesIF::RETURN_OK;
}
@ -1611,9 +1577,8 @@ class TmPacket : public SpacePacket, public MPSoCReturnValuesIF {
*/
class EraseMemory : public SupvTcSpacePacket {
public:
EraseMemory(uint8_t memoryId, uint32_t startAddress, uint32_t length)
: SupvTcSpacePacket(PAYLOAD_LENGTH, apid),
EraseMemory(uint8_t memoryId, uint32_t startAddress, uint32_t length)
: SupvTcSpacePacket(PAYLOAD_LENGTH, APID_ERASE_MEMORY),
memoryId(memoryId),
startAddress(startAddress),
length(length) {
@ -1624,25 +1589,85 @@ class EraseMemory : public SupvTcSpacePacket {
private:
static const uint16_t PAYLOAD_LENGTH = 10; // length without CRC field
uint8_t memoryId =0;
uint8_t memoryId = 0;
uint8_t n = 1;
uint32_t startAddress = 0;
uint32_t length = 0;
void initPacket() {
size_t serializedSize = 0;
uint8_t* data_field_ptr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&memoryId, &data_field_ptr, &serializedSize,
uint8_t* dataFieldPtr = this->localData.fields.buffer;
SerializeAdapter::serialize<uint8_t>(&memoryId, &dataFieldPtr, &serializedSize,
sizeof(memoryId), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint8_t>(&n, &data_field_ptr, &serializedSize,
sizeof(n), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize<uint8_t>(&n, &dataFieldPtr, &serializedSize, sizeof(n),
SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&startAddress, &data_field_ptr, &serializedSize,
SerializeAdapter::serialize<uint32_t>(&startAddress, &dataFieldPtr, &serializedSize,
sizeof(startAddress), SerializeIF::Endianness::BIG);
serializedSize = 0;
SerializeAdapter::serialize<uint32_t>(&length, &data_field_ptr, &serializedSize,
sizeof(length), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize<uint32_t>(&length, &dataFieldPtr, &serializedSize, sizeof(length),
SerializeIF::Endianness::BIG);
}
};
class UpdateStatusReport : public TmPacket {
public:
UpdateStatusReport() : TmPacket() {}
ReturnValue_t parseDataField() {
ReturnValue_t result = lengthCheck();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
uint8_t* dataFieldPtr = this->localData.fields.buffer;
size_t size = sizeof(memoryId);
SerializeAdapter::deSerialize(&memoryId, dataFieldPtr, &size, SerializeIF::Endianness::BIG);
dataFieldPtr += size;
size = sizeof(n);
SerializeAdapter::deSerialize(&n, dataFieldPtr, &size, SerializeIF::Endianness::BIG);
dataFieldPtr += size;
size = sizeof(startAddress);
SerializeAdapter::deSerialize(&startAddress, dataFieldPtr, &size, SerializeIF::Endianness::BIG);
dataFieldPtr += size;
size = sizeof(length);
SerializeAdapter::deSerialize(&length, dataFieldPtr, &size, SerializeIF::Endianness::BIG);
dataFieldPtr += size;
size = sizeof(crc);
SerializeAdapter::deSerialize(&crc, dataFieldPtr, &size, SerializeIF::Endianness::BIG);
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t verifycrc(uint16_t goodCrc) const {
if (crc != goodCrc) {
return SupvReturnValuesIF::UPDATE_CRC_FAILURE;
}
return HasReturnvaluesIF::RETURN_OK;
}
uint16_t getCrc() const {
return crc;
}
uint16_t getNominalSize() const {
return FULL_SIZE;
}
private:
// Nominal size of the space packet
static const uint16_t FULL_SIZE = 20; // header, data field and crc
uint8_t memoryId = 0;
uint8_t n = 0;
uint32_t startAddress = 0;
uint32_t length = 0;
uint16_t crc = 0;
ReturnValue_t lengthCheck() {
if (this->getFullSize() != FULL_SIZE) {
return SupvReturnValuesIF::UPDATE_STATUS_REPORT_INVALID_LENGTH;
}
return HasReturnvaluesIF::RETURN_OK;
}
};
} // namespace supv