Merge pull request #20 from IoTManagerProject/ver4dev

452 исправлен баг пропадания виджетов в приложении

src/EspFileSystem.cpp

@@ -1,7 +1,8 @@
 #include "EspFileSystem.h"
 #include "Global.h"
 
-bool fileSystemInit() {
+bool fileSystemInit()
+{
     if (!FileFS.begin()) {
         SerialPrint(F("E"), F("FS"), F("Init ERROR, may be FS was not flashed"));
         return false;
@@ -10,7 +11,8 @@ bool fileSystemInit() {
     return true;
 }
 
-void globalVarsSync() {
+void globalVarsSync()
+{
     settingsFlashJson = readFile(F("settings.json"), 4096);
     settingsFlashJson.replace("\r\n", "");
 
@@ -18,44 +20,42 @@ void globalVarsSync() {
     valuesFlashJson.replace("\r\n", "");
 
     mqttPrefix = jsonReadStr(settingsFlashJson, F("mqttPrefix"));
-    mqttRootDevice = mqttPrefix + "/" + chipId;
-    jsonWriteStr_(settingsFlashJson, "root", mqttRootDevice);
     jsonWriteStr_(settingsFlashJson, "id", chipId);
 
-    // jsonWriteStr_(errorsHeapJson, "errors_", "");   //метка для парсинга удалить
-    // jsonWriteStr_(ssidListHeapJson, "ssids_", "");  //метка для парсинга удалить
+    mqttRootDevice = mqttPrefix + "/" + chipId;
+
+    // это не используется - удалить в последствии
+    jsonWriteStr_(settingsFlashJson, "root", mqttRootDevice);
 }
 
-// к удалению. не используется
-//  String getParamsJson() {
-//      String json;
-//      serializeJson(*getLocalItemsAsJSON(), json);
-//      jsonWriteStr_(json, "params", "");
-//      return json;
-//  }
-
-void syncSettingsFlashJson() {
+void syncSettingsFlashJson()
+{
     writeFile(F("settings.json"), settingsFlashJson);
 }
 
-void syncValuesFlashJson() {
+void syncValuesFlashJson()
+{
     writeFile(F("values.json"), valuesFlashJson);
 }
 
-const String getChipId() {
-    return String(ESP_getChipId()) + "-" + String(getFlashChipIdNew());  // + "v" + String(FIRMWARE_VERSION);
+const String getChipId()
+{
+    return String(ESP_getChipId()) + "-" + String(getFlashChipIdNew()); // + "v" + String(FIRMWARE_VERSION);
 }
 
-void setChipId() {
+void setChipId()
+{
     chipId = getChipId();
     SerialPrint("i", "System", "id: " + chipId);
 }
 
-const String getUniqueId(const char* name) {
+const String getUniqueId(const char* name)
+{
     return String(name) + getMacAddress();
 }
 
-const String getWebVersion() {
+const String getWebVersion()
+{
     String text = readFile("/index.html", 2000);
     text = selectFromMarkerToMarker(text, "title", 1);
     text = selectFromMarkerToMarker(text, " ", 2);
@@ -64,7 +64,8 @@ const String getWebVersion() {
     return text;
 }
 
-uint32_t ESP_getChipId(void) {
+uint32_t ESP_getChipId(void)
+{
 #ifdef ESP32
     uint32_t id = 0;
     for (uint32_t i = 0; i < 17; i = i + 8) {
@@ -78,7 +79,8 @@ uint32_t ESP_getChipId(void) {
 
 // устарела используем новую функцию ниже
 #ifndef esp32s2_4mb
-uint32_t ESP_getFlashChipId(void) {
+uint32_t ESP_getFlashChipId(void)
+{
 #ifdef ESP32
     // Нет аналогичной (без доп.кода) функций в 32
     // надо использовать другой id - варианты есть
@@ -92,7 +94,8 @@ uint32_t ESP_getFlashChipId(void) {
 // https://github.com/espressif/arduino-esp32/issues/6945#issuecomment-1199900892
 // получение flash ch id из проекта esp easy
 
-uint32_t getFlashChipIdNew() {
+uint32_t getFlashChipIdNew()
+{
     // Cache since size does not change
     static uint32_t flashChipId = 0;
 
@@ -109,14 +112,15 @@ uint32_t getFlashChipIdNew() {
         //    esp_flash_read_id(nullptr, &flashChipId);
 #elif defined(ESP8266)
         flashChipId = ESP.getFlashChipId();
-#endif  // ifdef ESP32
+#endif // ifdef ESP32
     }
     return flashChipId;
 }
 
-const String getMacAddress() {
+const String getMacAddress()
+{
     uint8_t mac[6];
-    char buf[13] = {0};
+    char buf[13] = { 0 };
 #if defined(ESP8266)
     WiFi.macAddress(mac);
     sprintf(buf, MACSTR, MAC2STR(mac));

src/WsServer.cpp

@@ -3,334 +3,339 @@
 extern IoTScenario iotScen;
 
 #ifdef STANDARD_WEB_SOCKETS
-void standWebSocketsInit() {
+void standWebSocketsInit()
+{
     standWebSocket.begin();
     standWebSocket.onEvent(webSocketEvent);
     SerialPrint("i", "WS", "WS server initialized");
 }
 
 void webSocketEvent(uint8_t num, WStype_t type, uint8_t* payload,
-                    size_t length) {
+    size_t length)
+{
     switch (type) {
-        case WStype_ERROR: {
-            Serial.printf("[%u] Error!\n", num);
-        } break;
+    case WStype_ERROR: {
+        Serial.printf("[%u] Error!\n", num);
+    } break;
 
-        case WStype_DISCONNECTED: {
-            Serial.printf("[%u] Disconnected!\n", num);
-        } break;
+    case WStype_DISCONNECTED: {
+        Serial.printf("[%u] Disconnected!\n", num);
+    } break;
 
-        case WStype_CONNECTED: {
-            // IPAddress ip = standWebSocket.remoteIP(num);
-            SerialPrint("i", "WS " + String(num), "WS client connected");
-            if (num >= 3) {
-                SerialPrint("E", "WS", "Too many clients, connection closed!!!");
-                jsonWriteInt(errorsHeapJson, "wse1", 1);
-                standWebSocket.close();
-                standWebSocketsInit();
+    case WStype_CONNECTED: {
+        // IPAddress ip = standWebSocket.remoteIP(num);
+        SerialPrint("i", "WS " + String(num), "WS client connected");
+        if (num >= 3) {
+            SerialPrint("E", "WS", "Too many clients, connection closed!!!");
+            jsonWriteInt(errorsHeapJson, "wse1", 1);
+            standWebSocket.close();
+            standWebSocketsInit();
+        }
+        // Serial.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0],
+        // ip[1], ip[2], ip[3], payload); standWebSocket.sendTXT(num,
+        // "Connected");
+    } break;
+
+    case WStype_TEXT: {
+        bool endOfHeaderFound = false;
+        size_t maxAllowedHeaderSize = 15; // максимальное количество символов заголовка
+        size_t headerLenth = 0;
+        String headerStr;
+        for (size_t i = 0; i <= maxAllowedHeaderSize; i++) {
+            headerLenth++;
+            char s = (char)payload[i];
+            headerStr += s;
+            if (s == '|') {
+                endOfHeaderFound = true;
+                break;
             }
-            // Serial.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0],
-            // ip[1], ip[2], ip[3], payload); standWebSocket.sendTXT(num,
-            // "Connected");
-        } break;
+        }
+        if (!endOfHeaderFound) {
+            SerialPrint("E", "WS " + String(num), "Package without header");
+        }
 
-        case WStype_TEXT: {
-            bool endOfHeaderFound = false;
-            size_t maxAllowedHeaderSize = 15;  // максимальное количество символов заголовка
-            size_t headerLenth = 0;
-            String headerStr;
-            for (size_t i = 0; i <= maxAllowedHeaderSize; i++) {
-                headerLenth++;
-                char s = (char)payload[i];
-                headerStr += s;
-                if (s == '|') {
-                    endOfHeaderFound = true;
-                    break;
-                }
-            }
-            if (!endOfHeaderFound) {
-                SerialPrint("E", "WS " + String(num), "Package without header");
-            }
+        //----------------------------------------------------------------------//
+        // Страница веб интерфейса dashboard
+        //----------------------------------------------------------------------//
 
-            //----------------------------------------------------------------------//
-            // Страница веб интерфейса dashboard
-            //----------------------------------------------------------------------//
+        // публикация всех виджетов
+        if (headerStr == "/|") {
+            sendFileToWsByFrames("/layout.json", "layout", "", num, WEB_SOCKETS_FRAME_SIZE);
+        }
 
-            // публикация всех виджетов
-            if (headerStr == "/|") {
-                sendFileToWsByFrames("/layout.json", "layout", "", num, WEB_SOCKETS_FRAME_SIZE);
-            }
-
-            if (headerStr == "/params|") {
-                // публикация всех статус сообщений при подключении svelte приложения
-                String params = "{}";
-                for (std::list<IoTItem*>::iterator it = IoTItems.begin();
-                     it != IoTItems.end(); ++it) {
-                    if ((*it)->getSubtype() != "Loging") {
-                        if ((*it)->getSubtype() != "LogingDaily") {
-                            if ((*it)->iAmLocal)
-                                jsonWriteStr(params, (*it)->getID(), (*it)->getValue());
-                        }
-                    }
-                }
-                sendStringToWs("params", params, num);
-
-                // генерация события подключения в модулях
-                for (std::list<IoTItem*>::iterator it = IoTItems.begin();
-                     it != IoTItems.end(); ++it) {
-                    if ((*it)->iAmLocal) (*it)->onMqttWsAppConnectEvent();
-                }
-            }
-
-            // отвечаем на запрос графиков
-            if (headerStr == "/charts|") {
-                // обращение к логированию из ядра
-                // отправка данных графиков только в выбранный сокет
-                for (std::list<IoTItem*>::iterator it = IoTItems.begin();
-                     it != IoTItems.end(); ++it) {
-                    // сбрасываем даты графиков
-                    //  if ((*it)->getID().endsWith("-date")) {
-                    //     (*it)->setTodayDate();
-                    // }
-                    if ((*it)->getSubtype() == "Loging" || "LogingDaily") {
-                        (*it)->setPublishDestination(TO_WS, num);
-                        (*it)->publishValue();
+        if (headerStr == "/params|") {
+            // публикация всех статус сообщений при подключении svelte приложения
+            String params = "{}";
+            for (std::list<IoTItem*>::iterator it = IoTItems.begin();
+                 it != IoTItems.end(); ++it) {
+                if ((*it)->getSubtype() != "Loging") {
+                    if ((*it)->getSubtype() != "LogingDaily") {
+                        if ((*it)->iAmLocal)
+                            jsonWriteStr(params, (*it)->getID(), (*it)->getValue());
                     }
                 }
             }
+            sendStringToWs("params", params, num);
 
-            //----------------------------------------------------------------------//
-            // Страница веб интерфейса configutation
-            //----------------------------------------------------------------------//
-
-            // отвечаем данными на запрос страницы
-            if (headerStr == "/config|") {
-                sendFileToWsByFrames("/items.json", "itemsj", "", num, WEB_SOCKETS_FRAME_SIZE);
-                sendFileToWsByFrames("/widgets.json", "widget", "", num, WEB_SOCKETS_FRAME_SIZE);
-                sendFileToWsByFrames("/config.json", "config", "", num, WEB_SOCKETS_FRAME_SIZE);
-                sendFileToWsByFrames("/scenario.txt", "scenar", "", num, WEB_SOCKETS_FRAME_SIZE);
-                sendStringToWs("settin", settingsFlashJson, num);
+            // генерация события подключения в модулях
+            for (std::list<IoTItem*>::iterator it = IoTItems.begin();
+                 it != IoTItems.end(); ++it) {
+                if ((*it)->iAmLocal)
+                    (*it)->onMqttWsAppConnectEvent();
             }
+        }
 
-            // обработка кнопки сохранить
-            if (headerStr == "/gifnoc|") {
-                writeFileUint8tByFrames("config.json", payload, length, headerLenth,
-                                        256);
-            }
-            if (headerStr == "/tuoyal|") {
-                writeFileUint8tByFrames("layout.json", payload, length, headerLenth,
-                                        256);
-            }
-            if (headerStr == "/oiranecs|") {
-                writeFileUint8tByFrames("scenario.txt", payload, length, headerLenth,
-                                        256);
-                clearConfigure();
-                configure("/config.json");
-                iotScen.loadScenario("/scenario.txt");
-                // создаем событие завершения конфигурирования для возможности
-                // выполнения блока кода при загрузке
-                createItemFromNet("onStart", "1", 1);
-            }
-
-            //----------------------------------------------------------------------//
-            // Страница веб интерфейса connection
-            //----------------------------------------------------------------------//
-
-            // отвечаем данными на запрос страницы
-            if (headerStr == "/connection|") {
-                sendStringToWs("settin", settingsFlashJson, num);
-                sendStringToWs("ssidli", ssidListHeapJson, num);
-                sendStringToWs("errors", errorsHeapJson, num);
-                // запуск асинхронного сканирования wifi сетей при переходе на страницу
-                // соединений RouterFind(jsonReadStr(settingsFlashJson,
-                // F("routerssid")));
-            }
-
-            // обработка кнопки сохранить settings.json
-            if (headerStr == "/sgnittes|") {
-                writeUint8tToString(payload, length, headerLenth, settingsFlashJson);
-                writeFileUint8tByFrames("settings.json", payload, length, headerLenth,
-                                        256);
-                sendStringToWs("errors", errorsHeapJson, num);
-                // если не было создано приема данных по udp - то создадим его
-                addThisDeviceToList();
-            }
-
-            // обработка кнопки сохранить настройки mqtt
-            if (headerStr == "/mqtt|") {
-                sendStringToWs("settin", settingsFlashJson,
-                               num);         // отправляем в ответ новые полученные настройки
-                handleMqttStatus(false, 8);  // меняем статус на неопределенный
-                mqttReconnect();             // начинаем переподключение
-                sendStringToWs("errors", errorsHeapJson,
-                               num);  // отправляем что статус неопределен
-                sendStringToWs("ssidli", ssidListHeapJson, num);
-            }
-
-            // запуск асинхронного сканирования wifi сетей при нажатии выпадающего
-            // списка
-            if (headerStr == "/scan|") {
-                std::vector<String> jArray;
-                jsonReadArray(settingsFlashJson, "routerssid", jArray);
-                RouterFind(jArray);
-                sendStringToWs("ssidli", ssidListHeapJson, num);
-            }
-
-            //----------------------------------------------------------------------//
-            // Страница веб интерфейса list
-            //----------------------------------------------------------------------//
-
-            // отвечаем данными на запрос страницы list
-            if (headerStr == "/list|") {
-                sendStringToWs("settin", settingsFlashJson, num);
-                // отправим список устройств в зависимости от того что выбрал user
-                // sendDeviceList(num);
-            }
-
-            // отвечаем на запрос списка устройств (это отдельный запрос который
-            // делает приложение при подключении)
-            if (headerStr == "/devlist|") {
-                // отправим список устройств в зависимости от того что выбрал user
-                sendDeviceList(num);
-            }
-
-            // сохраняем данные листа
-            if (headerStr == "/tsil|") {
-                writeFileUint8tByFrames("devlist.json", payload, length, headerLenth,
-                                        256);
-            }
-
-            //----------------------------------------------------------------------//
-            // Страница веб интерфейса system
-            //----------------------------------------------------------------------//
-
-            // отвечаем данными на запрос страницы
-            if (headerStr == "/system|") {
-                sendStringToWs("errors", errorsHeapJson, num);
-                sendStringToWs("settin", settingsFlashJson, num);
-            }
-
-            //----------------------------------------------------------------------//
-            // Страница веб интерфейса dev
-            //----------------------------------------------------------------------//
-            if (headerStr == "/dev|") {
-                sendStringToWs("errors", errorsHeapJson, num);
-                sendStringToWs("settin", settingsFlashJson, num);
-                sendFileToWsByFrames("/config.json", "config", "", num, WEB_SOCKETS_FRAME_SIZE);
-                sendFileToWsByFrames("/items.json", "itemsj", "", num, WEB_SOCKETS_FRAME_SIZE);
-                // sendFileToWsByFrames("/layout.json", "layout", "", num,
-                // WEB_SOCKETS_FRAME_SIZE);
-            }
-
-            //----------------------------------------------------------------------//
-            // Страница веб интерфейса update
-            //----------------------------------------------------------------------//
-            if (headerStr == "/profile|") {
-                sendFileToWsByFrames("/myProfile.json", "prfile", "", num,
-                                     WEB_SOCKETS_FRAME_SIZE);
-            }
-
-            //----------------------------------------------------------------------//
-            // отдельные команды веб интерфейса
-            //----------------------------------------------------------------------//
-
-            // переписать любое поле в errors json
-            if (headerStr == "/rorre|") {
-                writeUint8tValueToJsonString(payload, length, headerLenth, errorsHeapJson);
-            }
-
-            // команда перезагрузки esp
-            if (headerStr == "/reboot|") {
-                ESP.restart();
-            }
-
-            // команда очистки всех логов esp
-            if (headerStr == "/clean|") {
-                cleanLogs();
-            }
-
-            // команда обновления прошивки esp
-            if (headerStr == "/update|") {
-                String path;
-                writeUint8tToString(payload, length, headerLenth, path);
-                upgrade_firmware(3, path);
-            }
-
-            // Прием команд control c dashboard
-            if (headerStr == "/control|") {
-                String msg;
-                writeUint8tToString(payload, length, headerLenth, msg);
-                String key = selectFromMarkerToMarker(msg, "/", 0);
-                String value = selectFromMarkerToMarker(msg, "/", 1);
-                generateOrder(key, value);
-                SerialPrint("i", F("=>WS"), "Msg from svelte web, WS No: " + String(num) + ", msg: " + msg);
-            }
-
-            if (headerStr == "/tst|") {
-                standWebSocket.sendTXT(num, "/tstr|");
-            }
-
-            // получаем команду посланную из модуля
-            if (headerStr == "/order|") {
-                String json;
-                writeUint8tToString(payload, length, headerLenth, json);
-
-                String id, key, value;
-                jsonRead(json, "id", id);
-                jsonRead(json, "key", key);
-                jsonRead(json, "value", value);
-
-                SerialPrint("i", F("=>WS"), "Msg from module, id: " + id);
-
-                for (std::list<IoTItem*>::iterator it = IoTItems.begin();
-                     it != IoTItems.end(); ++it) {
-                    if ((*it)->getID() == id) {
-                        (*it)->onModuleOrder(key, value);
-                    }
+        // отвечаем на запрос графиков
+        if (headerStr == "/charts|") {
+            // обращение к логированию из ядра
+            // отправка данных графиков только в выбранный сокет
+            for (std::list<IoTItem*>::iterator it = IoTItems.begin();
+                 it != IoTItems.end(); ++it) {
+                // сбрасываем даты графиков
+                //  if ((*it)->getID().endsWith("-date")) {
+                //     (*it)->setTodayDate();
+                // }
+                if ((*it)->getSubtype() == "Loging" || "LogingDaily") {
+                    (*it)->setPublishDestination(TO_WS, num);
+                    (*it)->publishValue();
                 }
             }
+        }
 
-        } break;
+        //----------------------------------------------------------------------//
+        // Страница веб интерфейса configutation
+        //----------------------------------------------------------------------//
 
-        case WStype_BIN: {
-            Serial.printf("[%u] get binary length: %u\n", num, length);
-            // hexdump(payload, length);
-            // standWebSocket.sendBIN(num, payload, length);
-        } break;
+        // отвечаем данными на запрос страницы
+        if (headerStr == "/config|") {
+            sendFileToWsByFrames("/items.json", "itemsj", "", num, WEB_SOCKETS_FRAME_SIZE);
+            sendFileToWsByFrames("/widgets.json", "widget", "", num, WEB_SOCKETS_FRAME_SIZE);
+            sendFileToWsByFrames("/config.json", "config", "", num, WEB_SOCKETS_FRAME_SIZE);
+            sendFileToWsByFrames("/scenario.txt", "scenar", "", num, WEB_SOCKETS_FRAME_SIZE);
+            sendStringToWs("settin", settingsFlashJson, num);
+        }
 
-        case WStype_FRAGMENT_TEXT_START: {
-            Serial.printf("[%u] fragment test start: %u\n", num, length);
-        } break;
+        // обработка кнопки сохранить
+        if (headerStr == "/gifnoc|") {
+            writeFileUint8tByFrames("config.json", payload, length, headerLenth,
+                256);
+        }
+        if (headerStr == "/tuoyal|") {
+            writeFileUint8tByFrames("layout.json", payload, length, headerLenth,
+                256);
+        }
+        if (headerStr == "/oiranecs|") {
+            writeFileUint8tByFrames("scenario.txt", payload, length, headerLenth,
+                256);
+            clearConfigure();
+            configure("/config.json");
+            iotScen.loadScenario("/scenario.txt");
+            // создаем событие завершения конфигурирования для возможности
+            // выполнения блока кода при загрузке
+            createItemFromNet("onStart", "1", 1);
+        }
 
-        case WStype_FRAGMENT_BIN_START: {
-            Serial.printf("[%u] fragment bin start: %u\n", num, length);
-        } break;
+        //----------------------------------------------------------------------//
+        // Страница веб интерфейса connection
+        //----------------------------------------------------------------------//
 
-        case WStype_FRAGMENT: {
-            Serial.printf("[%u] fragment: %u\n", num, length);
-        } break;
+        // отвечаем данными на запрос страницы
+        if (headerStr == "/connection|") {
+            sendFileToWsByFrames("/widgets.json", "widget", "", num, WEB_SOCKETS_FRAME_SIZE);
+            sendFileToWsByFrames("/config.json", "config", "", num, WEB_SOCKETS_FRAME_SIZE);
+            sendStringToWs("settin", settingsFlashJson, num);
+            sendStringToWs("ssidli", ssidListHeapJson, num);
+            sendStringToWs("errors", errorsHeapJson, num);
+            // запуск асинхронного сканирования wifi сетей при переходе на страницу
+            // соединений RouterFind(jsonReadStr(settingsFlashJson,
+            // F("routerssid")));
+        }
 
-        case WStype_FRAGMENT_FIN: {
-            Serial.printf("[%u] fragment finish: %u\n", num, length);
-        } break;
+        // обработка кнопки сохранить settings.json
+        if (headerStr == "/sgnittes|") {
+            writeUint8tToString(payload, length, headerLenth, settingsFlashJson);
+            writeFileUint8tByFrames("settings.json", payload, length, headerLenth, 256);
+            sendStringToWs("errors", errorsHeapJson, num);
+            // если не было создано приема данных по udp - то создадим его
+            addThisDeviceToList();
+        }
 
-        case WStype_PING: {
-            Serial.printf("[%u] ping: %u\n", num, length);
-        } break;
+        // обработка кнопки сохранить настройки mqtt
+        if (headerStr == "/mqtt|") {
+            sendStringToWs("settin", settingsFlashJson,
+                num); // отправляем в ответ новые полученные настройки
+            handleMqttStatus(false, 8); // меняем статус на неопределенный
+            mqttReconnect(); // начинаем переподключение
+            sendStringToWs("errors", errorsHeapJson,
+                num); // отправляем что статус неопределен
+            sendStringToWs("ssidli", ssidListHeapJson, num);
+        }
 
-        case WStype_PONG: {
-            Serial.printf("[%u] pong: %u\n", num, length);
-        } break;
+        // запуск асинхронного сканирования wifi сетей при нажатии выпадающего
+        // списка
+        if (headerStr == "/scan|") {
+            std::vector<String> jArray;
+            jsonReadArray(settingsFlashJson, "routerssid", jArray);
+            RouterFind(jArray);
+            sendStringToWs("ssidli", ssidListHeapJson, num);
+        }
 
-        default: {
-            Serial.printf("[%u] not recognized: %u\n", num, length);
-        } break;
+        //----------------------------------------------------------------------//
+        // Страница веб интерфейса list
+        //----------------------------------------------------------------------//
+
+        // отвечаем данными на запрос страницы list
+        if (headerStr == "/list|") {
+            sendStringToWs("settin", settingsFlashJson, num);
+            // отправим список устройств в зависимости от того что выбрал user
+            // sendDeviceList(num);
+        }
+
+        // отвечаем на запрос списка устройств (это отдельный запрос который
+        // делает приложение при подключении)
+        if (headerStr == "/devlist|") {
+            // отправим список устройств в зависимости от того что выбрал user
+            sendDeviceList(num);
+        }
+
+        // сохраняем данные листа
+        if (headerStr == "/tsil|") {
+            writeFileUint8tByFrames("devlist.json", payload, length, headerLenth,
+                256);
+        }
+
+        //----------------------------------------------------------------------//
+        // Страница веб интерфейса system
+        //----------------------------------------------------------------------//
+
+        // отвечаем данными на запрос страницы
+        if (headerStr == "/system|") {
+            sendStringToWs("errors", errorsHeapJson, num);
+            sendStringToWs("settin", settingsFlashJson, num);
+        }
+
+        //----------------------------------------------------------------------//
+        // Страница веб интерфейса dev
+        //----------------------------------------------------------------------//
+        if (headerStr == "/dev|") {
+            sendStringToWs("errors", errorsHeapJson, num);
+            sendStringToWs("settin", settingsFlashJson, num);
+            sendFileToWsByFrames("/config.json", "config", "", num, WEB_SOCKETS_FRAME_SIZE);
+            sendFileToWsByFrames("/items.json", "itemsj", "", num, WEB_SOCKETS_FRAME_SIZE);
+            // sendFileToWsByFrames("/layout.json", "layout", "", num,
+            // WEB_SOCKETS_FRAME_SIZE);
+        }
+
+        //----------------------------------------------------------------------//
+        // Страница веб интерфейса update
+        //----------------------------------------------------------------------//
+        if (headerStr == "/profile|") {
+            sendFileToWsByFrames("/myProfile.json", "prfile", "", num,
+                WEB_SOCKETS_FRAME_SIZE);
+        }
+
+        //----------------------------------------------------------------------//
+        // отдельные команды веб интерфейса
+        //----------------------------------------------------------------------//
+
+        // переписать любое поле в errors json
+        if (headerStr == "/rorre|") {
+            writeUint8tValueToJsonString(payload, length, headerLenth, errorsHeapJson);
+        }
+
+        // команда перезагрузки esp
+        if (headerStr == "/reboot|") {
+            ESP.restart();
+        }
+
+        // команда очистки всех логов esp
+        if (headerStr == "/clean|") {
+            cleanLogs();
+        }
+
+        // команда обновления прошивки esp
+        if (headerStr == "/update|") {
+            String path;
+            writeUint8tToString(payload, length, headerLenth, path);
+            upgrade_firmware(3, path);
+        }
+
+        // Прием команд control c dashboard
+        if (headerStr == "/control|") {
+            String msg;
+            writeUint8tToString(payload, length, headerLenth, msg);
+            String key = selectFromMarkerToMarker(msg, "/", 0);
+            String value = selectFromMarkerToMarker(msg, "/", 1);
+            generateOrder(key, value);
+            SerialPrint("i", F("=>WS"), "Msg from svelte web, WS No: " + String(num) + ", msg: " + msg);
+        }
+
+        if (headerStr == "/tst|") {
+            standWebSocket.sendTXT(num, "/tstr|");
+        }
+
+        // получаем команду посланную из модуля
+        if (headerStr == "/order|") {
+            String json;
+            writeUint8tToString(payload, length, headerLenth, json);
+
+            String id, key, value;
+            jsonRead(json, "id", id);
+            jsonRead(json, "key", key);
+            jsonRead(json, "value", value);
+
+            SerialPrint("i", F("=>WS"), "Msg from module, id: " + id);
+
+            for (std::list<IoTItem*>::iterator it = IoTItems.begin();
+                 it != IoTItems.end(); ++it) {
+                if ((*it)->getID() == id) {
+                    (*it)->onModuleOrder(key, value);
+                }
+            }
+        }
+
+    } break;
+
+    case WStype_BIN: {
+        Serial.printf("[%u] get binary length: %u\n", num, length);
+        // hexdump(payload, length);
+        // standWebSocket.sendBIN(num, payload, length);
+    } break;
+
+    case WStype_FRAGMENT_TEXT_START: {
+        Serial.printf("[%u] fragment test start: %u\n", num, length);
+    } break;
+
+    case WStype_FRAGMENT_BIN_START: {
+        Serial.printf("[%u] fragment bin start: %u\n", num, length);
+    } break;
+
+    case WStype_FRAGMENT: {
+        Serial.printf("[%u] fragment: %u\n", num, length);
+    } break;
+
+    case WStype_FRAGMENT_FIN: {
+        Serial.printf("[%u] fragment finish: %u\n", num, length);
+    } break;
+
+    case WStype_PING: {
+        Serial.printf("[%u] ping: %u\n", num, length);
+    } break;
+
+    case WStype_PONG: {
+        Serial.printf("[%u] pong: %u\n", num, length);
+    } break;
+
+    default: {
+        Serial.printf("[%u] not recognized: %u\n", num, length);
+    } break;
     }
 }
 
 // публикация статус сообщений в ws (недостаток в том что делаем бродкаст всем
 // клиентам поднятым в свелте!!!)
-void publishStatusWs(const String& topic, const String& data) {
+void publishStatusWs(const String& topic, const String& data)
+{
     String path = mqttRootDevice + "/" + topic;
     String json = "{}";
     jsonWriteStr(json, "status", data);
@@ -339,7 +344,8 @@ void publishStatusWs(const String& topic, const String& data) {
 }
 
 // публикация дополнительных json сообщений в ws
-void publishJsonWs(const String& topic, String& json) {
+void publishJsonWs(const String& topic, String& json)
+{
     String path = mqttRootDevice + "/" + topic;
     jsonWriteStr(json, "topic", path);
     // TO DO отправка полей в веб
@@ -347,7 +353,8 @@ void publishJsonWs(const String& topic, String& json) {
 }
 
 // данные которые мы отправляем в сокеты переодически
-void periodicWsSend() {
+void periodicWsSend()
+{
     sendStringToWs("ssidli", ssidListHeapJson, -1);
     sendStringToWs("errors", errorsHeapJson, -1);
     // отправляем переодичестки только в авто режиме
@@ -357,10 +364,11 @@ void periodicWsSend() {
 }
 
 #ifdef ESP32
-void hexdump(const void* mem, uint32_t len, uint8_t cols = 16) {
+void hexdump(const void* mem, uint32_t len, uint8_t cols = 16)
+{
     const uint8_t* src = (const uint8_t*)mem;
     Serial.printf("\n[HEXDUMP] Address: 0x%08X len: 0x%X (%d)", (ptrdiff_t)src,
-                  len, len);
+        len, len);
     for (uint32_t i = 0; i < len; i++) {
         if (i % cols == 0) {
             Serial.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i);
@@ -374,7 +382,8 @@ void hexdump(const void* mem, uint32_t len, uint8_t cols = 16) {
 #endif
 
 void sendFileToWsByFrames(const String& filename, const String& header,
-                          const String& json, int client_id, size_t frameSize) {
+    const String& json, int client_id, size_t frameSize)
+{
     if (header.length() != 6) {
         SerialPrint("E", "FS", F("wrong header size"));
         return;
@@ -447,7 +456,8 @@ void sendFileToWsByFrames(const String& filename, const String& header,
     file.close();
 }
 
-void sendStringToWs(const String& header, String& payload, int client_id) {
+void sendStringToWs(const String& header, String& payload, int client_id)
+{
     if ((!getNumAPClients() && !isNetworkActive()) || !getNumWSClients()) {
         // standWebSocket.disconnect(); // это и ниже надо сделать при -
         // standWebSocket.close();      // - отключении AP И WiFi(STA), надо менять ядро WiFi. Сейчас не закрывается сессия клиента при пропаже AP И WiFi(STA)
@@ -471,7 +481,8 @@ void sendStringToWs(const String& header, String& payload, int client_id) {
     }
 }
 
-void sendDeviceList(uint8_t num) {
+void sendDeviceList(uint8_t num)
+{
     if (jsonReadInt(settingsFlashJson, F("udps")) != 0) {
         // если включен автопоиск то отдаем список из оперативной памяти
         SerialPrint("i", "FS", "heap list");
@@ -479,11 +490,12 @@ void sendDeviceList(uint8_t num) {
     } else {
         // если выключен автопоиск то отдаем список из флешь памяти
         sendFileToWsByFrames("/devlist.json", "devlis", "", num,
-                             WEB_SOCKETS_FRAME_SIZE);
+            WEB_SOCKETS_FRAME_SIZE);
         SerialPrint("i", "FS", "flash list");
     }
 }
 
-int getNumWSClients() {
+int getNumWSClients()
+{
     return standWebSocket.connectedClients(false);
 }