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,26 +18,28 @@ 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 (encodedIndex + 1 >= maxDestLen) {
-				return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE_CHAR;
-				++encodedIndex;
-				/* Escaped byte will be actual byte + 0x40. This prevents
-				 * STX, ETX, and carriage return characters from appearing
-				 * in the encoded data stream at all, so when polling an
-				 * encoded stream, the transmission can be stopped at ETX.
-				 * 0x40 was chosen at random with special requirements:
-				 *  - Prevent going from one control char to another
-				 *  - Prevent overflow for common characters */
-				destStream[encodedIndex] = nextByte + 0x40;
-			}
+		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;
+	            }
+	            else {
+	                destStream[encodedIndex] = DLE_CHAR;
+	                ++encodedIndex;
+	                /* Escaped byte will be actual byte + 0x40. This prevents
+	                 * STX, ETX, and carriage return characters from appearing
+	                 * in the encoded data stream at all, so when polling an
+	                 * encoded stream, the transmission can be stopped at ETX.
+	                 * 0x40 was chosen at random with special requirements:
+	                 *  - Prevent going from one control char to another
+	                 *  - Prevent overflow for common characters */
+	                destStream[encodedIndex] = nextByte + 0x40;
+	            }
+		    }
 		}
 		// DLE characters are simply escaped with DLE.
 		else if (nextByte == DLE_CHAR) {
@@ -90,16 +93,22 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 				destStream[decodedIndex] = nextByte;
 			}
 			else {
-			    /* 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) {
-					destStream[decodedIndex] = nextByte - 0x40;
-				}
-				else {
-				    return DECODING_ERROR;
-				}
+			    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 == 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;
 		}