ploc update

linux/devices/ploc/PlocSupvHelper.cpp

@@ -8,6 +8,8 @@
 #include "bsp_q7s/memory/FilesystemHelper.h"
 #endif
 
+#include "bsp_q7s/memory/FilesystemHelper.h"
+#include "fsfw/globalfunctions/CRC.h"
 #include "mission/utility/Timestamp.h"
 
 PlocSupvHelper::PlocSupvHelper(object_id_t objectId) : SystemObject(objectId) {}
@@ -51,12 +53,12 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
   }
 }
 
-ReturnValue_t PlocSupvHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
-  uartComIF = dynamic_cast<UartComIF*>(communicationInterface_);
-  if (uartComIF == nullptr) {
-    sif::warning << "PlocSupvHelper::initialize: Invalid uart com if" << std::endl;
+ReturnValue_t PlocSupvHelper::setComIF(UartComIF* uartComIF_) {
+  if (uartComIF_ == nullptr) {
+    sif::warning << "PlocSupvHelper::initialize: Provided invalid uart com if" << std::endl;
     return RETURN_FAILED;
   }
+  uartComIF = uartComIF_;
   return RETURN_OK;
 }
 
@@ -68,14 +70,34 @@ ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId,
 #ifdef XIPHOS_Q7S
   result = FilesystemHelper::checkPath(file);
   if (result != RETURN_OK) {
-    sif::warning << "PlocSupvHelper::startUpdate: File " << file << " does not exists" << std::endl;
+    sif::warning << "PlocSupvHelper::startUpdate: File " << file << " does not exist" << std::endl;
     return result;
   }
+  result = FileSytemHelper::fileExists(file);
+  if (result != RETURN_OK) {
+    sif::warning << "PlocSupvHelper::startUpdate: The file " << file << " does not exist"
+                 << std::endl;
+    reurn result;
+  }
+#endif
+#ifdef TE0720_1CFA
+  if (not std::filesystem::exists(file)) {
+    sif::warning << "PlocSupvHelper::startUpdate: The file " << file << " does not exist"
+                 << std::endl;
+    return RETURN_FAILED;
+  }
 #endif
   update.file = file;
+  update.length = getFileSize(update.file);
   update.memoryId = memoryId;
   update.startAddress = startAddress;
+  result = calcImageCrc();
+  if (result != RETURN_OK) {
+    return result;
+  }
   internalState = InternalState::UPDATE;
+  uartComIF->flushUartTxAndRxBuf(comCookie);
+  semaphore.release();
   return result;
 }
 
