eive/eive-obsw
eive/eive-obsw
12
3
Fork 0
Code Issues 3 Pull Requests Releases 118 Wiki Activity

update ploc supv helper

Browse Source
This commit is contained in:
Robin Müller 2022-08-24 12:02:16 +02:00
parent 1aeebcc0ee
commit e561805f3a
No known key found for this signature in database
GPG Key ID: 71B58F8A3CDFA9AC
6 changed files with 126 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -160,6 +160,15 @@ static const size_t MAX_PACKET_SIZE = 1024;
static const uint8_t SPACE_PACKET_HEADER_LENGTH = 6; static const uint8_t SPACE_PACKET_HEADER_LENGTH = 6;
struct UpdateParams {
std::string file;
uint8_t memId;
uint32_t startAddr;
uint32_t bytesWritten;
uint16_t seqCount;
bool deleteMemory;
};
enum PoolIds : lp_id_t { enum PoolIds : lp_id_t {
NUM_TMS, NUM_TMS,
TEMP_PS, TEMP_PS,
@ -1247,11 +1256,14 @@ class DisableAutoTm : public ploc::SpTcBase {
*/ */
class RequestLoggingData : public ploc::SpTcBase { class RequestLoggingData : public ploc::SpTcBase {
public: public:
/**
* Subapid
*/
enum class Sa : uint8_t { enum class Sa : uint8_t {
REQUEST_COUNTERS = 1, REQUEST_COUNTERS = 1, /**< REQUEST_COUNTERS */
REQUEST_EVENT_BUFFERS = 2, REQUEST_EVENT_BUFFERS = 2, /**< REQUEST_EVENT_BUFFERS */
CLEAR_COUNTERS = 3, CLEAR_COUNTERS = 3, /**< CLEAR_COUNTERS */
SET_LOGGING_TOPIC = 4 SET_LOGGING_TOPIC = 4 /**< SET_LOGGING_TOPIC */
}; };
RequestLoggingData(ploc::SpTcParams params) : ploc::SpTcBase(params) { RequestLoggingData(ploc::SpTcParams params) : ploc::SpTcBase(params) {
@ -1260,6 +1272,11 @@ class RequestLoggingData : public ploc::SpTcBase {
spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT); spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
} }
/**
* @param sa
* @param tpc Topic
* @return
*/
ReturnValue_t buildPacket(Sa sa, uint8_t tpc = 0) { ReturnValue_t buildPacket(Sa sa, uint8_t tpc = 0) {
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
if (res != result::OK) { if (res != result::OK) {
@ -1659,7 +1676,8 @@ class ExecutionReport : public VerificationReport {
} }
default: default:
sif::warning << "ExecutionReport::printStatusInformation: Invalid status code: 0x" sif::warning << "ExecutionReport::printStatusInformation: Invalid status code: 0x"
<< std::hex << static_cast<uint16_t>(statusCode) << std::endl; << std::hex << std::setfill('0') << std::setw(4)
<< static_cast<uint16_t>(statusCode) << std::dec << std::endl;
break; break;
} }
} }

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

@ -121,8 +121,7 @@ ReturnValue_t PlocSupervisorHandler::executeAction(ActionId_t actionId,
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
result = supvHelper->performUpdate(params.file, params.memId, params.startAddr, result = supvHelper->performUpdate(params);
params.bytesWritten, params.seqCount);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
@ -1992,7 +1991,7 @@ ReturnValue_t PlocSupervisorHandler::getTimeStampString(std::string& timeStamp)
} }
ReturnValue_t PlocSupervisorHandler::extractUpdateCommand(const uint8_t* commandData, size_t size, ReturnValue_t PlocSupervisorHandler::extractUpdateCommand(const uint8_t* commandData, size_t size,
UpdateParams& params) { supv::UpdateParams& params) {
size_t remSize = size; size_t remSize = size;
if (size > (config::MAX_FILENAME_SIZE + config::MAX_PATH_SIZE + sizeof(params.memId)) + if (size > (config::MAX_FILENAME_SIZE + config::MAX_PATH_SIZE + sizeof(params.memId)) +
sizeof(params.startAddr) + sizeof(params.bytesWritten) + sizeof(params.seqCount)) { sizeof(params.startAddr) + sizeof(params.bytesWritten) + sizeof(params.seqCount)) {
@ -2017,11 +2016,19 @@ ReturnValue_t PlocSupervisorHandler::extractUpdateCommand(const uint8_t* command
<< std::endl; << std::endl;
return result; return result;
} }
result = SerializeAdapter::deSerialize(&params.deleteMemory, &commandData, &remSize,
SerializeIF::Endianness::BIG);
if (result != RETURN_OK) {
sif::warning
<< "PlocSupervisorHandler::extractUpdateCommand: Failed to deserialize whether to delete "
"memory" << std::endl;
return result;
}
return RETURN_OK; return RETURN_OK;
} }
ReturnValue_t PlocSupervisorHandler::extractBaseParams(const uint8_t** commandData, size_t& remSize, ReturnValue_t PlocSupervisorHandler::extractBaseParams(const uint8_t** commandData, size_t& remSize,
UpdateParams& params) { supv::UpdateParams& params) {
bool nullTermFound = false; bool nullTermFound = false;
for (size_t idx = 0; idx < remSize; idx++) { for (size_t idx = 0; idx < remSize; idx++) {
if ((*commandData)[idx] == '\0') { if ((*commandData)[idx] == '\0') {

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

@ -367,17 +367,10 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
ReturnValue_t prepareSetShutdownTimeoutCmd(const uint8_t* commandData); ReturnValue_t prepareSetShutdownTimeoutCmd(const uint8_t* commandData);
struct UpdateParams { ReturnValue_t extractUpdateCommand(const uint8_t* commandData, size_t size,
std::string file; supv::UpdateParams& params);
uint8_t memId;
uint32_t startAddr;
uint32_t bytesWritten;
uint16_t seqCount;
};
ReturnValue_t extractUpdateCommand(const uint8_t* commandData, size_t size, UpdateParams& params);
ReturnValue_t extractBaseParams(const uint8_t** commandData, size_t& remSize, ReturnValue_t extractBaseParams(const uint8_t** commandData, size_t& remSize,
UpdateParams& params); supv::UpdateParams& params);
ReturnValue_t eventSubscription(); ReturnValue_t eventSubscription();
ReturnValue_t handleExecutionSuccessReport(const uint8_t* data); ReturnValue_t handleExecutionSuccessReport(const uint8_t* data);

131
linux/devices/ploc/PlocSupvHelper.cpp
View File

@ -46,7 +46,7 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
break; break;
} }
case InternalState::UPDATE: { case InternalState::UPDATE: {
result = performUpdate(); result = executeUpdate();
if (result == RETURN_OK) { if (result == RETURN_OK) {
triggerEvent(SUPV_UPDATE_SUCCESSFUL, result); triggerEvent(SUPV_UPDATE_SUCCESSFUL, result);
} else if (result == PROCESS_TERMINATED) { } else if (result == PROCESS_TERMINATED) {
@ -107,22 +107,28 @@ void PlocSupvHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_
ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId, ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId,
uint32_t startAddress) { uint32_t startAddress) {
return performUpdate(file, memoryId, startAddress, 0, 1); supv::UpdateParams params;
params.file = file;
params.memId = memoryId;
params.startAddr = startAddress;
params.bytesWritten = 0;
params.seqCount = 1;
params.deleteMemory = true;
return performUpdate(params);
} }
ReturnValue_t PlocSupvHelper::performUpdate(std::string file, uint8_t memoryId, ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) {
uint32_t startAddress, size_t startBytesWritten,
uint16_t initSeqCount) {
ReturnValue_t result = RETURN_OK; ReturnValue_t result = RETURN_OK;
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
result = FilesystemHelper::checkPath(file); result = FilesystemHelper::checkPath(params.file);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "PlocSupvHelper::startUpdate: File " << file << " does not exist" << std::endl; sif::warning << "PlocSupvHelper::startUpdate: File " << params.file << " does not exist"
<< std::endl;
return result; return result;
} }
result = FilesystemHelper::fileExists(file); result = FilesystemHelper::fileExists(params.file);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "PlocSupvHelper::startUpdate: The file " << file << " does not exist" sif::warning << "PlocSupvHelper::startUpdate: The file " << params.file << " does not exist"
<< std::endl; << std::endl;
return result; return result;
} }
@ -134,21 +140,22 @@ ReturnValue_t PlocSupvHelper::performUpdate(std::string file, uint8_t memoryId,
return RETURN_FAILED; return RETURN_FAILED;
} }
#endif #endif
update.file = file; update.file = params.file;
update.fullFileSize = getFileSize(update.file); update.fullFileSize = getFileSize(update.file);
if (startBytesWritten > update.fullFileSize) { if (params.bytesWritten > update.fullFileSize) {
sif::warning << "Invalid start bytes counter " << startBytesWritten sif::warning << "Invalid start bytes counter " << params.bytesWritten
<< ", smaller than full file length" << update.fullFileSize << std::endl; << ", smaller than full file length" << update.fullFileSize << std::endl;
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
update.length = update.fullFileSize - startBytesWritten; update.length = update.fullFileSize - params.bytesWritten;
update.memoryId = memoryId; update.memoryId = params.memId;
update.startAddress = startAddress; update.startAddress = params.startAddr;
update.progressPercent = 0; update.progressPercent = 0;
update.bytesWritten = startBytesWritten; update.bytesWritten = params.bytesWritten;
update.crcShouldBeChecked = true; update.crcShouldBeChecked = true;
update.packetNum = 1; update.packetNum = 1;
update.sequenceCount = initSeqCount; update.deleteMemory = params.deleteMemory;
update.sequenceCount = params.seqCount;
internalState = InternalState::UPDATE; internalState = InternalState::UPDATE;
uartComIF->flushUartTxAndRxBuf(comCookie); uartComIF->flushUartTxAndRxBuf(comCookie);
semaphore.release(); semaphore.release();
@ -229,7 +236,7 @@ void PlocSupvHelper::executeFullCheckMemoryCommand() {
} }
} }
ReturnValue_t PlocSupvHelper::performUpdate() { ReturnValue_t PlocSupvHelper::executeUpdate() {
ReturnValue_t result = RETURN_OK; ReturnValue_t result = RETURN_OK;
sif::info << "PLOC SUPV Update MPSoC: Calculating Image CRC" << std::endl; sif::info << "PLOC SUPV Update MPSoC: Calculating Image CRC" << std::endl;
result = calcImageCrc(); result = calcImageCrc();
@ -246,10 +253,12 @@ ReturnValue_t PlocSupvHelper::performUpdate() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
sif::info << "PLOC SUPV Update MPSoC: Erasing Memory" << std::endl; if(update.deleteMemory) {
result = eraseMemory(); sif::info << "PLOC SUPV Update MPSoC: Erasing Memory" << std::endl;
if (result != RETURN_OK) { result = eraseMemory();
return result; if (result != RETURN_OK) {
return result;
}
} }
return updateOperation(); return updateOperation();
} }
@ -372,13 +381,38 @@ ReturnValue_t PlocSupvHelper::performEventBufferRequest() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
result = handleEventBufferReception(); result =
handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), supv::recv_timeout::UPDATE_STATUS_REPORT);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
result = handleExe(); ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size());
if (result != RETURN_OK) { bool exeAlreadyReceived = false;
return result; if (spReader.getApid() == supv::APID_EXE_FAILURE) {
exeAlreadyReceived = true;
result = handleRemainingExeReport(spReader);
} else if (spReader.getApid() == supv::APID_MRAM_DUMP_TM) {
result = handleEventBufferReception(spReader);
}
if (not exeAlreadyReceived) {
result = handleExe();
if (result != RETURN_OK) {
return result;
}
}
return result;
}
ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader) {
size_t remBytes = reader.getPacketDataLen() + 1;
ReturnValue_t result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN);
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Reading exe failure report failed" << std::endl;
}
result = exeReportHandling();
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Handling exe report failed" << std::endl;
} }
return result; return result;
} }
@ -652,22 +686,17 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
return result; return result;
} }
result = bool exeAlreadyHandled = false;
handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), supv::recv_timeout::UPDATE_STATUS_REPORT); uint32_t timeout = std::max(CRC_EXECUTION_TIMEOUT, supv::recv_timeout::UPDATE_STATUS_REPORT);
SpacePacketReader spReader(tmBuf.data(), tmBuf.size()); result = handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), timeout);
ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size());
if (spReader.getApid() == supv::APID_EXE_FAILURE) { if (spReader.getApid() == supv::APID_EXE_FAILURE) {
size_t remBytes = spReader.getPacketDataLen() + 1; exeAlreadyHandled = true;
result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN); result = handleRemainingExeReport(spReader);
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Reading exe failure report failed" << std::endl;
}
result = exeReportHandling();
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Handling exe report failed" << std::endl;
}
} else if (spReader.getApid() == supv::APID_UPDATE_STATUS_REPORT) { } else if (spReader.getApid() == supv::APID_UPDATE_STATUS_REPORT) {
size_t remBytes = spReader.getPacketDataLen() + 1; size_t remBytes = spReader.getPacketDataLen() + 1;
result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN); result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN,
supv::recv_timeout::UPDATE_STATUS_REPORT);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning sif::warning
<< "PlocSupvHelper::handleCheckMemoryCommand: Failed to receive update status report" << "PlocSupvHelper::handleCheckMemoryCommand: Failed to receive update status report"
@ -683,9 +712,11 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
std::memcpy(statusReportBuf.data(), tmBuf.data(), updateStatusReport.getNominalSize()); std::memcpy(statusReportBuf.data(), tmBuf.data(), updateStatusReport.getNominalSize());
} }
result = handleExe(CRC_EXECUTION_TIMEOUT); if (not exeAlreadyHandled) {
if (result != RETURN_OK) { result = handleExe(CRC_EXECUTION_TIMEOUT);
return result; if (result != RETURN_OK) {
return result;
}
} }
// Now process the status report // Now process the status report
@ -715,14 +746,14 @@ uint32_t PlocSupvHelper::getFileSize(std::string filename) {
return size; return size;
} }
ReturnValue_t PlocSupvHelper::handleEventBufferReception() { ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) {
ReturnValue_t result = RETURN_OK; ReturnValue_t result = RETURN_OK;
std::string filename = Filenaming::generateAbsoluteFilename( std::string filename = Filenaming::generateAbsoluteFilename(
eventBufferReq.path, eventBufferReq.filename, timestamping); eventBufferReq.path, eventBufferReq.filename, timestamping);
std::ofstream file(filename, std::ios_base::app | std::ios_base::out); std::ofstream file(filename, std::ios_base::app | std::ios_base::out);
uint32_t packetsRead = 0; uint32_t packetsRead = 0;
size_t requestLen = 0; size_t requestLen = 0;
ploc::SpTmReader tmReader(tmBuf.data(), tmBuf.size()); bool firstPacket = true;
for (packetsRead = 0; packetsRead < NUM_EVENT_BUFFER_PACKETS; packetsRead++) { for (packetsRead = 0; packetsRead < NUM_EVENT_BUFFER_PACKETS; packetsRead++) {
if (terminate) { if (terminate) {
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_TERMINATED, packetsRead - 1); triggerEvent(SUPV_EVENT_BUFFER_REQUEST_TERMINATED, packetsRead - 1);
@ -734,6 +765,10 @@ ReturnValue_t PlocSupvHelper::handleEventBufferReception() {
} else { } else {
requestLen = SIZE_EVENT_BUFFER_FULL_PACKET; requestLen = SIZE_EVENT_BUFFER_FULL_PACKET;
} }
if (firstPacket) {
firstPacket = false;
requestLen -= 6;
}
result = handleTmReception(requestLen); result = handleTmReception(requestLen);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::debug << "PlocSupvHelper::handleEventBufferReception: Failed while trying to read packet" sif::debug << "PlocSupvHelper::handleEventBufferReception: Failed while trying to read packet"
@ -741,20 +776,20 @@ ReturnValue_t PlocSupvHelper::handleEventBufferReception() {
file.close(); file.close();
return result; return result;
} }
ReturnValue_t result = tmReader.checkCrc(); ReturnValue_t result = reader.checkCrc();
if (result != RETURN_OK) { if (result != RETURN_OK) {
triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid); triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
return result; return result;
} }
uint16_t apid = tmReader.getApid(); uint16_t apid = reader.getApid();
if (apid != supv::APID_MRAM_DUMP_TM) { if (apid != supv::APID_MRAM_DUMP_TM) {
sif::warning << "PlocSupvHelper::handleEventBufferReception: Did not expect space packet " sif::warning << "PlocSupvHelper::handleEventBufferReception: Did not expect space packet "
<< "with APID 0x" << std::hex << apid << std::endl; << "with APID 0x" << std::hex << apid << std::endl;
file.close(); file.close();
return EVENT_BUFFER_REPLY_INVALID_APID; return EVENT_BUFFER_REPLY_INVALID_APID;
} }
file.write(reinterpret_cast<const char*>(tmReader.getPacketData()), file.write(reinterpret_cast<const char*>(reader.getPacketData()),
tmReader.getPayloadDataLength()); reader.getPayloadDataLength());
} }
return result; return result;
} }

