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

added new verify boot cmd
Some checks failed
EIVE/eive-obsw/pipeline/head There was a failure building this commit
Details

Browse Source
This commit is contained in:
Robin Müller 2024-04-17 14:32:36 +02:00
parent 758bc6e0e6
commit eb883ed93f
Signed by: muellerr
GPG Key ID: A649FB78196E3849
4 changed files with 138 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

197
linux/payload/FreshMpsocHandler.cpp
View File

@ -9,6 +9,7 @@
#include "fsfw/ipc/MessageQueueIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/ipc/QueueFactory.h" #include "fsfw/ipc/QueueFactory.h"
#include "fsfw/returnvalues/returnvalue.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/serialize/SerializeAdapter.h"
#include "linux/payload/MpsocCommunication.h" #include "linux/payload/MpsocCommunication.h"
#include "linux/payload/plocMpsocHelpers.h" #include "linux/payload/plocMpsocHelpers.h"
#include "linux/payload/plocSupvDefs.h" #include "linux/payload/plocSupvDefs.h"
@ -54,21 +55,26 @@ void FreshMpsocHandler::performDeviceOperation(uint8_t opCode) {
} }
void FreshMpsocHandler::performDefaultDeviceOperation() { void FreshMpsocHandler::performDefaultDeviceOperation() {
handleQueue(); if (transitionState != TransitionState::NONE) {
if (transitionState == TransitionState::TO_ON) { if (transitionState == TransitionState::TO_ON) {
handleTransitionToOn(); handleTransitionToOn();
} else if (transitionState == TransitionState::TO_OFF) { } else if (transitionState == TransitionState::TO_OFF) {
handleTransitionToOff(); handleTransitionToOff();
} else if (transitionState == TransitionState::SUBMODE) { } else if (transitionState == TransitionState::SUBMODE) {
if (!activeCmdInfo.pending) { if (!activeCmdInfo.pending) {
commandSubmodeTransition(); commandSubmodeTransition();
}
} else {
// This should never happen.
sif::error << "FreshMpsocHandler: Invalid transition mode: " << targetMode << std::endl;
targetMode = MODE_OFF;
targetSubmode = 0;
handleTransitionToOff();
}
if (modeHelper.isTimedOut()) {
// Set old mode and submode.
setMode(mode, submode);
} }
} else {
// This should never happen.
sif::error << "FreshMpsocHandler: Invalid transition mode: " << targetMode << std::endl;
targetMode = MODE_OFF;
targetSubmode = 0;
handleTransitionToOff();
} }
if (mode == MODE_NORMAL and not activeCmdInfo.pending) { if (mode == MODE_NORMAL and not activeCmdInfo.pending) {
@ -219,6 +225,7 @@ ReturnValue_t FreshMpsocHandler::checkModeCommand(Mode_t mode, Submode_t submode
return HasModesIF::INVALID_SUBMODE; return HasModesIF::INVALID_SUBMODE;
} }
} }
*msToReachTheMode = MPSOC_MODE_CMD_TIMEOUT_MS;
return returnvalue::OK; return returnvalue::OK;
} }
@ -305,11 +312,10 @@ void FreshMpsocHandler::startTransition(Mode_t newMode, Submode_t submode) {
// We are already on and only a submode change is commanded. // We are already on and only a submode change is commanded.
if ((mode == MODE_ON or mode == MODE_NORMAL) && (newMode == MODE_ON or newMode == MODE_NORMAL)) { if ((mode == MODE_ON or mode == MODE_NORMAL) && (newMode == MODE_ON or newMode == MODE_NORMAL)) {
transitionState = TransitionState::SUBMODE; transitionState = TransitionState::SUBMODE;
} } else if ((newMode == MODE_ON or newMode == MODE_NORMAL) &&
if (newMode == MODE_ON && ((mode == MODE_OFF) or (mode == MODE_UNDEFINED))) { ((mode == MODE_OFF) or (mode == MODE_UNDEFINED))) {
transitionState = TransitionState::TO_ON; transitionState = TransitionState::TO_ON;
} } else if (newMode == MODE_OFF) {
if (newMode == MODE_OFF) {
transitionState = TransitionState::TO_OFF; transitionState = TransitionState::TO_OFF;
} }
targetMode = newMode; targetMode = newMode;
@ -321,14 +327,14 @@ ReturnValue_t FreshMpsocHandler::performDeviceOperationPreQueueHandling(uint8_t
} }
void FreshMpsocHandler::commandSubmodeTransition() { void FreshMpsocHandler::commandSubmodeTransition() {
if (targetSubmode != mpsoc::Submode::IDLE_OR_NONE) { if (targetSubmode == mpsoc::Submode::IDLE_OR_NONE) {
if (targetSubmode == mpsoc::Submode::SNAPSHOT) { commandTcModeIdle();
commandTcModeSnapshot(); } else if (targetSubmode == mpsoc::Submode::SNAPSHOT) {
} else if (targetSubmode == mpsoc::Submode::REPLAY) { commandTcModeSnapshot();
commandTcModeReplay(); } else if (targetSubmode == mpsoc::Submode::REPLAY) {
} else { commandTcModeReplay();
sif::error << "FreshMpsocHandler::handleTransitionToOn: Invalid submode" << std::endl; } else {
} sif::error << "FreshMpsocHandler::handleTransitionToOn: Invalid submode" << std::endl;
} }
} }
@ -452,71 +458,69 @@ ReturnValue_t FreshMpsocHandler::executeRegularCmd(ActionId_t actionId,
ReturnValue_t result; ReturnValue_t result;
switch (actionId) { switch (actionId) {
case (mpsoc::TC_MEM_WRITE): { case (mpsoc::TC_MEM_WRITE): {
result = prepareTcMemWrite(commandData, commandDataLen); result = commandTcMemWrite(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_VERIFY_BOOT): {
uint8_t cmdData[6]{};
size_t serLen = 0;
uint16_t wordLen = 1;
SerializeAdapter::serialize(&mpsoc::DEADBEEF_ADDR, cmdData, &serLen, 4,
SerializeIF::Endianness::NETWORK);
SerializeAdapter::serialize(&wordLen, cmdData + 4, &serLen, 2,
SerializeIF::Endianness::NETWORK);
result = commandTcMemRead(commandData, commandDataLen);
}
case (mpsoc::TC_MEM_READ): { case (mpsoc::TC_MEM_READ): {
result = prepareTcMemRead(commandData, commandDataLen); result = commandTcMemRead(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_FLASHDELETE): { case (mpsoc::TC_FLASHDELETE): {
result = prepareTcFlashDelete(commandData, commandDataLen); result = commandTcFlashDelete(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_REPLAY_START): { case (mpsoc::TC_REPLAY_START): {
result = prepareTcReplayStart(commandData, commandDataLen); result = commandTcReplayStart(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_REPLAY_STOP): { case (mpsoc::TC_REPLAY_STOP): {
result = prepareTcReplayStop(); result = commandTcReplayStop();
break; break;
} }
case (mpsoc::TC_DOWNLINK_PWR_ON): { case (mpsoc::TC_DOWNLINK_PWR_ON): {
result = prepareTcDownlinkPwrOn(commandData, commandDataLen); result = commandTcDownlinkPwrOn(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_DOWNLINK_PWR_OFF): { case (mpsoc::TC_DOWNLINK_PWR_OFF): {
result = prepareTcDownlinkPwrOff(); result = commandTcDownlinkPwrOff();
break; break;
} }
case (mpsoc::TC_REPLAY_WRITE_SEQUENCE): { case (mpsoc::TC_REPLAY_WRITE_SEQUENCE): {
result = prepareTcReplayWriteSequence(commandData, commandDataLen); result = commandTcReplayWriteSequence(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_GET_HK_REPORT): { case (mpsoc::TC_GET_HK_REPORT): {
result = prepareTcGetHkReport(); result = commandTcGetHkReport();
break; break;
} }
case (mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT): { case (mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT): {
result = prepareTcGetDirContent(commandData, commandDataLen); result = commandTcGetDirContent(commandData, commandDataLen);
break;
}
case (mpsoc::TC_MODE_REPLAY_LEGACY): {
result = commandTcModeReplay();
break;
}
case (mpsoc::TC_MODE_IDLE_LEGACY): {
result = commandTcModeIdle();
break; break;
} }
case (mpsoc::TC_CAM_CMD_SEND): { case (mpsoc::TC_CAM_CMD_SEND): {
result = prepareTcCamCmdSend(commandData, commandDataLen); result = commandTcCamCmdSend(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_CAM_TAKE_PIC): { case (mpsoc::TC_CAM_TAKE_PIC): {
result = prepareTcCamTakePic(commandData, commandDataLen); result = commandTcCamTakePic(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_SIMPLEX_SEND_FILE): { case (mpsoc::TC_SIMPLEX_STREAM_FILE): {
result = prepareTcSimplexSendFile(commandData, commandDataLen); result = commandTcSimplexSendFile(commandData, commandDataLen);
break; break;
} }
case (mpsoc::TC_DOWNLINK_DATA_MODULATE): { case (mpsoc::TC_DOWNLINK_DATA_MODULATE): {
result = prepareTcDownlinkDataModulate(commandData, commandDataLen); result = commandTcDownlinkDataModulate(commandData, commandDataLen);
break;
}
case (mpsoc::TC_MODE_SNAPSHOT_LEGACY): {
result = commandTcModeSnapshot();
break; break;
} }
default: default:
@ -537,7 +541,7 @@ ReturnValue_t FreshMpsocHandler::executeRegularCmd(ActionId_t actionId,
return result; return result;
} }
ReturnValue_t FreshMpsocHandler::prepareTcMemWrite(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcMemWrite(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
mpsoc::TcMemWrite tcMemWrite(spParams, commandSequenceCount); mpsoc::TcMemWrite tcMemWrite(spParams, commandSequenceCount);
@ -545,11 +549,11 @@ ReturnValue_t FreshMpsocHandler::prepareTcMemWrite(const uint8_t* commandData,
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcMemWrite); finishAndSendTc(mpsoc::TC_MEM_WRITE, tcMemWrite);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcMemRead(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcMemRead(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
mpsoc::TcMemRead tcMemRead(spParams, commandSequenceCount); mpsoc::TcMemRead tcMemRead(spParams, commandSequenceCount);
@ -557,12 +561,12 @@ ReturnValue_t FreshMpsocHandler::prepareTcMemRead(const uint8_t* commandData,
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcMemRead); finishAndSendTc(mpsoc::TC_MEM_READ, tcMemRead);
tmMemReadReport.rememberRequestedSize = tcMemRead.getMemLen() * 4 + TmMemReadReport::FIX_SIZE; tmMemReadReport.rememberRequestedSize = tcMemRead.getMemLen() * 4 + TmMemReadReport::FIX_SIZE;
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcFlashDelete(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcFlashDelete(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) { if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
return mpsoc::NAME_TOO_LONG; return mpsoc::NAME_TOO_LONG;
@ -574,11 +578,11 @@ ReturnValue_t FreshMpsocHandler::prepareTcFlashDelete(const uint8_t* commandData
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcFlashDelete); finishAndSendTc(mpsoc::TC_FLASHDELETE, tcFlashDelete);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcReplayStart(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcReplayStart(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
mpsoc::TcReplayStart tcReplayStart(spParams, commandSequenceCount); mpsoc::TcReplayStart tcReplayStart(spParams, commandSequenceCount);
@ -586,17 +590,17 @@ ReturnValue_t FreshMpsocHandler::prepareTcReplayStart(const uint8_t* commandData
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcReplayStart); finishAndSendTc(mpsoc::TC_REPLAY_START, tcReplayStart);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcReplayStop() { ReturnValue_t FreshMpsocHandler::commandTcReplayStop() {
mpsoc::TcReplayStop tcReplayStop(spParams, commandSequenceCount); mpsoc::TcReplayStop tcReplayStop(spParams, commandSequenceCount);
finishAndSendTc(tcReplayStop); finishAndSendTc(mpsoc::TC_REPLAY_STOP, tcReplayStop);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcDownlinkPwrOn(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(spParams, commandSequenceCount); mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(spParams, commandSequenceCount);
@ -604,107 +608,107 @@ ReturnValue_t FreshMpsocHandler::prepareTcDownlinkPwrOn(const uint8_t* commandDa
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcDownlinkPwrOn); finishAndSendTc(mpsoc::TC_DOWNLINK_PWR_ON, tcDownlinkPwrOn);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcDownlinkPwrOff() { ReturnValue_t FreshMpsocHandler::commandTcDownlinkPwrOff() {
mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(spParams, commandSequenceCount); mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(spParams, commandSequenceCount);
finishAndSendTc(tcDownlinkPwrOff); finishAndSendTc(mpsoc::TC_DOWNLINK_PWR_OFF, tcDownlinkPwrOff);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcGetHkReport() { ReturnValue_t FreshMpsocHandler::commandTcGetHkReport() {
mpsoc::TcGetHkReport tcGetHkReport(spParams, commandSequenceCount); mpsoc::TcGetHkReport tcGetHkReport(spParams, commandSequenceCount);
finishAndSendTc(tcGetHkReport); finishAndSendTc(mpsoc::TC_GET_HK_REPORT, tcGetHkReport);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcReplayWriteSequence(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcReplayWriteSequence(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
mpsoc::TcReplayWriteSeq tcReplayWriteSeq(spParams, commandSequenceCount); mpsoc::TcReplayWriteSeq tcReplayWriteSeq(spParams, commandSequenceCount);
ReturnValue_t result = tcReplayWriteSeq.setPayload(commandData, commandDataLen); ReturnValue_t result = tcReplayWriteSeq.setPayload(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcReplayWriteSeq); finishAndSendTc(mpsoc::TC_REPLAY_WRITE_SEQUENCE, tcReplayWriteSeq);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::commandTcModeReplay() { ReturnValue_t FreshMpsocHandler::commandTcModeReplay() {
mpsoc::TcModeReplay tcModeReplay(spParams, commandSequenceCount); mpsoc::TcModeReplay tcModeReplay(spParams, commandSequenceCount);
finishAndSendTc(tcModeReplay); finishAndSendTc(mpsoc::TC_MODE_REPLAY, tcModeReplay);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::commandTcModeIdle() { ReturnValue_t FreshMpsocHandler::commandTcModeIdle() {
mpsoc::TcModeIdle tcModeIdle(spParams, commandSequenceCount); mpsoc::TcModeIdle tcModeIdle(spParams, commandSequenceCount);
finishAndSendTc(tcModeIdle); finishAndSendTc(mpsoc::TC_MODE_IDLE, tcModeIdle);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcCamCmdSend(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcCamCmdSend(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
mpsoc::TcCamcmdSend tcCamCmdSend(spParams, commandSequenceCount); mpsoc::TcCamcmdSend tcCamCmdSend(spParams, commandSequenceCount);
ReturnValue_t result = tcCamCmdSend.setPayload(commandData, commandDataLen); ReturnValue_t result = tcCamCmdSend.setPayload(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcCamCmdSend); finishAndSendTc(mpsoc::TC_CAM_CMD_SEND, tcCamCmdSend);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcCamTakePic(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcCamTakePic(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
mpsoc::TcCamTakePic tcCamTakePic(spParams, commandSequenceCount); mpsoc::TcCamTakePic tcCamTakePic(spParams, commandSequenceCount);
ReturnValue_t result = tcCamTakePic.setPayload(commandData, commandDataLen); ReturnValue_t result = tcCamTakePic.setPayload(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcCamTakePic); finishAndSendTc(mpsoc::TC_CAM_TAKE_PIC, tcCamTakePic);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcSimplexSendFile(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcSimplexSendFile(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
mpsoc::TcSimplexSendFile tcSimplexSendFile(spParams, commandSequenceCount); mpsoc::TcSimplexSendFile tcSimplexSendFile(spParams, commandSequenceCount);
ReturnValue_t result = tcSimplexSendFile.setPayload(commandData, commandDataLen); ReturnValue_t result = tcSimplexSendFile.setPayload(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcSimplexSendFile); finishAndSendTc(mpsoc::TC_SIMPLEX_STREAM_FILE, tcSimplexSendFile);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcGetDirContent(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcGetDirContent(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
mpsoc::TcGetDirContent tcGetDirContent(spParams, commandSequenceCount); mpsoc::TcGetDirContent tcGetDirContent(spParams, commandSequenceCount);
ReturnValue_t result = tcGetDirContent.setPayload(commandData, commandDataLen); ReturnValue_t result = tcGetDirContent.setPayload(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcGetDirContent); finishAndSendTc(mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT, tcGetDirContent);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::prepareTcDownlinkDataModulate(const uint8_t* commandData, ReturnValue_t FreshMpsocHandler::commandTcDownlinkDataModulate(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
mpsoc::TcDownlinkDataModulate tcDownlinkDataModulate(spParams, commandSequenceCount); mpsoc::TcDownlinkDataModulate tcDownlinkDataModulate(spParams, commandSequenceCount);
ReturnValue_t result = tcDownlinkDataModulate.setPayload(commandData, commandDataLen); ReturnValue_t result = tcDownlinkDataModulate.setPayload(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
finishAndSendTc(tcDownlinkDataModulate); finishAndSendTc(mpsoc::TC_DOWNLINK_DATA_MODULATE, tcDownlinkDataModulate);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::commandTcModeSnapshot() { ReturnValue_t FreshMpsocHandler::commandTcModeSnapshot() {
mpsoc::TcModeSnapshot tcModeSnapshot(spParams, commandSequenceCount); mpsoc::TcModeSnapshot tcModeSnapshot(spParams, commandSequenceCount);
finishAndSendTc(tcModeSnapshot); finishAndSendTc(mpsoc::TC_MODE_SNAPSHOT, tcModeSnapshot);
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t FreshMpsocHandler::finishAndSendTc(mpsoc::TcBase& tcBase) { ReturnValue_t FreshMpsocHandler::finishAndSendTc(DeviceCommandId_t cmdId, mpsoc::TcBase& tcBase) {
ReturnValue_t result = tcBase.finishPacket(); ReturnValue_t result = tcBase.finishPacket();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -718,6 +722,9 @@ ReturnValue_t FreshMpsocHandler::finishAndSendTc(mpsoc::TcBase& tcBase) {
<< tcBase.getSeqCount() << std::endl; << tcBase.getSeqCount() << std::endl;
} }
activeCmdInfo.cmdCountdown.resetTimer(); activeCmdInfo.cmdCountdown.resetTimer();
activeCmdInfo.pending = true;
activeCmdInfo.pendingCmd = cmdId;
activeCmdInfo.pendingCmdMpsocApid = tcBase.getApid();
return comInterface.send(tcBase.getFullPacket(), tcBase.getFullPacketLen()); return comInterface.send(tcBase.getFullPacket(), tcBase.getFullPacketLen());
} }
@ -745,7 +752,7 @@ void FreshMpsocHandler::cmdDoneHandler(bool success, ReturnValue_t result) {
} }
transitionState = TransitionState::NONE; transitionState = TransitionState::NONE;
} }
if (activeCmdInfo.commandedBy != MessageQueueIF::NO_QUEUE) { if (activeCmdInfo.pending && (activeCmdInfo.commandedBy != MessageQueueIF::NO_QUEUE)) {
actionHelper.finish(success, activeCmdInfo.commandedBy, activeCmdInfo.pendingCmd, result); actionHelper.finish(success, activeCmdInfo.commandedBy, activeCmdInfo.pendingCmd, result);
} }
activeCmdInfo.reset(); activeCmdInfo.reset();
@ -774,6 +781,22 @@ ReturnValue_t FreshMpsocHandler::handleDeviceReply() {
case (mpsoc::apid::ACK_FAILURE): case (mpsoc::apid::ACK_FAILURE):
break; break;
case (mpsoc::apid::TM_MEMORY_READ_REPORT): case (mpsoc::apid::TM_MEMORY_READ_REPORT):
if (activeCmdInfo.pendingCmd == mpsoc::TC_VERIFY_BOOT) {
// 6 byte header, 4 byte address, 2 byte read width, 4 byte read back value
if (replyReader.getFullPacketLen() >= 6 + 4 + 2 + 4) {
uint32_t readBack = 0;
size_t deserLen = 0;
ReturnValue_t result =
SerializeAdapter::deSerialize(&readBack, replyReader.getFullData() + 6 + 4 + 2,
&deserLen, SerializeIF::Endianness::NETWORK);
if (result != returnvalue::OK or readBack != mpsoc::DEADBEEF_VALUE) {
cmdDoneHandler(false, result);
}
cmdDoneHandler(true, returnvalue::OK);
} else {
cmdDoneHandler(false, result);
}
}
result = reportReplyData(mpsoc::TM_MEMORY_READ_REPORT); result = reportReplyData(mpsoc::TM_MEMORY_READ_REPORT);
break; break;
case (mpsoc::apid::TM_CAM_CMD_RPT): case (mpsoc::apid::TM_CAM_CMD_RPT):
@ -835,7 +858,7 @@ ReturnValue_t FreshMpsocHandler::handleExecutionReport() {
} }
} }
if (commandId == DeviceHandlerIF::NO_COMMAND_ID) { if (commandId == DeviceHandlerIF::NO_COMMAND_ID) {
sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl; sif::warning << "FreshMpsocHandler::handleExecutionReport: Unknown Command ID" << std::endl;
} }
uint16_t status = mpsoc::getStatusFromRawData(replyReader.getFullData()); uint16_t status = mpsoc::getStatusFromRawData(replyReader.getFullData());
sif::warning << "MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl; sif::warning << "MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;

33
linux/payload/FreshMpsocHandler.h
View File

@ -17,6 +17,7 @@ static constexpr bool MPSOC_RX_WIRETAPPING = true;
class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsIF { class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsIF {
public: public:
enum OpCode { DEFAULT_OPERATION = 0, PARSE_TM = 1 }; enum OpCode { DEFAULT_OPERATION = 0, PARSE_TM = 1 };
static constexpr uint32_t MPSOC_MODE_CMD_TIMEOUT_MS = 120000;
FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface, FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface,
PlocMpsocSpecialComHelper& specialComHelper, Gpio uartIsolatorSwitch, PlocMpsocSpecialComHelper& specialComHelper, Gpio uartIsolatorSwitch,
@ -43,7 +44,7 @@ class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsI
enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE; enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE;
enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE }; enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE };
enum TransitionState { NONE, TO_ON, TO_OFF, SUBMODE } transitionState; enum TransitionState { NONE, TO_ON, TO_OFF, SUBMODE } transitionState = TransitionState::NONE;
MpsocCommunication& comInterface; MpsocCommunication& comInterface;
PlocMpsocSpecialComHelper& specialComHelper; PlocMpsocSpecialComHelper& specialComHelper;
MessageQueueIF* eventQueue = nullptr; MessageQueueIF* eventQueue = nullptr;
@ -169,24 +170,24 @@ class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsI
void handleTransitionToOff(); void handleTransitionToOff();
ReturnValue_t commandTcModeReplay(); ReturnValue_t commandTcModeReplay();
ReturnValue_t prepareTcMemWrite(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcMemWrite(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcMemRead(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcMemRead(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcFlashDelete(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcFlashDelete(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcReplayStart(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcReplayStart(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcReplayStop(); ReturnValue_t commandTcReplayStop();
ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcDownlinkPwrOff(); ReturnValue_t commandTcDownlinkPwrOff();
ReturnValue_t prepareTcGetHkReport(); ReturnValue_t commandTcGetHkReport();
ReturnValue_t prepareTcGetDirContent(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcGetDirContent(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t commandTcModeIdle(); ReturnValue_t commandTcModeIdle();
ReturnValue_t prepareTcCamTakePic(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcCamTakePic(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcSimplexSendFile(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcSimplexSendFile(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t prepareTcDownlinkDataModulate(const uint8_t* commandData, size_t commandDataLen); ReturnValue_t commandTcDownlinkDataModulate(const uint8_t* commandData, size_t commandDataLen);
ReturnValue_t commandTcModeSnapshot(); ReturnValue_t commandTcModeSnapshot();
ReturnValue_t finishAndSendTc(mpsoc::TcBase& tcBase); ReturnValue_t finishAndSendTc(DeviceCommandId_t cmdId, mpsoc::TcBase& tcBase);
void handleEvent(EventMessage* eventMessage); void handleEvent(EventMessage* eventMessage);
void cmdDoneHandler(bool success, ReturnValue_t result); void cmdDoneHandler(bool success, ReturnValue_t result);
ReturnValue_t handleDeviceReply(); ReturnValue_t handleDeviceReply();

15
linux/payload/plocMpsocHelpers.h
View File

@ -80,6 +80,8 @@ enum FileAccessModes : uint8_t {
}; };
static constexpr uint32_t HK_SET_ID = 0; static constexpr uint32_t HK_SET_ID = 0;
static constexpr uint32_t DEADBEEF_ADDR = 0x40000004;
static constexpr uint32_t DEADBEEF_VALUE= 0xdeadbeef;
namespace poolid { namespace poolid {
enum { enum {
@ -135,23 +137,26 @@ static const DeviceCommandId_t TC_REPLAY_STOP = 12;
static const DeviceCommandId_t TC_REPLAY_WRITE_SEQUENCE = 13; static const DeviceCommandId_t TC_REPLAY_WRITE_SEQUENCE = 13;
static const DeviceCommandId_t TC_DOWNLINK_PWR_ON = 14; static const DeviceCommandId_t TC_DOWNLINK_PWR_ON = 14;
static const DeviceCommandId_t TC_DOWNLINK_PWR_OFF = 15; static const DeviceCommandId_t TC_DOWNLINK_PWR_OFF = 15;
static const DeviceCommandId_t TC_MODE_REPLAY = 16;
static const DeviceCommandId_t TC_CAM_CMD_SEND = 17; static const DeviceCommandId_t TC_CAM_CMD_SEND = 17;
static const DeviceCommandId_t TC_MODE_IDLE = 18;
static const DeviceCommandId_t TM_CAM_CMD_RPT = 19; static const DeviceCommandId_t TM_CAM_CMD_RPT = 19;
static const DeviceCommandId_t SET_UART_TX_TRISTATE = 20; static const DeviceCommandId_t SET_UART_TX_TRISTATE = 20;
static const DeviceCommandId_t RELEASE_UART_TX = 21; static const DeviceCommandId_t RELEASE_UART_TX = 21;
static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22; static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22;
static const DeviceCommandId_t TC_SIMPLEX_SEND_FILE = 23; // Stream file down using E-Band component directly.
static const DeviceCommandId_t TC_SIMPLEX_STREAM_FILE = 23;
static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24; static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24;
static const DeviceCommandId_t TC_MODE_SNAPSHOT = 25;
static const DeviceCommandId_t TC_GET_HK_REPORT = 26; static const DeviceCommandId_t TC_GET_HK_REPORT = 26;
static const DeviceCommandId_t TM_GET_HK_REPORT = 27; static const DeviceCommandId_t TM_GET_HK_REPORT = 27;
static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28; static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28;
static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29; static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29;
static constexpr DeviceCommandId_t TC_FLASH_READ_FULL_FILE = 30; static constexpr DeviceCommandId_t TC_FLASH_READ_FULL_FILE = 30;
// Store file on MPSoC.
static const DeviceCommandId_t TC_SIMPLEX_STORE_FILE = 31;
static const DeviceCommandId_t TC_VERIFY_BOOT = 32;
// Do not use those, use submode instead.
static const DeviceCommandId_t TC_MODE_REPLAY_LEGACY = 16;
static const DeviceCommandId_t TC_MODE_IDLE_LEGACY = 18;
static const DeviceCommandId_t TC_MODE_SNAPSHOT_LEGACY = 25;
// Will reset the sequence count of the OBSW. Not required anymore after MPSoC update. // Will reset the sequence count of the OBSW. Not required anymore after MPSoC update.
static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT_LEGACY = 50; static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT_LEGACY = 50;

2
tmtc

@ -1 +1 @@
Subproject commit fc5fb0eed333a46407c59e40cc9ca018ab3e217c Subproject commit 18860ec2c670230722f47a149a2486377a75da52