fix PTME

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 313 translations.
  * @details
- * Generated on: 2023-10-11 10:54:39
+ * Generated on: 2023-10-13 09:17:41
  */
 #include "translateEvents.h"
 

linux/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 178 translations.
- * Generated on: 2023-10-11 10:54:39
+ * Generated on: 2023-10-13 09:17:41
  */
 #include "translateObjects.h"
 

linux/ipcore/PapbVcInterface.cpp

@@ -23,7 +23,7 @@ ReturnValue_t PapbVcInterface::initialize() {
   return returnvalue::OK;
 }
 
-ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
+ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size, size_t& writtenSize) {
   // There are no packets smaller than 4, this is considered a configuration error.
   if (size < 4) {
     return returnvalue::FAILED;
@@ -37,19 +37,7 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
     abortPacketTransfer();
     return returnvalue::FAILED;
   }
-  for (size_t idx = 0; idx < size; idx++) {
-    if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
-      abortPacketTransfer();
-      return returnvalue::FAILED;
-    }
-    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
-  }
-  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
-    abortPacketTransfer();
-    return returnvalue::FAILED;
-  }
-  completePacketTransfer();
-  return returnvalue::OK;
+  return finishWritePartialOpt(data, size, true);
 }
 
 void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
@@ -65,6 +53,26 @@ bool PapbVcInterface::pollReadyForPacket() const {
   return (reg >> 6) & 0b1;
 }
 
