Add message framing (start, end, escape bytes) to UART

Same functionality as previous commit. But way more stable and clean.
Previous proof of concept approach had issues with random partial or
too large messages due to time based method
Rework send and receive functions to work more stable
- send: encode data with frame (start, end byte)
- receive: read each byte one after the other, assemble message,
  handle actual data in handle function
- add semaphore to write operation to prevent parallel write of
  different data when called from other tasks

board_control/main/main.cpp

@@ -142,7 +142,7 @@ void setLoglevels(void){
 	esp_log_level_set("wifi", ESP_LOG_INFO);
 	esp_log_level_set("http", ESP_LOG_INFO);
 	esp_log_level_set("automatedArmchair", ESP_LOG_DEBUG);
-		esp_log_level_set("uart_common", ESP_LOG_INFO);
+	esp_log_level_set("uart-common", ESP_LOG_INFO);
 	esp_log_level_set("uart", ESP_LOG_INFO);
 
 	//

board_control/main/uart.cpp

@@ -14,25 +14,17 @@ extern "C"
 #include "freertos/queue.h"
 #include "driver/uart.h"
 }
-
 #include "uart.hpp"
 
 static const char * TAG = "uart";
 
 
-//TESTING
-#include "control.hpp"
-#include "config.hpp"
 
 //==============================
 //====== task_uartReceive ======
 //==============================
 //TODO copy receive task from board_motorctl/uart.cpp
 void task_uartReceive(void *arg){
-	//--- testing force http mode after startup ---
-	//TESTING
-	vTaskDelay(5000 / portTICK_PERIOD_MS);
-	control.changeMode(controlMode_t::HTTP);
 	while (1) {
 		vTaskDelay(200 / portTICK_PERIOD_MS);
 	}
@@ -43,13 +35,15 @@ void task_uartReceive(void *arg){
 //=============================
 //======= task_uartSend =======
 //=============================
-//repeatedly send structs to uart
+//repeatedly send structs via uart
+//note: uart_sendStruct() from uart_common.hpp can be used anywhere
 void task_uartSend(void *arg){
 	static const char * TAG = "uart-send";
 	uartData_test_t data = {123, 0, 1.1};
-	ESP_LOGW(TAG, "startloop...");
+	ESP_LOGW(TAG, "send task started");
+	//repeatedly send data for testing uart
 	while (1) {
-		vTaskDelay(10000 / portTICK_PERIOD_MS);    
+		vTaskDelay(5000 / portTICK_PERIOD_MS);    
 		uart_sendStruct<uartData_test_t>(data);
 
 		//change data values

board_control/main/uart.hpp

@@ -1,8 +1,8 @@
 #pragma once
-
 #include "uart_common.hpp"
 
-void uart_task_testing(void *arg);
+//===== uart board CONTROL =====
+//
 void task_uartReceive(void *arg);
 void task_uartSend(void *arg);
 

board_motorctl/main/main.cpp

@@ -26,7 +26,7 @@ extern "C"
 //=========================
 //only run uart test code at the end
 //disables other functionality
-#define UART_TEST_ONLY
+//#define UART_TEST_ONLY
 
 
 //tag for logging
@@ -35,7 +35,6 @@ static const char * TAG = "main";
 
 
 #ifndef UART_TEST_ONLY
-#include "control.hpp" 
 //====================================
 //========== motorctl task ===========
 //====================================

board_motorctl/main/uart.cpp

@@ -1,49 +1,58 @@
 #include "uart.hpp"
 #include "config.hpp"
 #include "types.hpp"
+#include "uart_common.hpp"
 //===== uart board MOTORCTL =====
 
 static const char * TAG = "uart";
 
 
+
+//handle received payload from uart
+void handleMessage(uint8_t *receivedData, int len) {
+	ESP_LOGI(TAG, "complete message received len=%d", len);
+	//local variables
+	uartData_test_t dataTest;
+	motorCommands_t dataMotorCommands;
+	//assign data to struct
+	switch (len){
+		case sizeof(uartData_test_t):
+			dataTest = serialData2Struct<uartData_test_t>(receivedData);
+			ESP_LOGW(TAG, "received uartDataStruct len=%d DATA: timestamp=%d, id=%d, value=%.1f", len, dataTest.timestamp, dataTest.id, dataTest.value);
+			break;
+
+		case sizeof(motorCommands_t):
+			dataMotorCommands = serialData2Struct<motorCommands_t>(receivedData);
+			ESP_LOGI(TAG, "received motorCommands struct len=%d left=%.2f%% right=%.2f%%, update target...", len, dataMotorCommands.left.duty, dataMotorCommands.right.duty);
+			//update target motor state and duty
+			motorLeft.setTarget(dataMotorCommands.left.state, 
+					dataMotorCommands.left.duty);
+			motorRight.setTarget(dataMotorCommands.right.state, 
+					dataMotorCommands.right.duty);
+			break;
+
+			//TODO add other received structs here
+		default:
+			ESP_LOGE(TAG, "received data len=%d cant be associated with configures struct", len);
+			break;
+	}
+}
+
+
+
 //==============================
 //====== task_uartReceive ======
 //==============================
+//TODO duplicate code, same task in both boards, only handleMessage function has to be passed -> move to uart_common
 void task_uartReceive(void *arg){
 	ESP_LOGW(TAG, "receive task started");
-	//receive data from uart, detect associated struct and copy/handle the data
+	while (1) {
-	//TODO use queue instead of check interval?
+		uint8_t byte;
-	uartData_test_t dataTest;
+		//read 1 byte TODO: use uart queue here? data might get lost when below function takes longer than data arrives
-	motorCommands_t dataMotorCommands;
+		int len = uart_read_bytes(UART_NUM_1, &byte, 1, portMAX_DELAY);
-	uint8_t receivedData[1024-1];
+		if (len > 0) {
-	while(1){
+			//process received byte
-		//note: check has to be more frequent than pause time between sending
+			uart_processReceivedByte(byte, handleMessage);
-		vTaskDelay(50 / portTICK_PERIOD_MS);
-		//read bytes (max 1023) until 20ms pause is happening
-		int len = uart_read_bytes(UART_NUM_1, receivedData, sizeof(receivedData), 20 / portTICK_PERIOD_MS);
-		uart_flush_input(UART_NUM_1);
-		if (len < 1) continue;
-		switch (len){
-
-			case sizeof(uartData_test_t):
-				dataTest = serialData2Struct<uartData_test_t>(receivedData);
-				ESP_LOGW(TAG, "received uartDataStruct len=%d DATA: timestamp=%d, id=%d, value=%.1f", len, dataTest.timestamp, dataTest.id, dataTest.value);
-				break;
-
-			case sizeof(motorCommands_t):
-				dataMotorCommands = serialData2Struct<motorCommands_t>(receivedData);
-				ESP_LOGI(TAG, "received motorCommands struct len=%d left=%.2f%% right=%.2f%%, update target...", len, dataMotorCommands.left.duty, dataMotorCommands.right.duty);
-				//update target motor state and duty
-				motorLeft.setTarget(dataMotorCommands.left.state, 
-						dataMotorCommands.left.duty);
-				motorRight.setTarget(dataMotorCommands.right.state, 
-						dataMotorCommands.right.duty);
-				break;
-
-				//TODO add other received structs here
-			default:
-				ESP_LOGE(TAG, "received data len=%d cant be associated with configures struct", len);
-				break;
 		}
 	}
 }

board_motorctl/main/uart.hpp

@@ -1,7 +1,6 @@
 #pragma once
 #include "uart_common.hpp"
 
-
 //===== uart board MOTORCTL =====
 
 void task_uartReceive(void *arg);

common/uart_common.cpp

@@ -1,6 +1,9 @@
 #include "uart_common.hpp"
 
 static const char * TAG = "uart-common";
+SemaphoreHandle_t uart_semaphoreSend = NULL;
+bool uart_isInitialized = false;
+
 
 
 //===========================
@@ -9,6 +12,8 @@ static const char * TAG = "uart-common";
 //initial struct on given pins
 //TODO add pins and baud rate to config?
 void uart_init(void){
+	ESP_LOGW(TAG, "initializing uart1...");
+	uart_semaphoreSend = xSemaphoreCreateBinary();
 	uart_config_t uart1_config = {
 		.baud_rate = 115198,
 		.data_bits = UART_DATA_8_BITS,
@@ -22,8 +27,91 @@ void uart_init(void){
 	ESP_ERROR_CHECK(uart_set_pin(UART_NUM_1, 23, 22, 0, 0));
 	ESP_LOGI(TAG, "init...");
 	ESP_ERROR_CHECK(uart_driver_install(UART_NUM_1, 1024, 1024, 10, NULL, 0));
+	uart_isInitialized = true;
+	xSemaphoreGive(uart_semaphoreSend);
 }
 
 
+
+//===========================
+//===== uart_sendBinary  ====
+//===========================
+//encode byte array to message (start, stop, escape pattern)
+//and send it via uart
+//note: use sendStruct template in uart_common.hpp
+void uart_sendBinary(uint8_t *data, int length) {
+	const uint8_t startPattern = START_PATTERN;
+	const uint8_t endPattern = END_PATTERN;
+	const uint8_t escapeByte = ESCAPE_BYTE;
+	ESP_LOGI(TAG, "encoding and sending bytes len=%d", length);
+	//wait for last message to finish sending
+	if (xSemaphoreTake(uart_semaphoreSend, UART_WRITE_WAIT_TIMEOUT / portTICK_PERIOD_MS) == pdTRUE){
+		//send start byte
+		uart_write_bytes(UART_NUM_1, &startPattern, 1);
+
+		for (int i = 0; i < length; i++) {
+			if (data[i] == START_PATTERN || data[i] == END_PATTERN || data[i] == ESCAPE_BYTE) {
+				//add escape byte if next byte is special pattern by accident
+				uart_write_bytes(UART_NUM_1, &escapeByte, 1);
+			}
+			uart_write_bytes(UART_NUM_1, (const char *)&data[i], 1);
+		}
+		//send end byte
+		uart_write_bytes(UART_NUM_1, &endPattern, 1);
+		vTaskDelay(UART_WRITE_MIN_DELAY / portTICK_PERIOD_MS);
+		xSemaphoreGive(uart_semaphoreSend);
+	} else ESP_LOGE(TAG, "timeout waiting for uart write semaphore! dropping data");
+}
+
+
+
+
+//================================
+//=== uart_processReceivedByte ===
+//================================
+//decode received message to byte array (start, stop, escape pattern)
+//has to be run for each receibed byte
+//runs provided messageHandler function when complete message received
+uint8_t receivedData[MAX_MESSAGE_LENGTH];
+int dataIndex = 0;
+bool insideMessage = false;
+bool escaped = false;
+
+void uart_processReceivedByte(uint8_t data, messageHandleFunc_t messageHandler){
+	ESP_LOGD(TAG, "process byte %x", data);
+	if (escaped) {
+		//this byte is actual data, no end/start byte
+		escaped = false;
+		receivedData[dataIndex++] = data;
+		if (dataIndex >= MAX_MESSAGE_LENGTH) {
+			insideMessage = false;
+			dataIndex = 0;
+		}
+	} else if (data == START_PATTERN) {
+		//start of message
+		insideMessage = true;
+		dataIndex = 0;
+	} else if (insideMessage) {
+		if (data == ESCAPE_BYTE) {
+			ESP_LOGI(TAG, "escape byte received");
+			//escape next byte
+			escaped = true;
+		} else if (data == END_PATTERN) {
+			//end of message
+			insideMessage = false;
+			//call provided function that handles actual messages
+			messageHandler(receivedData, dataIndex);
+			dataIndex = 0;
+		} else if (dataIndex < MAX_MESSAGE_LENGTH - 2) {
+			//normal byte - append byte to data
+			receivedData[dataIndex++] = data;
+		} else {
+			//message too long / buffer exceeded
+			insideMessage = false;
+			dataIndex = 0;
+			ESP_LOGE(TAG, "received message too long! dropped");
+		}
+	} else ESP_LOGE(TAG, "start pattern missing! ignoreing byte");
+}
 	
 

common/uart_common.hpp

@@ -11,12 +11,31 @@ extern "C"
 #include "esp_log.h"
 #include "sdkconfig.h"
 #include <string.h>
+#include "freertos/semphr.h"
 
 #include "freertos/queue.h"
 #include "driver/uart.h"
 }
 #include "types.hpp"
 
+//idea with time gap dropped, replaced with encoding
+//#define UART_RECEIVE_DURATION 10 
+//receive interval may not miss messages but also may not read multiple messages
+//has to be significantly smaller than WRITE_MNIN_DELAY but larger than longest message
+//semaphore for assuring min delay between sent data
+//extern SemaphoreHandle_t uart_semaphoreSend;
+
+//==== parameters message frame ====
+#define START_PATTERN 0xAA
+#define END_PATTERN 0xBB
+#define MAX_MESSAGE_LENGTH 1024
+#define ESCAPE_BYTE   0xCC
+//min delay after each message (no significant effect)
+#define UART_WRITE_MIN_DELAY 50
+#define UART_WRITE_WAIT_TIMEOUT 2000
+
+extern bool uart_isInitialized;
+
 //struct for testing uart
 typedef struct {
 	uint32_t timestamp;
@@ -32,23 +51,57 @@ typedef struct {
 } uartData_motorCommands_t;
 
 
+//function that handles receieved messages as byte array
+//-> do something with received data
+typedef void (*messageHandleFunc_t)(uint8_t *data, int length);
+
+
+
 //===== uart_init =====
 //should be run once at startup
 void uart_init(void);
 
 
+//===== uart_processReceivedByte =====
+//decode received message to byte array (start, stop, escape pattern)
+//has to be run for each receibed byte
+//runs provided messageHandler function when complete message received
+void uart_processReceivedByte(uint8_t data, messageHandleFunc_t messageHandler);
+
+
+//===== uart_sendBinary =====
+//encode byte array to message (start, stop, escape pattern)
+//and send it via uart
+void uart_sendBinary(uint8_t *data, int length);
+
+
+
 //============================
 //====== uart_sendStruct =====
 //============================
 //send and struct via uart
+//waits when another struct was sent less than UART_WRITE_MIN_DELAY ago
 template <typename T> void uart_sendStruct(T dataStruct) {
 	static const char * TAG = "uart-common";
-	//TODO check if initialized?
+	//check if uart is initialized
+	if (!uart_isInitialized){
+		ESP_LOGE(TAG, "uart not initialized! droping data");
+		return;
+	}
 	uint8_t dataSerial[sizeof(T)];
+	//struct to serial bytes
 	memcpy(dataSerial, &dataStruct, sizeof(T));
-	uart_write_bytes(UART_NUM_1, (const char *)dataSerial, sizeof(T));
+	// 	//wait for min delay after last write DROPPED
-	ESP_LOGW(TAG, "sent data struct with len %d", sizeof(T));
+	// 	if (xSemaphoreTake(uart_semaphoreSend, UART_WRITE_WAIT_TIMEOUT / portTICK_PERIOD_MS) == pdTRUE){
-	//ESP_LOGW(TAG, "sent DATA: timestamp=%d, id=%d, value=%.1f", data.timestamp, data.id, data.value);
+	// 		//send bytes
+	// 		uart_write_bytes(UART_NUM_1, (const char *)dataSerial, sizeof(T));
+	// 		ESP_LOGW(TAG, "sent data struct with len %d", sizeof(T));
+	// 	} else ESP_LOGE(TAG, "timeout waiting for uart write semaphore! dropping data");
+	// 	//wait min delay before next write is allowed
+	// 	vTaskDelay(UART_WRITE_MIN_DELAY / portTICK_PERIOD_MS);
+	// 	xSemaphoreGive(uart_semaphoreSend);
+
+	uart_sendBinary(dataSerial, sizeof(T));
 }
 
 
@@ -62,7 +115,7 @@ template <typename T> T serialData2Struct(uint8_t *dataSerial){
 	static const char * TAG = "uart-common";
 	T dataStruct;
 	memcpy(&dataStruct, dataSerial, sizeof(T));
-	ESP_LOGW(TAG, "converted serial data len=%d to struct", sizeof(T));
+	ESP_LOGI(TAG, "converted serial data len=%d to struct", sizeof(T));
 	return dataStruct;
 }