DLE FRAM packets can be read now

linux/devices/CMakeLists.txt

@@ -6,6 +6,7 @@ endif()
 
 target_sources(${OBSW_NAME} PRIVATE
 	ScexUartReader.cpp
+	ScexDleParser.cpp
 )
 add_subdirectory(ploc)
 add_subdirectory(startracker)

linux/devices/ScexDleParser.cpp

@@ -0,0 +1,6 @@
+#include "ScexDleParser.h"
+
+ScexDleParser::ScexDleParser(SimpleRingBuffer &decodeRingBuf, DleEncoder &decoder,
+                             BufPair encodedBuf, BufPair decodedBuf, FoundPacketHandler handler,
+                             void *args)
+    : DleParser(decodeRingBuf, decoder, encodedBuf, decodedBuf, handler, args) {}

linux/devices/ScexDleParser.h

@@ -0,0 +1,12 @@
+#ifndef LINUX_DEVICES_SCEXDLEPARSER_H_
+#define LINUX_DEVICES_SCEXDLEPARSER_H_
+
+#include <fsfw/globalfunctions/DleParser.h>
+
+class ScexDleParser : public DleParser {
+ public:
+  ScexDleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
+                BufPair decodedBuf, FoundPacketHandler handler, void* args);
+};
+
+#endif /* LINUX_DEVICES_SCEXDLEPARSER_H_ */

linux/devices/ScexUartReader.cpp

@@ -6,6 +6,7 @@
 #include <fsfw/ipc/MutexGuard.h>
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <fsfw_hal/linux/uart/UartCookie.h>
+#include <linux/devices/ScexDleParser.h>
 #include <unistd.h>  // write(), read(), close()
 
 #include <cerrno>  // Error integer and strerror() function
@@ -14,7 +15,12 @@
 #include "OBSWConfig.h"
 
 ScexUartReader::ScexUartReader(object_id_t objectId)
-    : SystemObject(objectId), ringBuffer(200 * 2048, true), sizesQueue(200) {
+    : SystemObject(objectId),
+      decodeRingBuf(4096, true),
+      ipcRingBuf(200 * 2048, true),
+      ipcQueue(200),
+      dleParser(decodeRingBuf, dleEncoder, {encodedBuf.data(), encodedBuf.size()},
+                {decodedBuf.data(), decodedBuf.size()}, &foundDlePacketHandler, this) {
   semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
   semaphore->acquire();
   lock = MutexFactory::instance()->createMutex();
@@ -47,10 +53,10 @@ ReturnValue_t ScexUartReader::performOperation(uint8_t operationCode) {
         sif::error << "ScexUartReader::performOperation: Receive buffer too small" << std::endl;
       } else if (bytesRead > 0) {
         MutexGuard mg(lock);
-        sizesQueue.insert(bytesRead);
-        ReturnValue_t result = ringBuffer.writeData(recBuf.data(), bytesRead);
+        ipcQueue.insert(bytesRead);
+        ReturnValue_t result = dleParser.passData(recBuf.data(), bytesRead);
         if (result != HasReturnvaluesIF::RETURN_OK) {
-          sif::warning << "ScexUartReader::performOperation: Writing into ring buffer failed"
+          sif::warning << "ScexUartReader::performOperation: Passing data to DLE parser failed"
                        << std::endl;
         }
         if (debugMode) {
@@ -91,10 +97,9 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
   // Use non-canonical mode and clear echo flag
   tty.c_lflag &= ~(ICANON | ECHO);
 
-  // Non-blocking mode, read until either line is 0.1 second idle or maximum of 255 bytes are
-  // received in one go
-  tty.c_cc[VTIME] = 20;  // Read for up to 2 seconds
-  tty.c_cc[VMIN] = 0;    // Read as much as there is available
+  // Non-blocking mode, use polling
+  tty.c_cc[VTIME] = 0;  // Read for up to 2 seconds
+  tty.c_cc[VMIN] = 0;   // Read as much as there is available
 
   // Q7S UART Lite has fixed baud rate. For other linux systems, set baud rate here.
 #if !defined(XIPHOS_Q7S)
@@ -157,16 +162,26 @@ ReturnValue_t ScexUartReader::finish() {
   return RETURN_OK;
 }
 
+void ScexUartReader::foundDlePacketHandler(uint8_t *packet, size_t len, void *args) {
+  ScexUartReader *obj = reinterpret_cast<ScexUartReader *>(args);
+  obj->handleFoundDlePacket(packet, len);
+}
+
+void ScexUartReader::handleFoundDlePacket(uint8_t *packet, size_t len) {
+  // TODO: insert data into IPC ring buffer here
+  sif::info << "Detected DLE encoded packet with decoded size " << len << std::endl;
+}
+
 ReturnValue_t ScexUartReader::readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
                                                   size_t *size) {
   MutexGuard mg(lock);
-  if (sizesQueue.empty()) {
+  if (ipcQueue.empty()) {
     *size = 0;
     return RETURN_OK;
   }
-  *size = sizesQueue.pop();
+  *size = ipcQueue.pop();
   *buffer = ipcBuffer.data();
-  ReturnValue_t result = ringBuffer.readData(ipcBuffer.data(), *size, true);
+  ReturnValue_t result = ipcRingBuf.readData(ipcBuffer.data(), *size, true);
   if (result != RETURN_OK) {
     sif::warning << "ScexUartReader::readReceivedMessage: Reading RingBuffer failed" << std::endl;
   }

linux/devices/ScexUartReader.h

@@ -8,6 +8,7 @@
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/tasks/ExecutableObjectIF.h>
 #include <fsfw/timemanager/Countdown.h>
+#include <linux/devices/ScexDleParser.h>
 #include <termios.h>  // Contains POSIX terminal control definitions
 
 class SemaphoreIF;
@@ -34,13 +35,20 @@ class ScexUartReader : public SystemObject,  // strg+shift+n
   struct termios tty = {};
   bool doFinish = false;
   DleEncoder dleEncoder = DleEncoder();
-  SimpleRingBuffer ringBuffer;
-  DynamicFIFO<size_t> sizesQueue;
+  SimpleRingBuffer decodeRingBuf;
+
   Countdown finishCoutdown = Countdown(180 * 1000);
   std::array<uint8_t, 256> cmdbuf = {};
-  std::array<uint8_t, 4096> recBuf = {};
-
+  std::array<uint8_t, 524> recBuf = {};
+  std::array<uint8_t, 4096> encodedBuf = {};
+  std::array<uint8_t, 4096> decodedBuf = {};
   std::array<uint8_t, 4096> ipcBuffer = {};
+  SimpleRingBuffer ipcRingBuf;
+  DynamicFIFO<size_t> ipcQueue;
+  ScexDleParser dleParser;
+
+  static void foundDlePacketHandler(uint8_t *packet, size_t len, void *args);
+  void handleFoundDlePacket(uint8_t *packet, size_t len);
 
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;