DebugTrace, Nextion, BrokerMQTT

include/DebugTrace.h

@@ -0,0 +1,20 @@
+#pragma once
+//
+#include "Global.h"
+
+#define RESTART_DEBUG_INFO
+#if defined(RESTART_DEBUG_INFO) && defined(ESP32) && !defined(esp32c3m_4mb)
+#define CONFIG_RESTART_DEBUG_STACK_DEPTH 15
+typedef struct {
+  size_t heap_total;
+  size_t heap_free;
+  size_t heap_free_min;
+  time_t heap_min_time;
+  uint32_t backtrace[CONFIG_RESTART_DEBUG_STACK_DEPTH];
+} re_restart_debug_t;
+
+#endif // RESTART_DEBUG_INFO
+extern "C" void __real_esp_panic_handler(void*);
+void printDebugTrace();
+void sendDebugTraceAndFreeMemory(bool);
+void IRAM_ATTR debugUpdate();

platformio.ini

@@ -1,5 +1,5 @@
 [platformio]
-default_envs = esp8266_4mb
+default_envs = esp32_4mb3f
 data_dir = data_svelte
 
 [common_env_data]
@@ -185,9 +185,10 @@ lib_deps =
 	${common_env_data.lib_deps_external}
 	${env:esp32_4mb_fromitems.lib_deps}
 build_flags = -Desp32_4mb="esp32_4mb"
+	-Wl,--wrap=esp_panic_handler
 framework = arduino
 board = esp32dev
-platform = espressif32 @5.1.1
+platform = espressif32 @6.6.0
 monitor_filters = esp32_exception_decoder
 upload_speed = 921600
 monitor_speed = 115200
@@ -206,9 +207,10 @@ lib_deps =
 	${common_env_data.lib_deps_external}
 	${env:esp32_4mb3f_fromitems.lib_deps}
 build_flags = -Desp32_4mb="esp32_4mb"
+	-Wl,--wrap=esp_panic_handler
 framework = arduino
 board = esp32dev
-platform = espressif32 @5.1.1
+platform = espressif32 @6.6.0
 monitor_filters = esp32_exception_decoder
 upload_speed = 921600
 monitor_speed = 115200
@@ -231,9 +233,10 @@ build_flags =
 	-Desp32cam_4mb="esp32cam_4mb"
 	-DBOARD_HAS_PSRAM
 	-mfix-esp32-psram-cache-issue
+	-Wl,--wrap=esp_panic_handler
 framework = arduino
 board = esp32cam
-platform = espressif32 @5.1.1
+platform = espressif32 @6.6.0
 monitor_filters = esp32_exception_decoder
 upload_speed = 921600
 monitor_speed = 115200
@@ -251,13 +254,13 @@ extra_scripts = pre:tools/patch32_ws.py
 lib_deps = 
 	${common_env_data.lib_deps_external}
 	${env:esp32s2_4mb_fromitems.lib_deps}
-build_flags = 
+build_flags = -Desp32s2_4mb="esp32s2_4mb"
-	-Desp32s2_4mb="esp32s2_4mb"
 	-DARDUINO_USB_CDC_ON_BOOT=1
 	-DARDUINO_USB_MODE=0
+	-Wl,--wrap=esp_panic_handler
 framework = arduino
 board = lolin_s2_mini
-platform = espressif32 @6.3.1
+platform = espressif32 @6.6.0
 monitor_filters = esp32_exception_decoder
 upload_speed = 921600
 monitor_speed = 115200
@@ -275,11 +278,11 @@ extra_scripts = pre:tools/patch32_ws.py
 lib_deps = 
 	${common_env_data.lib_deps_external}
 	${env:esp32c3m_4mb_fromitems.lib_deps}
-build_flags = 
+build_flags = -Desp32c3m_4mb="esp32c3m_4mb"
-	-Desp32c3m_4mb="esp32c3m_4mb"
+	-Wl,--wrap=esp_panic_handler
 framework = arduino
 board = lolin_c3_mini
-platform = espressif32 @6.3.1
+platform = espressif32 @6.6.0
 monitor_filters = esp32_exception_decoder
 upload_speed = 921600
 monitor_speed = 115200
@@ -300,10 +303,11 @@ lib_deps =
 	${env:esp32s3_16mb_fromitems.lib_deps}
 build_flags = 
 	-Desp32s3_16mb="esp32s3_16mb"
+	-Wl,--wrap=esp_panic_handler
 framework = arduino
 board = esp32-s3-devkitc-1
 board_build.mcu = esp32s3
-platform = espressif32 @6.3.1
+platform = espressif32 @6.6.0
 monitor_filters = esp32_exception_decoder
 upload_speed = 921600
 monitor_speed = 115200
@@ -324,9 +328,10 @@ lib_deps =
 	${common_env_data.lib_deps_external}
 	${env:esp32_16mb_fromitems.lib_deps}
 build_flags = -Desp32_16mb="esp32_16mb"
+	-Wl,--wrap=esp_panic_handler
 framework = arduino
 board = esp32dev
-platform = espressif32 @5.1.1
+platform = espressif32 @6.6.0
 monitor_filters = esp32_exception_decoder
 upload_port = COM11
 upload_speed = 921600

src/DebugTrace.cpp

@@ -0,0 +1,287 @@
+#include "DebugTrace.h"
+#if defined(RESTART_DEBUG_INFO) && defined(ESP32) && !defined(esp32c3m_4mb)
+//#ifdef RESTART_DEBUG_INFO
+__NOINIT_ATTR static re_restart_debug_t _debug_info;
+
+#include "esp_debug_helpers.h"
+#include "esp_types.h"
+#include "esp_attr.h"
+#include "esp_err.h"
+#include "soc/soc_memory_layout.h"
+#include "soc/cpu.h"
+
+// RU: Размер буфера для конвертации даты и времeни в строку
+#define CONFIG_FORMAT_STRFTIME_BUFFER_SIZE 32
+#define CONFIG_FORMAT_STRFTIME_DTS_BUFFER_SIZE 20 // YYYY.MM.DD HH:NN:SS + \n
+
+// RU: Форматы даты и времени
+#define CONFIG_FORMAT_DTS "%d.%m.%Y %H:%M:%S"
+
+void IRAM_ATTR debugHeapUpdate()
+{
+  _debug_info.heap_total = heap_caps_get_total_size(MALLOC_CAP_DEFAULT);
+  _debug_info.heap_free = heap_caps_get_free_size(MALLOC_CAP_DEFAULT);
+  size_t _new_free_min = heap_caps_get_minimum_free_size(MALLOC_CAP_DEFAULT);
+  if ((_debug_info.heap_free_min == 0) || (_new_free_min < _debug_info.heap_free_min))
+  {
+    _debug_info.heap_free_min = _new_free_min;
+    _debug_info.heap_min_time = time(nullptr);
+  };
+}
+
+void IRAM_ATTR debugBacktraceUpdate()
+{
+  esp_backtrace_frame_t stk_frame;
+  esp_backtrace_get_start(&(stk_frame.pc), &(stk_frame.sp), &(stk_frame.next_pc));
+  _debug_info.backtrace[0] = esp_cpu_process_stack_pc(stk_frame.pc);
+
+  bool corrupted = (esp_stack_ptr_is_sane(stk_frame.sp) &&
+                    esp_ptr_executable((void *)esp_cpu_process_stack_pc(stk_frame.pc)))
+                       ? false
+                       : true;
+
+  uint8_t i = CONFIG_RESTART_DEBUG_STACK_DEPTH;
+  while (i-- > 0 && stk_frame.next_pc != 0 && !corrupted)
+  {
+    if (!esp_backtrace_get_next_frame(&stk_frame))
+    {
+      corrupted = true;
+    };
+    _debug_info.backtrace[CONFIG_RESTART_DEBUG_STACK_DEPTH - i] = esp_cpu_process_stack_pc(stk_frame.pc);
+  };
+}
+
+void IRAM_ATTR debugUpdate()
+{
+  debugHeapUpdate();
+  debugBacktraceUpdate();
+}
+
+extern "C" void __wrap_esp_panic_handler(void *info)
+{
+
+  debugHeapUpdate();
+  debugBacktraceUpdate();
+  // Call the original panic handler function to finish processing this error (creating a core dump for example...)
+  __real_esp_panic_handler(info);
+}
+
+re_restart_debug_t debugGet()
+{
+  re_restart_debug_t ret;
+  memset(&ret, 0, sizeof(re_restart_debug_t));
+  esp_reset_reason_t esp_reason = esp_reset_reason();
+  if ((esp_reason != ESP_RST_UNKNOWN) && (esp_reason != ESP_RST_POWERON))
+  {
+    uint8_t i = CONFIG_RESTART_DEBUG_STACK_DEPTH;
+    ret = _debug_info;
+    if (_debug_info.heap_total > heap_caps_get_total_size(MALLOC_CAP_DEFAULT))
+    {
+      memset(&ret, 0, sizeof(re_restart_debug_t));
+    };
+  };
+  memset(&_debug_info, 0, sizeof(re_restart_debug_t));
+  return ret;
+}
+
+#define CONFIG_MESSAGE_TG_VERSION_DEF "! Устройство запущено\n\nИмя устройства:     %s\nПричина перезапуска: %s\nCPU0: %s\nCPU1: %s"
+#define CONFIG_MESSAGE_TG_VERSION_HEAP "! Устройство аварийно перезапущено !\n\nИмя устройства:     %s\nПричина перезапуска: %s\nCPU0: %s\nCPU1: %s\nHEAP: %s"
+#define CONFIG_MESSAGE_TG_VERSION_TRACE "! Устройство  аварийно перезапущено !\n\nИмя устройства:     %s\nПричина перезапуска: %s\nCPU0:  %s\nCPU1:  %s\nHEAP:  %s\nTRACE: %s"
+
+char *malloc_stringf(const char *format, ...)
+{
+  char *ret = nullptr;
+  if (format != nullptr)
+  {
+    // get the list of arguments
+    va_list args1, args2;
+    va_start(args1, format);
+    va_copy(args2, args1);
+    // calculate length of resulting string
+    int len = vsnprintf(nullptr, 0, format, args1);
+    va_end(args1);
+    // allocate memory for string
+    if (len > 0)
+    {
+#if USE_ESP_MALLOC
+      ret = (char *)esp_malloc(len + 1);
+#else
+      ret = (char *)malloc(len + 1);
+#endif
+      if (ret != nullptr)
+      {
+        memset(ret, 0, len + 1);
+        vsnprintf(ret, len + 1, format, args2);
+      }
+      else
+      {
+        // rlog_e(tagHEAP, "Failed to format string: out of memory!");
+      };
+    };
+    va_end(args2);
+  };
+  return ret;
+}
+
+static char *statesGetDebugHeap(re_restart_debug_t *debug)
+{
+  if ((debug->heap_total > 0) && (debug->heap_total > debug->heap_free))
+  {
+    struct tm timeinfo;
+    localtime_r(&debug->heap_min_time, &timeinfo);
+    char time_buffer[CONFIG_FORMAT_STRFTIME_DTS_BUFFER_SIZE];
+    memset(&time_buffer, 0, CONFIG_FORMAT_STRFTIME_DTS_BUFFER_SIZE);
+    strftime(time_buffer, CONFIG_FORMAT_STRFTIME_DTS_BUFFER_SIZE, CONFIG_FORMAT_DTS, &timeinfo);
+
+    double heapTotal = (double)debug->heap_total / 1024;
+    double heapFree = (double)debug->heap_free / 1024;
+    double heapFreeMin = (double)debug->heap_free_min / 1024;
+
+    return malloc_stringf("Total %.1fkB ; Free %.1fkB (%.1f%%) ; FreeMin %.1fkB (%.1f%%) %s",
+                          heapTotal,
+                          heapFree, 100.0 * (heapFree / heapTotal),
+                          heapFreeMin, 100.0 * (heapFreeMin / heapTotal), time_buffer);
+  };
+  return nullptr;
+}
+
+static char *statesGetDebugTrace(re_restart_debug_t *debug)
+{
+  char *backtrace = nullptr;
+  char *item = nullptr;
+  char *temp = nullptr;
+  for (uint8_t i = 0; i < CONFIG_RESTART_DEBUG_STACK_DEPTH; i++)
+  {
+    if (debug->backtrace[i] != 0)
+    {
+      item = malloc_stringf("0x%08x", debug->backtrace[i]);
+      if (item)
+      {
+        if (backtrace)
+        {
+          temp = backtrace;
+          backtrace = malloc_stringf("%s %s", temp, item);
+          free(item);
+          free(temp);
+        }
+        else
+        {
+          backtrace = item;
+        };
+        item = nullptr;
+      };
+    }
+    else
+    {
+      break;
+    }
+  };
+  return backtrace;
+}
+
+void printDebugTrace()
+{
+  // esp_register_shutdown_handler(debugUpdate);
+  re_restart_debug_t debug = debugGet();
+  char *debug_heap = statesGetDebugHeap(&debug);
+  char *debug_trace = nullptr;
+  if (debug_heap)
+  {
+    debug_trace = statesGetDebugTrace(&debug);
+    if (debug_trace)
+    {
+      Serial.printf(CONFIG_MESSAGE_TG_VERSION_TRACE,
+                    jsonReadStr(settingsFlashJson, F("name")), ESP_getResetReason().c_str(), ESP32GetResetReason(0).c_str(), ESP32GetResetReason(1).c_str(),
+                    debug_heap, debug_trace);
+      //    free(debug_trace);
+    }
+    else
+    {
+      Serial.printf(CONFIG_MESSAGE_TG_VERSION_HEAP,
+                    jsonReadStr(settingsFlashJson, F("name")), ESP_getResetReason().c_str(), ESP32GetResetReason(0).c_str(), ESP32GetResetReason(1).c_str(),
+                    debug_heap);
+    };
+    //  free(debug_heap);
+  }
+  else
+  {
+    //            Serial.println("DEVICE START");
+    Serial.printf(CONFIG_MESSAGE_TG_VERSION_DEF,
+                  jsonReadStr(settingsFlashJson, F("name")), ESP_getResetReason().c_str(), ESP32GetResetReason(0).c_str(), ESP32GetResetReason(1).c_str());
+  }
+  
+}
+
+void sendDebugTraceAndFreeMemory( bool postMsg)
+{
+  // esp_register_shutdown_handler(debugUpdate);
+  re_restart_debug_t debug = debugGet();
+  char *debug_heap = statesGetDebugHeap(&debug);
+  char *debug_trace = nullptr;
+
+  if (debug_heap)
+  {
+    if (isNetworkActive() && postMsg)
+    {
+      debug_trace = statesGetDebugTrace(&debug);
+      if (debug_trace)
+      {
+        if (tlgrmItem)
+        {
+          char *msg;
+          msg = malloc_stringf(CONFIG_MESSAGE_TG_VERSION_TRACE,
+                               jsonReadStr(settingsFlashJson, F("name")).c_str(), ESP_getResetReason().c_str(), ESP32GetResetReason(0).c_str(), ESP32GetResetReason(1).c_str(),
+                               debug_heap, debug_trace);
+          tlgrmItem->sendTelegramMsg(false, String(msg));
+          tlgrmItem->sendTelegramMsg(false, String("Подробности /helpDebug в Telegram_v2"));
+          free(msg);
+        }
+        free(debug_trace);
+      }
+      else
+      {
+        /*
+        Serial.printf(CONFIG_MESSAGE_TG_VERSION_HEAP,
+                      jsonReadStr(settingsFlashJson, F("name")), ESP_getResetReason().c_str(), ESP32GetResetReason(0).c_str(), ESP32GetResetReason(1).c_str(),
+                      debug_heap);
+                      */
+        if (tlgrmItem)
+        {
+          char *msg;
+          msg = malloc_stringf(CONFIG_MESSAGE_TG_VERSION_HEAP,
+                               jsonReadStr(settingsFlashJson, F("name")).c_str(), ESP_getResetReason().c_str(), ESP32GetResetReason(0).c_str(), ESP32GetResetReason(1).c_str(),
+                               debug_heap);
+          tlgrmItem->sendTelegramMsg(false, String(msg));
+          tlgrmItem->sendTelegramMsg(false, String("Подробности /helpDebug в Telegram_v2"));
+          free(msg);
+        }
+      }
+    }
+    free(debug_heap);
+  }
+/*  else
+  {
+    //            Serial.println("DEVICE START");
+    //  Serial.printf(CONFIG_MESSAGE_TG_VERSION_DEF,
+    //               FIRMWARE_VERSION, ESP_getResetReason().c_str(), ESP32GetResetReason(0).c_str(), ESP32GetResetReason(1).c_str());
+    if (tlgrmItem && isNetworkActive())
+    {
+      char *msg;
+      msg = malloc_stringf(CONFIG_MESSAGE_TG_VERSION_DEF,
+                            WiFi.localIP().toString(), FIRMWARE_VERSION, ESP_getResetReason().c_str(), ESP32GetResetReason(0).c_str(), ESP32GetResetReason(1).c_str());
+      tlgrmItem->sendTelegramMsg(false, String(msg));
+      free(msg);
+    }
+  };*/
+}
+
+#else
+void printDebugTrace() {}
+void sendDebugTraceAndFreeMemory(bool) {}
+void IRAM_ATTR debugUpdate() {}
+extern "C" void __wrap_esp_panic_handler(void *info)
+{
+  // Call the original panic handler function to finish processing this error (creating a core dump for example...)
+  __real_esp_panic_handler(info);
+}
+#endif // RESTART_DEBUG_INFO

src/EspFileSystem.cpp

@@ -79,7 +79,7 @@ uint32_t ESP_getChipId(void)
 #endif
 }
 
-// устарела используем новую функцию ниже
+/*// устарела используем новую функцию ниже
 #if !defined(esp32s2_4mb) && !defined(esp32c3m_4mb) && !defined(esp32s3_16mb)
 //#ifndef esp32s2_4mb
 uint32_t ESP_getFlashChipId(void)
@@ -93,6 +93,7 @@ uint32_t ESP_getFlashChipId(void)
 #endif
 }
 #endif
+*/
 
 // https://github.com/espressif/arduino-esp32/issues/6945#issuecomment-1199900892
 // получение flash ch id из проекта esp easy

src/Main.cpp

@@ -4,6 +4,7 @@
 #include "utils/Statistic.h"
 #include "classes/IoTBench.h"
 #include <Wire.h>
+#include "DebugTrace.h"
 #if defined(esp32s2_4mb) || defined(esp32s3_16mb)
 #include <USB.h>
 #endif
@@ -97,6 +98,12 @@ void setup() {
 
     Serial.begin(115200);
     Serial.flush();
+    //----------- Отладка EXCEPTION (функции с заглушками для отключения) ---------
+    //Привязка коллбэк функции для вызова при перезагрузке
+    esp_register_shutdown_handler(debugUpdate);
+    // Печать или оправка отладочной информации
+    printDebugTrace();
+
     Serial.println();
     Serial.println(F("--------------started----------------"));
 
@@ -179,6 +186,10 @@ void setup() {
 
     stopErrorMarker(SETUPINET_ERRORMARKER);
 
+    bool postMsgTelegram;
+    if (!jsonRead(settingsFlashJson, "debugTrace", postMsgTelegram, false)) postMsgTelegram = 1;
+    sendDebugTraceAndFreeMemory(postMsgTelegram);
+    
     initErrorMarker(SETUPLAST_ERRORMARKER);
 
     elementsLoop();

src/PeriodicTasks.cpp

@@ -61,7 +61,22 @@ String ESP_getResetReason(void) {
 #endif
 #if defined(esp32s2_4mb) || defined(esp32s3_16mb) || defined(esp32c3m_4mb)
 String ESP_getResetReason(void) {
-    return ESP32GetResetReason(0);  // CPU 0
+ //   return ESP32GetResetReason(0);  // CPU 0
+        esp_reset_reason_t esp_reason = esp_reset_reason();
+  switch (esp_reason) {
+    case ESP_RST_UNKNOWN:   return "UNKNOWN";
+    case ESP_RST_POWERON:   return "POWER ON";
+    case ESP_RST_EXT:       return "EXTERNAL PIN";
+    case ESP_RST_SW:        return "SOFTWARE RESET";
+    case ESP_RST_PANIC:     return "EXCEPTION / PANIC";
+    case ESP_RST_INT_WDT:   return "INTERRUPT WATCHDOG";
+    case ESP_RST_TASK_WDT:  return "TASK WATCHDOG";
+    case ESP_RST_WDT:       return "WATCHDOGS";
+    case ESP_RST_DEEPSLEEP: return "EXITING DEEP SLLEP MODE";
+    case ESP_RST_BROWNOUT:  return "BROWNOUT";
+    case ESP_RST_SDIO:      return "SDIO";
+    default :               return "NO MEAN";
+  };
 }
 String ESP32GetResetReason(uint32_t cpu_no) {
     // tools\sdk\include\esp32\rom\rtc.h
@@ -103,7 +118,22 @@ String ESP32GetResetReason(uint32_t cpu_no) {
 #endif
 #if defined(esp32_4mb) || defined(esp32_16mb) || defined(esp32cam_4mb)
 String ESP_getResetReason(void) {
-    return ESP32GetResetReason(0);  // CPU 0
+  //  return ESP32GetResetReason(0);  // CPU 0
+    esp_reset_reason_t esp_reason = esp_reset_reason();
+  switch (esp_reason) {
+    case ESP_RST_UNKNOWN:   return "UNKNOWN";
+    case ESP_RST_POWERON:   return "POWER ON";
+    case ESP_RST_EXT:       return "EXTERNAL PIN";
+    case ESP_RST_SW:        return "SOFTWARE RESET";
+    case ESP_RST_PANIC:     return "EXCEPTION / PANIC";
+    case ESP_RST_INT_WDT:   return "INTERRUPT WATCHDOG";
+    case ESP_RST_TASK_WDT:  return "TASK WATCHDOG";
+    case ESP_RST_WDT:       return "WATCHDOGS";
+    case ESP_RST_DEEPSLEEP: return "EXITING DEEP SLLEP MODE";
+    case ESP_RST_BROWNOUT:  return "BROWNOUT";
+    case ESP_RST_SDIO:      return "SDIO";
+    default :               return "NO MEAN";
+  };
 }
 String ESP32GetResetReason(uint32_t cpu_no) {
     // tools\sdk\include\esp32\rom\rtc.h

src/modules/display/Nextion/ESPNexUpload.cpp

@@ -22,66 +22,22 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
+#ifdef CORE_DEBUG_LEVEL
+#undef CORE_DEBUG_LEVEL
+#endif
+
+#define CORE_DEBUG_LEVEL 3
+#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
 
-#define DEBUG_SERIAL_ENABLE
 #include "ESPNexUpload.h"
 
-#ifdef DEBUG_SERIAL_ENABLE
+static const char *TAG = "nextion upload";
-#define dbSerialPrint(a) Serial.print(a)
-#define dbSerialPrintHex(a) Serial.print(a, HEX)
-#define dbSerialPrintln(a) Serial.println(a)
-#define dbSerialBegin(a) Serial.begin(a)
-#else
-#define dbSerialPrint(a) \
-	do                   \
-	{                    \
-	} while (0)
-#define dbSerialPrintHex(a) \
-	do                      \
-	{                       \
-	} while (0)
-#define dbSerialPrintln(a) \
-	do                     \
-	{                      \
-	} while (0)
-#define dbSerialBegin(a) \
-	do                   \
-	{                    \
-	} while (0)
-#endif
 
-ESPNexUpload::ESPNexUpload(uint32_t upload_baudrate, int line, int rx, int tx)
+ESPNexUpload::ESPNexUpload(uart_port_t uart_num, uint32_t baud_rate, gpio_num_t tx_io_num, gpio_num_t rx_io_num)
 {
-	_upload_baudrate = upload_baudrate;
+	_upload_uart_lock = xSemaphoreCreateMutex();
-	_rx = rx;
+	_uart_diver_installed = false;
-	_tx = tx;
+	setBaudrate(uart_num, baud_rate, tx_io_num, rx_io_num);
-	_line = line;
-
-#if defined ESP8266
-	nexSerial = new SoftwareSerial(_rx, _tx);
-#else
-	if (line >= 0) {
-        nexSerial = new HardwareSerial(line);
- //       ((HardwareSerial*)nexSerial)->begin(_upload_baudrate, SERIAL_8N1, _rx, _tx);
-    } else {
-        nexSerial = new SoftwareSerial(_rx, _tx);
- //       ((SoftwareSerial*)nexSerial)->begin(_upload_baudrate);
-    }
-#endif
-
-}
-
-void ESPNexUpload::nexSerialBegin(uint32_t _speed, int _line, int _rx, int _tx)
-{
-#if defined ESP8266
-	nexSerial->begin(_speed);
-#else
-	if (_line >= 0) {
-        ((HardwareSerial*)nexSerial)->begin(_speed, SERIAL_8N1, _rx, _tx);
-    } else {
-        ((SoftwareSerial*)nexSerial)->begin(_speed);
-    }
-#endif	
 }
 
 bool ESPNexUpload::connect()
@@ -90,13 +46,11 @@ bool ESPNexUpload::connect()
 	yield();
 #endif
 
-	dbSerialBegin(115200);
+	ESP_LOGI(TAG, "serial tests & connect");
-	_printInfoLine(F("serial tests & connect"));
 
 	if (_getBaudrate() == 0)
 	{
-		statusMessage = F("get baudrate error");
+		ESP_LOGE(TAG, "get baudrate error");
-		_printInfoLine(statusMessage);
 		return false;
 	}
 
@@ -104,31 +58,31 @@ bool ESPNexUpload::connect()
 
 	if (!_echoTest("mystop_yesABC"))
 	{
-		statusMessage = F("echo test failed");
+		ESP_LOGE(TAG, "echo test failed");
-		_printInfoLine(statusMessage);
 		return false;
 	}
 
 	if (!_handlingSleepAndDim())
 	{
-		statusMessage = F("handling sleep and dim settings failed");
+		ESP_LOGE(TAG, "handling sleep and dim settings failed");
-		_printInfoLine(statusMessage);
 		return false;
 	}
 
 	if (!_setPrepareForFirmwareUpdate(_upload_baudrate))
 	{
-		statusMessage = F("modifybaudrate error");
+		ESP_LOGE(TAG, "modifybaudrate error");
-		_printInfoLine(statusMessage);
 		return false;
 	}
 
 	return true;
 }
 
-bool ESPNexUpload::prepareUpload(uint32_t file_size)
+bool ESPNexUpload::prepareUpload(uint32_t file_size, bool prot)
 {
+	protv2 = prot;
 	_undownloadByte = file_size;
+	ESP_LOGD(TAG, "prepareUpload: %" PRIu32, file_size);
+	vTaskDelay(5 / portTICK_PERIOD_MS);
 	return this->connect();
 }
 
@@ -142,74 +96,73 @@ uint16_t ESPNexUpload::_getBaudrate(void)
 		if (_searchBaudrate(baudrate_array[i]))
 		{
 			_baudrate = baudrate_array[i];
-			_printInfoLine(F("baudrate determined"));
+			ESP_LOGI(TAG, "baudrate determined: %i", _baudrate);
 			break;
 		}
-		delay(1500); // wait for 1500 ms
+		vTaskDelay(1500 / portTICK_PERIOD_MS); // wait for 1500 ms
 	}
 	return _baudrate;
 }
 
-bool ESPNexUpload::_searchBaudrate(uint32_t baudrate)
+bool ESPNexUpload::_searchBaudrate(int baudrate)
 {
 
 #if defined ESP8266
 	yield();
 #endif
 
-	String response = String("");
+	std::string response = "";
-	_printInfoLine();
+	ESP_LOGD(TAG, "init nextion serial interface on baudrate: %i", baudrate);
-	dbSerialPrint(F("init nextion serial interface on baudrate: "));
-	dbSerialPrintln(baudrate);
 
-	nexSerialBegin(baudrate, _line, _rx, _tx);
+	setBaudrate(_upload_uart_num,
-	_printInfoLine(F("ESP baudrate established, try to connect to display"));
+				baudrate,
+				_upload_tx_io_num,
+				_upload_rx_io_num);
+
+	ESP_LOGD(TAG, "ESP baudrate established, try to connect to display");
 	const char _nextion_FF_FF[3] = {0xFF, 0xFF, 0x00};
 
-	this->sendCommand("DRAKJHSUYDGBNCJHGJKSHBDN");
+	this->sendCommand("DRAKJHSUYDGBNCJHGJKSHBDN", true, true); // 0x00 0xFF 0xFF 0xFF
-	this->sendCommand("", true, true); // 0x00 0xFF 0xFF 0xFF
-
 	this->recvRetString(response);
 	if (response[0] != 0x1A)
 	{
-		_printInfoLine(F("first indication that baudrate is wrong"));
+		ESP_LOGW(TAG, "first indication that baudrate is wrong");
 	}
 	else
 	{
-		_printInfoLine(F("first respone from display, first indication that baudrate is correct"));
+		ESP_LOGI(TAG, "first respone from display, first indication that baudrate is correct");
 	}
 
 	this->sendCommand("connect"); // first connect attempt
-
 	this->recvRetString(response);
-	if (response.indexOf(F("comok")) == -1)
+	if (response.find("comok") == -1)
 	{
-		_printInfoLine(F("display doesn't accept the first connect request"));
+		ESP_LOGW(TAG, "display doesn't accept the first connect request");
 	}
 	else
 	{
-		_printInfoLine(F("display accept the first connect request"));
+		ESP_LOGI(TAG, "display accept the first connect request");
 	}
 
-	response = String("");
+	vTaskDelay(110 / portTICK_PERIOD_MS); // based on serial analyser from Nextion editor V0.58 to Nextion display NX4024T032_011R
-	delay(110); // based on serial analyser from Nextion editor V0.58 to Nextion display NX4024T032_011R
 	this->sendCommand(_nextion_FF_FF, false);
 
 	this->sendCommand("connect"); // second attempt
 	this->recvRetString(response);
-	if (response.indexOf(F("comok")) == -1 && response[0] != 0x1A)
+
+	if (response.find("comok") == -1 && response[0] != 0x1A)
 	{
-		_printInfoLine(F("display doesn't accept the second connect request"));
+		ESP_LOGW(TAG, "display doesn't accept the second connect request");
-		_printInfoLine(F("conclusion, wrong baudrate"));
+		ESP_LOGW(TAG, "conclusion, wrong baudrate");
-		return 0;
+		return false;
 	}
 	else
 	{
-		_printInfoLine(F("display accept the second connect request"));
+		ESP_LOGI(TAG, "display accept the second connect request");
-		_printInfoLine(F("conclusion, correct baudrate"));
+		ESP_LOGI(TAG, "conclusion, correct baudrate");
 	}
 
-	return 1;
+	return true;
 }
 
 void ESPNexUpload::sendCommand(const char *cmd, bool tail, bool null_head)
@@ -221,25 +174,25 @@ void ESPNexUpload::sendCommand(const char *cmd, bool tail, bool null_head)
 
 	if (null_head)
 	{
-		((HardwareSerial*)nexSerial)->write(0x00);
+		uartWrite(0x00);
 	}
 
-	while (nexSerial->available())
+	while (uartAvailable())
 	{
-		nexSerial->read();
+		uartRead();
 	}
 
-	nexSerial->print(cmd);
+	uartWriteBuf(cmd, strlen(cmd));
+
 	if (tail)
 	{
-		nexSerial->write(0xFF);
+		uartWrite(0xFF);
-		nexSerial->write(0xFF);
+		uartWrite(0xFF);
-		nexSerial->write(0xFF);
+		uartWrite(0xFF);
 	}
-	_printSerialData(true, cmd);
 }
 
-uint16_t ESPNexUpload::recvRetString(String &response, uint32_t timeout, bool recv_flag)
+uint16_t ESPNexUpload::recvRetString(std::string &response, uint32_t timeout, bool recv_flag)
 {
 
 #if defined ESP8266
@@ -252,18 +205,19 @@ uint16_t ESPNexUpload::recvRetString(String &response, uint32_t timeout, bool re
 	long start;
 	bool exit_flag = false;
 	bool ff_flag = false;
+	response = "";
 	if (timeout != 500)
-		_printInfoLine("timeout setting serial read: " + String(timeout));
+		ESP_LOGD(TAG, "timeout setting serial read: %" PRIu32, timeout);
 
-	start = millis();
+	start = (unsigned long)(esp_timer_get_time() / 1000ULL);
 
-	while (millis() - start <= timeout)
+	while ((unsigned long)(esp_timer_get_time() / 1000ULL) - start <= timeout)
 	{
 
-		while (nexSerial->available())
+		while (uartAvailable())
 		{
 
-			c = nexSerial->read();
+			c = uartRead();
 			if (c == 0)
 			{
 				continue;
@@ -284,7 +238,7 @@ uint16_t ESPNexUpload::recvRetString(String &response, uint32_t timeout, bool re
 
 			if (recv_flag)
 			{
-				if (response.indexOf(0x05) != -1)
+				if (response.find(0x05) != -1)
 				{
 					exit_flag = true;
 				}
@@ -295,16 +249,12 @@ uint16_t ESPNexUpload::recvRetString(String &response, uint32_t timeout, bool re
 			break;
 		}
 	}
-	_printSerialData(false, response);
-
-	// if the exit flag and the ff flag are both not found, than there is a timeout
-	// if(!exit_flag && !ff_flag)
-	// _printInfoLine(F("recvRetString: timeout"));
 
 	if (ff_flag)
-		response = response.substring(0, response.length() - 3); // Remove last 3 0xFF
+		response = response.substr(0, response.length() - 3); // Remove last 3 0xFF
 
 	ret = response.length();
+
 	return ret;
 }
 
@@ -315,18 +265,19 @@ bool ESPNexUpload::_setPrepareForFirmwareUpdate(uint32_t upload_baudrate)
 	yield();
 #endif
 
-	String response = String("");
+	std::string response = "";
-	String cmd = String("");
+	std::string cmd = "";
 
-	cmd = F("00");
+	cmd = "00";
 	this->sendCommand(cmd.c_str());
-	delay(0.1);
+	vTaskDelay(10 / portTICK_PERIOD_MS);
-
 	this->recvRetString(response, 800, true); // normal response time is 400ms
-
+	ESP_LOGD(TAG, "response (00): %s", response.c_str());
-	String filesize_str = String(_undownloadByte, 10);
+	if (protv2)
-	String baudrate_str = String(upload_baudrate);
+		cmd = "whmi-wris " + std::to_string(_undownloadByte) + "," + std::to_string(upload_baudrate) + ",1";
-	cmd = "whmi-wri " + filesize_str + "," + baudrate_str + ",0";
+	else
+		cmd = "whmi-wri " + std::to_string(_undownloadByte) + "," + std::to_string(upload_baudrate) + ",0";
+	ESP_LOGI(TAG, "cmd: %s", cmd.c_str());
 
 	this->sendCommand(cmd.c_str());
 
@@ -334,136 +285,215 @@ bool ESPNexUpload::_setPrepareForFirmwareUpdate(uint32_t upload_baudrate)
 	// because switching to another baudrate (nexSerialBegin command) has an higher prio.
 	// The ESP will first jump to the new 'upload_baudrate' and than process the serial 'transmit buffer'
 	// The flush command forced the ESP to wait until the 'transmit buffer' is empty
-	nexSerial->flush();
+	// nexSerial.flush();
-
+	uartFlushTxOnly();
-	nexSerialBegin(upload_baudrate, _line, _rx, _tx);
-	_printInfoLine(F("changing upload baudrate..."));
-	_printInfoLine(String(upload_baudrate));
 
 	this->recvRetString(response, 800, true); // normal response time is 400ms
 
+	ESP_LOGD(TAG, "response (01): %s", response.c_str());
+
 	// The Nextion display will, if it's ready to accept data, send a 0x05 byte.
-	if (response.indexOf(0x05) != -1)
+	if (response.find(0x05) != -1)
 	{
-		_printInfoLine(F("preparation for firmware update done"));
+		ESP_LOGI(TAG, "preparation for firmware update done");
-		return 1;
+		return true;
 	}
 	else
 	{
-		_printInfoLine(F("preparation for firmware update failed"));
+		ESP_LOGE(TAG, "preparation for firmware update failed");
-		return 0;
+		return false;
 	}
 }
 
-void ESPNexUpload::setUpdateProgressCallback(THandlerFunction value)
+bool ESPNexUpload::upload(const uint8_t *file_buf, size_t file_size)
-{
-	_updateProgressCallback = value;
-}
-
-bool ESPNexUpload::upload(const uint8_t *file_buf, size_t buf_size)
 {
 
 #if defined ESP8266
 	yield();
 #endif
 
-	uint8_t c;
+	// uint8_t c;
 	uint8_t timeout = 0;
-	String string = String("");
+	std::string response = "";
+	uint8_t sent_bulk_counter = 0;
+	// uint8_t buff[4096] = {0};
+	uint32_t offset = 0;
+	int remainingBlocks = ceil(file_size / 4096);
+	int blockSize = 4096;
 
-	for (uint16_t i = 0; i < buf_size; i++)
+	while (remainingBlocks > 0)
 	{
-
+		if (remainingBlocks == 1)
-		// Users must split the .tft file contents into 4096 byte sized packets with the final partial packet size equal to the last remaining bytes (<4096 bytes).
-		if (_sent_packets == 4096)
 		{
-
+			blockSize = file_size - offset;
-			// wait for the Nextion to return its 0x05 byte confirming reception and readiness to receive the next packets
-			this->recvRetString(string, 500, true);
-			if (string.indexOf(0x05) != -1)
-			{
-
-				// reset sent packets counter
-				_sent_packets = 0;
-
-				// reset receive String
-				string = "";
 		}
+		uartWriteBuf((char*)file_buf[offset], blockSize);
+		// wait for the Nextion to return its 0x05 byte confirming reception and readiness to receive the next packets
+		this->recvRetString(response, 2000, true);
+
+		if (response[0] == 0x08 && response.size() == 5)
+		{ // handle partial upload request
+			remainingBlocks -= 1;
+			_sent_packets_total += blockSize;
+			sent_bulk_counter++;
+			if (sent_bulk_counter % 10 == 0)
+			{
+				ESP_LOGI(TAG, "bulk: %i, total bytes %" PRIu32 ", response: %s", sent_bulk_counter, _sent_packets_total, response.c_str());
+			}
+
+			ESP_LOGE(TAG, "response [%s]",
+					 format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str());
+
+			for (int j = 0; j < 4; ++j)
+			{
+				offset += static_cast<uint8_t>(response[j + 1]) << (8 * j);
+				ESP_LOGI(TAG, "Offset : %" PRIu32, offset);
+			}
+			if (offset)
+				remainingBlocks = ceil((file_size - offset) / blockSize);
+		}
+		else if (response[0] == 0x05)
+		{
+			remainingBlocks -= 1;
+			_sent_packets_total += blockSize;
+			sent_bulk_counter++;
+			if (sent_bulk_counter % 10 == 0)
+			{
+				ESP_LOGI(TAG, "bulk: %i, total bytes %" PRIu32 ", response: %s", sent_bulk_counter, _sent_packets_total, response.c_str());
+			}
+
+			ESP_LOGE(TAG, "response [%s]",
+					 format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str());
+			offset += 4096;
+		}
+
 		else
 		{
-				if (timeout >= 8)
+			if (timeout >= 2)
 			{
-					statusMessage = F("serial connection lost");
+				ESP_LOGE(TAG, "upload failed, no valid response from display, total bytes send : %" PRIu32, _sent_packets_total);
-					_printInfoLine(statusMessage);
+				sent_bulk_counter = 0;
 				return false;
 			}
-
 			timeout++;
 		}
-
-			// delay current byte
-			i--;
 	}
-		else
+	ESP_LOGI(TAG, "upload send last bytes %" PRIu32 ", response: %s", _sent_packets_total, response.c_str());
-		{
+	// ESP_LOGI(TAG,"upload finished, total bytes send : %"PRIu32, _sent_packets_total);
-
+	sent_bulk_counter = 0;
-			// read buffer
-			c = file_buf[i];
-
-			// write byte to nextion over serial
-			nexSerial->write(c);
-
-			// update sent packets counter
-			_sent_packets++;
-		}
-	}
-
 	return true;
 }
 
 bool ESPNexUpload::upload(Stream &myFile)
 {
+
 #if defined ESP8266
 	yield();
 #endif
-
+	// uint8_t c;
-	// create buffer for read
+	uint8_t timeout = 0;
-	uint8_t buff[4096] = {0};
+	std::string response = "";
-
+	uint8_t sent_bulk_counter = 0;
-	// read all data from server
+	uint8_t file_buf[4096] = {0};
-	while (_undownloadByte > 0 || _undownloadByte == -1)
+	uint32_t offset = 0;
-	{
+	uint32_t _seekByte = 0;
-
+	uint32_t _packets_total_byte = 0;
 	// get available data size
-		size_t size = myFile.available();
+	size_t file_size = myFile.available();
-
+	if (file_size)
-		if (size)
 	{
-			// read up to 2048 byte into the buffer
+		int remainingBlocks = ceil(file_size / 4096);
-			int c = myFile.readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size));
+		int blockSize = 4096;
 
-			// Write the buffered bytes to the nextion. If this fails, return false.
+		while (remainingBlocks > 0)
-			if (!this->upload(buff, c))
 		{
-				return false;
+			file_size = myFile.available();
+			// read up to 4096 byte into the buffer
+			if (_seekByte > 0)
+			{
+				if (file_size > _seekByte)
+				{
+					blockSize = myFile.readBytes(file_buf, _seekByte);
+					file_size = myFile.available();
+					ESP_LOGI(TAG, "Seek file: %" PRIu32 ", left bytes %" PRIu32, _seekByte, file_size);
 				}
 				else
 				{
-				if (_updateProgressCallback)
+					ESP_LOGE(TAG, "File failed seek");
-				{
+					return false;
-					_updateProgressCallback();
 				}
+				blockSize = myFile.readBytes(file_buf, ((file_size > sizeof(file_buf)) ? sizeof(file_buf) : file_size));
+			}
+			else
+				blockSize = myFile.readBytes(file_buf, ((file_size > sizeof(file_buf)) ? sizeof(file_buf) : file_size));
+
+			uartWriteBuf((char*)file_buf, blockSize);
+			// wait for the Nextion to return its 0x05 byte confirming reception and readiness to receive the next packets
+			this->recvRetString(response, 2000, true);
+
+			if (response[0] == 0x08 && response.size() == 5)
+			{ // handle partial upload request
+				remainingBlocks -= 1;
+				_sent_packets_total += blockSize;
+				_packets_total_byte += blockSize;
+				sent_bulk_counter++;
+				if (sent_bulk_counter % 10 == 0)
+				{
+					ESP_LOGI(TAG, "bulk: %i, total bytes %" PRIu32 ", response: %s", sent_bulk_counter, _sent_packets_total, response.c_str());
 				}
 
-			if (_undownloadByte > 0)
+				ESP_LOGE(TAG, "response [%s]",
+						 format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str());
+
+				for (int j = 0; j < 4; ++j)
 				{
-				_undownloadByte -= c;
+					offset += static_cast<uint8_t>(response[j + 1]) << (8 * j);
+					ESP_LOGI(TAG, "Offset : %" PRIu32, offset);
+				}
+				if (offset)
+				{
+					remainingBlocks = ceil((file_size - offset) / blockSize);
+					_seekByte = offset - _packets_total_byte;
+					_packets_total_byte += _seekByte;
 				}
 			}
-		delay(1);
+			else if (response[0] == 0x05)
+			{
+				remainingBlocks -= 1;
+				_sent_packets_total += blockSize;
+				_packets_total_byte += blockSize;
+				sent_bulk_counter++;
+				if (sent_bulk_counter % 10 == 0)
+				{
+					ESP_LOGI(TAG, "bulk: %i, total bytes %" PRIu32 ", response: %s", sent_bulk_counter, _sent_packets_total, response.c_str());
 				}
 
+				ESP_LOGE(TAG, "response [%s]",
+						 format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str());
+				offset += 4096;
+			}
+
+			else
+			{
+				if (timeout >= 2)
+				{
+					ESP_LOGE(TAG, "upload failed, no valid response from display, total bytes send : %" PRIu32, _sent_packets_total);
+					sent_bulk_counter = 0;
+					return false;
+				}
+				timeout++;
+			}
+		}
+		ESP_LOGI(TAG, "upload send last bytes %" PRIu32 ", response: %s", _sent_packets_total, response.c_str());
+		// ESP_LOGI(TAG,"upload finished, total bytes send : %"PRIu32, _sent_packets_total);
+		sent_bulk_counter = 0;
 		return true;
+	}
+	else
+	{
+		ESP_LOGE(TAG, "File failed available");
+		return false;
+	}
 }
 
 void ESPNexUpload::softReset(void)
@@ -475,139 +505,129 @@ void ESPNexUpload::softReset(void)
 void ESPNexUpload::end()
 {
 
+	if (_upload_uart_num == NULL)
+	{
+		return;
+	}
+
 	// wait for the nextion to finish internal processes
-	delay(1600);
+	vTaskDelay(1600 / portTICK_PERIOD_MS);
 
 	// soft reset the nextion
 	this->softReset();
 
 	// end Serial connection
-	((HardwareSerial*)nexSerial)->end();
+	uart_mutex_lock();
+	ESP_ERROR_CHECK(uart_driver_delete(_upload_uart_num));
+	uart_mutex_unlock();
 
 	// reset sent packets counter
-	_sent_packets = 0;
+	//_sent_packets = 0;
+	_sent_packets_total = 0;
 
-	statusMessage = F("upload ok");
+	ESP_LOGI(TAG, "serial connection closed");
-	_printInfoLine(statusMessage + F("\r\n"));
 }
 
 void ESPNexUpload::_setRunningMode(void)
 {
-	String cmd = String("");
+	vTaskDelay(100 / portTICK_PERIOD_MS);
-	delay(100);
+	this->sendCommand("runmod=2");
-	cmd = F("runmod=2");
+	vTaskDelay(60 / portTICK_PERIOD_MS);
-	this->sendCommand(cmd.c_str());
-	delay(60);
 }
 
-bool ESPNexUpload::_echoTest(String input)
+bool ESPNexUpload::_echoTest(std::string input)
 {
-	String cmd = String("");
-	String response = String("");
 
-	cmd = "print \"" + input + "\"";
+	std::string response = "";
+	std::string cmd = "print \"" + input + "\"";
+
 	this->sendCommand(cmd.c_str());
-
 	uint32_t duration_ms = calculateTransmissionTimeMs(cmd) * 2 + 10; // times 2  (send + receive) and 10 ms extra
 	this->recvRetString(response, duration_ms);
 
-	return (response.indexOf(input) != -1);
+	return (response.find(input) != -1);
 }
 
 bool ESPNexUpload::_handlingSleepAndDim(void)
 {
-	String cmd = String("");
+
-	String response = String("");
+	std::string response = "";
 	bool set_sleep = false;
 	bool set_dim = false;
 
-	cmd = F("get sleep");
+	this->sendCommand("get sleep");
-	this->sendCommand(cmd.c_str());
-
 	this->recvRetString(response);
 
 	if (response[0] != 0x71)
 	{
-		statusMessage = F("unknown response from 'get sleep' request");
+		ESP_LOGE(TAG, "unknown response from 'get sleep' request");
-		_printInfoLine(statusMessage);
 		return false;
 	}
 
 	if (response[1] != 0x00)
 	{
-		_printInfoLine(F("sleep enabled"));
+		ESP_LOGD(TAG, "sleep enabled");
 		set_sleep = true;
 	}
 	else
 	{
-		_printInfoLine(F("sleep disabled"));
+		ESP_LOGD(TAG, "sleep disabled");
 	}
 
-	response = String("");
+	this->sendCommand("get dim");
-	cmd = F("get dim");
-	this->sendCommand(cmd.c_str());
-
 	this->recvRetString(response);
 
 	if (response[0] != 0x71)
 	{
-		statusMessage = F("unknown response from 'get dim' request");
+		ESP_LOGE(TAG, "unknown response from 'get dim' request");
-		_printInfoLine(statusMessage);
 		return false;
 	}
 
 	if (response[1] == 0x00)
 	{
-		_printInfoLine(F("dim is 0%, backlight from display is turned off"));
+		ESP_LOGD(TAG, "dim is 0%%, backlight from display is turned off");
 		set_dim = true;
 	}
 	else
 	{
-		_printInfoLine();
+		ESP_LOGD(TAG, "dim %i%%", (uint8_t)response[1]);
-		dbSerialPrint(F("dim "));
-		dbSerialPrint((uint8_t)response[1]);
-		dbSerialPrintln(F("%"));
 	}
 
 	if (!_echoTest("ABC"))
 	{
-		statusMessage = F("echo test in 'handling sleep and dim' failed");
+		ESP_LOGE(TAG, "echo test in 'handling sleep and dim' failed");
-		_printInfoLine(statusMessage);
 		return false;
 	}
 
 	if (set_sleep)
 	{
-		cmd = F("sleep=0");
+		this->sendCommand("sleep=0");
-		this->sendCommand(cmd.c_str());
 		// Unfortunately the display doesn't send any respone on the wake up request (sleep=0)
 		// Let the ESP wait for one second, this is based on serial analyser from Nextion editor V0.58 to Nextion display NX4024T032_011R
 		// This gives the Nextion display some time to wake up
-		delay(1000);
+		vTaskDelay(1000 / portTICK_PERIOD_MS);
 	}
 
 	if (set_dim)
 	{
-		cmd = F("dim=100");
+		this->sendCommand("dim=100");
-		this->sendCommand(cmd.c_str());
+		vTaskDelay(15 / portTICK_PERIOD_MS);
-		delay(15);
 	}
 
 	return true;
 }
 
-void ESPNexUpload::_printSerialData(bool esp_request, String input)
+void ESPNexUpload::_printSerialData(bool esp_request, std::string input)
 {
-
 	char c;
 	if (esp_request)
-		dbSerialPrint(F("ESP     request: "));
+		ESP_LOGI(TAG, "ESP     request: ");
 	else
-		dbSerialPrint(F("Nextion respone: "));
+		ESP_LOGI(TAG, "Nextion respone: ");
 
 	if (input.length() == 0)
 	{
-		dbSerialPrintln(F("none"));
+		ESP_LOGW(TAG, "none");
 		return;
 	}
 
@@ -616,18 +636,15 @@ void ESPNexUpload::_printSerialData(bool esp_request, String input)
 
 		c = input[i];
 		if ((uint8_t)c >= 0x20 && (uint8_t)c <= 0x7E)
-			dbSerialPrint(c);
+			printf("%c", c);
 		else
 		{
-			dbSerialPrint(F("0x"));
+			printf("0x\\%02hhx", c);
-			dbSerialPrintHex(c);
-			dbSerialPrint(F(" "));
 		}
 	}
-	dbSerialPrintln();
 }
 
-uint32_t ESPNexUpload::calculateTransmissionTimeMs(String message)
+uint32_t ESPNexUpload::calculateTransmissionTimeMs(std::string message)
 {
 	// In general, 1 second (s) = 1000 (10^-3) millisecond (ms) or
 	//             1 second (s) = 1000 000 (10^-6) microsecond (us).
@@ -645,13 +662,160 @@ uint32_t ESPNexUpload::calculateTransmissionTimeMs(String message)
 	uint32_t duration_message_us = nr_of_bytes * duration_one_byte_us;
 	uint32_t return_value_ms = duration_message_us / 1000;
 
-	_printInfoLine("calculated transmission time: " + String(return_value_ms) + " ms");
+	ESP_LOGD(TAG, "calculated transmission time: %" PRIu32 " ms", return_value_ms);
 	return return_value_ms;
 }
 
-void ESPNexUpload::_printInfoLine(String line)
+uint32_t ESPNexUpload::uartAvailable()
 {
-	dbSerialPrint(F("Status     info: "));
+	if (_upload_uart_num == NULL)
-	if (line.length() != 0)
+	{
-		dbSerialPrintln(line);
+		return 0;
+	}
+
+	uart_mutex_lock();
+	size_t available;
+	uart_get_buffered_data_len(_upload_uart_num, &available);
+	if (_upload_uart_has_peek)
+		available++;
+	uart_mutex_unlock();
+	return available;
+}
+
+uint8_t ESPNexUpload::uartRead()
+{
+	if (_upload_uart_num == NULL)
+	{
+		return 0;
+	}
+	uint8_t c = 0;
+
+	uart_mutex_lock();
+	if (_upload_uart_has_peek)
+	{
+		_upload_uart_has_peek = false;
+		c = _upload_uart_peek_byte;
+	}
+	else
+	{
+
+		int len = uart_read_bytes(_upload_uart_num, &c, 1, 20 / portTICK_RATE_MS);
+		if (len == 0)
+		{
+			c = 0;
+		}
+	}
+	uart_mutex_unlock();
+	return c;
+}
+
+void ESPNexUpload::uartWrite(uint8_t c)
+{
+	if (_upload_uart_num == NULL)
+	{
+		return;
+	}
+	uart_mutex_lock();
+	uart_write_bytes(_upload_uart_num, &c, 1);
+	uart_mutex_unlock();
+}
+
+void ESPNexUpload::uartWriteBuf(const char *data, size_t len)
+{
+	if (_upload_uart_num == NULL || data == NULL || !len)
+	{
+		return;
+	}
+
+	uart_mutex_lock();
+	uart_write_bytes(_upload_uart_num, data, len);
+	uart_mutex_unlock();
+}
+
+void ESPNexUpload::uartFlushTxOnly()
+{
+
+	bool txOnly = true;
+	if (_upload_uart_num == NULL)
+	{
+		return;
+	}
+
+	uart_mutex_lock();
+	ESP_ERROR_CHECK(uart_wait_tx_done(_upload_uart_num, portMAX_DELAY));
+
+	if (!txOnly)
+	{
+		ESP_ERROR_CHECK(uart_flush_input(_upload_uart_num));
+	}
+	uart_mutex_unlock();
+}
+
+void ESPNexUpload::setBaudrate(uart_port_t uart_num, uint32_t baud_rate, gpio_num_t tx_io_num, gpio_num_t rx_io_num)
+{
+
+	ESP_LOGD(TAG, "installing driver on uart %d with baud rate %d", uart_num, baud_rate);
+
+	_upload_uart_num = uart_num;
+	_upload_baudrate = baud_rate;
+	_upload_tx_io_num = tx_io_num;
+	_upload_rx_io_num = rx_io_num;
+
+	const uart_config_t uart_config = {
+		.baud_rate = (int)baud_rate,
+		.data_bits = UART_DATA_8_BITS,
+		.parity = UART_PARITY_DISABLE,
+		.stop_bits = UART_STOP_BITS_1,
+		.flow_ctrl = UART_HW_FLOWCTRL_DISABLE};
+
+	// Do not change the UART initialization order.
+	// This order was gotten from: https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/uart.html
+
+	ESP_ERROR_CHECK(uart_param_config(uart_num, &uart_config));
+	if (_uart_diver_installed == true)
+	{
+		ESP_LOGD(TAG, "baud rate changed");
+		return;
+	}
+
+	ESP_ERROR_CHECK(uart_set_pin(uart_num, tx_io_num, rx_io_num, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
+	ESP_ERROR_CHECK(uart_driver_install(uart_num,
+										CONFIG_NEX_UART_RECV_BUFFER_SIZE, // Receive buffer size.
+										0,								  // Transmit buffer size.
+										10,								  // Queue size.
+										NULL,							  // Queue pointer.
+										0));							  // Allocation flags.
+	ESP_LOGD(TAG, "driver installed");
+	_uart_diver_installed = true;
+}
+
+std::string ESPNexUpload::str_snprintf(const char *fmt, size_t len, ...) {
+  std::string str;
+  va_list args;
+
+  str.resize(len);
+  va_start(args, len);
+  size_t out_length = vsnprintf(&str[0], len + 1, fmt, args);
+  va_end(args);
+
+  if (out_length < len)
+    str.resize(out_length);
+
+  return str;
+}
+char ESPNexUpload::format_hex_pretty_char(uint8_t v) { return v >= 10 ? 'A' + (v - 10) : '0' + v; }
+std::string ESPNexUpload::format_hex_pretty(const uint8_t *data, size_t length) {
+  if (length == 0)
+    return "";
+  std::string ret;
+  ret.resize(3 * length - 1);
+  for (size_t i = 0; i < length; i++) {
+    ret[3 * i] = format_hex_pretty_char((data[i] & 0xF0) >> 4);
+    ret[3 * i + 1] = format_hex_pretty_char(data[i] & 0x0F);
+    if (i != length - 1)
+      ret[3 * i + 2] = '.';
+  }
+  if (length > 4)
+    return ret + " (" + str_snprintf("%u", 32, length) + ")";
+  return ret;
 }

src/modules/display/Nextion/ESPNexUpload.h

@@ -2,6 +2,15 @@
  * @file NexUpload.h
  * The definition of class NexUpload. 
  * 
+ * 1 - Removed all the Arduino code and replaced it by ESP-IDF
+ * 2 - Removed hard-coded UART configuration, see ESPNexUpload constructor
+ * 3 - Removed statusMessage and the function _printInfoLine
+ * 4 - Removed call-back functionality
+ * 5 - Removed one out of two upload functions
+ * 6 - BugFix in upload function 
+ * @author Machiel Mastenbroek (machiel.mastenbroek@gmail.com)
+ * @date   2022/08/14
+ * @version 0.6.0
  * 
  * 1 - BugFix when display baudrate is diffrent from initial ESP baudrate
  * 2 - Improved debug information
@@ -52,25 +61,27 @@
 
 #ifndef __ESPNEXUPLOAD_H__
 #define __ESPNEXUPLOAD_H__
-#include <functional>
+//#include <iostream>
+#include <string.h>      /* printf, scanf, NULL */
+
+//#include <inttypes.h>
+#include "esp_log.h"
+//#include "freertos/FreeRTOS.h"
+//#include "freertos/task.h"
+//#include "driver/gpio.h"
+#include "driver/uart.h"
+
+//#include "hal/uart_types.h"
 #include <Arduino.h>
 #include <StreamString.h>
 
-#ifdef ESP8266
+#define CONFIG_NEX_UART_RECV_BUFFER_SIZE 256
-#include <SoftwareSerial.h>
-#else
-#include <HardwareSerial.h>
-#include <SoftwareSerial.h>
-#endif
 
 /**
  * @addtogroup CoreAPI 
  * @{ 
  */
 
-// callback template definition
-typedef std::function<void(void)> THandlerFunction;
-
 /**
  *
  * Provides the API for nextion to upload the ftf file.
@@ -78,21 +89,18 @@ typedef std::function<void(void)> THandlerFunction;
 class ESPNexUpload
 {
 public: /* methods */
-    // callback template definition
-    typedef std::function<void(void)> THandlerFunction;
 	
     /**
      * Constructor. 
      * 
-     * @param uint32_t upload_baudrate - set upload baudrate.
      */
-    ESPNexUpload(uint32_t upload_baudrate, int line, int rx, int tx);
+    ESPNexUpload(uart_port_t uart_num, uint32_t baud_rate, gpio_num_t tx_io_num, gpio_num_t rx_io_num);
     
     /**
      * destructor. 
      * 
      */
-    ~ESPNexUpload() {}
+    ~ESPNexUpload(){}
 	
     /**
      * Connect to Nextion over serial
@@ -106,14 +114,7 @@ public: /* methods */
      *
      * @return true if success, false for failure.
      */
-    bool prepareUpload(uint32_t file_size);
+	bool prepareUpload(uint32_t file_size, bool prot);
-
-    /**
-     * set Update Progress Callback. (What to do during update progress)
-     *
-     * @return none
-     */
-    void setUpdateProgressCallback(THandlerFunction value);
     
     /**
      * start update tft file to nextion. 
@@ -124,14 +125,7 @@ public: /* methods */
      */
     bool upload(const uint8_t *file_buf, size_t buf_size);
 
-    /**
-     * start update tft file to nextion.
-     *
-     * @param Stream &myFile
-     * @return true if success, false for failure.
-     */
     bool upload(Stream &myFile);
-
     /**
      * Send reset command to Nextion over serial
      *
@@ -146,10 +140,14 @@ public: /* methods */
      */
 	void end(void);
 	
-public: /* data */
-    String statusMessage = "";
-
 private: /* methods */
+    /*
+     * Semaphore construction to prevent double UART actions
+     *
+     */
+    void uart_mutex_lock(void) {do {} while (xSemaphoreTake(_upload_uart_lock, portMAX_DELAY) != pdPASS);};
+    void uart_mutex_unlock(void) {xSemaphoreGive(_upload_uart_lock);};
+
     /*
      * get communicate baudrate. 
      * 
@@ -165,7 +163,7 @@ private: /* methods */
      *   
      * @return true if success, false for failure. 
      */
-    bool _searchBaudrate(uint32_t baudrate);
+    bool _searchBaudrate(int baudrate);
 
     /*
      * set download baudrate.
@@ -197,7 +195,7 @@ private: /* methods */
 	 * This test is used by the 'upload to Nextion device' feature of the Nextion Editor V0.58
 	 *
      */
-    bool _echoTest(String input);
+    bool _echoTest(std::string input);
     
     /*
      * This function get the sleep and dim value from the Nextion display.
@@ -219,14 +217,7 @@ private: /* methods */
 	 * @param input - string to print
 	 *
      */
-    void _printSerialData(bool esp_request, String input);
+    void _printSerialData(bool esp_request, std::string input);
-
-    /*
-     * This function print a prefix debug line
-     *
-     * @param line: optional debug/ info line
-     */
-    void _printInfoLine(String line = "");
 	
     /*
      * Send command to Nextion.
@@ -237,7 +228,7 @@ private: /* methods */
      *
      * @return none.
      */
-    void sendCommand(const char *cmd, bool tail = true, bool null_head = false);
+    void sendCommand(const char* cmd, bool tail = true, bool null_head = false);
 
     /*
      * Receive string data. 
@@ -249,7 +240,7 @@ private: /* methods */
      * @return the length of string buffer.
      *
      */   
-    uint16_t recvRetString(String &string, uint32_t timeout = 500, bool recv_flag = false);
+    uint16_t recvRetString(std::string &string, uint32_t timeout = 500,bool recv_flag = false);
 
     /*
      * 
@@ -261,25 +252,72 @@ private: /* methods */
      * @return time in us length of string buffer.
      *
      */
-    uint32_t calculateTransmissionTimeMs(String message);
+    uint32_t calculateTransmissionTimeMs(std::string message);
     
-    void nexSerialBegin(uint32_t upload_baudrate, int line, int rx, int tx);
+    /*
+     * Setup UART for communication with display
+     * 
+     * @param uart_num - UART number
+     * @param baud_rate - baud rate speed
+     * @param tx_io_num - GPIO TX pin
+     * @param rx_io_num - GPIO RX pin
+     *
+     */   
+    void setBaudrate(uart_port_t uart_num, uint32_t baud_rate, gpio_num_t tx_io_num, gpio_num_t rx_io_num);
+
+    /*
+     * Check is UART is avaialble
+     */
+    uint32_t uartAvailable();
+
+    /*
+     * Read one RX byte
+     *
+     * @return one received UART byte
+     */
+    uint8_t uartRead();
+
+    /*
+     * Write one TX byte
+     *
+     * @param c - one byte
+     * 
+     */
+    void uartWrite(uint8_t c);
+
+    /*
+     * Write char string
+     *
+     * @param data - char string of data to send 
+     * @param len - length of the string 
+     * 
+     */
+    void uartWriteBuf(const char * data, size_t len);
+
+    /*
+     * Clear TX UART buffer
+     */
+    void uartFlushTxOnly();
 
 private: /* data */ 
+    bool protv2;
     uint32_t _baudrate; 	            /* nextion serail baudrate */
     uint32_t _undownloadByte; 	        /* undownload byte of tft file */
+    uart_port_t _upload_uart_num;       /* upload uart port number */
     uint32_t    _upload_baudrate;       /* upload baudrate */
-    uint16_t _sent_packets = 0; /* upload baudrate */
+    gpio_num_t  _upload_tx_io_num;      /* upload gpio TX */
-    uint8_t _rx;
+    gpio_num_t  _upload_rx_io_num;      /* upload gpio RX */
-    uint8_t _tx;
+    xSemaphoreHandle _upload_uart_lock; /* semaphore to prevent double UART actions */
-    uint8_t _line;
+    bool _upload_uart_has_peek;         /* UART RX peek flag */
-    THandlerFunction _updateProgressCallback;
+    uint8_t _upload_uart_peek_byte;     /* UART RX peek byte */ 
+    //uint16_t _sent_packets = 0;         /* _sent_packets till 4096 bytes */ 
+    uint32_t _sent_packets_total = 0;   /* total number of uploaded display firmware bytes */
+    bool _uart_diver_installed;         /* flag, if true UART is installed */
 
-#ifdef ESP8266
+std::string str_snprintf(const char *fmt, size_t len, ...);
-        SoftwareSerial* nexSerial;
+    /// Format the byte array \p data of length \p len in pretty-printed, human-readable hex.
-#else
+std::string format_hex_pretty(const uint8_t *data, size_t length);
-        Stream* nexSerial;
+static char format_hex_pretty_char(uint8_t v);
-#endif
 };
 /**
  * @}

src/modules/display/Nextion/Nextion.cpp

@@ -14,6 +14,7 @@ private:
     bool _UpTelegram;
     char _inc;
     String _inStr = "";     // буфер приема строк в режимах 0, 1, 2
+    bool _protv2;
 
     // Выводим русские буквы на экран Nextion (преобразуем в кодировку ISO-8859-5)
     String convertRUS(String text)
@@ -65,6 +66,7 @@ public:
         jsonRead(parameters,  "speed", _speed);
         jsonRead(parameters,  "line", _line);
         jsonRead(parameters, "uploadTelegram", _UpTelegram);
+        jsonRead(parameters, "protv2", _protv2);
     }
 
     IoTValue execute(String command, std::vector<IoTValue> &param)
@@ -213,8 +215,7 @@ public:
                 SerialPrint("I", F("NextionUpdate"), "connecting to  " + (String)_host);
                 HTTPClient http;
 #if defined ESP8266
-                WiFiClient client;
+                if (!http.begin(_host, 80, _url))
-                if (!http.begin(client, _host, 80, _url))
                     SerialPrint("I", F("NextionUpdate"), "connection failed  ");
 #elif defined ESP32
                 if (!http.begin(String("http://") + _host + _url))
@@ -269,29 +270,31 @@ public:
         int contentLength = http.getSize();
         SerialPrint("I", F("NextionUpdate"), "File received. Update Nextion...   ");
         bool result;
-        ESPNexUpload nexUp(_speed, _line, _rx, _tx);
+        ESPNexUpload nexUp(_line, _speed, (gpio_num_t)_tx, (gpio_num_t)_rx);
-        nexUp.setUpdateProgressCallback([]()
+  //      nexUp.setUpdateProgressCallback([]()
-                                          { SerialPrint("I", F("NextionUpdate"), "...   "); });
+  //                                        { SerialPrint("I", F("NextionUpdate"), "...   "); });
 
-        result = nexUp.prepareUpload(contentLength);
+        result = nexUp.prepareUpload(contentLength, _protv2);
         if (!result)
         {
-            SerialPrint("I", F("NextionUpdate"), "Error:    " + (String)nexUp.statusMessage);
+            SerialPrint("I", F("NextionUpdate"), "Error Connect in prepare upload");
         }
         else
         {
+            updated = true;
             SerialPrint("I", F("NextionUpdate"), "Start upload. File size is:     " + (String)contentLength);
             result = nexUp.upload(*http.getStreamPtr());
             if (result)
             {
-                updated = true;
+
                 SerialPrint("I", F("NextionUpdate"), "Succesfully updated Nextion!     ");
             }
             else
             {
-                SerialPrint("I", F("NextionUpdate"), "Error updating Nextion:      " + (String)nexUp.statusMessage);
+                SerialPrint("I", F("NextionUpdate"), "Error updating Nextion" );
             }
             nexUp.end();
+            updated = false;
         }
     }
 //---------------------NEXTION-UPDATE---END------------------------

src/modules/display/Nextion/modinfo.json

@@ -17,6 +17,7 @@
       "rx": 16,
       "line": 2,
       "speed": 9600,
+      "protv2": 1,
       "uploadTelegram": 1
     }
   ],
@@ -28,8 +29,8 @@
     "moduleName": "Nextion",
     "moduleVersion": "2.0",
     "usedRam": {
-      "esp32_4mb": 15,
+      "esp32_4mb": 152,
-      "esp8266_4mb": 15
+      "esp8266_4mb": 152
     },
     "title": "Nextion",
     "moduleDesc": "загрузка прошивки в дисплей Nextion. Команда для запуска обновления дисплея: Nextion.Update(); ",
@@ -40,6 +41,7 @@
       "line": "Актуально только для ESP32: номер линии hardUART. =2 rx=16 tx=17, для SoftwarwSerial в ESP32 line = -1",
       "host": "Сервер обновления. Можно использовать LiveServer из VisualCode, указывать ip адрес",
       "url": "файл прошивки экрана, указывать с расширением, например nextion.tft или iotm/test.tft",
+      "protv2": "1-использует быстрый протоколо прошивки v1.2, 0-использует оффициальный протокол прошивки",
       "uploadTelegram": "1 - разрешает прошивать экран через модуль Telegram_v2",
       "btn-uploadServer": "Кнопка загрузки прошивки с сервера LiveServer или другого по ip"
     },
@@ -87,7 +89,12 @@
   },
   "defActive": false,
   "usedLibs": {
-    "esp32*": [],
+    "esp32_4mb": [],
-    "esp82*": []
+    "esp32_4mb3f": [],
+    "esp8266_4mb": [],
+    "esp8266_1mb": [],
+    "esp8266_1mb_ota": [],
+    "esp8285_1mb": [],
+    "esp8285_1mb_ota": []
   }
 }

src/modules/exec/BrokerMQTT/BrokerMQTT.cpp

@@ -125,6 +125,8 @@ namespace _Broker
         }
     }
 
+    bool _debug;
+
     class BrokerMQTT : public IoTItem
     {
     private:
@@ -132,7 +134,7 @@ namespace _Broker
         int _port = 0;
         String _user;
         String _pass;
-        bool _debug;
+        //bool _debug;
         bool _brige;
         String _server;
         String _srvUser;
@@ -152,19 +154,6 @@ namespace _Broker
             jsonRead(parameters, "srvUser", _srvUser);
             jsonRead(parameters, "srvPass", _srvPass);
             jsonRead(parameters, "srvPort", _srvPort);
-
-            if (_brige)
-            {
-                clientMqtt = new PicoMQTT::Client(_server.c_str(), _srvPort, nullptr, _srvUser.c_str(), _srvPass.c_str());
-                if (_debug)
-                {
-                    SerialPrint("i", F("BrigeMQTT"), "Bridge mode : ON");
-                    SerialPrint("i", F("BrigeMQTT"), "Bridge server: " + _server);
-                    SerialPrint("i", F("BrigeMQTT"), "Bridge port: " + String(_srvPort));
-                    SerialPrint("i", F("BrigeMQTT"), "Bridge user: " + _srvUser);
-                    SerialPrint("i", F("BrigeMQTT"), "Bridge pass: " + _srvPass);
-                }
-            }
         }
 
         void doByInterval()
@@ -178,11 +167,30 @@ namespace _Broker
                 picoMqtt->begin();
                 picoMqtt->setDebug(_debug);
                 picoMqtt->setAuth(_user, _pass);
+                if (_brige)
+                {
+                    clientMqtt = new PicoMQTT::Client(_server.c_str(), _srvPort, chipId.c_str(), _srvUser.c_str(), _srvPass.c_str());
+                    clientMqtt->begin();
+                    if (_debug)
+                    {
+                        SerialPrint("i", F("BrigeMQTT"), "Bridge mode : ON");
+                        SerialPrint("i", F("BrigeMQTT"), "Bridge server: " + _server);
+                        SerialPrint("i", F("BrigeMQTT"), "Bridge port: " + String(_srvPort));
+                        SerialPrint("i", F("BrigeMQTT"), "Bridge user: " + _srvUser);
+                        SerialPrint("i", F("BrigeMQTT"), "Bridge pass: " + _srvPass);
+                    }
+                }
                 if (_brige && picoMqtt && clientMqtt)
                 {
                     picoMqtt->subscribe("#", [](const char *topic, const char *message)
                                         { clientMqtt->publish(topic, message);
-                                         SerialPrint("i", F("BrigeMQTT"), "client publish, topic: " + String(topic) + " msg: " + String(message) ); });
+                                    if (_debug)
+                                        SerialPrint("i", F("BrigeMQTT"), "Client publish, topic: " + String(topic) + " msg: " + String(message) ); });
+
+                    clientMqtt->subscribe("#", [](const char *topic, const char *message)
+                                          { picoMqtt->publish(topic, message); 
+                                      if (_debug)
+                                        SerialPrint("i", F("BrigeMQTT"), "Server publish, topic: " + String(topic) + " msg: " + String(message) ); });
                 }
                 // picoMqtt.begin();
                 xTaskCreatePinnedToCore(

src/modules/exec/Telegram_v2/Telegram_v2.cpp

@@ -686,7 +686,7 @@ public:
             {
                 _myBot->sendMessage("ID: " + chipId, _chatID);
                 _myBot->sendMessage("chatID: " + _chatID, _chatID);
-                _myBot->sendMessage("Command: /help - this text \n /all - inline menu get all values \n /allMenu - bottom menu get all values \n /menu - bottom USER menu from scenario \n /get_id - get value by ID \n /set_id_value - set value in ID \n /file_name_type - take file from esp \n /file_type - support file type \n /reboot - reboot esp \n\n send file and write download - \"download\" file to esp \n\n send *.tft file - flash Nextion \n\n send firmware.bin or littltfs.bin - firmware ESP ", _chatID);
+                _myBot->sendMessage("Command: /help - this text \n /all - inline menu get all values \n /allMenu - bottom menu get all values \n /menu - bottom USER menu from scenario \n /get_id - get value by ID \n /set_id_value - set value in ID \n /file_/path/name_type - take file from esp \n /file_type - support file type \n /reboot - reboot esp \n\n send file and write download - \"download\" file to esp \n\n send *.tft file - flash Nextion \n\n send firmware.bin or littltfs.bin - firmware ESP ", _chatID);
             }
         }
         else if (msg.text.indexOf("/reboot") != -1)