okay, PAPB IF caches packet now

linux/ipcore/PapbVcInterface.cpp

@@ -8,8 +8,12 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId,
-                                 std::string uioFile, int mapNum)
-    : gpioComIF(gpioComIF), papbEmptyId(papbEmptyId), uioFile(std::move(uioFile)), mapNum(mapNum) {}
+                                 std::string uioFile, int mapNum, size_t maxPacketSize)
+    : gpioComIF(gpioComIF),
+      papbEmptyId(papbEmptyId),
+      packetBuf(maxPacketSize),
+      uioFile(std::move(uioFile)),
+      mapNum(mapNum) {}
 
 PapbVcInterface::~PapbVcInterface() {}
 
@@ -29,9 +33,17 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size, size_t& w
     return returnvalue::FAILED;
   }
   // The user must call finishWrite before starting a new packet transfer.
-  if (partialWriteActive) {
-    return INCOMPLETE_PARTIAL_WRITE;
+  if (writeActive) {
+    return IS_BUSY;
   }
+  if (size > packetBuf.capacity()) {
+    sif::error << "PapbVcInterface: Packet with size " << size << " larger than maximum configured"
+               << " byte size " << packetBuf.capacity() << std::endl;
+    return returnvalue::FAILED;
+  }
+  std::memcpy(packetBuf.data(), data, size);
+  currentPacketSize = size;
+  currentPacketIndex = 0;
   if (pollReadyForPacket()) {
     startPacketTransfer(ByteWidthCfg::ONE);
   } else {
@@ -41,14 +53,17 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size, size_t& w
     abortPacketTransfer();
     return returnvalue::FAILED;
   }
-  return finishWriteInternal(data, 0, size, writtenSize, false);
+  return advanceWrite(writtenSize);
 }
 
 void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
   *vcBaseReg = CONFIG_DATA_INPUT | initWidth;
 }
 
-void PapbVcInterface::completePacketTransfer() { *vcBaseReg = CONFIG_END; }
+void PapbVcInterface::completePacketTransfer() {
+  *vcBaseReg = CONFIG_END;
+  writeActive = false;
+}
 
 bool PapbVcInterface::pollReadyForPacket() const {
   //  Check if PAPB interface is ready to receive data. Use the configuration register for this.
@@ -57,34 +72,20 @@ bool PapbVcInterface::pollReadyForPacket() const {
   return (reg >> 6) & 0b1;
 }
 
-ReturnValue_t PapbVcInterface::finishWrite(const uint8_t* data, size_t start,
-                                           size_t remainingSize) {
+ReturnValue_t PapbVcInterface::advanceWrite(size_t& writtenSize) {
   if (not pollReadyForPacket()) {
-    return returnvalue::FAILED;
+    return IS_BUSY;
   }
-  size_t dummy = 0;
-  return finishWriteInternal(data, start, remainingSize, dummy, true);
-}
-
-ReturnValue_t PapbVcInterface::finishWriteInternal(const uint8_t* data, size_t start,
-                                                   size_t remainingSize, size_t& writtenSize,
-                                                   bool abortOnPartialWrite) {
-  for (size_t idx = 0; idx < remainingSize; idx++) {
+  for (size_t idx = currentPacketIndex; idx < currentPacketSize; idx++) {
     if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
       if (not pollReadyForPacket()) {
-        writtenSize = start + idx;
-        partialWriteActive = true;
-        if (abortOnPartialWrite) {
-          abortPacketTransfer();
-          partialWriteActive = false;
-          return returnvalue::FAILED;
-        }
         return PARTIALLY_WRITTEN;
       }
       abortPacketTransfer();
       return returnvalue::FAILED;
     }
-    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[start + idx]);
+    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(packetBuf[currentPacketIndex]);
+    writtenSize++;
   }
   if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
     abortPacketTransfer();