diff --git a/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h b/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h index 58166e98..9aac6b0f 100644 --- a/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h +++ b/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h @@ -56,6 +56,10 @@ 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; /** Reply IDs */ static const DeviceCommandId_t ACK_REPORT = 50; @@ -66,9 +70,9 @@ 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 = 48; -static const uint16_t SIZE_BOOT_STATUS_REPORT = 22; -static const uint16_t SIZE_LATCHUP_STATUS_REPORT = 55; +static const uint16_t SIZE_HK_REPORT = 52; +static const uint16_t SIZE_BOOT_STATUS_REPORT = 24; +static const uint16_t SIZE_LATCHUP_STATUS_REPORT = 31; /** * SpacePacket apids of telemetry packets @@ -99,6 +103,10 @@ 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_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_UPDATE_AVAILABLE = 0xB0; static const uint16_t APID_UPDATE_IMAGE_DATA = 0xB1; static const uint16_t APID_UPDATE_VERIFY = 0xB2; @@ -182,6 +190,8 @@ enum PoolIds : lp_id_t { BP0_STATE, BP1_STATE, BP2_STATE, + BOOT_STATE, + BOOT_CYCLES, LATCHUP_ID, CNT0, @@ -199,7 +209,6 @@ enum PoolIds : lp_id_t { LATCHUP_RPT_TIME_YEAR, LATCHUP_RPT_TIME_MSEC, LATCHUP_RPT_TIME_USEC, - LATCHUP_RPT_TIME_IS_SET, }; static const uint8_t HK_SET_ENTRIES = 13; @@ -307,38 +316,41 @@ class SetTimeRef : public SpacePacket { } private: - static const uint16_t DATA_FIELD_LENGTH = 34; + static const uint16_t DATA_FIELD_LENGTH = 10; static const uint16_t DEFAULT_SEQUENCE_COUNT = 1; static const uint16_t CRC_OFFSET = DATA_FIELD_LENGTH - 2; + static const uint16_t SYNC = 0x8000; void initPacket(Clock::TimeOfDay_t* time) { size_t serializedSize = 0; uint8_t* data_field_ptr = this->localData.fields.buffer; - SerializeAdapter::serialize(&time->second, &data_field_ptr, &serializedSize, - sizeof(time->second), SerializeIF::Endianness::BIG); - serializedSize = 0; - SerializeAdapter::serialize(&time->minute, &data_field_ptr, &serializedSize, - sizeof(time->minute), SerializeIF::Endianness::BIG); - serializedSize = 0; - SerializeAdapter::serialize(&time->hour, &data_field_ptr, &serializedSize, - sizeof(time->hour), SerializeIF::Endianness::BIG); - serializedSize = 0; - SerializeAdapter::serialize(&time->day, &data_field_ptr, &serializedSize, - sizeof(time->day), SerializeIF::Endianness::BIG); - serializedSize = 0; - SerializeAdapter::serialize(&time->month, &data_field_ptr, &serializedSize, - sizeof(time->month), SerializeIF::Endianness::BIG); - serializedSize = 0; - SerializeAdapter::serialize(&time->year, &data_field_ptr, &serializedSize, - sizeof(time->year), SerializeIF::Endianness::BIG); - serializedSize = 0; - uint32_t milliseconds = time->usecond / 1000; - SerializeAdapter::serialize(&milliseconds, &data_field_ptr, &serializedSize, + uint16_t milliseconds = static_cast(time->usecond / 1000) | SYNC; + SerializeAdapter::serialize(&milliseconds, &data_field_ptr, &serializedSize, sizeof(milliseconds), SerializeIF::Endianness::BIG); + uint8_t second = static_cast(time->second); serializedSize = 0; - uint32_t isSet = 0xFFFFFFFF; - SerializeAdapter::serialize(&isSet, &data_field_ptr, &serializedSize, sizeof(isSet), - SerializeIF::Endianness::BIG); + SerializeAdapter::serialize(&second, &data_field_ptr, &serializedSize, + sizeof(time->second), SerializeIF::Endianness::BIG); + uint8_t minute = static_cast(time->minute); + serializedSize = 0; + SerializeAdapter::serialize(&minute, &data_field_ptr, &serializedSize, + sizeof(time->minute), SerializeIF::Endianness::BIG); + uint8_t hour = static_cast(time->hour); + serializedSize = 0; + SerializeAdapter::serialize(&hour, &data_field_ptr, &serializedSize, + sizeof(time->hour), SerializeIF::Endianness::BIG); + uint8_t day = static_cast(time->day); + serializedSize = 0; + SerializeAdapter::serialize(&day, &data_field_ptr, &serializedSize, sizeof(time->day), + SerializeIF::Endianness::BIG); + uint8_t month = static_cast(time->month); + serializedSize = 0; + SerializeAdapter::serialize(&month, &data_field_ptr, &serializedSize, + sizeof(time->month), SerializeIF::Endianness::BIG); + uint8_t year = static_cast(time->year); + serializedSize = 0; + SerializeAdapter::serialize(&year, &data_field_ptr, &serializedSize, + sizeof(time->year), SerializeIF::Endianness::BIG); serializedSize = 0; /* Calculate crc */ uint16_t crc = CRC::crc16ccitt(this->localData.byteStream, @@ -1359,6 +1371,36 @@ 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(); + } + + private: + uint16_t PACKET_LEN = 1; // uint32_t timeout + CRC - 1 + static const uint16_t DEFAULT_SEQUENCE_COUNT = 1; + + uint32_t timeout = 0; + uint8_t crcOffset = 0; + + void initPacket() { + uint8_t* data_field_ptr = this->localData.fields.buffer; + size_t serializedSize = 0; + SerializeAdapter::serialize(&timeout, data_field_ptr, &serializedSize, + sizeof(timeout), SerializeIF::Endianness::BIG); + this->setPacketDataLength(PACKET_LEN); + serializedSize = 0; + uint16_t crc = + CRC::crc16ccitt(this->localData.byteStream, sizeof(CCSDSPrimaryHeader) + PACKET_LEN - 1); + uint8_t* crcPos = this->localData.fields.buffer + crcOffset; + SerializeAdapter::serialize(&crc, &crcPos, &serializedSize, sizeof(crc), + SerializeIF::Endianness::BIG); + } +}; + class SupvTcSpacePacket : public SpacePacket { public: SupvTcSpacePacket(size_t payloadDataLen, uint16_t apid) @@ -1480,6 +1522,8 @@ class BootStatusReport : public StaticLocalDataSet { lp_var_t bp0State = lp_var_t(sid.objectId, PoolIds::BP0_STATE, this); lp_var_t bp1State = lp_var_t(sid.objectId, PoolIds::BP1_STATE, this); lp_var_t bp2State = lp_var_t(sid.objectId, PoolIds::BP2_STATE, this); + lp_var_t bootState = lp_var_t(sid.objectId, PoolIds::BOOT_STATE, this); + lp_var_t bootCycles = lp_var_t(sid.objectId, PoolIds::BOOT_CYCLES, this); }; /** @@ -1494,7 +1538,7 @@ class HkSet : public StaticLocalDataSet { lp_var_t tempPs = lp_var_t(sid.objectId, PoolIds::TEMP_PS, this); lp_var_t tempPl = lp_var_t(sid.objectId, PoolIds::TEMP_PS, this); lp_var_t tempSup = lp_var_t(sid.objectId, PoolIds::TEMP_SUP, this); - lp_var_t uptime = lp_var_t(sid.objectId, PoolIds::UPTIME, this); + lp_var_t uptime = lp_var_t(sid.objectId, PoolIds::UPTIME, this); lp_var_t cpuLoad = lp_var_t(sid.objectId, PoolIds::CPULOAD, this); lp_var_t availableHeap = lp_var_t(sid.objectId, PoolIds::AVAILABLEHEAP, this); lp_var_t numTcs = lp_var_t(sid.objectId, PoolIds::NUM_TCS, this); @@ -1524,22 +1568,16 @@ class LatchupStatusReport : public StaticLocalDataSet { lp_var_t cnt4 = lp_var_t(sid.objectId, PoolIds::CNT4, this); lp_var_t cnt5 = lp_var_t(sid.objectId, PoolIds::CNT5, this); lp_var_t cnt6 = lp_var_t(sid.objectId, PoolIds::CNT6, this); - lp_var_t timeSec = - lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_SEC, this); - lp_var_t timeMin = - lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_MIN, this); - lp_var_t timeHour = - lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_HOUR, this); - lp_var_t timeDay = - lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_DAY, this); - lp_var_t timeMon = - lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_MON, this); - lp_var_t timeYear = - lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_YEAR, this); - lp_var_t timeMsec = - lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_MSEC, this); - lp_var_t isSet = - lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_IS_SET, this); + lp_var_t timeMsec = + lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_MSEC, this); + lp_var_t timeSec = lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_SEC, this); + lp_var_t timeMin = lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_MIN, this); + lp_var_t timeHour = + lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_HOUR, this); + lp_var_t timeDay = lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_DAY, this); + lp_var_t timeMon = lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_MON, this); + lp_var_t timeYear = + lp_var_t(sid.objectId, PoolIds::LATCHUP_RPT_TIME_YEAR, this); }; } // namespace supv diff --git a/linux/devices/ploc/PlocSupervisorHandler.cpp b/linux/devices/ploc/PlocSupervisorHandler.cpp index 5065c7dd..88cfb1fb 100644 --- a/linux/devices/ploc/PlocSupervisorHandler.cpp +++ b/linux/devices/ploc/PlocSupervisorHandler.cpp @@ -259,6 +259,26 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d nextReplyId = supv::ACK_REPORT; result = RETURN_OK; break; + case (supv::PREPARE_UPDATE): { + prepareEmptyCmd(supv::APID_PREPARE_UPDATE); + result = RETURN_OK; + break; + } + case (supv::START_MPSOC_QUIET): { + prepareEmptyCmd(supv::APID_START_MPSOC_QUIET); + result = RETURN_OK; + break; + } + case (supv::SET_SHUTDOWN_TIMEOUT): { + prepareSetShutdownTimeoutCmd(commandData); + result = RETURN_OK; + break; + } + case (supv::FACTORY_FLASH): { + prepareEmptyCmd(supv::APID_FACTORY_FLASH); + result = RETURN_OK; + break; + } default: sif::debug << "PlocSupervisorHandler::buildCommandFromCommand: Command not implemented" << std::endl; @@ -317,6 +337,10 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() { this->insertInCommandMap(supv::FACTORY_RESET_CLEAR_MIRROR); this->insertInCommandMap(supv::FACTORY_RESET_CLEAR_CIRCULAR); this->insertInCommandMap(supv::CAN_LOOPBACK_TEST); + this->insertInCommandMap(supv::PREPARE_UPDATE); + this->insertInCommandMap(supv::START_MPSOC_QUIET); + this->insertInCommandMap(supv::SET_SHUTDOWN_TIMEOUT); + this->insertInCommandMap(supv::FACTORY_FLASH); this->insertInCommandAndReplyMap(supv::FIRST_MRAM_DUMP, 3); this->insertInCommandAndReplyMap(supv::CONSECUTIVE_MRAM_DUMP, 3); this->insertInReplyMap(supv::ACK_REPORT, 3, nullptr, supv::SIZE_ACK_REPORT); @@ -445,7 +469,7 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool localDataPoolMap.emplace(supv::MISSION_IO_STATE, new PoolEntry({0})); localDataPoolMap.emplace(supv::FMC_STATE, new PoolEntry({0})); localDataPoolMap.emplace(supv::NUM_TCS, new PoolEntry({0})); - localDataPoolMap.emplace(supv::UPTIME, new PoolEntry({0})); + localDataPoolMap.emplace(supv::UPTIME, new PoolEntry({0})); localDataPoolMap.emplace(supv::CPULOAD, new PoolEntry({0})); localDataPoolMap.emplace(supv::AVAILABLEHEAP, new PoolEntry({0})); @@ -466,14 +490,13 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool localDataPoolMap.emplace(supv::CNT4, new PoolEntry({0})); localDataPoolMap.emplace(supv::CNT5, new PoolEntry({0})); localDataPoolMap.emplace(supv::CNT6, new PoolEntry({0})); - localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_SEC, new PoolEntry({0})); - localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MIN, new PoolEntry({0})); - localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_HOUR, new PoolEntry({0})); - localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_DAY, new PoolEntry({0})); - localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MON, new PoolEntry({0})); - localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_YEAR, new PoolEntry({0})); - localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MSEC, new PoolEntry({0})); - localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_IS_SET, new PoolEntry({0})); + localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MSEC, new PoolEntry({0})); + localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_SEC, new PoolEntry({0})); + localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MIN, new PoolEntry({0})); + localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_HOUR, new PoolEntry({0})); + localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_DAY, new PoolEntry({0})); + localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MON, new PoolEntry({0})); + localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_YEAR, new PoolEntry({0})); return HasReturnvaluesIF::RETURN_OK; } @@ -575,6 +598,10 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite case supv::FACTORY_RESET_CLEAR_CIRCULAR: case supv::REQUEST_LOGGING_DATA: case supv::DISABLE_PERIOIC_HK_TRANSMISSION: + case supv::PREPARE_UPDATE: + case supv::START_MPSOC_QUIET: + case supv::SET_SHUTDOWN_TIMEOUT: + case supv::FACTORY_FLASH: enabledReplies = 2; break; default: @@ -722,9 +749,10 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) { hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 | *(data + offset + 3); offset += 4; - hkset.uptime = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 | - *(data + offset + 3); - offset += 4; + size_t size = sizeof(hkset.uptime.value); + result = SerializeAdapter::deSerialize(&hkset.uptime, data + offset, &size, + SerializeIF::Endianness::BIG); + offset += 8; hkset.cpuLoad = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 | *(data + offset + 3); offset += 4; @@ -806,6 +834,10 @@ ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data) bootStatusReport.bp1State = *(data + offset); offset += 1; bootStatusReport.bp2State = *(data + offset); + offset += 1; + bootStatusReport.bootState = *(data + offset); + offset += 1; + bootStatusReport.bootCycles = *(data + offset); nextReplyId = supv::EXE_REPORT; @@ -859,30 +891,19 @@ ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* da offset += 2; latchupStatusReport.cnt6 = *(data + offset) << 8 | *(data + offset + 1); offset += 2; - latchupStatusReport.timeSec = *(data + offset) << 24 | *(data + offset + 1) << 16 | - *(data + offset + 2) << 8 | *(data + offset + 3); - offset += 4; - latchupStatusReport.timeMin = *(data + offset) << 24 | *(data + offset + 1) << 16 | - *(data + offset + 2) << 8 | *(data + offset + 3); - offset += 4; - latchupStatusReport.timeHour = *(data + offset) << 24 | *(data + offset + 1) << 16 | - *(data + offset + 2) << 8 | *(data + offset + 3); - offset += 4; - latchupStatusReport.timeDay = *(data + offset) << 24 | *(data + offset + 1) << 16 | - *(data + offset + 2) << 8 | *(data + offset + 3); - offset += 4; - latchupStatusReport.timeMon = *(data + offset) << 24 | *(data + offset + 1) << 16 | - *(data + offset + 2) << 8 | *(data + offset + 3); - offset += 4; - latchupStatusReport.timeYear = *(data + offset) << 24 | *(data + offset + 1) << 16 | - *(data + offset + 2) << 8 | *(data + offset + 3); - offset += 4; - latchupStatusReport.timeMsec = *(data + offset) << 24 | *(data + offset + 1) << 16 | - *(data + offset + 2) << 8 | *(data + offset + 3); - offset += 4; - latchupStatusReport.isSet = *(data + offset) << 24 | *(data + offset + 1) << 16 | - *(data + offset + 2) << 8 | *(data + offset + 3); - offset += 4; + latchupStatusReport.timeMsec = *(data + offset) << 8 | *(data + offset + 1); + offset += 2; + latchupStatusReport.timeSec = *(data + offset); + offset += 1; + latchupStatusReport.timeMin = *(data + offset); + offset += 1; + latchupStatusReport.timeHour = *(data + offset); + offset += 1; + latchupStatusReport.timeDay = *(data + offset); + offset += 1; + latchupStatusReport.timeMon = *(data + offset); + offset += 1; + latchupStatusReport.timeYear = *(data + offset); nextReplyId = supv::EXE_REPORT; @@ -1267,6 +1288,21 @@ void PlocSupervisorHandler::packetToOutBuffer(uint8_t* packetData, size_t fullSi nextReplyId = supv::ACK_REPORT; } +void PlocSupervisorHandler::prepareSetShutdownTimeoutCmd(const uint8_t* commandData) { + uint32_t timeout = 0; + ReturnValue_t result = RETURN_OK; + size_t size = sizeof(timeout); + result = + SerializeAdapter::deSerialize(&timeout, &commandData, &size, SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + sif::warning + << "PlocSupervisorHandler::prepareSetShutdownTimeoutCmd: Failed to deserialize timeout" + << std::endl; + } + supv::SetShutdownTimeout packet(timeout); + packetToOutBuffer(packet.getWholeData(), packet.getFullSize()); +} + void PlocSupervisorHandler::disableAllReplies() { DeviceReplyMap::iterator iter; diff --git a/linux/devices/ploc/PlocSupervisorHandler.h b/linux/devices/ploc/PlocSupervisorHandler.h index b21ecf91..5b5b3478 100644 --- a/linux/devices/ploc/PlocSupervisorHandler.h +++ b/linux/devices/ploc/PlocSupervisorHandler.h @@ -348,6 +348,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase { ReturnValue_t createMramDumpFile(); ReturnValue_t getTimeStampString(std::string& timeStamp); + + void prepareSetShutdownTimeoutCmd(const uint8_t* commandData); }; #endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */