improved DLE encoder

src/fsfw/globalfunctions/DleEncoder.cpp

@@ -1,6 +1,7 @@
 #include "fsfw/globalfunctions/DleEncoder.h"
 
-DleEncoder::DleEncoder() {}
+DleEncoder::DleEncoder(bool escapeStxEtx, bool escapeCr): escapeStxEtx(escapeStxEtx),
+        escapeCr(escapeCr) {}
 
 DleEncoder::~DleEncoder() {}
 
@@ -17,11 +18,12 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		++encodedIndex;
 	}
 
-	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
+	while (encodedIndex < maxDestLen and sourceIndex < sourceLen) {
-	{
 		nextByte = sourceStream[sourceIndex];
 		// STX, ETX and CR characters in the stream need to be escaped with DLE
-		if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
+		if ((nextByte == STX_CHAR or nextByte == ETX_CHAR) or
+		        (this->escapeCr and nextByte == CARRIAGE_RETURN)) {
+		    if(this->escapeStxEtx) {
 	            if (encodedIndex + 1 >= maxDestLen) {
 	                return STREAM_TOO_SHORT;
 	            }
@@ -38,6 +40,7 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 	                destStream[encodedIndex] = nextByte + 0x40;
 	            }
 		    }
+		}
 		// DLE characters are simply escaped with DLE.
 		else if (nextByte == DLE_CHAR) {
 			if (encodedIndex + 1 >= maxDestLen) {
@@ -90,17 +93,23 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 				destStream[decodedIndex] = nextByte;
 			}
 			else {
+			    if(this->escapeStxEtx) {
 	                /* The next byte is a STX, DTX or 0x0D character which
 	                 * was escaped by a DLE character. The actual byte was
 	                 * also encoded by adding + 0x40 to prevent having control chars,
 	                 * in the stream at all, so we convert it back. */
-				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
+	                if ((nextByte == STX_CHAR + 0x40 or nextByte == ETX_CHAR + 0x40) or
+	                        (this->escapeCr and nextByte == CARRIAGE_RETURN + 0x40)) {
 	                    destStream[decodedIndex] = nextByte - 0x40;
 	                }
 	                else {
 	                    return DECODING_ERROR;
 	                }
 			    }
+			    else {
+	                return DECODING_ERROR;
+			    }
+			}
 			++encodedIndex;
 		}
 		else {

src/fsfw/globalfunctions/DleEncoder.h

@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
 #define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
 /**
@@ -13,9 +13,9 @@
  *
  * This encoder can be used to achieve a basic transport layer when using
  * char based transmission systems.
- * The passed source strean is converted into a encoded stream by adding
+ * The passed source stream is converted into a encoded stream by adding
  * a STX marker at the start of the stream and an ETX marker at the end of
- * the stream. Any STX, ETX, DLE and CR occurrences in the source stream are
+ * the stream. Any STX, ETX, DLE and CR occurrences in the source stream can be
  * escaped by a DLE character. The encoder also replaces escaped control chars
  * by another char, so STX, ETX and CR should not appear anywhere in the actual
  * encoded data stream.
@@ -26,7 +26,7 @@
  */
 class DleEncoder: public HasReturnvaluesIF {
 private:
-	DleEncoder();
+    DleEncoder(bool escapeStxEtx = true, bool escapeCr = false);
     virtual ~DleEncoder();
 
 public:
@@ -45,19 +45,26 @@ public:
 
     /**
      * Encodes the give data stream by preceding it with the STX marker
-     * and ending it with an ETX marker. STX, ETX and DLE characters inside
+     * and ending it with an ETX marker. DLE characters inside
-     * the stream are escaped by DLE characters and also replaced by adding
+     * the stream are escaped by DLE characters. STX, ETX and CR characters can be escaped with a
-     * 0x40 (which is reverted in the decoding process).
+     * DLE character as well. The escaped characters are also encoded by adding
+     * 0x40 (which is reverted in the decoding process). This is performed so the source stream
+     * does not have STX/ETX/CR occurrences anymore, so the receiving side can simply parse for
+     * start and end markers
      * @param sourceStream
      * @param sourceLen
      * @param destStream
      * @param maxDestLen
      * @param encodedLen
-     * @param addStxEtx
+     * @param addStxEtx     Adding STX start marker and ETX end marker can be omitted,
-     * Adding STX and ETX can be omitted, if they are added manually.
+     *                      if they are added manually
+     * @param escapeStxEtx  STX and ETX occurrences in the given source stream will be escaped and
+     *                      encoded by adding 0x40
+     * @param escapeCr      CR characters in the given source stream will be escaped and encoded
+     *                      by adding 0x40
      * @return
      */
-    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
+    ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
             uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
             bool addStxEtx = true);
 
@@ -69,11 +76,20 @@ public:
      * @param destStream
      * @param maxDestStreamlen
      * @param decodedLen
+     * @param escapeStxEtx  STX and ETX characters were escaped in the encoded stream and need to
+     *                      be decoded back as well
+     * @param escapeCr      CR characters were escaped in the encoded stream and need to
+     *                      be decoded back as well by subtracting 0x40
      * @return
      */
-	static ReturnValue_t decode(const uint8_t *sourceStream,
+    ReturnValue_t decode(const uint8_t *sourceStream,
             size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
             size_t maxDestStreamlen, size_t *decodedLen);
+
+private:
+
+    bool escapeStxEtx;
+    bool escapeCr;
 };
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */