try to do this in a simpler way

src/fsfw/globalfunctions/DleParser.cpp

@@ -3,6 +3,8 @@
 #include <fsfw/serviceinterface/ServiceInterface.h>
 
 #include <cstdio>
+#include <fstream>
+#include <iostream>
 
 DleParser::DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
                      BufPair decodedBuf, UserHandler handler, void* args)
@@ -21,143 +23,207 @@ DleParser::DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPa
   }
 }
 
-ReturnValue_t DleParser::passData(uint8_t* data, size_t len) {
+ReturnValue_t DleParser::passData(const uint8_t* data, size_t len) {
   if (data == nullptr or len == 0 or handler == nullptr) {
     return returnvalue::FAILED;
   }
-  size_t copyIntoRingBufFromHere = 0;
-  size_t copyAmount = len;
-  size_t startIdx = 0;
-  ReturnValue_t result = returnvalue::OK;
-  bool startFoundInThisPacket = false;
-  for (size_t idx = 0; idx < len; idx++) {
-    if (data[idx] == DleEncoder::STX_CHAR) {
-      if (not startFound and not startFoundInThisPacket) {
-        startIdx = idx;
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
+  return decodeRingBuf.writeData(data , len);
+//  std::string filename = std::string("/mnt/sd0/scex/transfer") + std::to_string(COUNTER++);
+//  std::ofstream of(filename);
+//  of.write(reinterpret_cast<const char*>(data), len);
+//  size_t copyIntoRingBufFromHere = 0;
+//  size_t copyAmount = len;
+//  size_t startIdx = 0;
+//  ReturnValue_t result = returnvalue::OK;
+//  bool startFoundInThisPacket = false;
+//  for (size_t idx = 0; idx < len; idx++) {
+//    if (data[idx] == DleEncoder::STX_CHAR) {
+//      if (not startFound and not startFoundInThisPacket) {
+//        startIdx = idx;
+//        copyIntoRingBufFromHere = idx;
+//        copyAmount = len - idx;
+//      } else {
+//        // Maybe print warning, should not happen
+//        decodeRingBuf.clear();
+//        ErrorInfo info;
+//        info.len = idx;
+//        prepareErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
+//        handler(ctx);
+//        copyIntoRingBufFromHere = idx;
+//        copyAmount = len - idx;
+//      }
+//      startFound = true;
+//      startFoundInThisPacket = true;
+//    } else if (data[idx] == DleEncoder::ETX_CHAR) {
+//      if (startFoundInThisPacket) {
+//        size_t readLen = 0;
+//        size_t decodedLen = 0;
+//        result = decoder.decode(data + startIdx, idx + 1 - startIdx, &readLen, decodedBuf.first,
+//                                decodedBuf.second, &decodedLen);
+//        if (result == returnvalue::OK) {
+//          ctx.setType(ContextType::PACKET_FOUND);
+//          ctx.decodedPacket.first = decodedBuf.first;
+//          ctx.decodedPacket.second = decodedLen;
+//          this->handler(ctx);
+//        } else if (result == DleEncoder::STREAM_TOO_SHORT) {
+//          ErrorInfo info;
+//          info.res = result;
+//          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
+//          handler(ctx);
+//        } else {
+//          ErrorInfo info;
+//          info.res = result;
+//          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
+//          handler(ctx);
+//        }
+//        decodeRingBuf.clear();
+//        if ((idx + 1) < len) {
+//          copyIntoRingBufFromHere = idx + 1;
+//          copyAmount = len - idx - 1;
+//        } else {
+//          copyAmount = 0;
+//        }
+//      } else if (startFound) {
+//        // ETX found but STX was found in another mini packet. Reconstruct the full packet
+//        // to decode it
+//        result = decodeRingBuf.writeData(data, idx + 1);
+//        if (result != returnvalue::OK) {
+//          ErrorInfo info;
+//          info.res = result;
+//          prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
+//          handler(ctx);
+//        }
+//        size_t fullEncodedLen = decodeRingBuf.getAvailableReadData();
+//        if (fullEncodedLen > encodedBuf.second) {
+//          ErrorInfo info;
+//          info.len = fullEncodedLen;
+//          prepareErrorContext(ErrorTypes::ENCODED_BUF_TOO_SMALL, info);
+//          handler(ctx);
+//          decodeRingBuf.clear();
+//        } else {
+//          size_t decodedLen = 0;
+//          size_t readLen = 0;
+//          decodeRingBuf.readData(encodedBuf.first, fullEncodedLen, true);
+//          result = decoder.decode(encodedBuf.first, fullEncodedLen, &readLen, decodedBuf.first,
+//                                  decodedBuf.second, &decodedLen);
+//          if (result == returnvalue::OK) {
+//            if (this->handler != nullptr) {
+//              ctx.setType(ContextType::PACKET_FOUND);
+//              ctx.decodedPacket.first = decodedBuf.first;
+//              ctx.decodedPacket.second = decodedLen;
+//              this->handler(ctx);
+//            }
+//          } else if (result == DleEncoder::STREAM_TOO_SHORT) {
+//            ErrorInfo info;
+//            info.res = result;
+//            prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
+//            handler(ctx);
+//          } else {
+//            ErrorInfo info;
+//            info.res = result;
+//            prepareErrorContext(ErrorTypes::DECODE_ERROR, info);
+//            handler(ctx);
+//          }
+//          decodeRingBuf.clear();
+//          startFound = false;
+//          startFoundInThisPacket = false;
+//          if ((idx + 1) < len) {
+//            copyIntoRingBufFromHere = idx + 1;
+//            copyAmount = len - idx - 1;
+//          } else {
+//            copyAmount = 0;
+//          }
+//        }
+//      } else {
+//        // End data without preceeding STX
+//        ErrorInfo info;
+//        info.len = idx + 1;
+//        prepareErrorContext(ErrorTypes::CONSECUTIVE_ETX_CHARS, info);
+//        handler(ctx);
+//        decodeRingBuf.clear();
+//        if ((idx + 1) < len) {
+//          copyIntoRingBufFromHere = idx + 1;
+//          copyAmount = len - idx - 1;
+//        } else {
+//          copyAmount = 0;
+//        }
+//      }
+//      startFoundInThisPacket = false;
+//      startFound = false;
+//    }
+//  }
+//  if (copyAmount > 0) {
+//    result = decodeRingBuf.writeData(data + copyIntoRingBufFromHere, copyAmount);
+//    if (result != returnvalue::OK) {
+//      ErrorInfo info;
+//      info.res = result;
+//      prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
+//      handler(ctx);
+//    }
+//  }
+}
+
+
+ReturnValue_t DleParser::parseRingBuf(size_t& readSize) {
+  size_t availableData = decodeRingBuf.getAvailableReadData();
+  if (availableData > encodedBuf.second) {
+    ErrorInfo info;
+    info.len = decodeRingBuf.getAvailableReadData();
+     prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
+     handler(ctx);
+  }
+  ReturnValue_t result = decodeRingBuf.readData(encodedBuf.first, availableData);
+  if(result != returnvalue::OK) {
+    ErrorInfo info;
+    info.res = result;
+    prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
+  }
+  bool stxFound = false;
+  size_t stxIdx = 0;
+  for (size_t vectorIdx = 0; vectorIdx < availableData; vectorIdx++) {
+    // handle STX char
+    if (encodedBuf.first[vectorIdx] == DleEncoder::STX_CHAR) {
+      if (not stxFound) {
+        stxFound = true;
+        stxIdx = vectorIdx;
       } else {
-        // Maybe print warning, should not happen
-        decodeRingBuf.clear();
-        ErrorInfo info;
-        info.len = idx;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
-        handler(ctx);
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
+        // might be lost packet, so we should advance the read pointer
+        // without skipping the STX
+        readSize = vectorIdx;
+        return POSSIBLE_PACKET_LOSS;
       }
-      startFound = true;
-      startFoundInThisPacket = true;
-    } else if (data[idx] == DleEncoder::ETX_CHAR) {
-      if (startFoundInThisPacket) {
-        size_t readLen = 0;
+    }
+    // handle ETX char
+    if (encodedBuf.first[vectorIdx] == DleEncoder::ETX_CHAR) {
+      if (stxFound) {
+        // This is propably a packet, so we decode it.
         size_t decodedLen = 0;
-        result = decoder.decode(data + startIdx, idx + 1 - startIdx, &readLen, decodedBuf.first,
-                                decodedBuf.second, &decodedLen);
+        size_t dummy = 0;
+        readSize = vectorIdx;
+        ReturnValue_t result = decoder.decode(&encodedBuf.first[stxIdx], availableData - stxIdx,
+                                                  &dummy, decodedBuf.first, decodedBuf.second, &decodedLen);
         if (result == returnvalue::OK) {
           ctx.setType(ContextType::PACKET_FOUND);
           ctx.decodedPacket.first = decodedBuf.first;
           ctx.decodedPacket.second = decodedLen;
           this->handler(ctx);
-        } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
+          return returnvalue::OK;
         } else {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        }
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
-      } else if (startFound) {
-        // ETX found but STX was found in another mini packet. Reconstruct the full packet
-        // to decode it
-        result = decodeRingBuf.writeData(data, idx + 1);
-        if (result != returnvalue::OK) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-          handler(ctx);
-        }
-        size_t fullEncodedLen = decodeRingBuf.getAvailableReadData();
-        if (fullEncodedLen > encodedBuf.second) {
-          ErrorInfo info;
-          info.len = fullEncodedLen;
-          prepareErrorContext(ErrorTypes::ENCODED_BUF_TOO_SMALL, info);
-          handler(ctx);
-          decodeRingBuf.clear();
-        } else {
-          size_t decodedLen = 0;
-          size_t readLen = 0;
-          decodeRingBuf.readData(encodedBuf.first, fullEncodedLen, true);
-          result = decoder.decode(encodedBuf.first, fullEncodedLen, &readLen, decodedBuf.first,
-                                  decodedBuf.second, &decodedLen);
-          if (result == returnvalue::OK) {
-            if (this->handler != nullptr) {
-              ctx.setType(ContextType::PACKET_FOUND);
-              ctx.decodedPacket.first = decodedBuf.first;
-              ctx.decodedPacket.second = decodedLen;
-              this->handler(ctx);
-            }
-          } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-            handler(ctx);
-          } else {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODE_ERROR, info);
-            handler(ctx);
-          }
-          decodeRingBuf.clear();
-          startFound = false;
-          startFoundInThisPacket = false;
-          if ((idx + 1) < len) {
-            copyIntoRingBufFromHere = idx + 1;
-            copyAmount = len - idx - 1;
-          } else {
-            copyAmount = 0;
-          }
+          // invalid packet, skip.
+          readSize = ++vectorIdx;
+          return POSSIBLE_PACKET_LOSS;
         }
       } else {
-        // End data without preceeding STX
-        ErrorInfo info;
-        info.len = idx + 1;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_ETX_CHARS, info);
-        handler(ctx);
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
+        // might be lost packet, so we should advance the read pointer
+        readSize = ++vectorIdx;
+        return POSSIBLE_PACKET_LOSS;
       }
-      startFoundInThisPacket = false;
-      startFound = false;
-    }
-  }
-  if (copyAmount > 0) {
-    result = decodeRingBuf.writeData(data + copyIntoRingBufFromHere, copyAmount);
-    if (result != returnvalue::OK) {
-      ErrorInfo info;
-      info.res = result;
-      prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-      handler(ctx);
     }
   }
   return returnvalue::OK;
 }
 
+
 void DleParser::defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -224,6 +290,10 @@ void DleParser::prepareErrorContext(ErrorTypes err, ErrorInfo info) {
   ctx.error.second = info;
 }
 
+ReturnValue_t DleParser::confirmBytesRead(size_t bytesRead) {
+  return decodeRingBuf.deleteData(bytesRead);
+}
+
 void DleParser::reset() {
   startFound = false;
   decodeRingBuf.clear();

src/fsfw/globalfunctions/DleParser.h

@@ -18,6 +18,8 @@
  */
 class DleParser {
  public:
+  static constexpr ReturnValue_t NO_PACKET_FOUND = returnvalue::makeCode(1, 1);
+  static constexpr ReturnValue_t POSSIBLE_PACKET_LOSS = returnvalue::makeCode(1, 2);
   using BufPair = std::pair<uint8_t*, size_t>;
 
   enum class ContextType { PACKET_FOUND, ERROR };
@@ -88,7 +90,11 @@ class DleParser {
    * @param len
    * @return
    */
-  ReturnValue_t passData(uint8_t* data, size_t len);
+  ReturnValue_t passData(const uint8_t* data, size_t len);
+
+  ReturnValue_t parseRingBuf(size_t& bytesRead);
+
+  ReturnValue_t confirmBytesRead(size_t bytesRead);
 
   /**
    * Example found packet handler

src/fsfw_hal/linux/uart/CMakeLists.txt

@@ -1 +1 @@
-target_sources(${LIB_FSFW_NAME} PUBLIC UartComIF.cpp UartCookie.cpp helper.cpp)
+target_sources(${LIB_FSFW_NAME} PUBLIC UartComIF.cpp UartCookie.cpp)

src/fsfw_hal/linux/uart/UartComIF.cpp

@@ -1,4 +1,5 @@
 #include "UartComIF.h"
+
 #include <errno.h>
 #include <fcntl.h>
 #include <termios.h>
@@ -92,7 +93,7 @@ int UartComIF::configureUartPort(UartCookie* uartCookie) {
   setStopBitOptions(&options, uartCookie);
   setDatasizeOptions(&options, uartCookie);
   setFixedOptions(&options);
-  uart::setMode(options, uartCookie->getUartMode());
+  setUartMode(&options, *uartCookie);
   if (uartCookie->getInputShouldBeFlushed()) {
     tcflush(fd, TCIFLUSH);
   }
@@ -101,7 +102,7 @@ int UartComIF::configureUartPort(UartCookie* uartCookie) {
   options.c_cc[VTIME] = 0;
   options.c_cc[VMIN] = 0;
 
-  uart::setBaudrate(options, uartCookie->getBaudrate());
+  configureBaudrate(&options, uartCookie);
 
   /* Save option settings */
   if (tcsetattr(fd, TCSANOW, &options) != 0) {
@@ -190,6 +191,138 @@ void UartComIF::setFixedOptions(struct termios* options) {
   options->c_oflag &= ~ONLCR;
 }
 
+void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCookie) {
+  switch (uartCookie->getBaudrate()) {
+    case UartBaudRate::RATE_50:
+      cfsetispeed(options, B50);
+      cfsetospeed(options, B50);
+      break;
+    case UartBaudRate::RATE_75:
+      cfsetispeed(options, B75);
+      cfsetospeed(options, B75);
+      break;
+    case UartBaudRate::RATE_110:
+      cfsetispeed(options, B110);
+      cfsetospeed(options, B110);
+      break;
+    case UartBaudRate::RATE_134:
+      cfsetispeed(options, B134);
+      cfsetospeed(options, B134);
+      break;
+    case UartBaudRate::RATE_150:
+      cfsetispeed(options, B150);
+      cfsetospeed(options, B150);
+      break;
+    case UartBaudRate::RATE_200:
+      cfsetispeed(options, B200);
+      cfsetospeed(options, B200);
+      break;
+    case UartBaudRate::RATE_300:
+      cfsetispeed(options, B300);
+      cfsetospeed(options, B300);
+      break;
+    case UartBaudRate::RATE_600:
+      cfsetispeed(options, B600);
+      cfsetospeed(options, B600);
+      break;
+    case UartBaudRate::RATE_1200:
+      cfsetispeed(options, B1200);
+      cfsetospeed(options, B1200);
+      break;
+    case UartBaudRate::RATE_1800:
+      cfsetispeed(options, B1800);
+      cfsetospeed(options, B1800);
+      break;
+    case UartBaudRate::RATE_2400:
+      cfsetispeed(options, B2400);
+      cfsetospeed(options, B2400);
+      break;
+    case UartBaudRate::RATE_4800:
+      cfsetispeed(options, B4800);
+      cfsetospeed(options, B4800);
+      break;
+    case UartBaudRate::RATE_9600:
+      cfsetispeed(options, B9600);
+      cfsetospeed(options, B9600);
+      break;
+    case UartBaudRate::RATE_19200:
+      cfsetispeed(options, B19200);
+      cfsetospeed(options, B19200);
+      break;
+    case UartBaudRate::RATE_38400:
+      cfsetispeed(options, B38400);
+      cfsetospeed(options, B38400);
+      break;
+    case UartBaudRate::RATE_57600:
+      cfsetispeed(options, B57600);
+      cfsetospeed(options, B57600);
+      break;
+    case UartBaudRate::RATE_115200:
+      cfsetispeed(options, B115200);
+      cfsetospeed(options, B115200);
+      break;
+    case UartBaudRate::RATE_230400:
+      cfsetispeed(options, B230400);
+      cfsetospeed(options, B230400);
+      break;
+#ifndef __APPLE__
+    case UartBaudRate::RATE_460800:
+      cfsetispeed(options, B460800);
+      cfsetospeed(options, B460800);
+      break;
+    case UartBaudRate::RATE_500000:
+      cfsetispeed(options, B500000);
+      cfsetospeed(options, B500000);
+      break;
+    case UartBaudRate::RATE_576000:
+      cfsetispeed(options, B576000);
+      cfsetospeed(options, B576000);
+      break;
+    case UartBaudRate::RATE_921600:
+      cfsetispeed(options, B921600);
+      cfsetospeed(options, B921600);
+      break;
+    case UartBaudRate::RATE_1000000:
+      cfsetispeed(options, B1000000);
+      cfsetospeed(options, B1000000);
+      break;
+    case UartBaudRate::RATE_1152000:
+      cfsetispeed(options, B1152000);
+      cfsetospeed(options, B1152000);
+      break;
+    case UartBaudRate::RATE_1500000:
+      cfsetispeed(options, B1500000);
+      cfsetospeed(options, B1500000);
+      break;
+    case UartBaudRate::RATE_2000000:
+      cfsetispeed(options, B2000000);
+      cfsetospeed(options, B2000000);
+      break;
+    case UartBaudRate::RATE_2500000:
+      cfsetispeed(options, B2500000);
+      cfsetospeed(options, B2500000);
+      break;
+    case UartBaudRate::RATE_3000000:
+      cfsetispeed(options, B3000000);
+      cfsetospeed(options, B3000000);
+      break;
+    case UartBaudRate::RATE_3500000:
+      cfsetispeed(options, B3500000);
+      cfsetospeed(options, B3500000);
+      break;
+    case UartBaudRate::RATE_4000000:
+      cfsetispeed(options, B4000000);
+      cfsetospeed(options, B4000000);
+      break;
+#endif  // ! __APPLE__
+    default:
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
+#endif
+      break;
+  }
+}
+
 ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
   int fd = 0;
   std::string deviceFile;
@@ -459,4 +592,12 @@ ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF* cookie) {
   return returnvalue::FAILED;
 }
 
-
+void UartComIF::setUartMode(struct termios* options, UartCookie& uartCookie) {
+  UartModes uartMode = uartCookie.getUartMode();
+  if (uartMode == UartModes::NON_CANONICAL) {
+    /* Disable canonical mode */
+    options->c_lflag &= ~ICANON;
+  } else if (uartMode == UartModes::CANONICAL) {
+    options->c_lflag |= ICANON;
+  }
+}

src/fsfw_hal/linux/uart/UartComIF.h

@@ -1,15 +1,13 @@
 #ifndef BSP_Q7S_COMIF_UARTCOMIF_H_
 #define BSP_Q7S_COMIF_UARTCOMIF_H_
 
-#include "UartCookie.h"
-#include "helper.h"
-
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
 
 #include <unordered_map>
 #include <vector>
 
+#include "UartCookie.h"
 
 /**
  * @brief 	This is the communication interface to access serial ports on linux based operating
@@ -103,6 +101,14 @@ class UartComIF : public DeviceCommunicationIF, public SystemObject {
    */
   void setDatasizeOptions(struct termios* options, UartCookie* uartCookie);
 
+  /**
+   * @brief   This functions adds the  baudrate specified in the uartCookie to the termios options
+   *          struct.
+   */
+  void configureBaudrate(struct termios* options, UartCookie* uartCookie);
+
+  void setUartMode(struct termios* options, UartCookie& uartCookie);
+
   ReturnValue_t handleCanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
                                     size_t requestLen);
   ReturnValue_t handleNoncanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,

src/fsfw_hal/linux/uart/UartCookie.h

@@ -1,14 +1,51 @@
 #ifndef SAM9G20_COMIF_COOKIES_UART_COOKIE_H_
 #define SAM9G20_COMIF_COOKIES_UART_COOKIE_H_
 
-#include "helper.h"
-
 #include <fsfw/devicehandlers/CookieIF.h>
 #include <fsfw/objectmanager/SystemObjectIF.h>
 
 #include <string>
 
+enum class Parity { NONE, EVEN, ODD };
 
+enum class StopBits { ONE_STOP_BIT, TWO_STOP_BITS };
+
+enum class UartModes { CANONICAL, NON_CANONICAL };
+
+enum class BitsPerWord { BITS_5, BITS_6, BITS_7, BITS_8 };
+
+enum class UartBaudRate {
+  RATE_50,
+  RATE_75,
+  RATE_110,
+  RATE_134,
+  RATE_150,
+  RATE_200,
+  RATE_300,
+  RATE_600,
+  RATE_1200,
+  RATE_1800,
+  RATE_2400,
+  RATE_4800,
+  RATE_9600,
+  RATE_19200,
+  RATE_38400,
+  RATE_57600,
+  RATE_115200,
+  RATE_230400,
+  RATE_460800,
+  RATE_500000,
+  RATE_576000,
+  RATE_921600,
+  RATE_1000000,
+  RATE_1152000,
+  RATE_1500000,
+  RATE_2000000,
+  RATE_2500000,
+  RATE_3000000,
+  RATE_3500000,
+  RATE_4000000
+};
 
 /**
  * @brief   Cookie for the UartComIF. There are many options available to configure the UART driver.

src/fsfw_hal/linux/uart/helper.cpp

@@ -1,150 +0,0 @@
-#include "helper.h"
-#include "fsfw/serviceinterface.h"
-
-#include <sys/ioctl.h>
-
-void uart::setMode(struct termios& options, UartModes mode) {
-  if (mode == UartModes::NON_CANONICAL) {
-    /* Disable canonical mode */
-    options.c_lflag &= ~ICANON;
-  } else if (mode == UartModes::CANONICAL) {
-    options.c_lflag |= ICANON;
-  }
-}
-
-void uart::setBaudrate(struct termios& options, UartBaudRate baud) {
-  switch (baud) {
-    case UartBaudRate::RATE_50:
-      cfsetispeed(&options, B50);
-      cfsetospeed(&options, B50);
-      break;
-    case UartBaudRate::RATE_75:
-      cfsetispeed(&options, B75);
-      cfsetospeed(&options, B75);
-      break;
-    case UartBaudRate::RATE_110:
-      cfsetispeed(&options, B110);
-      cfsetospeed(&options, B110);
-      break;
-    case UartBaudRate::RATE_134:
-      cfsetispeed(&options, B134);
-      cfsetospeed(&options, B134);
-      break;
-    case UartBaudRate::RATE_150:
-      cfsetispeed(&options, B150);
-      cfsetospeed(&options, B150);
-      break;
-    case UartBaudRate::RATE_200:
-      cfsetispeed(&options, B200);
-      cfsetospeed(&options, B200);
-      break;
-    case UartBaudRate::RATE_300:
-      cfsetispeed(&options, B300);
-      cfsetospeed(&options, B300);
-      break;
-    case UartBaudRate::RATE_600:
-      cfsetispeed(&options, B600);
-      cfsetospeed(&options, B600);
-      break;
-    case UartBaudRate::RATE_1200:
-      cfsetispeed(&options, B1200);
-      cfsetospeed(&options, B1200);
-      break;
-    case UartBaudRate::RATE_1800:
-      cfsetispeed(&options, B1800);
-      cfsetospeed(&options, B1800);
-      break;
-    case UartBaudRate::RATE_2400:
-      cfsetispeed(&options, B2400);
-      cfsetospeed(&options, B2400);
-      break;
-    case UartBaudRate::RATE_4800:
-      cfsetispeed(&options, B4800);
-      cfsetospeed(&options, B4800);
-      break;
-    case UartBaudRate::RATE_9600:
-      cfsetispeed(&options, B9600);
-      cfsetospeed(&options, B9600);
-      break;
-    case UartBaudRate::RATE_19200:
-      cfsetispeed(&options, B19200);
-      cfsetospeed(&options, B19200);
-      break;
-    case UartBaudRate::RATE_38400:
-      cfsetispeed(&options, B38400);
-      cfsetospeed(&options, B38400);
-      break;
-    case UartBaudRate::RATE_57600:
-      cfsetispeed(&options, B57600);
-      cfsetospeed(&options, B57600);
-      break;
-    case UartBaudRate::RATE_115200:
-      cfsetispeed(&options, B115200);
-      cfsetospeed(&options, B115200);
-      break;
-    case UartBaudRate::RATE_230400:
-      cfsetispeed(&options, B230400);
-      cfsetospeed(&options, B230400);
-      break;
-#ifndef __APPLE__
-    case UartBaudRate::RATE_460800:
-      cfsetispeed(&options, B460800);
-      cfsetospeed(&options, B460800);
-      break;
-    case UartBaudRate::RATE_500000:
-      cfsetispeed(&options, B500000);
-      cfsetospeed(&options, B500000);
-      break;
-    case UartBaudRate::RATE_576000:
-      cfsetispeed(&options, B576000);
-      cfsetospeed(&options, B576000);
-      break;
-    case UartBaudRate::RATE_921600:
-      cfsetispeed(&options, B921600);
-      cfsetospeed(&options, B921600);
-      break;
-    case UartBaudRate::RATE_1000000:
-      cfsetispeed(&options, B1000000);
-      cfsetospeed(&options, B1000000);
-      break;
-    case UartBaudRate::RATE_1152000:
-      cfsetispeed(&options, B1152000);
-      cfsetospeed(&options, B1152000);
-      break;
-    case UartBaudRate::RATE_1500000:
-      cfsetispeed(&options, B1500000);
-      cfsetospeed(&options, B1500000);
-      break;
-    case UartBaudRate::RATE_2000000:
-      cfsetispeed(&options, B2000000);
-      cfsetospeed(&options, B2000000);
-      break;
-    case UartBaudRate::RATE_2500000:
-      cfsetispeed(&options, B2500000);
-      cfsetospeed(&options, B2500000);
-      break;
-    case UartBaudRate::RATE_3000000:
-      cfsetispeed(&options, B3000000);
-      cfsetospeed(&options, B3000000);
-      break;
-    case UartBaudRate::RATE_3500000:
-      cfsetispeed(&options, B3500000);
-      cfsetospeed(&options, B3500000);
-      break;
-    case UartBaudRate::RATE_4000000:
-      cfsetispeed(&options, B4000000);
-      cfsetospeed(&options, B4000000);
-      break;
-#endif  // ! __APPLE__
-    default:
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
-#endif
-      break;
-  }
-}
-
-int uart::readCountersAndErrors(int serialPort, serial_icounter_struct& icounter) {
-   return ioctl(serialPort, TIOCGICOUNT, &icounter);
-}
-

