32 broken

src/Clock.cpp

@@ -0,0 +1,54 @@
+#include "Clock.h"
+
+#include "Utils/TimeUtils.h"
+
+static const char* MODULE = "Clock";
+
+void startTimeSync() {
+    if (!hasTimeSynced()) {
+        pm.info("Start syncing");
+        reconfigTime();
+    }
+}
+
+void setupSntp() {
+    int tzs = getBiasInSeconds();
+    int tzh = tzs / 3600;
+    tzs -= tzh * 3600;
+    int tzm = tzs / 60;
+    tzs -= tzm * 60;
+
+    String ntp = jsonReadStr(configSetupJson, "ntp");
+    pm.info("Setup ntp: " + ntp);
+    char tzstr[64];
+    snprintf(tzstr, sizeof tzstr, "ESPUSER<%+d:%02d:%02d>", tzh, tzm, tzs);
+    return configTime(tzstr, ntp.c_str(), "pool.ntp.org", "time.nist.gov");
+}
+
+void reconfigTime() {
+#ifdef ESP32
+    uint8_t i = 0;
+    struct tm timeinfo;
+    while (!getLocalTime(&timeinfo) && i <= 4) {
+        Serial.print(".");
+        i++;
+        delay(1000);
+    }
+#endif
+
+#ifdef ESP8266
+    setupSntp();
+    uint8_t i = 0;
+    while (!hasTimeSynced() && i < 4) {
+        Serial.print(".");
+        i++;
+        delay(300);
+    }
+#endif
+
+    if (getTimeUnix() != "failed") {
+        pm.info("Time synced " + getDateDigitalFormated() + " " + getTime());
+    } else {
+        pm.error("Failed to obtain");
+    }
+}

src/Cmd.cpp

@@ -549,6 +549,7 @@ void firmwareVersion() {
     choose_widget_and_create(widget_name, page_name, page_number, "any-data", "firmver");
 }
 
+
 //==============================================================================================================================
 //============================выполнение команд (в лупе) по очереди из строки order=============================================
 void handleCMD_loop() {

src/Errors.cpp

@@ -1,25 +0,0 @@
-#include "Errors.h"
-
-static const char *str_info = "Info";
-static const char *str_warn = "Warn";
-static const char *str_error = "Error";
-static const char *str_unknown = "Unknown";
-
-String getErrorLevelStr(ErrorLevel_t level) {
-    const char *ptr;
-    switch (level) {
-        case EL_INFO:
-            ptr = str_info;
-            break;
-        case EL_WARNING:
-            ptr = str_warn;
-            break;
-        case EL_ERROR:
-            ptr = str_error;
-            break;
-        default:
-            ptr = str_unknown;
-            break;
-    }
-    return String(ptr);
-}

src/Global.cpp

@@ -9,6 +9,7 @@ AsyncWebSocket ws;
 //AsyncEventSource events;
 #endif
 
+
 TickerScheduler ts(TEST + 1);
 
 WiFiClient espClient;

src/Init.cpp

@@ -1,14 +1,10 @@
 #include "Global.h"
 
-unsigned long UptimeInterval::_uptime_seconds;
-
-UptimeInterval myUptime(10);
-
 void handle_uptime();
 void handle_statistics();
+void telemetry_init();
 
 void loadConfig() {
-
     configSetupJson = readFile("config.json", 4096);
     configSetupJson.replace(" ", "");
     configSetupJson.replace("\r\n", "");
@@ -81,7 +77,9 @@ void uptime_init() {
             handle_uptime();
         },
         nullptr, true);
+}
 
+void telemetry_init() {
     if (TELEMETRY_UPDATE_INTERVAL) {
         ts.add(
             STATISTICS, TELEMETRY_UPDATE_INTERVAL, [&](void*) {
@@ -92,9 +90,7 @@ void uptime_init() {
 }
 
 void handle_uptime() {
-    if (myUptime.check()) {
-        jsonWriteStr(configSetupJson, "uptime", prettyMillis());
-    }
+    jsonWriteStr(configSetupJson, "uptime", prettyMillis());
 }
 
 void handle_statistics() {

src/Module/Telnet.cpp

@@ -0,0 +1,84 @@
+#include "Module/Telnet.h"
+
+bool Telnet::onInit() {
+    _server = new WiFiServer(_port);
+    _term = new Terminal();
+    _term->enableControlCodes();
+    _term->enableEcho(false);
+    _term->setStream(&_client);
+
+    // _shell = new CommandShell(Cli::get());
+    _shell->setTerm(_term);
+    return true;
+}
+
+void Telnet::onEnd() {
+    delete _server;
+}
+
+bool Telnet::onStart() {
+    _server->begin();
+    _server->setNoDelay(true);
+    return _server->status() != CLOSED;
+}
+
+void Telnet::onStop() {
+    if (hasClient()) {
+        _client.stop();
+    }
+    _server->stop();
+}
+
+bool Telnet::hasClient() { return _client.connected(); }
+
+void Telnet::sendData(const String& data) {
+    if (hasClient()) {
+        _client.write(data.c_str());
+    }
+}
+
+void Telnet::setEventHandler(TelnetEventHandler h) { _eventHandler = h; }
+
+void Telnet::onLoop() {
+    if (_server->hasClient()) {
+        if (!_client) {
+            _client = _server->available();
+        } else {
+            if (!_client.connected()) {
+                _server->stop();
+                _client = _server->available();
+            } else {
+                WiFiClient rejected;
+                rejected = _server->available();
+                rejected.stop();
+            }
+        }
+    }
+
+    if (_lastConnected != hasClient()) {
+        _lastConnected = hasClient();
+        if (_lastConnected) {
+            onConnect();
+        } else {
+            onDisconnect();
+        }
+    }
+
+    if (hasClient() && _shell != nullptr) _shell->loop();
+}
+
+bool Telnet::isShellActive() {
+    return _shell->active();
+}
+
+void Telnet::onConnect() {
+    if (_eventHandler) {
+        _eventHandler(TE_CONNECTED, &_client);
+    }
+}
+
+void Telnet::onDisconnect() {
+    if (_eventHandler) {
+        _eventHandler(TE_DISCONNECTED, nullptr);
+    }
+}

src/Mqtt.cpp

@@ -22,7 +22,7 @@ void MQTT_init() {
                 Serial.println("[VV] WiFi-ok");
                 if (client_mqtt.connected()) {
                     Serial.println("[VV] MQTT-ok");
-                    led_blink("off");
+                    setLedStatus(LED_OFF);
                 } else {
                     MQTT_Connecting();
                     if (!just_load) mqtt_lost_error++;
@@ -31,7 +31,7 @@ void MQTT_init() {
                 Serial.println("[E] Lost WiFi connection");
                 wifi_lost_error++;
                 ts.remove(WIFI_MQTT_CONNECTION_CHECK);
-                StartAPMode();
+                startAPMode();
             }
         },
         nullptr, true);
@@ -58,14 +58,14 @@ boolean MQTT_Connecting() {
     String mqtt_server = jsonReadStr(configSetupJson, "mqttServer");
     if ((mqtt_server != "")) {
         Serial.println("[E] Lost MQTT connection, start reconnecting");
-        led_blink("fast");
+        setLedStatus(LED_FAST);
         client_mqtt.setServer(mqtt_server.c_str(), jsonReadInt(configSetupJson, "mqttPort"));
         if (WiFi.status() == WL_CONNECTED) {
             if (!client_mqtt.connected()) {
                 Serial.println("[V] Connecting to MQTT server commenced");
                 if (client_mqtt.connect(chipId.c_str(), jsonReadStr(configSetupJson, "mqttUser").c_str(), jsonReadStr(configSetupJson, "mqttPass").c_str())) {
                     Serial.println("[VV] MQTT connected");
-                    led_blink("off");
+                    setLedStatus(LED_OFF);
                     client_mqtt.setCallback(callback);
                     client_mqtt.subscribe(jsonReadStr(configSetupJson, "mqttPrefix").c_str());                                  // Для приема получения HELLOW и подтверждения связи
                     client_mqtt.subscribe((jsonReadStr(configSetupJson, "mqttPrefix") + "/" + chipId + "/+/control").c_str());  // Подписываемся на топики control
@@ -77,7 +77,7 @@ boolean MQTT_Connecting() {
                     res = true;
                 } else {
                     Serial.println("[E] try again in " + String(MQTT_RECONNECT_INTERVAL / 1000) + " sec");
-                    led_blink("fast");
+                    setLedStatus(LED_FAST);
                 }
             }
         }

src/Upgrade.cpp

@@ -1,5 +1,5 @@
 #include "Global.h"
-void initUpgrade() {
+void init_updater() {
 #ifdef ESP8266
     if (WiFi.status() == WL_CONNECTED) last_version = getURL("http://91.204.228.124:1100/update/esp8266/version.txt");
 #endif

src/Utils/FileUtils.cpp

@@ -1,18 +1,15 @@
 #include "Utils/FileUtils.h"
+#include "Utils/PrintMessage.h"
 
 static const char* MODULE = "FS";
 
-void printError(const String str) {
-    Serial.printf("[E] [%s] %s\n", MODULE, str.c_str());
-}
-
 const String filepath(const String& filename) {
     return filename.startsWith("/") ? filename : "/" + filename;
 }
 
 bool fileSystemInit() {
     if (!LittleFS.begin()) {
-        printError("init");
+        pm.error("init");
         return false;
     }
     return true;
@@ -20,14 +17,14 @@ bool fileSystemInit() {
 
 void removeFile(const String filename) {
     if (!LittleFS.remove(filepath(filename))) {
-        printError("remove " + filename);
+        pm.error("remove " + filename);
     }
 }
 
 File seekFile(const String filename, size_t position) {
     auto file = LittleFS.open(filepath(filename), "r");
     if (!file) {
-        printError("open " + filename);
+        pm.error("open " + filename);
     }
     // поставим курсор в начало файла
     file.seek(position, SeekSet);

src/Utils/StringUtils.cpp

@@ -61,7 +61,7 @@ uint16_t hexStringToUint16(String hex) {
     }
 }
 
-size_t itemsCount(String str, const String& separator) {
+size_t itemsCount(String str, const String &separator) {
     // если строки поиск нет сразу выход
     if (str.indexOf(separator) == -1) {
         return 0;
@@ -77,7 +77,7 @@ size_t itemsCount(String str, const String& separator) {
     return cnt;
 }
 
-boolean isDigitStr(const String& str) {
+boolean isDigitStr(const String &str) {
     for (size_t i = 0; i < str.length(); i++) {
         if (!isDigit(str.charAt(i))) {
             return false;
@@ -96,3 +96,27 @@ String prettyBytes(size_t size) {
     else
         return String(size / 1024.0 / 1024.0 / 1024.0) + "GB";
 }
+
+static const char *str_info = "I";
+static const char *str_warn = "W";
+static const char *str_error = "E";
+static const char *str_unknown = "?";
+
+String getErrorLevelStr(ErrorLevel_t level) {
+    const char *ptr;
+    switch (level) {
+        case EL_INFO:
+            ptr = str_info;
+            break;
+        case EL_WARNING:
+            ptr = str_warn;
+            break;
+        case EL_ERROR:
+            ptr = str_error;
+            break;
+        default:
+            ptr = str_unknown;
+            break;
+    }
+    return String(ptr);
+}

src/Utils/TimeUtils.cpp

@@ -3,54 +3,33 @@
 #include "Global.h"
 #include "Utils\StringUtils.h"
 
-void Time_Init() {
-    ts.add(
-        TIME_SYNC, 30000, [&](void*) {
-            time_check();
-        },
-        nullptr, true);
+#define ONE_MINUTE_s 60
+#define ONE_HOUR_s 60 * ONE_MINUTE_s
+
+int getBiasInSeconds() {
+    return 3600 * jsonReadStr(configSetupJson, "timezone").toInt();
 }
 
-void time_check() {
-    if (getTimeUnix() == "failed") {
-        Serial.println("[I] Trying to obtain time");
-        reconfigTime();
-    }
+int getBiasInMinutes() {
+    return getBiasInSeconds() / 60;
 }
 
-void reconfigTime() {
-    if (WiFi.status() == WL_CONNECTED) {
-        String ntp = jsonReadStr(configSetupJson, "ntp");
-        configTime(0, 0, ntp.c_str());
-        Serial.println("[I] Time sync");
-#ifdef ESP32
-        uint8_t i = 0;
-        struct tm timeinfo;
-        while (!getLocalTime(&timeinfo) && i <= 4) {
-            Serial.print(".");
-            i++;
-            delay(1000);
-        }
-#endif
-#ifdef ESP8266
-        //uint8_t i = 0;
-        //while (!time(nullptr) && i < 4) {
-        //  Serial.print(".");
-        //  i++;
-        delay(2000);
-        //}
-#endif
-        if (getTimeUnix() != "failed") {
-            Serial.print("[V] Got time = ");
-            Serial.print(getDateDigitalFormated());
-            Serial.print(' ');
-            Serial.println(getTime());
-        } else {
-            Serial.println("[E] Failed to obtain time, retry in 30 sec");
-        }
-    } else {
-        Serial.println("[E] Unable to obtain time");
-    }
+const timezone getTimeZone() {
+    return timezone{getBiasInMinutes(), 0};
+}
+
+time_t getSystemTime() {
+    timeval tv{0, 0};
+    timezone tz = getTimeZone();
+    time_t epoch = 0;
+    if (gettimeofday(&tv, &tz) != -1)
+        epoch = tv.tv_sec;
+    return epoch;
+}
+
+bool hasTimeSynced() {
+    time_t now = time(nullptr);
+    return now > millis();
 }
 
 String getTimeUnix() {
@@ -69,7 +48,7 @@ boolean getUnixTimeStr(String& res) {
 }
 
 String getTime() {
-    time_t now = time(nullptr);  // получаем время с помощью библиотеки time.h
+    time_t now = time(nullptr);
     int zone = 3600 * jsonReadStr(configSetupJson, "timezone").toInt();
     now = now + zone;
     String Time = "";                     // Строка для результатов времени
@@ -80,7 +59,7 @@ String getTime() {
 }
 
 String getTimeWOsec() {
-    time_t now = time(nullptr);  // получаем время с помощью библиотеки time.h
+    time_t now = time(nullptr);
     int zone = 3600 * jsonReadStr(configSetupJson, "timezone").toInt();
     now = now + zone;
     String Time = "";                     // Строка для результатов времени
@@ -91,7 +70,7 @@ String getTimeWOsec() {
 }
 
 String getDate() {
-    time_t now = time(nullptr);  // получаем время с помощью библиотеки time.h
+    time_t now = time(nullptr);
     int zone = 3600 * jsonReadStr(configSetupJson, "timezone").toInt();
     now = now + zone;
     String Data = "";     // Строка для результатов времени
@@ -142,11 +121,11 @@ int timeToMin(String Time) {
     return min;
 }
 
-static const char* TIME_FORMAT PROGMEM = "%2d:%2d:%2d";
-static const char* TIME_FORMAT_WITH_DAYS PROGMEM = "%dd %2d:%2d";
+static const char* TIME_FORMAT PROGMEM = "%02d:%02d:%02d";
+static const char* TIME_FORMAT_WITH_DAYS PROGMEM = "%dd %02d:%02d";
 
 const String prettyMillis(unsigned long time_ms) {
-    unsigned long tmp = time_ms;
+    unsigned long tmp = time_ms / 1000;
     unsigned long seconds;
     unsigned long minutes;
     unsigned long hours;
@@ -156,15 +135,137 @@ const String prettyMillis(unsigned long time_ms) {
 
     minutes = tmp % 60;
     tmp = tmp / 60;
+
     hours = tmp % 24;
     days = tmp / 24;
 
-    char buf[16];
+    char buf[32];
 
     if (days) {
-        sprintf_P(buf, TIME_FORMAT, hours, minutes, seconds);
+        sprintf_P(buf, TIME_FORMAT_WITH_DAYS, days, hours, minutes, seconds);
     } else {
-        sprintf_P(buf, TIME_FORMAT_WITH_DAYS, days, hours, minutes);
+        sprintf_P(buf, TIME_FORMAT, hours, minutes, seconds);
     }
     return String(buf);
 }
+
+int timeZoneInSeconds(const byte timeZone) {
+    int res = 0;
+    switch (constrain(timeZone, 1, 38)) {
+        case 1:
+            res = -12 * ONE_HOUR_s;
+            break;
+        case 2:
+            res = -11 * ONE_HOUR_s;
+            break;
+        case 3:
+            res = -10 * ONE_HOUR_s;
+            break;
+        case 4:
+            res = -9 * ONE_HOUR_s - 30 * ONE_MINUTE_s;
+            break;
+        case 5:
+            res = -9 * ONE_HOUR_s;
+            break;
+        case 6:
+            res = -8 * ONE_HOUR_s;
+            break;
+        case 7:
+            res = -7 * ONE_HOUR_s;
+            break;
+        case 8:
+            res = -6 * ONE_HOUR_s;
+            break;
+        case 9:
+            res = -5 * ONE_HOUR_s;
+            break;
+        case 10:
+            res = -4 * ONE_HOUR_s;
+            break;
+        case 11:
+            res = -3 * ONE_HOUR_s - 30 * ONE_MINUTE_s;
+            break;
+        case 12:
+            res = -3 * ONE_HOUR_s;
+            break;
+        case 13:
+            res = -2 * ONE_HOUR_s;
+            break;
+        case 14:
+            res = -1 * ONE_HOUR_s;
+            break;
+        case 15:
+            res = 0;
+            break;
+        case 16:
+            res = 1 * ONE_HOUR_s;
+            break;
+        case 17:
+            res = 2 * ONE_HOUR_s;
+            break;
+        case 18:
+            res = 3 * ONE_HOUR_s;
+            break;
+        case 19:
+            res = 3 * ONE_HOUR_s + 30 * ONE_MINUTE_s;
+            break;
+        case 20:
+            res = 4 * ONE_HOUR_s;
+            break;
+        case 21:
+            res = 4 * ONE_HOUR_s + 30 * ONE_MINUTE_s;
+            break;
+        case 22:
+            res = 5 * ONE_HOUR_s;
+            break;
+        case 23:
+            res = 5 * ONE_HOUR_s + 30 * ONE_MINUTE_s;
+            break;
+        case 24:
+            res = 5 * ONE_HOUR_s + 45 * ONE_MINUTE_s;
+            break;
+        case 25:
+            res = 6 * ONE_HOUR_s;
+            break;
+        case 26:
+            res = 6 * ONE_HOUR_s + 30 * ONE_MINUTE_s;
+            break;
+        case 27:
+            res = 7 * ONE_HOUR_s;
+            break;
+        case 28:
+            res = 8 * ONE_HOUR_s;
+            break;
+        case 29:
+            res = 8 * ONE_HOUR_s + 45 * ONE_MINUTE_s;
+            break;
+        case 30:
+            res = 9 * ONE_HOUR_s;
+            break;
+        case 31:
+            res = 9 * ONE_HOUR_s + 30 * ONE_MINUTE_s;
+            break;
+        case 32:
+            res = 10 * ONE_HOUR_s;
+            break;
+        case 33:
+            res = 10 * ONE_HOUR_s + 30 * ONE_MINUTE_s;
+            break;
+        case 34:
+            res = 11 * ONE_HOUR_s;
+            break;
+        case 35:
+            res = 12 * ONE_HOUR_s;
+            break;
+        case 36:
+            res = 12 * ONE_HOUR_s + 45 * ONE_MINUTE_s;
+            break;
+        case 37:
+            res = 13 * ONE_HOUR_s;
+            break;
+        case 38:
+            res = 14 * ONE_HOUR_s;
+            break;
+    }
+    return res;
+}

src/Utils/WiFiUtils.cpp

@@ -0,0 +1,108 @@
+#include "Utils/WiFiUtils.h"
+
+static const char* MODULE = "WiFi";
+
+void startSTAMode() {
+    setLedStatus(LED_SLOW);
+    pm.info("STA Mode");
+
+    String ssid = jsonReadStr(configSetupJson, "routerssid");
+    String passwd = jsonReadStr(configSetupJson, "routerpass");
+
+    WiFi.mode(WIFI_STA);
+    if (ssid == "" && passwd == "") {
+        WiFi.begin();
+    } else {
+        if (WiFi.begin(ssid.c_str(), passwd.c_str()) == WL_CONNECT_FAILED) {
+            pm.error("failed on start");
+        }
+    }
+
+    bool keepConnecting = true;
+    uint8_t tries = 20;
+    do {
+        sint8_t connRes = WiFi.waitForConnectResult(1000);
+        switch (connRes) {
+            case WL_NO_SSID_AVAIL: {
+                pm.error("No ssid available");
+                keepConnecting = false;
+            } break;
+            case WL_CONNECTED: {
+                String hostIpStr = WiFi.localIP().toString();
+                pm.info("http://" + hostIpStr);
+                jsonWriteStr(configSetupJson, "ip", hostIpStr);
+                keepConnecting = false;
+            } break;
+            case WL_CONNECT_FAILED: {
+                pm.error("Check credentials");
+                jsonWriteInt(configOptionJson, "pass_status", 1);
+                keepConnecting = false;
+            } break;
+            default:
+                break;
+        }
+    } while (keepConnecting && tries--);
+
+    if (WiFi.status() == WL_CONNECTED) {
+        MQTT_init();
+        setLedStatus(LED_OFF);
+    } else {
+        startAPMode();
+    };
+}
+
+bool startAPMode() {
+    setLedStatus(LED_ON);
+    pm.info("AP Mode");
+
+    String ssid = jsonReadStr(configSetupJson, "apssid");
+    String passwd = jsonReadStr(configSetupJson, "appass");
+
+    WiFi.mode(WIFI_AP);
+
+    WiFi.softAP(ssid.c_str(), passwd.c_str());
+    String hostIpStr = WiFi.softAPIP().toString();
+    pm.info("Host IP: " + hostIpStr);
+    jsonWriteStr(configSetupJson, "ip", hostIpStr);
+
+    ts.add(
+        WIFI_SCAN, 10 * 1000,
+        [&](void*) {
+            String sta_ssid = jsonReadStr(configSetupJson, "routerssid");
+            pm.info("scanning for " + sta_ssid);
+            if (scanWiFi(sta_ssid)) {
+                ts.remove(WIFI_SCAN);
+                startSTAMode();
+            }
+        },
+        nullptr, true);
+
+    return true;
+}
+
+boolean scanWiFi(String ssid) {
+    bool res = false;
+    int8_t n = WiFi.scanComplete();
+    pm.info("scan result: " + String(n, DEC));
+    if (n == -2) {
+        // не было запущено, запускаем
+        pm.info("start scanning");
+        // async, show_hidden
+        WiFi.scanNetworks(true, false);
+    } else if (n == -1) {
+        // все еще выполняется
+        pm.info("scanning in progress");
+    } else if (n == 0) {
+        // не найдена ни одна сеть
+        pm.info("no networks found");
+        WiFi.scanNetworks(true, false);
+    } else if (n > 0) {
+        for (int8_t i = 0; i < n; i++) {
+            if (WiFi.SSID(i) == ssid) {
+                res = true;
+            }
+            pm.info((res ? "*" : "") + String(i, DEC) + ") " + WiFi.SSID(i));
+        }
+    }
+    return res;
+}

src/WiFiUtils.cpp

@@ -1,113 +0,0 @@
-#include "Global.h"
-
-boolean RouterFind(String ssid);
-
-void ROUTER_Connecting() {
-    led_blink("slow");
-
-    WiFi.mode(WIFI_STA);
-
-    byte tries = 20;
-    String _ssid = jsonReadStr(configSetupJson, "routerssid");
-    String _password = jsonReadStr(configSetupJson, "routerpass");
-    //WiFi.persistent(false);
-
-    if (_ssid == "" && _password == "") {
-        WiFi.begin();
-    } else {
-        WiFi.begin(_ssid.c_str(), _password.c_str());
-        Serial.print("ssid: ");
-        Serial.println(_ssid);
-    }
-    // Делаем проверку подключения до тех пор пока счетчик tries
-    // не станет равен нулю или не получим подключение
-    while (--tries && WiFi.status() != WL_CONNECTED) {
-        if (WiFi.status() == WL_CONNECT_FAILED) {
-            Serial.println("[E] password is not correct");
-            tries = 1;
-            jsonWriteInt(configOptionJson, "pass_status", 1);
-        }
-        Serial.print(".");
-        delay(1000);
-    }
-
-    if (WiFi.status() != WL_CONNECTED) {
-        // Если не удалось подключиться запускаем в режиме AP
-        Serial.println("");
-        // WiFi.disconnect(true);
-        StartAPMode();
-
-    } else {
-        // Иначе удалось подключиться отправляем сообщение
-        // о подключении и выводим адрес IP
-        Serial.println("");
-        Serial.println("[V] WiFi connected");
-        Serial.print("[V] IP address: http://");
-        Serial.print(WiFi.localIP());
-        Serial.println("");
-        jsonWriteStr(configSetupJson, "ip", WiFi.localIP().toString());
-        led_blink("off");
-        //add_dev_in_list("dev.txt", chipID, WiFi.localIP().toString());
-        MQTT_init();
-    }
-}
-
-bool StartAPMode() {
-    Serial.println("[I] WiFi AP");
-    WiFi.disconnect();
-
-    WiFi.mode(WIFI_AP);
-
-    String _ssidAP = jsonReadStr(configSetupJson, "apssid");
-    String _passwordAP = jsonReadStr(configSetupJson, "appass");
-    WiFi.softAP(_ssidAP.c_str(), _passwordAP.c_str());
-    IPAddress myIP = WiFi.softAPIP();
-    led_blink("on");
-    Serial.printf("[I] AP IP: %s\n", myIP.toString().c_str());
-    jsonWriteStr(configSetupJson, "ip", myIP.toString());
-
-    //if (jsonReadInt(configOptionJson, "pass_status") != 1) {
-    ts.add(
-        ROUTER_SEARCHING, 10 * 1000, [&](void*) {
-            Serial.println("[I] searching ssid");
-            if (RouterFind(jsonReadStr(configSetupJson, "routerssid"))) {
-                ts.remove(ROUTER_SEARCHING);
-                WiFi.scanDelete();
-                ROUTER_Connecting();
-            }
-        },
-        nullptr, true);
-    //}
-    return true;
-}
-
-boolean RouterFind(String ssid) {
-    bool res = false;
-
-    int8_t n = WiFi.scanComplete();
-    Serial.printf("[I][WIFI] scan result = %d\n", n);
-    if (n == -2) {
-        // не было запущено, запускаем
-        Serial.println("[I][WIFI] start scanning");
-        // async, show_hidden
-        WiFi.scanNetworks(true, false);
-    } else if (n == -1) {
-        // все еще выполняется
-        Serial.println("[I][WIFI] scanning in progress");
-    } else if (n == 0) {
-        // не найдена ни одна сеть
-        Serial.println("[I][WIFI] no wifi stations, start scanning");
-        WiFi.scanNetworks(true, false);
-    } else if (n > 0) {
-        for (int8_t i = 0; i < n; i++) {
-            if (WiFi.SSID(i) == ssid) {
-                WiFi.scanDelete();
-                res = true;
-            } else {
-                Serial.printf("%d) %s;\n", i, WiFi.SSID(i).c_str());
-            }
-        }
-        WiFi.scanDelete();
-    }
-    return res;
-}

src/iot_firmware.cpp

@@ -1,87 +0,0 @@
-#include "Global.h"
-
-void not_async_actions();
-
-void setup() {
-    Serial.begin(115200);
-    Serial.println();
-    Serial.println("--------------started----------------");
-
-    setChipId();
-
-    fileSystemInit();
-
-    loadConfig();
-
-    CMD_init();
-    Serial.println("[V] Commands");
-
-    sensors_init();
-    Serial.println("[V] Sensors");
-
-    All_init();
-    Serial.println("[V] All");
-
-    ROUTER_Connecting();
-    Serial.println("[V] ROUTER_Connecting");
-
-    uptime_init();
-    Serial.println("[V] statistics_init");
-
-    initUpgrade();
-    Serial.println("[V] initUpgrade");
-
-    Web_server_init();
-    Serial.println("[V] Web_server_init");
-
-    web_init();
-    Serial.println("[V] web_init");
-
-    Time_Init();
-    Serial.println("[V] Time_Init");
-
-#ifdef UDP_ENABLED
-    UDP_init();
-    Serial.println("[V] UDP_init");
-#endif
-
-    ts.add(
-        TEST, 10000, [&](void*) {
-            printMemoryStatus("[I] sysinfo ");
-        },
-        nullptr, true);
-
-    just_load = false;
-}
-
-void loop() {
-#ifdef OTA_UPDATES_ENABLED
-    ArduinoOTA.handle();
-#endif
-
-#ifdef WS_enable
-    ws.cleanupClients();
-#endif
-
-    not_async_actions();
-
-    handleMQTT();
-    handleCMD_loop();
-    handleButton();
-    handleScenario();
-#ifdef UDP_ENABLED
-    handleUdp();
-#endif
-    ts.update();
-}
-
-void not_async_actions() {
-    do_mqtt_connection();
-    do_upgrade_url();
-    do_upgrade();
-#ifdef UDP_ENABLED
-    do_udp_data_parse();
-    do_mqtt_send_settings_to_udp();
-#endif
-    do_i2c_scanning();
-}

src/main.cpp

@@ -1,9 +1,111 @@
 #include "Global.h"
 
+void not_async_actions();
+
+static const char* MODULE = "Main";
+
+void setup() {
+    WiFi.setAutoConnect(false);
+    WiFi.persistent(false);
+
+    Serial.begin(115200);
+    Serial.flush();
+    Serial.println();
+    Serial.println("--------------started----------------");
+
+    setChipId();
+
+    pm.info("FS");
+    fileSystemInit();
+
+    pm.info("Config");
+    loadConfig();
+
+    pm.info("Commands");
+    CMD_init();
+
+    pm.info("Sensors");
+    sensors_init();
+
+    pm.info("Init");
+    All_init();
+
+    pm.info("Network");
+    startSTAMode();
+
+    pm.info("Uptime");
+    uptime_init();
+
+    pm.info("Telemery: " + !TELEMETRY_UPDATE_INTERVAL ? "Disabled" : "Enabled");
+    telemetry_init();
+
+    pm.info("Updater");
+    init_updater();
+
+    pm.info("WebServer");
+    Web_server_init();
+
+    pm.info("WebAdmin");
+    web_init();
+
+    pm.info("TimeSync");
+    ts.add(
+        TIME_SYNC, 30000, [&](void*) {
+            startTimeSync();
+        },
+        nullptr, true);
+
+#ifdef UDP_ENABLED
+    UDP_init();
+    pm.info("Broadcast");
+#endif
+    ts.add(
+        TEST, 10000, [&](void*) {
+            printMemoryStatus();
+        },
+        nullptr, true);
+
+    just_load = false;
+}
+
 void saveConfig() {
     writeFile("config.json", configSetupJson);
 }
 
+void loop() {
+#ifdef OTA_UPDATES_ENABLED
+    ArduinoOTA.handle();
+#endif
+
+#ifdef WS_enable
+    ws.cleanupClients();
+#endif
+
+    not_async_actions();
+
+    handleMQTT();
+    handleCMD_loop();
+    handleButton();
+    handleScenario();
+#ifdef UDP_ENABLED
+    handleUdp();
+#endif
+    ts.update();
+}
+
+void not_async_actions() {
+    do_mqtt_connection();
+    do_upgrade_url();
+    do_upgrade();
+
+#ifdef UDP_ENABLED
+    do_udp_data_parse();
+    do_mqtt_send_settings_to_udp();
+#endif
+
+    do_i2c_scanning();
+}
+
 String getURL(const String& urls) {
     String res = "";
     HTTPClient http;
@@ -54,18 +156,27 @@ void setChipId() {
 
 #ifdef ESP8266
 #ifdef LED_PIN
-void led_blink(String satus) {
+
+void setLedStatus(LedStatus_t status) {
     pinMode(LED_PIN, OUTPUT);
-    if (satus == "off") {
-        noTone(LED_PIN);
-        digitalWrite(LED_PIN, HIGH);
+    switch (status) {
+        case LED_OFF:
+            noTone(LED_PIN);
+            digitalWrite(LED_PIN, HIGH);
+            break;
+        case LED_ON:
+            noTone(LED_PIN);
+            digitalWrite(LED_PIN, LOW);
+            break;
+        case LED_SLOW:
+            tone(LED_PIN, 1);
+            break;
+        case LED_FAST:
+            tone(LED_PIN, 20);
+            break;
+        default:
+            break;
     }
-    if (satus == "on") {
-        noTone(LED_PIN);
-        digitalWrite(LED_PIN, LOW);
-    }
-    if (satus == "slow") tone(LED_PIN, 1);
-    if (satus == "fast") tone(LED_PIN, 20);
 }
 #endif
 #endif