replay command

linux/devices/devicedefinitions/PlocMPSoCDefinitions.h

@@ -24,6 +24,7 @@ static const DeviceCommandId_t TC_REPLAY_STOP = 12;
 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_OFF = 15;
+static const DeviceCommandId_t TC_MODE_REPLAY = 16;
 
 static const uint16_t SIZE_ACK_REPORT = 14;
 static const uint16_t SIZE_EXE_REPORT = 14;
@@ -43,6 +44,7 @@ namespace apid {
     static const uint16_t TC_FLASHFOPEN = 0x119;
     static const uint16_t TC_FLASHFCLOSE = 0x11A;
     static const uint16_t TC_FLASHDELETE = 0x11C;
+    static const uint16_t TC_MODE_REPLAY = 0x11F;
     static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
     static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
     static const uint16_t ACK_SUCCESS = 0x400;
@@ -610,6 +612,30 @@ class FlashWritePusCmd : public MPSoCReturnValuesIF {
   std::string obcFile = "";
   std::string mpsocFile = "";
 };
+
+/**
+ * @brief   Class to build replay stop space packet.
+ */
+class TcModeReplay : public TcBase {
+public:
+
+    TcModeReplay(uint16_t sequenceCount) :
+            TcBase(apid::TC_MODE_REPLAY, sequenceCount) {
+    }
+
+    ReturnValue_t createPacket() {
+        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+        result = addCrc();
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+};
+
 }
 
+
+
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */

linux/devices/ploc/PlocMPSoCHandler.cpp

@@ -163,6 +163,10 @@ ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t device
       result = prepareTcReplayWriteSequence(commandData, commandDataLen);
       break;
     }
+    case (mpsoc::TC_MODE_REPLAY): {
+	  result = prepareTcModeReplay();
+	  break;
+	}
     default:
       sif::debug << "PlocMPSoCHandler::buildCommandFromCommand: Command not implemented"
                  << std::endl;
@@ -189,6 +193,7 @@ void PlocMPSoCHandler::fillCommandAndReplyMap() {
   this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_ON);
   this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_OFF);
   this->insertInCommandMap(mpsoc::TC_REPLAY_WRITE_SEQUENCE);
+  this->insertInCommandMap(mpsoc::TC_MODE_REPLAY);
   this->insertInReplyMap(mpsoc::ACK_REPORT, 1, nullptr, mpsoc::SIZE_ACK_REPORT);
   this->insertInReplyMap(mpsoc::EXE_REPORT, 3, nullptr, mpsoc::SIZE_EXE_REPORT);
   this->insertInReplyMap(mpsoc::TM_MEMORY_READ_REPORT, 2, nullptr, mpsoc::SIZE_TM_MEM_READ_REPORT);
@@ -398,6 +403,22 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* comm
   return RETURN_OK;
 }
 
+ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
+	ReturnValue_t result = RETURN_OK;
+	sequenceCount++;
+	mpsoc::TcModeReplay tcModeReplay(sequenceCount);
+	result = tcModeReplay.createPacket();
+	if (result != RETURN_OK) {
+		sequenceCount--;
+		return result;
+	}
+	memcpy(commandBuffer, tcModeReplay.getWholeData(), tcModeReplay.getFullSize());
+	rawPacket = commandBuffer;
+	rawPacketLen = tcModeReplay.getFullSize();
+	nextReplyId = mpsoc::ACK_REPORT;
+	return RETURN_OK;
+}
+
 void PlocMPSoCHandler::copyToCommandBuffer(mpsoc::TcBase* tc) {
   if (tc == nullptr) {
     sif::debug << "PlocMPSoCHandler::copyToCommandBuffer: Invalid TC" << std::endl;
@@ -487,6 +508,7 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
       } else {
         sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl;
       }
+      printStatus(data);
       sendFailureReport(mpsoc::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
       disableExeReportReply();
       result = IGNORE_REPLY_DATA;
@@ -533,6 +555,7 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
     case mpsoc::TC_DOWNLINK_PWR_ON:
     case mpsoc::TC_DOWNLINK_PWR_OFF:
     case mpsoc::TC_REPLAY_WRITE_SEQUENCE:
+    case mpsoc::TC_MODE_REPLAY:
       enabledReplies = 2;
       break;
     case mpsoc::TC_MEM_READ: {
@@ -714,3 +737,9 @@ void PlocMPSoCHandler::disableExeReportReply() {
   /* Expected replies is set to one here. The value will set to 0 in replyToReply() */
   info->command->second.expectedReplies = 0;
 }
+
+void PlocMPSoCHandler::printStatus(const uint8_t* data) {
+	uint16_t status = *(data + STATUS_OFFSET) << 8 | *(data + STATUS_OFFSET + 1);
+	sif::info << "Verification report status: 0x" << std::hex << status << std::endl;
+}
+

linux/devices/ploc/PlocMPSoCHandler.h

@@ -77,6 +77,7 @@ private:
 
     static const uint16_t APID_MASK = 0x7FF;
     static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
+    static const uint8_t STATUS_OFFSET = 10;
 
     MessageQueueIF* eventQueue = nullptr;
 
@@ -201,6 +202,10 @@ private:
 	 *          the variable expectedReplies of an active command will be set to 0.
 	 */
 	void disableExeReportReply();
+
+	void printStatus(const uint8_t* data);
+
+	ReturnValue_t prepareTcModeReplay();
 };
 
 #endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */

tmtc

@@ -1 +1 @@
-Subproject commit 71c16f78aebadbc7b3d52bd5b09838937bbbc7d1
+Subproject commit 6572a5df6169772b517f2de2f3e4a1ba8f6471f4