@@ -83,48 +105,73 @@ void PlocSupvHelper::stopProcess() { terminate = true; }
 
 ReturnValue_t PlocSupvHelper::performUpdate() {
   ReturnValue_t result = RETURN_OK;
+  result = prepareUpdate();
+  if (result != RETURN_OK) {
+    return result;
+  }
   result = eraseMemory();
   if (result != RETURN_OK) {
     return result;
   }
-  uint8_t tempData[supv::UpdatePacket::MAX_UPDATE_DATA];
+  uint8_t tempData[supv::WriteMemory::CHUNK_MAX];
   std::ifstream file(update.file, std::ifstream::binary);
-  // Set position of next character to end of file input stream
-  file.seekg(0, file.end);
-  // tellg returns position of character in input stream
-  size_t remainingSize = file.tellg();
-  size_t dataLength = 0;
-  size_t bytesRead = 0;
+  size_t remainingSize = update.length;
+  uint16_t dataLength = 0;
+  size_t bytesWritten = 0;
+  uint16_t sequenceCount = 1;
+  supv::SequenceFlags seqFlags = supv::SequenceFlags::FIRST_PKT;
   while (remainingSize > 0) {
-    update.startAddress = bytesRead;
     if (terminate) {
-      return RETURN_OK;
+      return PROCESS_TERMINATED;
     }
-    if (remainingSize > supv::UpdatePacket::MAX_UPDATE_DATA) {
-      dataLength = supv::UpdatePacket::MAX_UPDATE_DATA;
+    if (remainingSize > supv::WriteMemory::CHUNK_MAX) {
+      dataLength = supv::WriteMemory::CHUNK_MAX;
     } else {
       dataLength = remainingSize;
     }
     if (file.is_open()) {
-      file.seekg(bytesRead, file.beg);
+      file.seekg(bytesWritten, file.beg);
       file.read(reinterpret_cast<char*>(tempData), dataLength);
-      bytesRead += dataLength;
       remainingSize -= dataLength;
     } else {
       return FILE_CLOSED_ACCIDENTALLY;
     }
-    supv::UpdatePacket tc(update.memoryId, update.startAddress, tempData);
-    result = handlePacketTransmission(tc);
+    if (bytesWritten == 0) {
+      seqFlags = supv::SequenceFlags::FIRST_PKT;
+    } else if (remainingSize == 0) {
+      seqFlags = supv::SequenceFlags::LAST_PKT;
+    } else {
+      seqFlags = supv::SequenceFlags::CONTINUED_PKT;
+    }
+    supv::WriteMemory packet(seqFlags, sequenceCount++, update.memoryId,
+                             update.startAddress + bytesWritten, dataLength, tempData);
+    result = handlePacketTransmission(packet);
     if (result != RETURN_OK) {
       return result;
     }
+    bytesWritten += dataLength;
+  }
+
+  result = handleCheckMemoryCommand();
+  if (result != RETURN_OK) {
+    return result;
   }
   return result;
 }
 
+ReturnValue_t PlocSupvHelper::prepareUpdate() {
+  ReturnValue_t result = RETURN_OK;
+  supv::ApidOnlyPacket packet(supv::APID_PREPARE_UPDATE);
+  result = handlePacketTransmission(packet);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  return RETURN_OK;
+}
+
 ReturnValue_t PlocSupvHelper::eraseMemory() {
   ReturnValue_t result = RETURN_OK;
-  supv::EraseMemory eraseMemory(memoryId, startAddress, length);
+  supv::EraseMemory eraseMemory(update.memoryId, update.startAddress, update.length);
   result = handlePacketTransmission(eraseMemory);
   if (result != RETURN_OK) {
     return result;
@@ -132,24 +179,9 @@ ReturnValue_t PlocSupvHelper::eraseMemory() {
   return RETURN_OK;
 }
 
-ReturnValue_t PlocSupvHelper::flashfclose() {
+ReturnValue_t PlocSupvHelper::handlePacketTransmission(SpacePacket& packet) {
   ReturnValue_t result = RETURN_OK;
-  (*sequenceCount)++;
-  supv::FlashFclose flashFclose(*sequenceCount);
-  result = flashFclose.createPacket(flashWrite.mpsocFile);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  result = handlePacketTransmission(flashFclose);
-  if (result != RETURN_OK) {
-    return result;
-  }
-  return RETURN_OK;
-}
-
-ReturnValue_t PlocSupvHelper::handlePacketTransmission(SpacePacket& tc) {
-  ReturnValue_t result = RETURN_OK;
-  result = sendCommand(tc);
+  result = sendCommand(packet);
   if (result != RETURN_OK) {
     return result;
   }
@@ -164,12 +196,12 @@ ReturnValue_t PlocSupvHelper::handlePacketTransmission(SpacePacket& tc) {
   return RETURN_OK;
 }
 
-ReturnValue_t PlocSupvHelper::sendCommand(supv::TcBase& tc) {
+ReturnValue_t PlocSupvHelper::sendCommand(SpacePacket& packet) {
   ReturnValue_t result = RETURN_OK;
-  result = uartComIF->sendMessage(comCookie, tc.getWholeData(), tc.getFullSize());
+  result = uartComIF->sendMessage(comCookie, packet.getWholeData(), packet.getFullSize());
   if (result != RETURN_OK) {
     sif::warning << "PlocSupvHelper::sendCommand: Failed to send command" << std::endl;
-    triggerEvent(SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
+    triggerEvent(SUPV_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
     return result;
   }
   return result;
@@ -180,6 +212,8 @@ ReturnValue_t PlocSupvHelper::handleAck() {
   supv::TmPacket tmPacket;
   result = handleTmReception(&tmPacket, supv::SIZE_ACK_REPORT);
   if (result != RETURN_OK) {
+    sif::warning << "PlocSupvHelper::handleAck: Error in reception of acknowledgment report"
+                 << std::endl;
     return result;
   }
   uint16_t apid = tmPacket.getAPID();
@@ -192,11 +226,11 @@ ReturnValue_t PlocSupvHelper::handleAck() {
 
 void PlocSupvHelper::handleAckApidFailure(uint16_t apid) {
   if (apid == supv::APID_ACK_FAILURE) {
-    triggerEvent(ACK_FAILURE_REPORT, static_cast<uint32_t>(internalState));
+    triggerEvent(SUPV_ACK_FAILURE_REPORT, static_cast<uint32_t>(internalState));
     sif::warning << "PlocSupvHelper::handleAckApidFailure: Received acknowledgement failure "
                  << "report" << std::endl;
   } else {
-    triggerEvent(ACK_INVALID_APID, apid, static_cast<uint32_t>(internalState));
+    triggerEvent(SUPV_ACK_INVALID_APID, apid, static_cast<uint32_t>(internalState));
     sif::warning << "PlocSupvHelper::handleAckApidFailure: Expected acknowledgement report "
                  << "but received space packet with apid " << std::hex << apid << std::endl;
   }
@@ -207,10 +241,12 @@ ReturnValue_t PlocSupvHelper::handleExe() {
   supv::TmPacket tmPacket;
   result = handleTmReception(&tmPacket, supv::SIZE_EXE_REPORT);
   if (result != RETURN_OK) {
+    sif::warning << "PlocSupvHelper::handleExe: Error in reception of execution report"
+                 << std::endl;
     return result;
   }
   uint16_t apid = tmPacket.getAPID();
-  if (apid != supv::apid::EXE_SUCCESS) {
+  if (apid != supv::APID_EXE_SUCCESS) {
     handleExeApidFailure(apid);
     return RETURN_FAILED;
   }
@@ -218,7 +254,7 @@ ReturnValue_t PlocSupvHelper::handleExe() {
 }
 
 void PlocSupvHelper::handleExeApidFailure(uint16_t apid) {
-  if (apid == supv::apid::EXE_FAILURE) {
+  if (apid == supv::APID_EXE_FAILURE) {
     triggerEvent(SUPV_EXE_FAILURE_REPORT, static_cast<uint32_t>(internalState));
     sif::warning << "PlocSupvHelper::handleExeApidFailure: Received execution failure "
                  << "report" << std::endl;
@@ -246,7 +282,7 @@ ReturnValue_t PlocSupvHelper::handleTmReception(supv::TmPacket* tmPacket, size_t
   }
   if (remainingBytes != 0) {
     sif::warning << "PlocSupvHelper::handleTmReception: Failed to receive reply" << std::endl;
-    triggerEvent(MISSING_EXE, remainingBytes, static_cast<uint32_t>(internalState));
+    triggerEvent(SUPV_MISSING_EXE, remainingBytes, static_cast<uint32_t>(internalState));
     return RETURN_FAILED;
   }
   result = tmPacket->checkCrc();
@@ -254,12 +290,6 @@ ReturnValue_t PlocSupvHelper::handleTmReception(supv::TmPacket* tmPacket, size_t
     sif::warning << "PlocSupvHelper::handleTmReception: CRC check failed" << std::endl;
     return result;
   }
-  (*sequenceCount)++;
-  uint16_t recvSeqCnt = tmPacket->getPacketSequenceCount();
-  if (recvSeqCnt != *sequenceCount) {
-    triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
-    *sequenceCount = recvSeqCnt;
-  }
   return result;
 }
 
@@ -269,14 +299,14 @@ ReturnValue_t PlocSupvHelper::receive(uint8_t* data, size_t* readBytes, size_t r
   result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
   if (result != RETURN_OK) {
     sif::warning << "PlocSupvHelper::receive: Failed to request reply" << std::endl;
-    triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result,
+    triggerEvent(SUPV_HELPER_REQUESTING_REPLY_FAILED, result,
                  static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
     return RETURN_FAILED;
   }
   result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
   if (result != RETURN_OK) {
     sif::warning << "PlocSupvHelper::receive: Failed to read received message" << std::endl;
-    triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
+    triggerEvent(SUPV_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
     return RETURN_FAILED;
   }
   if (*readBytes > 0) {
@@ -284,3 +314,68 @@ ReturnValue_t PlocSupvHelper::receive(uint8_t* data, size_t* readBytes, size_t r
   }
   return result;
 }
+
+ReturnValue_t PlocSupvHelper::calcImageCrc() {
+  ReturnValue_t result = RETURN_OK;
+#ifdef XIPHOS_Q7S
+  result = FilesystemHelper::checkPath(update.file);
+#endif
+  if (result != RETURN_OK) {
+    sif::warning << "PlocSupvHelper::calcImageCrc: File " << update.file << " does not exist"
+                 << std::endl;
+    return result;
+  }
+  std::ifstream file(update.file, std::ifstream::binary);
+  uint16_t remainder = CRC16_INIT;
+  uint8_t input;
+  for (uint32_t byteCount = 0; byteCount < update.length; byteCount++) {
+    file.seekg(byteCount, file.beg);
+    file.read(reinterpret_cast<char*>(&input), 1);
+    remainder = CRC::crc16ccitt(&input, sizeof(input), remainder);
+  }
+  file.close();
+  update.crc = remainder;
+  return result;
+}
+
+ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
+  ReturnValue_t result = RETURN_OK;
+  // Verification of update write procedure
+  supv::CheckMemory packet(update.memoryId, update.startAddress, update.length);
+  result = sendCommand(packet);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = handleAck();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  supv::UpdateStatusReport updateStatusReport;
+  result = handleTmReception(&updateStatusReport,
+                             static_cast<size_t>(updateStatusReport.getNominalSize()));
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = handleExe();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = updateStatusReport.parseDataField();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = updateStatusReport.verifycrc(update.crc);
+  if (result != RETURN_OK) {
+    sif::warning << "PlocSupvHelper::performUpdate: CRC failure. Expected CRC 0x" << std::hex
+                 << update.crc << " but received CRC 0x" << updateStatusReport.getCrc()
+                 << std::endl;
+    return result;
+  }
+  return result;
+}
+
+uint32_t PlocSupvHelper::getFileSize(std::string filename) {
+  std::ifstream file(filename, std::ifstream::binary);
+  file.seekg(0, file.end);
+  return file.tellg();
+}