src/fsfw_hal/linux/uart/helper.h

@@ -1,62 +0,0 @@
-#ifndef FSFW_HAL_LINUX_UART_HELPER_H_
-#define FSFW_HAL_LINUX_UART_HELPER_H_
-
-#include <termios.h>
-#include <linux/serial.h>
-
-enum class Parity { NONE, EVEN, ODD };
-
-enum class StopBits { ONE_STOP_BIT, TWO_STOP_BITS };
-
-enum class UartModes { CANONICAL, NON_CANONICAL };
-
-enum class BitsPerWord { BITS_5, BITS_6, BITS_7, BITS_8 };
-
-enum class UartBaudRate {
-  RATE_50,
-  RATE_75,
-  RATE_110,
-  RATE_134,
-  RATE_150,
-  RATE_200,
-  RATE_300,
-  RATE_600,
-  RATE_1200,
-  RATE_1800,
-  RATE_2400,
-  RATE_4800,
-  RATE_9600,
-  RATE_19200,
-  RATE_38400,
-  RATE_57600,
-  RATE_115200,
-  RATE_230400,
-  RATE_460800,
-  RATE_500000,
-  RATE_576000,
-  RATE_921600,
-  RATE_1000000,
-  RATE_1152000,
-  RATE_1500000,
-  RATE_2000000,
-  RATE_2500000,
-  RATE_3000000,
-  RATE_3500000,
-  RATE_4000000
-};
-
-namespace uart {
-
-void setMode(struct termios& options, UartModes mode);
-/**
- * @brief   This functions adds the  baudrate specified in the uartCookie to the termios options
- *          struct.
- */
-void setBaudrate(struct termios& options, UartBaudRate baud);
-
-int readCountersAndErrors(int serialPort, serial_icounter_struct& icounter);
-
-}
-
-
-#endif /* FSFW_HAL_LINUX_UART_HELPER_H_ */