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
This commit is contained in:
jonny_jr9
parent
1e544613ee
commit
446c246f43
@ -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);
|
||||
|
||||
//
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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);
|
||||
|
||||
|
||||
@ -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 ===========
|
||||
//====================================
|
||||
|
||||
@ -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
|
||||
//TODO use queue instead of check interval?
|
||||
uartData_test_t dataTest;
|
||||
motorCommands_t dataMotorCommands;
|
||||
uint8_t receivedData[1024-1];
|
||||
while(1){
|
||||
//note: check has to be more frequent than pause time between sending
|
||||
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;
|
||||
while (1) {
|
||||
uint8_t byte;
|
||||
//read 1 byte TODO: use uart queue here? data might get lost when below function takes longer than data arrives
|
||||
int len = uart_read_bytes(UART_NUM_1, &byte, 1, portMAX_DELAY);
|
||||
if (len > 0) {
|
||||
//process received byte
|
||||
uart_processReceivedByte(byte, handleMessage);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
#pragma once
|
||||
#include "uart_common.hpp"
|
||||
|
||||
|
||||
//===== uart board MOTORCTL =====
|
||||
|
||||
void task_uartReceive(void *arg);
|
||||
|
||||
@ -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");
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -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));
|
||||
ESP_LOGW(TAG, "sent data struct with len %d", sizeof(T));
|
||||
//ESP_LOGW(TAG, "sent DATA: timestamp=%d, id=%d, value=%.1f", data.timestamp, data.id, data.value);
|
||||
// //wait for min delay after last write DROPPED
|
||||
// if (xSemaphoreTake(uart_semaphoreSend, UART_WRITE_WAIT_TIMEOUT / portTICK_PERIOD_MS) == pdTRUE){
|
||||
// //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;
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user