+ReturnValue_t PapbVcInterface::finishWritePartialOpt(const uint8_t* data, size_t remainingSize,
+                                                     bool handlePartial) {
+  for (size_t idx = 0; idx < remainingSize; idx++) {
+    if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+      if (not pollReadyForPacket()) {
+        return PARTIALLY_WRITTEN;
+      }
+      abortPacketTransfer();
+      return returnvalue::FAILED;
+    }
+    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
+  }
+  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+    abortPacketTransfer();
+    return returnvalue::FAILED;
+  }
+  completePacketTransfer();
+  return returnvalue::OK;
+}
+
 bool PapbVcInterface::isVcInterfaceBufferEmpty() {
   ReturnValue_t result = returnvalue::OK;
   gpio::Levels papbEmptyState = gpio::Levels::HIGH;
@@ -101,21 +109,8 @@ inline bool PapbVcInterface::pollReadyForOctet(uint32_t maxCycles) const {
   return false;
 }
 
-ReturnValue_t PapbVcInterface::sendTestFrame() {
-  /** Size of one complete transfer frame data field amounts to 1105 bytes */
-  uint8_t testPacket[1105];
-
-  /** Fill one test packet */
-  for (int idx = 0; idx < 1105; idx++) {
-    testPacket[idx] = static_cast<uint8_t>(idx & 0xFF);
-  }
-
-  ReturnValue_t result = write(testPacket, 1105);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  return returnvalue::OK;
+ReturnValue_t PapbVcInterface::finishWrite(const uint8_t* data, size_t remainingSize) {
+  return finishWritePartialOpt(data, remainingSize, false);
 }
 
 void PapbVcInterface::abortPacketTransfer() { *vcBaseReg = CONFIG_ABORT; }

linux/ipcore/PapbVcInterface.h

@@ -40,7 +40,11 @@ class PapbVcInterface : public VirtualChannelIF {
    * @param size
    * @return returnvalue::OK on successfull write, PAPB_BUSY if PAPB is busy.
    */
-  ReturnValue_t write(const uint8_t* data, size_t size) override;
+  ReturnValue_t write(const uint8_t* data, size_t size, size_t& writtenSize) override;
+
+  ReturnValue_t finishWrite(const uint8_t* data, size_t remainingSize) override;
+  ReturnValue_t finishWritePartialOpt(const uint8_t* data, size_t remainingSize,
+                                      bool handlePartial);
 
   void cancelTransfer() override;
 
@@ -126,12 +130,6 @@ class PapbVcInterface : public VirtualChannelIF {
    *          the packet buffer of the virtual channel or not.
    */
   bool isVcInterfaceBufferEmpty();
-
-  /**
-   * @brief   This function sends a complete telemetry transfer frame data field (1105 bytes)
-   *          to the papb interface of the PTME IP Core. Can be used to test the implementation.
-   */
-  ReturnValue_t sendTestFrame();
 };
 
 #endif /* LINUX_OBC_PAPBVCINTERFACE_H_ */

linux/ipcore/Ptme.cpp

@@ -19,15 +19,12 @@ ReturnValue_t Ptme::initialize() {
   return returnvalue::OK;
 }
 
-ReturnValue_t Ptme::writeToVc(uint8_t vcId, const uint8_t* data, size_t size) {
-  VcInterfaceMapIter vcInterfaceMapIter = vcInterfaceMap.find(vcId);
-  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
-    sif::warning << "Ptme::writeToVc: No virtual channel interface found for the virtual "
-                    "channel with id "
-                 << static_cast<unsigned int>(vcId) << std::endl;
-    return UNKNOWN_VC_ID;
+bool Ptme::containsVc(uint8_t vcId) const {
+  auto channelIter = vcInterfaceMap.find(vcId);
+  if (channelIter == vcInterfaceMap.end()) {
+    return false;
   }
-  return vcInterfaceMapIter->second->write(data, size);
+  return true;
 }
 
 void Ptme::addVcInterface(VcId_t vcId, VirtualChannelIF* vc) {
@@ -50,21 +47,10 @@ void Ptme::addVcInterface(VcId_t vcId, VirtualChannelIF* vc) {
   }
 }
 
-bool Ptme::isBusy(uint8_t vcId) const {
-  const auto& vcInterfaceMapIter = vcInterfaceMap.find(vcId);
-  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
-    sif::warning << "Ptme::writeToVc: No virtual channel interface found for the virtual "
-                    "channel with id "
-                 << static_cast<unsigned int>(vcId) << std::endl;
-    return UNKNOWN_VC_ID;
+VirtualChannelIF* Ptme::getVirtChannel(uint8_t vcId) {
+  auto channelIter = vcInterfaceMap.find(vcId);
+  if (channelIter == vcInterfaceMap.end()) {
+    return nullptr;
   }
-  return vcInterfaceMapIter->second->isBusy();
-}
-
-void Ptme::cancelTransfer(uint8_t vcId) {
-  VcInterfaceMapIter vcInterfaceMapIter = vcInterfaceMap.find(vcId);
-  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
-    return;
-  }
-  return vcInterfaceMapIter->second->cancelTransfer();
+  return channelIter->second;
 }

linux/ipcore/Ptme.h

@@ -34,9 +34,8 @@ class Ptme : public PtmeIF, public SystemObject {
   virtual ~Ptme();
 
   ReturnValue_t initialize() override;
-  ReturnValue_t writeToVc(uint8_t vcId, const uint8_t* data, size_t size) override;
-  bool isBusy(uint8_t vcId) const override;
-  void cancelTransfer(uint8_t vcId) override;
+  bool containsVc(uint8_t vcId) const override;
+  VirtualChannelIF* getVirtChannel(uint8_t vcId) override;
 
   /**
    * @brief   This function adds the reference to a virtual channel interface to the vcInterface

linux/ipcore/PtmeIF.h

@@ -1,6 +1,8 @@
 #ifndef LINUX_OBC_PTMEIF_H_
 #define LINUX_OBC_PTMEIF_H_
 
+#include <linux/ipcore/VirtualChannelIF.h>
+
 #include "fsfw/returnvalues/returnvalue.h"
 
 /**
@@ -14,16 +16,8 @@ class PtmeIF {
  public:
   virtual ~PtmeIF(){};
 
-  /**
-   * @brief   Implements to function to write to a specific virtual channel.
-   *
-   * @param vcId  Virtual channel to write to
-   * @param data  Pointer to buffer holding the data to write
-   * @param size  Number of bytes to write
-   */
-  virtual ReturnValue_t writeToVc(uint8_t vcId, const uint8_t* data, size_t size) = 0;
-  virtual bool isBusy(uint8_t vcId) const = 0;
-  virtual void cancelTransfer(uint8_t vcId) = 0;
+  virtual bool containsVc(uint8_t vcId) const = 0;
+  virtual VirtualChannelIF* getVirtChannel(uint8_t vcId) = 0;
 };
 
 #endif /* LINUX_OBC_PTMEIF_H_ */