9
linux/devices/ploc/PlocSupvHelper.h
View File

@ -116,8 +116,7 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF, public Ha
* *
* @return RETURN_OK if successful, otherwise error return value * @return RETURN_OK if successful, otherwise error return value
*/ */
ReturnValue_t performUpdate(std::string file, uint8_t memoryId, uint32_t startAddress, ReturnValue_t performUpdate(const supv::UpdateParams& params);
size_t startBytesWritten, uint16_t initSeqCount);
ReturnValue_t startUpdate(std::string file, uint8_t memoryId, uint32_t startAddress); ReturnValue_t startUpdate(std::string file, uint8_t memoryId, uint32_t startAddress);
ReturnValue_t performMemCheck(uint8_t memoryId, uint32_t startAddress, size_t sizeToCheck, ReturnValue_t performMemCheck(uint8_t memoryId, uint32_t startAddress, size_t sizeToCheck,
@ -177,6 +176,7 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF, public Ha
uint32_t packetNum; uint32_t packetNum;
uint16_t sequenceCount; uint16_t sequenceCount;
uint8_t progressPercent; uint8_t progressPercent;
bool deleteMemory = false;
}; };
struct Update update; struct Update update;
@ -220,7 +220,7 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF, public Ha
void executeFullCheckMemoryCommand(); void executeFullCheckMemoryCommand();
ReturnValue_t performUpdate(); ReturnValue_t executeUpdate();
ReturnValue_t continueUpdate(); ReturnValue_t continueUpdate();
ReturnValue_t updateOperation(); ReturnValue_t updateOperation();
ReturnValue_t writeUpdatePackets(); ReturnValue_t writeUpdatePackets();
@ -268,7 +268,8 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF, public Ha
* @return The size of the file * @return The size of the file
*/ */
uint32_t getFileSize(std::string filename); uint32_t getFileSize(std::string filename);
ReturnValue_t handleEventBufferReception(); ReturnValue_t handleEventBufferReception(ploc::SpTmReader& reader);
ReturnValue_t handleRemainingExeReport(ploc::SpTmReader& reader);
void resetSpParams(); void resetSpParams();
}; };

2
tmtc

@ -1 +1 @@
Subproject commit aec55035d7602226a2e61845565c94b5ed8f561c Subproject commit ac7821575c16b2c08740722f8d9ae0b456c60ece