diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..65469d13 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +.pio +.vscode/.browse.c_cpp.db* +.vscode/c_cpp_properties.json +.vscode/launch.json +.vscode/ipch +lib/libraies-master + diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 00000000..e80666bf --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,7 @@ +{ + // See http://go.microsoft.com/fwlink/?LinkId=827846 + // for the documentation about the extensions.json format + "recommendations": [ + "platformio.platformio-ide" + ] +} diff --git a/data/config.json b/data/config.json new file mode 100644 index 00000000..139fc773 --- /dev/null +++ b/data/config.json @@ -0,0 +1,37 @@ +{ + "name": "IoTmanager", + "chipID": "", + "apssid": "IoTmanager", + "appass": "", + "routerssid": "rise", + "routerpass": "hostel3333", + "timezone": 1, + "ntp": "pool.ntp.org", + "mqttServer": "91.204.228.124", + "mqttPort": 1883, + "mqttPrefix": "/iotTest", + "mqttUser": "rise", + "mqttPass": "23ri22se32", + "mqttServer2": "", + "mqttPort2": 1883, + "mqttPrefix2": "/iotTest", + "mqttUser2": "", + "mqttPass2": "", + "scen": "1", + "telegramApi": "1416711569:AAEI0j83GmXqwzb_gnK1B0Am0gDwZoJt5xo", + "telegonof": "0", + "teleginput": "0", + "autos": "1", + "weblogin": "admin", + "webpass": "admin", + "MqttIn": "0", + "MqttOut": "0", + "blink": "0", + "oneWirePin": "2", + "serverip": "http://206.189.49.244", + "uart": "0", + "uartS": "9600", + "uartTX": "12", + "uartRX": "13", + "grafmax": "0" +} \ No newline at end of file diff --git a/data/css/build.css.gz b/data/css/build.css.gz new file mode 100644 index 00000000..b62ceaf0 Binary files /dev/null and b/data/css/build.css.gz differ diff --git a/data/dev_conf.txt b/data/dev_conf.txt new file mode 100644 index 00000000..e69de29b diff --git a/data/edit.htm.gz b/data/edit.htm.gz new file mode 100644 index 00000000..5786121f Binary files /dev/null and b/data/edit.htm.gz differ diff --git a/data/favicon.ico b/data/favicon.ico new file mode 100644 index 00000000..50d908fa Binary files /dev/null and b/data/favicon.ico differ diff --git a/data/index.htm.gz b/data/index.htm.gz new file mode 100644 index 00000000..073ff4ab Binary files /dev/null and b/data/index.htm.gz differ diff --git a/data/index.json.gz b/data/index.json.gz new file mode 100644 index 00000000..1ba12d45 Binary files /dev/null and b/data/index.json.gz differ diff --git a/data/items/items.txt b/data/items/items.txt new file mode 100644 index 00000000..3b9d7ca4 --- /dev/null +++ b/data/items/items.txt @@ -0,0 +1,25 @@ +0;button-out;btnid;toggle;Кнопки;Освещение;order;gpio* +0;button-out;btnid;toggle;Кнопки;Освещение;order;gpio;inv[1]* +0;button-out;btnid;toggle;Кнопки;Освещение;order* +0;button-in;btnid;toggle;Кнопки;Освещение;order;gpio;db[20]* +0;pwm-out;pwmid;range;Ползунки;Яркость;order;gpio* +0;inoutput;dgtid;inputDigit;Ввод;Введите#цифру;order* +0;inoutput;tmid;inputTime;Ввод;Введите#время;order* +0;inoutput;txtid;anydata;Вывод;Сигнализация;order* +0;analog-adc;adcid;fillgauge;Сенсоры;Аналоговый;order;pin[0];map[0,1024,0,100];c[1];int[10]* +0;dallas-temp;tmpid;anydataTemp;Сенсоры;Температура;order;pin[2];index[0];int[10]* +0;ultrasonic-cm;cmid;anydata;Сенсоры;Расстояние;order;pin[12,13];map[0,500,0,100];c[1];int[10]* +0;dht;tmpid;anydataTemp;Сенсоры;Температура;1;c[1] +0;dht;humid;anydataHum;Сенсоры;Влажность;2;c[1];pin[2];type[dht11];int[10]* +0;dht;tmpid;anydataTemp;Сенсоры;Температура;1;c[1] +0;dht;humid;anydataHum;Сенсоры;Влажность;2;c[1];pin[2];type[dht22];int[10]* +0;bme280;tmpid;anydataTemp;Сенсоры;Температура;1;c[1] +0;bme280;humid;anydataHum;Сенсоры;Влажность;2;c[1] +0;bme280;prsid;anydataPress;Сенсоры;Давление;3;c[1];addr[0x76];int[10]* +0;bmp280;tmpid;anydataTemp;Сенсоры;Температура;1;c[1] +0;bmp280;prsid;anydataPress;Сенсоры;Давление;3;c[1];addr[0x76];int[10]* +0;impuls-out;impid;na;na;na;order;gpio* +0;count-down;cntid;anydata;Таймер;Обратный#отчет;order* +0;inoutput;txtid;anydata;Вывод;Вывод#uart;order* +0;logging;crtid;chart;Графики;История;order;val[any];int[60];cnt[100]* +0;uptime;uptid;anydataTime;Системные;%name%#uptime;order* \ No newline at end of file diff --git a/data/js/build.chart.js.gz b/data/js/build.chart.js.gz new file mode 100644 index 00000000..654707fd Binary files /dev/null and b/data/js/build.chart.js.gz differ diff --git a/data/js/function.js.gz b/data/js/function.js.gz new file mode 100644 index 00000000..5432e408 Binary files /dev/null and b/data/js/function.js.gz differ diff --git a/data/lang/lang.ru.json b/data/lang/lang.ru.json new file mode 100644 index 00000000..2c089bcb --- /dev/null +++ b/data/lang/lang.ru.json @@ -0,0 +1,39 @@ +{ + "SetDevConf": "Конфигурация устройства", + "SetDevPreset": "Выберите из списка подходящий пресет кофигурации", + + "ButSave":"Сохранить", + "ButMainPage":"Главная", + + + "SetUDPList": "Список других устройств в сети:", + "SetUDPWarn1": "После нажатия на кнопку переформировать список устройств ждите примерно минуту, а затем обновите страницу и список появится вновь", + + "SetUDPUpdateList":"Переформировать список устройств", + "SetUDPUpdatePage":"Обновить страницу", + "SetUDPNameOfDev":"Имя этого устройства:", + "SetUDPDateExchange":"Включить обмен данными между устройствами", + "SetUDPWarn2":"Если обмен данными включен, то устройства будут обмениваться широковещательными пакетами udp для формирования списка устройств и для осуществления посылки настроек mqtt. Данный обмен создает дополнительную нагрузку на wifi сеть.", + + "SetWiFiNameOfDev":"Имя устройства:", + "SetWiFiRouterConnect":"Подключение к WiFi роутеру:", + "SetWiFiAccessPoint":"Точка доступа:", + "SetWiFiWeb":"Логин и пароль web interface:", + "SetWiFiTimeZone":"Временная зона:", + "SetWiFiNTP":"Сервер NTP:", + "SetWiFiWarn1":"Имя устройства должно состоять из английских букв и иметь длинну от 6 до 12 символов", + "SetWiFiWarn2":"После того как вы введете логин пароль от вашего wifi роутера необходимо нажать кнопку сохранить, а затем обязательно нажать кнопку перезагрузить устройство внизу этой страницы", + "SetWiFiWarn3":"Устройство постоянно сканирует сеть на наличие wifi. Если роутер отключен, то устройство автоматически перейдет в режим точки доступа. Когда wifi появится устройство автоматически подключится к роутеру снова, и выключит точку доступа", + "SetWiFiWarn4":"После изменения поля NTP сервер необходимо перезагрузить устройство", + "SetWiFiWarn5":"Светодиод статуса подключения показывает четыре состояния подключения:
1. мигает редко - идет подключение к wifi
2. мигает часто - идет подключение к серверу mqtt
3. горит постоянно - модуль в режиме точки доступа,
4. не горит - модуль подключен к wifi и к mqtt.
Светодиод подключен к gpio2. Если галочка стоит - то использовать этот пин нельзя", + + "SetMQTTServerName":"Имя сервера:", + "SetMQTTPort":"Номер порта:", + "SetMQTTPrefix":"Префикс:", + "SetMQTTUserName":"Имя пользователя:", + "SetMQTTPassword":"Пароль:", + + "SetMQTTSendSettings":"Отправить настройки MQTT с этого устройства на все остальные", + "SetMQTTWarn1":"Обратите внимание что поле префикс может состоять только из одного слова и одного разделителя: /prefix, вариант вида: /prefix1/prefix2 работать не будет. После изменения поля prefix необходимо перезагрузить устройство", + "SetMQTTWarn2":"Прежде чем нажимать на кнопку Отправить настройки MQTT сохрание их, если Вы их меняли. Настройки получат и перезапишут все устройства в локальной сети" +} \ No newline at end of file diff --git a/data/presets/presets.c.txt b/data/presets/presets.c.txt new file mode 100644 index 00000000..f26eb705 --- /dev/null +++ b/data/presets/presets.c.txt @@ -0,0 +1,47 @@ +0;dallas-temp;t1;anydataTemp;Термостат1;Температура;1;pin[2];index[0];int[10] +0;logging;log1;chart;Термостат1;История;2;val[t1];int[60];cnt[100] +0;inoutput;tUp1;inputDigit;Термостат1;Верхний#порог;3 +0;inoutput;tLow1;inputDigit;Термостат1;Нижний#порог;4 +0;button-out;btn1;toggle;Термостат1;Нагрев;5;pin[12]* +0;dallas-temp;t2;anydataTemp;Термостат2;Температура;1;pin[2];index[0];int[10] +0;logging;log2;chart;Термостат2;История;2;val[t2];int[10];cnt[100] +0;inoutput;threshold;inputDigitTemp;Термостат2;Заданная#температура;3 +0;button-out;heater2;toggle;Термостат2;Нагреватель;7;pin[5] +0;inoutput;time21;inputTimeClock;Расписание2;Утренний#период;8 +0;inoutput;threshold1;inputDigitTemp;Расписание2;Температура;9 +0;inoutput;time22;inputTimeClock;Расписание2;Дневной#период;10 +0;inoutput;threshold2;inputDigitTemp;Расписание2;Температура;11 +0;inoutput;time23;inputTimeClock;Расписание2;Вечерний#период;12 +0;inoutput;threshold3;inputDigitTemp;Расписание2;Температура;13 +0;inoutput;time24;inputTimeClock;Расписание2;Ночной#период;14 +0;inoutput;threshold4;inputDigitTemp;Расписание2;Температура;15* +0;dht;t3;anydataTemp;Теплица3;Температура;1;c[1] +0;dht;h3;anydataHum;Теплица3;Влажность;2;c[1];pin[2];type[dht11];int[10] +0;logging;log3;chart;Теплица3;История;3;val[h3];int[60];cnt[100] +0;inoutput;hUp3;inputDigit;Теплица3;Верхний#порог;4 +0;inoutput;hLow3;inputDigit;Теплица3;Нижний#порог;5 +0;button-out;hUp3;toggle;Теплица3;Полив;6;pin[12]* +0;button-out;btn41;toggle;Реле4;Освещение;1;pin[12] +0;button-out;btn42;toggle;Реле4;Освещение;2;pin[13] +0;inoutput;time41;inputTime;Реле4;Введите#время#включения;3 +0;inoutput;time42;inputTime;Реле4;Введите#время#выключения;4* +0;button-out;btn51;toggle;Свет5;Выключить#все;1 +0;button-out;btn52;toggle;Свет5;Гостинная;2;pin[12] +0;button-out;btn53;toggle;Свет5;Спальня;3;pin[13] +0;button-out;btn54;toggle;Свет5;Прихожая;4;pin[14] +0;pwm-out;pwm51;range;Свет5;Яркость;5;pin[15] +0;pwm-out;pwm52;range;Свет5;Яркость;6;pin[16] +0;inoutput;txt5;anydata;Свет5;Статус;7* +0;button-out;button;toggle;Таймер;Освещение;1;pin[12] +0;count-down;count;anydata;Таймер;Обратный#отчет;2 +0;inoutput;input;inputDigit;Таймер;Введите#цифру;3* +0;inoutput;text;anydataAlarm;Сигнализация;Движение:;1 +0;inoutput;time;anydataTime;Сигнализация;Время:;2 +0;button-in;sensor;na;na;na;3;pin[0];db[20] +0;button-out;reset;toggle;Сигнализация;Сбросить;4* +0;button-in;sensor;na;na;na;1;pin[0];db[20] +0;button-out;light;toggle;Освещение;Освещение;2;pin[13] +0;count-down;count;anydata;Освещение;Обратный#отчет;3 +0;inoutput;period;inputDigit;Освещение;Период#включения;4* +0;button-out;light;toggle;Кнопки;Освещение;1;pin[13] +0;button-in;switch;na;na;na;2;pin[0];db[20]* \ No newline at end of file diff --git a/data/presets/presets.s.txt b/data/presets/presets.s.txt new file mode 100644 index 00000000..d0ebb9fb --- /dev/null +++ b/data/presets/presets.s.txt @@ -0,0 +1,84 @@ +t1 > tUp1 +btn1 0 +telegram Гостинная нагрев#выключен +end +t1 < tLow1 +btn1 1 +telegram Гостинная нагрев#включен +end* +t2 > threshold+-2 +heater2 0 +end +t2 < threshold+-2 +heater2 1 +end +timenow = time21 +threshold threshold1 +end +timenow = time22 +threshold threshold2 +end +timenow = time23 +threshold threshold3 +end +timenow = time24 +threshold threshold4 +end* +h3 > hUp3 +hUp3 0 +telegram Теплица полив#выключен +end +h3 < hLow3 +hUp3 1 +telegram Теплица полив#включен +end* +timenow = time41 +btn41 1 +btn42 0 +end +timenow = time42 +btn41 0 +btn42 1 +end* +btn51 = 1 +btn52 1 +btn53 1 +btn54 1 +pwm51 200 +pwm52 800 +txt5 включено +end +btn51 = 0 +btn52 0 +btn53 0 +btn54 0 +pwm51 800 +pwm52 200 +txt5 выключено +end* +button = 1 +count input +end +count = 0 +button 0 +end* +sensor = 1 +text обнаружено +time %date% +telegram often Обнаружено#движение +end +reset = 1 +text не#обнаружено +time %date% +reset 0 +end* +sensor = 1 +light 1 +count period +end +count = 0 +light 0 +end* +switch = 1 +light change +end* \ No newline at end of file diff --git a/data/s.conf.csv b/data/s.conf.csv new file mode 100644 index 00000000..40b35ae1 --- /dev/null +++ b/data/s.conf.csv @@ -0,0 +1 @@ +Удалить;Тип элемента;Id;Виджет;Имя вкладки;Имя виджета;Позиция виджета \ No newline at end of file diff --git a/data/s.scen.txt b/data/s.scen.txt new file mode 100644 index 00000000..ab0c0141 --- /dev/null +++ b/data/s.scen.txt @@ -0,0 +1 @@ +// \ No newline at end of file diff --git a/data/set.dev.json.gz b/data/set.dev.json.gz new file mode 100644 index 00000000..547ae998 Binary files /dev/null and b/data/set.dev.json.gz differ diff --git a/data/set.device.json.gz b/data/set.device.json.gz new file mode 100644 index 00000000..7ed66e68 Binary files /dev/null and b/data/set.device.json.gz differ diff --git a/data/set.manual.json.gz b/data/set.manual.json.gz new file mode 100644 index 00000000..17584676 Binary files /dev/null and b/data/set.manual.json.gz differ diff --git a/data/set.mqtt.json.gz b/data/set.mqtt.json.gz new file mode 100644 index 00000000..f6c1c7c4 Binary files /dev/null and b/data/set.mqtt.json.gz differ diff --git a/data/set.telegram.json.gz b/data/set.telegram.json.gz new file mode 100644 index 00000000..e8810e9b Binary files /dev/null and b/data/set.telegram.json.gz differ diff --git a/data/set.udp.json.gz b/data/set.udp.json.gz new file mode 100644 index 00000000..6091765c Binary files /dev/null and b/data/set.udp.json.gz differ diff --git a/data/set.utilities.json.gz b/data/set.utilities.json.gz new file mode 100644 index 00000000..5356db03 Binary files /dev/null and b/data/set.utilities.json.gz differ diff --git a/data/set.wifi.json.gz b/data/set.wifi.json.gz new file mode 100644 index 00000000..d5cab6bf Binary files /dev/null and b/data/set.wifi.json.gz differ diff --git a/data/widgets/alarm.json b/data/widgets/alarm.json new file mode 100644 index 00000000..e0e636c3 --- /dev/null +++ b/data/widgets/alarm.json @@ -0,0 +1,6 @@ +{ + "widget": "anydata", + "icon": "body", + "color": "red", + "descrColor": "red" +} \ No newline at end of file diff --git a/data/widgets/anydata.json b/data/widgets/anydata.json new file mode 100644 index 00000000..4157b9c9 --- /dev/null +++ b/data/widgets/anydata.json @@ -0,0 +1,5 @@ +{ + "widget": "anydata", + "after": "", + "icon": "" +} \ No newline at end of file diff --git a/data/widgets/anydataAlarm.json b/data/widgets/anydataAlarm.json new file mode 100644 index 00000000..d793d350 --- /dev/null +++ b/data/widgets/anydataAlarm.json @@ -0,0 +1,6 @@ +{ + "widget": "anydata", + "after": "", + "color":"red", + "icon": "walk" +} \ No newline at end of file diff --git a/data/widgets/anydataHum.json b/data/widgets/anydataHum.json new file mode 100644 index 00000000..ebc5b5af --- /dev/null +++ b/data/widgets/anydataHum.json @@ -0,0 +1,5 @@ +{ + "widget": "anydata", + "after": "%", + "icon": "water" +} \ No newline at end of file diff --git a/data/widgets/anydataPress.json b/data/widgets/anydataPress.json new file mode 100644 index 00000000..e67af2c8 --- /dev/null +++ b/data/widgets/anydataPress.json @@ -0,0 +1,5 @@ +{ + "widget": "anydata", + "after": "mm", + "icon": "speedometer" +} \ No newline at end of file diff --git a/data/widgets/anydataTemp.json b/data/widgets/anydataTemp.json new file mode 100644 index 00000000..112da222 --- /dev/null +++ b/data/widgets/anydataTemp.json @@ -0,0 +1,5 @@ +{ + "widget": "anydata", + "after": "°С", + "icon": "thermometer" +} \ No newline at end of file diff --git a/data/widgets/anydataTime.json b/data/widgets/anydataTime.json new file mode 100644 index 00000000..888a40f6 --- /dev/null +++ b/data/widgets/anydataTime.json @@ -0,0 +1,5 @@ +{ + "widget": "anydata", + "after": "", + "icon": "speedometer" + } \ No newline at end of file diff --git a/data/widgets/btn.json b/data/widgets/btn.json new file mode 100644 index 00000000..67dcc0d3 --- /dev/null +++ b/data/widgets/btn.json @@ -0,0 +1,6 @@ +{ + "widget": "btn", + "size": "large", + "color": "green", + "send": "test" +} \ No newline at end of file diff --git a/data/widgets/chart.json b/data/widgets/chart.json new file mode 100644 index 00000000..878ce0e4 --- /dev/null +++ b/data/widgets/chart.json @@ -0,0 +1,5 @@ +{ + "widget": "chart", + "dateFormat": "HH:mm", + "pointRadius": 0 +} \ No newline at end of file diff --git a/data/widgets/chart2.json b/data/widgets/chart2.json new file mode 100644 index 00000000..9ecc61e3 --- /dev/null +++ b/data/widgets/chart2.json @@ -0,0 +1,4 @@ +{ + "widget": "chart", + "dateFormat": "HH:mm" +} \ No newline at end of file diff --git a/data/widgets/fillgauge.json b/data/widgets/fillgauge.json new file mode 100644 index 00000000..34315ea8 --- /dev/null +++ b/data/widgets/fillgauge.json @@ -0,0 +1,7 @@ +{ + "widget": "fillgauge", + "circleColor": "#00FFFF", + "textColor": "#FFFFFF", + "waveTextColor": "#000000", + "waveColor": "#00FFFF" +} \ No newline at end of file diff --git a/data/widgets/inputDate.json b/data/widgets/inputDate.json new file mode 100644 index 00000000..ecc3113d --- /dev/null +++ b/data/widgets/inputDate.json @@ -0,0 +1,6 @@ +{ + "widget" : "input", + "size" : "small", + "color" : "orange", + "type" : "date" +} \ No newline at end of file diff --git a/data/widgets/inputDigit.json b/data/widgets/inputDigit.json new file mode 100644 index 00000000..20196c6a --- /dev/null +++ b/data/widgets/inputDigit.json @@ -0,0 +1,5 @@ +{ + "widget" : "input", + "color" : "blue", + "type" : "number" +} \ No newline at end of file diff --git a/data/widgets/inputDigitTemp.json b/data/widgets/inputDigitTemp.json new file mode 100644 index 00000000..28f19081 --- /dev/null +++ b/data/widgets/inputDigitTemp.json @@ -0,0 +1,7 @@ +{ + "widget" : "input", + "color" : "green", + "type" : "number", + "size" : "small", + "icon": "thermometer" +} \ No newline at end of file diff --git a/data/widgets/inputText.json b/data/widgets/inputText.json new file mode 100644 index 00000000..3484d53b --- /dev/null +++ b/data/widgets/inputText.json @@ -0,0 +1,6 @@ +{ + "widget" : "input", + "size" : "small", + "color" : "orange", + "type" : "text" +} \ No newline at end of file diff --git a/data/widgets/inputTime.json b/data/widgets/inputTime.json new file mode 100644 index 00000000..e39942a4 --- /dev/null +++ b/data/widgets/inputTime.json @@ -0,0 +1,5 @@ +{ + "widget" : "input", + "color" : "blue", + "type" : "time" +} \ No newline at end of file diff --git a/data/widgets/inputTimeClock.json b/data/widgets/inputTimeClock.json new file mode 100644 index 00000000..ab3186f8 --- /dev/null +++ b/data/widgets/inputTimeClock.json @@ -0,0 +1,7 @@ +{ + "widget" : "input", + "color" : "orange", + "type" : "time", + "size" : "small", + "icon": "alarm-outline" +} \ No newline at end of file diff --git a/data/widgets/progress-line.json b/data/widgets/progress-line.json new file mode 100644 index 00000000..b2a95529 --- /dev/null +++ b/data/widgets/progress-line.json @@ -0,0 +1,12 @@ +{ + "widget": "progress-line", + "icon": "sunny", + "descrColor": "", + "color": "", + "max": "100", + "background": "", + "stroke": "10", + "disabled": "", + "before": "", + "after": "" +} \ No newline at end of file diff --git a/data/widgets/progress-round.json b/data/widgets/progress-round.json new file mode 100644 index 00000000..bf3ddae5 --- /dev/null +++ b/data/widgets/progress-round.json @@ -0,0 +1,11 @@ +{ + "widget": "progress-round", + "descrColor": "", + "max": "100", + "stroke": "20", + "color": "#45ccce", + "background": "#777", + "before": "", + "semicircle": "1", + "after": "" +} \ No newline at end of file diff --git a/data/widgets/range.json b/data/widgets/range.json new file mode 100644 index 00000000..4d1e0ff3 --- /dev/null +++ b/data/widgets/range.json @@ -0,0 +1,9 @@ + { + "widget" : "range", + "descrColor": "red", + "after" : "%", + "k" : 0.0977, + "min" : 0, + "max" : 100, + "debounce": 500 +} \ No newline at end of file diff --git a/data/widgets/select.json b/data/widgets/select.json new file mode 100644 index 00000000..bad018fd --- /dev/null +++ b/data/widgets/select.json @@ -0,0 +1,8 @@ +{ + "widget": "select", + "options": [ + "Выключен", + "Включен" + ], + "status": 0 +} \ No newline at end of file diff --git a/data/widgets/toggle.json b/data/widgets/toggle.json new file mode 100644 index 00000000..4e9eed5e --- /dev/null +++ b/data/widgets/toggle.json @@ -0,0 +1,5 @@ +{ + "widget": "toggle", + "icon": "", + "iconOff": "" +} \ No newline at end of file diff --git a/data/widgets/toggleSunMoon.json b/data/widgets/toggleSunMoon.json new file mode 100644 index 00000000..5501aa75 --- /dev/null +++ b/data/widgets/toggleSunMoon.json @@ -0,0 +1,5 @@ +{ + "widget": "toggle", + "icon": "sunny", + "iconOff": "moon" +} \ No newline at end of file diff --git a/data_ungzip/index.json b/data_ungzip/index.json new file mode 100644 index 00000000..a520b982 --- /dev/null +++ b/data_ungzip/index.json @@ -0,0 +1,64 @@ +{ + "configs": [ + "/config.live.json", + "/config.setup.json", + "/lang/lang.ru.json" + ], + "title": "Главная", + "class": "col-sm-offset-1 col-sm-10 col-md-offset-2 col-md-8 col-lg-offset-3 col-lg-6", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "Конфигурация устройства", + "action": "/?set.device", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Конфигурация WIFI", + "action": "/?set.wifi", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Конфигурация MQTT", + "action": "/?set.mqtt", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Конфигурация telegram", + "action": "/?set.telegram", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Утилиты", + "action": "/?set.utilities", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Настройки разработчика", + "action": "/?set.dev", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Скачать приложение IoT Manager для android", + "action": "https://play.google.com/store/apps/details?id=ru.esp8266.iotmanager", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Скачать приложение IoT Manager для iphone", + "action": "https://apps.apple.com/ru/app/iot-manager/id1155934877", + "class": "btn btn-block btn-default" + } + ] +} diff --git a/data_ungzip/set.dev.json b/data_ungzip/set.dev.json new file mode 100644 index 00000000..6a96ef14 --- /dev/null +++ b/data_ungzip/set.dev.json @@ -0,0 +1,75 @@ +{ + "configs": [ + "/config.setup.json", + "/lang/lang.ru.json" + ], + "title": "Конфигурация", + "class": "col-sm-offset-1 col-sm-10 col-md-offset-2 col-md-8 col-lg-offset-3 col-lg-6", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "{{ButMainPage}}", + "action": "/", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "Адрес сервера обновлений" + }, + { + "type": "input", + "title": "ip address", + "name": "serverip-arg", + "state": "{{serverip}}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "action": "set?serverip=[[serverip-arg]]", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "Количество точек графика выгружаемое за раз" + }, + { + "type": "input", + "title": "ip address", + "name": "graf-arg", + "state": "{{grafmax}}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "action": "set?grafmax=[[graf-arg]]", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "name": "reset-block", + "style": "position:fixed;top:50%;left:50%;width:400px;margin-left:-200px;text-align:center;", + "class": "hidden" + }, + { + "type": "button", + "title": "Перезагрузить устройство", + "action": "/set?reqReset", + "response": "[[reset-block]]", + "class": "btn btn-block btn-danger" + } + ] + } \ No newline at end of file diff --git a/data_ungzip/set.device.json b/data_ungzip/set.device.json new file mode 100644 index 00000000..2fe56516 --- /dev/null +++ b/data_ungzip/set.device.json @@ -0,0 +1,261 @@ +{ + "configs": [ + "/config.setup.json", + "/config.option.json", + "/config.live.json", + "/lang/lang.ru.json" + ], + "class": "col-sm-offset-1 col-sm-10", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "{{ButMainPage}}", + "action": "/", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h4", + "title": "ID устройства: {{chipID}}" + }, + { + "type": "h4", + "title": "IP адрес: {{ip}}" + }, + { + "type": "h4", + "title": "Время: {{timenow}}" + }, + { + "type": "h4", + "title": "Uptime: {{uptime}}" + }, + { + "type": "h4", + "title": "Версия прошивки: {{firmware_version}}" + }, + { + "type": "h4", + "title": "Версия файловой системы: 274" + }, + { + "type": "h4", + "title": "{{signal}}" + }, + { + "type": "h4", + "title": "Остаток памяти: {{freeBytes}}" + }, + { + "type": "hr" + }, + { + "type": "text", + "title": "{{warning1}}" + }, + { + "type": "text", + "title": "{{warning2}}" + }, + { + "type": "text", + "title": "{{warning3}}" + }, + { + "type": "hr" + }, + { + "type": "dropdown", + "name": "help-url1", + "class": "btn btn-default", + "style": "display:inline", + "title": { + "#": "Выберите элемент из списка", + "/set?addItem=1": "1.Кнопка управляющая пином", + "/set?addItem=2": "2.Кнопка управляющая пином (с инверсией)", + "/set?addItem=3": "3.Кнопка виртуальная (не привязанная к пину, для использования в сценариях)", + "/set?addItem=4": "4.Кнопка физическая, чтение состояния пина (подключается провдами к устройству)", + "/set?addItem=5": "5.Широтно импульсная модуляция pwm", + "/set?addItem=6": "6.Окно ввода цифровых значений", + "/set?addItem=7": "7.Окно ввода времени", + "/set?addItem=8": "8.Окно вывода любого текста, предупреждения, цифры", + "/set?addItem=9": "9.Датчик аналоговый, чтение аналогового входа", + "/set?addItem=10": "10.Датчик температуры ds18b20", + "/set?addItem=11": "11.Датчик расстояния ультрозвуковой JSN-SR04T, HC-SR04, HY-SRF05", + "/set?addItem=12": "12.Датчик температуры и влажности DHT11", + "/set?addItem=13": "13.Датчик температуры и влажности DHT22, DHT33, DHT44, AM2302, RHT03", + "/set?addItem=14": "14.Датчик температуры, влажности и давления bme280", + "/set?addItem=15": "15.Датчик температуры и давления bmp280", + "/set?addItem=16": "16.Создать импульсы через заданный промежуток времени (управление шд)", + "/set?addItem=17": "17.Таймер обратного отчета", + "/set?addItem=18": "18.Виджет для отображения информации полученной из uart, get-запроса, или по udp", + "/set?addItem=19": "19.Логгирование и вывод в график любой величины", + "/set?addItem=20": "20.Отобразить время работы устройства" + } + }, + { + "type": "dropdown", + "name": "help-url2", + "class": "btn btn-default", + "style": "display:inline", + "title": { + "#": "Выберите пресет из списка", + "/set?addPreset=1": "1.Термостат на основе ds18b20 с оповещением в телеграм", + "/set?addPreset=2": "2.Гистерезис термостат на основе ds18b20 с суточным расписанием", + "/set?addPreset=3": "3.Контроль влажности на основе DHT с оповещением в телеграм", + "/set?addPreset=4": "4.Включение выключение реле в заданное время", + "/set?addPreset=5": "5.Выключить все (пример работы сценариев)", + "/set?addPreset=6": "6.Включить кнопку на определенное время (пример работы таймера обратного отчета)", + "/set?addPreset=7": "7.Охранный датчик движения", + "/set?addPreset=8": "8.Датчик движения включающий свет с настраиваемой задержкой", + "/set?addPreset=9": "9.Управление светом с помощью выключателя и приложения" + } + }, + { + "type": "hr" + }, + { + "type": "csv", + "title": [ + "checkbox", + "html", + "text", + "text", + "text", + "text", + "text" + ], + "state": "s.conf.csv", + "style": "width:100%;", + "action": "/set?saveItems", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "link", + "title": "Удалить выбранные элементы", + "action": "javascript:{send_request(this,'/set?delChoosingItems');setTimeout(function(){location.href='/?set.device' ; }, 1000);}", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Удалить все", + "action": "/set?delAllItems", + "class": "btn btn-block btn-default" + }, + { + "type": "text", + "title": "

После любого изменения таблицы элементов, включая удаление/добавление строк, необходимо нажать кнопку СОХРАНИТЬ ТАБЛИЦУ. Иногда, для корректной работы необходимо перезагрузить устройство после финального завершения его настройки

" + }, + { + "type": "h2", + "title": "Сценарии" + }, + { + "type": "checkbox", + "name": "scen", + "title": "Включить сценарии", + "action": "/set?scen=[[scen]]", + "state": "{{scen}}" + }, + { + "type": "file", + "state": "s.scen.txt", + "style": "width:100%;height:350px", + "title": "Сохранить", + "action": "/set?sceninit", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "checkbox", + "name": "MqttOut", + "title": "Передавать события другим устройствам", + "action": "/set?MqttOut=[[MqttOut]]", + "state": "{{MqttOut}}" + }, + { + "type": "hr" + }, + { + "type": "checkbox", + "name": "MqttIn", + "title": "Принимать события с других устройств", + "action": "/set?MqttIn=[[MqttIn]]", + "state": "{{MqttIn}}" + }, + { + "type": "hr" + }, + { + "type": "button", + "title": "Синхронизировать сценарии на всех устройствах", + "action": "/set?scenMqtt", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "button", + "title": "Очистить графики и введенные данные", + "action": "/set?cleanlog", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Ручная настройка", + "action": "/?set.manual", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "Инструкция к системе автоматизации", + "action": "https://github.com/IoTManagerProject/IoTManager/wiki", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "name": "my-block", + "style": "position:fixed;top:50%;left:50%;width:400px;margin-left:-200px;text-align:center;", + "class": "hidden" + }, + { + "type": "button", + "title": "Обновить прошивку устройства", + "action": "/check", + "response": "[[my-block]]", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "name": "reset-block", + "style": "position:fixed;top:50%;left:50%;width:400px;margin-left:-200px;text-align:center;", + "class": "hidden" + }, + { + "type": "button", + "title": "Перезагрузить устройство", + "action": "/set?reqReset", + "response": "[[reset-block]]", + "class": "btn btn-block btn-danger" + } + ] +} \ No newline at end of file diff --git a/data_ungzip/set.manual.json b/data_ungzip/set.manual.json new file mode 100644 index 00000000..bd3b7ba0 --- /dev/null +++ b/data_ungzip/set.manual.json @@ -0,0 +1,38 @@ +{ + "configs": [ + "/config.setup.json", + "/config.option.json", + "/config.live.json", + "/lang/lang.ru.json" + ], + "class": "col-sm-offset-1 col-sm-10", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "{{ButMainPage}}", + "action": "/", + "class": "btn btn-block btn-default" + }, + { + "type": "file", + "state": "s.conf.csv", + "style": "width:100%;height:350px", + "title": "Сохранить", + "action": "/set?saveItems", + "class": "btn btn-block btn-default" + }, + { + "type": "file", + "state": "s.scen.txt", + "style": "width:100%;height:350px", + "title": "Сохранить", + "action": "/set?sceninit", + "class": "btn btn-block btn-default" + } + ] +} \ No newline at end of file diff --git a/data_ungzip/set.mqtt.json b/data_ungzip/set.mqtt.json new file mode 100644 index 00000000..179f19d6 --- /dev/null +++ b/data_ungzip/set.mqtt.json @@ -0,0 +1,217 @@ +{ + "configs": [ + "/config.setup.json", + "/lang/lang.ru.json" + ], + "class": "col-sm-offset-1 col-sm-10 col-md-offset-2 col-md-8 col-lg-offset-3 col-lg-6", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "{{ButMainPage}}", + "action": "/", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "Основной брокер", + "style": "width:100%;float:left;" + }, + { + "type": "hr" + }, + { + "type": "h4", + "title": "{{SetMQTTServerName}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttServer-arg", + "state": "{{mqttServer}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "{{SetMQTTPort}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttPort-arg", + "state": "{{mqttPort}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "{{SetMQTTPrefix}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttPrefix-arg", + "state": "{{mqttPrefix}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "{{SetMQTTUserName}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttUser-arg", + "state": "{{mqttUser}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "{{SetMQTTPassword}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttPass-arg", + "state": "{{mqttPass}}", + "style": "width:40%;float:right" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "Резервный брокер", + "style": "width:100%;float:left;" + }, + { + "type": "hr" + }, + { + "type": "h4", + "title": "{{SetMQTTServerName}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttServer2-arg", + "state": "{{mqttServer2}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "{{SetMQTTPort}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttPort2-arg", + "state": "{{mqttPort2}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "{{SetMQTTPrefix}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttPrefix2-arg", + "state": "{{mqttPrefix2}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "{{SetMQTTUserName}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttUser2-arg", + "state": "{{mqttUser2}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "{{SetMQTTPassword}}", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "mqttPass2-arg", + "state": "{{mqttPass2}}", + "style": "width:40%;float:right" + }, + { + "type": "h3", + "name": "my-block", + "style": "position:fixed;top:30%;left:50%;width:400px;margin-left:-200px;text-align:center;", + "class": "hidden" + }, + { + "type": "button", + "title": "{{ButSave}}", + "style": "width:100%;float:left;", + "action": "set?mqttServer=[[mqttServer-arg]]&mqttPort=[[mqttPort-arg]]&mqttPrefix=[[mqttPrefix-arg]]&mqttUser=[[mqttUser-arg]]&mqttPass=[[mqttPass-arg]]&mqttServer2=[[mqttServer2-arg]]&mqttPort2=[[mqttPort2-arg]]&mqttPrefix2=[[mqttPrefix2-arg]]&mqttUser2=[[mqttUser2-arg]]&mqttPass2=[[mqttPass2-arg]]", + "class": "btn btn-block btn-default" + }, + + { + "type": "button", + "style": "width:100%;float:left;", + "title": "{{SetMQTTSendSettings}}", + "action": "set?mqttsend", + "class": "btn btn-block btn-default" + }, + { + "type": "button", + "style": "width:100%;float:left;", + "title": "Проверить соединение с MQTT", + "action": "set?mqttcheck", + "response": "[[my-block]]", + "class": "btn btn-block btn-default" + }, + { + "type": "text", + "style": "width:100%;float:left;", + "title": "

{{SetMQTTWarn1}}

" + }, + { + "type": "text", + "style": "width:100%;float:left;", + "title": "

{{SetMQTTWarn2}}

" + }, + { + "type": "hr" + }, + { + "type": "h3", + "name": "reset-block", + "style": "position:fixed;top:50%;left:50%;width:400px;margin-left:-200px;text-align:center;", + "class": "hidden" + }, + { + "type": "button", + "title": "Перезагрузить устройство", + "action": "/set?reqReset", + "response": "[[reset-block]]", + "class": "btn btn-block btn-danger" + } + ] +} \ No newline at end of file diff --git a/data_ungzip/set.telegram.json b/data_ungzip/set.telegram.json new file mode 100644 index 00000000..7b07378c --- /dev/null +++ b/data_ungzip/set.telegram.json @@ -0,0 +1,103 @@ +{ + "configs": [ + "/config.setup.json", + "/lang/lang.ru.json" + ], + "class": "col-sm-offset-1 col-sm-10 col-md-offset-2 col-md-8 col-lg-offset-3 col-lg-6", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "{{ButMainPage}}", + "action": "/", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "checkbox", + "name": "telegonof", + "title": "Включить телеграм", + "action": "/set?telegonof=[[telegonof]]", + "state": "{{telegonof}}" + }, + { + "type": "hr" + }, + { + "type": "checkbox", + "name": "teleginput", + "title": "Включить прием входящих сообщений", + "action": "/set?teleginput=[[teleginput]]", + "state": "{{teleginput}}" + }, + { + "type": "hr" + }, + { + "type": "checkbox", + "name": "autos", + "title": "Автоматически брать chat ID из входящих сообщений", + "action": "/set?autos=[[autos]]", + "state": "{{autos}}" + }, + { + "type": "hr" + }, + { + "type": "h4", + "title": "Telegram chat ID" + }, + { + "type": "input", + "title": "", + "name": "chatId-arg", + "state": "{{chatId}}" + }, + { + "type": "h4", + "title": "Telegram API token" + }, + { + "type": "input", + "title": "", + "name": "telegramApi-arg", + "state": "{{telegramApi}}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "action": "set?telegramApi=[[telegramApi-arg]]&chatId=[[chatId-arg]]", + "class": "btn btn-block btn-default", + "style": "width:100%;display:inline" + }, + { + "type": "hr" + }, + { + "type": "text", + "title": "

После настройки telegram перезагрузите устройство что бы изменения вступили в силу

" + }, + { + "type": "hr" + }, + { + "type": "h3", + "name": "reset-block", + "style": "position:fixed;top:50%;left:50%;width:400px;margin-left:-200px;text-align:center;", + "class": "hidden" + }, + { + "type": "button", + "title": "Перезагрузить устройство", + "action": "/set?reqReset", + "response": "[[reset-block]]", + "class": "btn btn-block btn-danger" + } + ] +} \ No newline at end of file diff --git a/data_ungzip/set.udp.json b/data_ungzip/set.udp.json new file mode 100644 index 00000000..6bea3042 --- /dev/null +++ b/data_ungzip/set.udp.json @@ -0,0 +1,96 @@ +{ + "configs": [ + "/config.setup.json", + "/lang/lang.ru.json" + ], + "title": "Главная", + "class": "col-sm-offset-1 col-sm-10 col-md-offset-2 col-md-8 col-lg-offset-3 col-lg-6", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "{{ButMainPage}}", + "action": "/", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "{{SetUDPList}}" + }, + { + "type": "hr" + }, + { + "type": "csv", + "title": [ + "html", + "html", + "html" + ], + "state": "dev.csv", + "style": "width:100%;", + "class": "nan" + }, + { + "type": "hr" + }, + { + "type": "link", + "title": "{{SetUDPUpdateList}}", + "action": "/set?updatelist", + "class": "btn btn-block btn-default" + }, + { + "type": "link", + "title": "{{SetUDPUpdatePage}}", + "action": "/set?updatepage", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "text", + "title": "

{{SetUDPWarn1}}

", + "style": "width:100%;float:left;" + }, + { + "type": "h3", + "title": "{{SetUDPNameOfDev}}" + }, + { + "type": "input", + "title": "{{SetUDPNameOfDev}}", + "name": "devname-arg", + "state": "{{name}}", + "pattern": "[A-Za-z0-9]{6,12}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "action": "/set?devname=[[devname-arg]]", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "checkbox", + "name": "udponoff", + "title": "{{SetUDPDateExchange}}", + "action": "/set?udponoff=[[udponoff]]", + "state": "{{udponoff}}" + }, + { + "type": "text", + "title": "

{{SetUDPWarn2}}

" + } + ] +} \ No newline at end of file diff --git a/data_ungzip/set.utilities.json b/data_ungzip/set.utilities.json new file mode 100644 index 00000000..16f10037 --- /dev/null +++ b/data_ungzip/set.utilities.json @@ -0,0 +1,109 @@ +{ + "configs": [ + "/config.live.json", + "/config.setup.json", + "/lang/lang.ru.json" + ], + "title": "Главная", + "class": "col-sm-offset-1 col-sm-10 col-md-offset-2 col-md-8 col-lg-offset-3 col-lg-6", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "{{ButMainPage}}", + "action": "/", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "Сканирование шины i2c" + }, + { + "type": "h4", + "title": "{{i2c}}" + }, + { + "type": "link", + "title": "Сканировать", + "action": "/set?i2c", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "UART" + }, + { + "type": "checkbox", + "name": "uart", + "title": "Включить UART", + "action": "/set?uart=[[uart]]", + "state": "{{uart}}" + }, + { + "type": "hr" + }, + { + "type": "checkbox", + "name": "uartEvents", + "title": "Включить отправку всех событий в UART", + "action": "/set?uartEvents=[[uartEvents]]", + "state": "{{uartEvents}}" + }, + { + "type": "hr" + }, + { + "type": "h4", + "title": "Скорость", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "uartS-arg", + "state": "{{uartS}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "Пин TX", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "uartTX-arg", + "state": "{{uartTX}}", + "style": "width:40%;float:right" + }, + { + "type": "h4", + "title": "Пин RX", + "style": "width:60%;float:left;" + }, + { + "type": "input", + "title": "", + "name": "uartRX-arg", + "state": "{{uartRX}}", + "style": "width:40%;float:right" + }, + { + "type": "button", + "title": "{{ButSave}}", + "style": "width:100%;float:left;", + "action": "set?uartS=[[uartS-arg]]&uartTX=[[uartTX-arg]]&uartRX=[[uartRX-arg]]", + "class": "btn btn-block btn-default" + } + ] +} \ No newline at end of file diff --git a/data_ungzip/set.wifi.json b/data_ungzip/set.wifi.json new file mode 100644 index 00000000..01fa46f9 --- /dev/null +++ b/data_ungzip/set.wifi.json @@ -0,0 +1,191 @@ +{ + "configs": [ + "/config.setup.json", + "/lang/lang.ru.json" + ], + "title": "Конфигурация", + "class": "col-sm-offset-1 col-sm-10 col-md-offset-2 col-md-8 col-lg-offset-3 col-lg-6", + "content": [ + { + "type": "h5", + "title": "{{name}}", + "class": "alert-default" + }, + { + "type": "link", + "title": "{{ButMainPage}}", + "action": "/", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "{{SetWiFiNameOfDev}}" + }, + { + "type": "input", + "title": "{{SetWiFiNameOfDev}}", + "name": "devname-arg", + "state": "{{name}}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "action": "set?devname=[[devname-arg]]", + "class": "btn btn-block btn-default" + }, + { + "type": "text", + "title": "

{{SetWiFiWarn1}}

" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "{{SetWiFiRouterConnect}}" + }, + { + "type": "input", + "title": "", + "name": "routerssid-arg", + "state": "{{routerssid}}" + }, + { + "type": "password", + "title": "", + "name": "routerpass-arg", + "state": "{{routerpass}}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "class": "btn btn-block btn-default", + "action": "set?routerssid=[[routerssid-arg]]&routerpass=[[routerpass-arg]]" + }, + { + "type": "text", + "title": "

{{SetWiFiWarn2}}

" + }, + { + "type": "hr" + }, + { + "type": "checkbox", + "name": "blink", + "title": "Включить светодиод статуса подключения", + "action": "/set?blink=[[blink]]", + "state": "{{blink}}" + }, + { + "type": "text", + "title": "

{{SetWiFiWarn5}}

" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "{{SetWiFiAccessPoint}}" + }, + { + "type": "input", + "title": "", + "name": "apssid-arg", + "state": "{{apssid}}", + "pattern": ".{1,20}" + }, + { + "type": "password", + "title": "", + "name": "appass-arg", + "state": "{{appass}}", + "pattern": ".{8,20}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "action": "set?apssid=[[apssid-arg]]&appass=[[appass-arg]]", + "class": "btn btn-block btn-default" + }, + { + "type": "text", + "title": "

{{SetWiFiWarn3}}

" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "{{SetWiFiWeb}}" + }, + { + "type": "input", + "title": "Логин", + "name": "weblogin-arg", + "state": "{{weblogin}}", + "pattern": ".{1,20}" + }, + { + "type": "password", + "title": "Пароль", + "name": "webpass-arg", + "state": "{{webpass}}", + "pattern": ".{1,20}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "action": "set?weblogin=[[weblogin-arg]]&webpass=[[webpass-arg]]", + "class": "btn btn-block btn-default" + }, + { + "type": "hr" + }, + { + "type": "h3", + "title": "{{SetWiFiTimeZone}}" + }, + { + "type": "input", + "title": "", + "name": "timezone-arg", + "state": "{{timezone}}", + "pattern": ".{1,20}" + }, + { + "type": "input", + "title": "", + "name": "ntp-arg", + "state": "{{ntp}}" + }, + { + "type": "button", + "title": "{{ButSave}}", + "action": "set?timezone=[[timezone-arg]]&ntp=[[ntp-arg]]", + "class": "btn btn-block btn-default" + }, + { + "type": "text", + "title": "

{{SetWiFiWarn4}}

" + }, + { + "type": "hr" + }, + { + "type": "h3", + "name": "reset-block", + "style": "position:fixed;top:50%;left:50%;width:400px;margin-left:-200px;text-align:center;", + "class": "hidden" + }, + { + "type": "button", + "title": "Перезагрузить устройство", + "action": "/set?reqReset", + "response": "[[reset-block]]", + "class": "btn btn-block btn-danger" + } + ] +} \ No newline at end of file diff --git a/doc/calculator.xlsx b/doc/calculator.xlsx new file mode 100644 index 00000000..dc077bcd Binary files /dev/null and b/doc/calculator.xlsx differ diff --git a/doc/conf/c001.txt b/doc/conf/c001.txt new file mode 100644 index 00000000..733f4c95 --- /dev/null +++ b/doc/conf/c001.txt @@ -0,0 +1,3 @@ +button 1 5 Включить#реле Реле 0 1 + +//это простая кнопка номер 1 управляющая пином 5 имеющая начальное состояние 0 \ No newline at end of file diff --git a/doc/conf/c002.txt b/doc/conf/c002.txt new file mode 100644 index 00000000..1e54f5dd --- /dev/null +++ b/doc/conf/c002.txt @@ -0,0 +1,6 @@ +inputTime time1 Во#сколько#включить? Таймеры 20-30-00 1 +inputTime time2 Во#сколько#выключить? Таймеры 20-35-00 2 +button 1 5 Кнопка#(по#таймеру) Таймеры 0 3 + +//время в приложение необходимо вводить в строгом формате: ЧЧ-ММ-СС +//можно создавать любое количество таймеров, копируя строку inputTime... \ No newline at end of file diff --git a/doc/conf/c003.txt b/doc/conf/c003.txt new file mode 100644 index 00000000..9f0c5c45 --- /dev/null +++ b/doc/conf/c003.txt @@ -0,0 +1,4 @@ +button 1 5 Вкл#на#время Таймеры 0 1 +inputDigit digit1 Через#сколько#секунд#выключить? Таймеры 5 2 + +//в сценариях можно поменять на sec, min или hours если нужны другие размерности времени \ No newline at end of file diff --git a/doc/conf/c004.txt b/doc/conf/c004.txt new file mode 100644 index 00000000..b0978b0d --- /dev/null +++ b/doc/conf/c004.txt @@ -0,0 +1,3 @@ +button 1 na Включить#все Освещение 0 1 + +//при нажатии на эту кнопку пины номер 5 и 13 поведут себя как установленно в сценариях \ No newline at end of file diff --git a/doc/conf/c005.txt b/doc/conf/c005.txt new file mode 100644 index 00000000..5ef7e5f5 --- /dev/null +++ b/doc/conf/c005.txt @@ -0,0 +1,4 @@ +button 1 13 Включить#реле Реле 0 1 +switch 1 0 10 + +//можно управлять реле на пине 13 кнопкой на пине 0 или кнопкой в приложении \ No newline at end of file diff --git a/doc/conf/c006.txt b/doc/conf/c006.txt new file mode 100644 index 00000000..db812455 --- /dev/null +++ b/doc/conf/c006.txt @@ -0,0 +1,6 @@ +button 1 5 Включить#все Реле 0 1 + + +//что бы использовать эту конфигурацию на другой esp необходимо активировать пресет +//"Вкл. выкл. локального реле", затем в сценарии данного модуля подставить Device ID +//того esp, кнопка на этом девайсе будет выключать другие устройства по воздуху \ No newline at end of file diff --git a/doc/conf/c007.txt b/doc/conf/c007.txt new file mode 100644 index 00000000..739a1424 --- /dev/null +++ b/doc/conf/c007.txt @@ -0,0 +1,6 @@ +switch 1 0 10 + +//что бы использовать эту конфигурацию на другой esp необходимо активировать пресет +//"Вкл. выкл. локального реле", затем в сценарии данного модуля подставить Device ID +//того esp, к данному модулю нужно подключить кнопку к пину 0 и тогда +//один девайс будет управлять другим по воздуху \ No newline at end of file diff --git a/doc/conf/c008.txt b/doc/conf/c008.txt new file mode 100644 index 00000000..09eef72c --- /dev/null +++ b/doc/conf/c008.txt @@ -0,0 +1,6 @@ +pwm 1 3 Яркость#коредор: Реле 1023 1 +pwm 2 4 Яркость#ванная: Реле 510 2 + +//в приложении появятся ползунки, соответствующее значение pwm +//будет установленно на пинах 3 и 4 +//1023 и 510 это начальные значения после загрузки модуля \ No newline at end of file diff --git a/doc/conf/c009.txt b/doc/conf/c009.txt new file mode 100644 index 00000000..496b4761 --- /dev/null +++ b/doc/conf/c009.txt @@ -0,0 +1,7 @@ +dhtT t 2 dht11 Температура#DHT,#t°C Датчики anydata 1 +dhtH h 2 dht11 Влажность#DHT,#t°C Датчики anydata 2 +dhtComfort Степень#комфорта: Датчики 3 +dhtPerception Восприятие: Датчики 4 +dhtDewpoint Точка#росы: Датчики 5 +logging t 1 50 Температура Датчики 6 +logging h 1 50 Влажность Датчики 7 \ No newline at end of file diff --git a/doc/conf/c010.txt b/doc/conf/c010.txt new file mode 100644 index 00000000..0972be00 --- /dev/null +++ b/doc/conf/c010.txt @@ -0,0 +1,7 @@ +dhtT t 2 dht22 Температура#DHT,#t°C Датчики anydata 1 +dhtH h 2 dht22 Влажность#DHT,#t°C Датчики anydata 2 +dhtComfort Степень#комфорта: Датчики 3 +dhtPerception Восприятие: Датчики 4 +dhtDewpoint Точка#росы: Датчики 5 +logging t 1 50 Температура Датчики 6 +logging h 1 50 Влажность Датчики 7 \ No newline at end of file diff --git a/doc/conf/c011.txt b/doc/conf/c011.txt new file mode 100644 index 00000000..acf8f5e3 --- /dev/null +++ b/doc/conf/c011.txt @@ -0,0 +1,8 @@ +analog adc 0 Аналоговый#вход,#% Датчики progress-round 310 620 1 100 1 +logging adc 5 100 Аналоговый#вход Датчики 2 + +//если датчик углекислого газа выдает напряжение от 1 вольта до 2 вольт, то значит +//значение чтения аналогового входа будут примерно равным +//при 1 вольте - 310, а при 2 вольтах - 620 (считаем по пропорции) +//данная строка переведет диапазон 310-620 в диапазон 1-100 и отобразит в приложении +//варианты отображения: anydata, progress-round, progress-line, fillgauge diff --git a/doc/conf/c012.txt b/doc/conf/c012.txt new file mode 100644 index 00000000..3793a877 --- /dev/null +++ b/doc/conf/c012.txt @@ -0,0 +1,6 @@ +bmp280T temp1 0x76 Температура#bmp280 Датчики anydata 1 +bmp280P press1 0x76 Давление#bmp280 Датчики anydata 2 +logging temp1 1 100 Температура Датчики 3 +logging press1 1 100 Давление Датчики 4 + +//Чтение и логгирование датчика bmp280. Датчик подключается к шине i2c (esp8266 - gpio 5, 4) \ No newline at end of file diff --git a/doc/conf/c013.txt b/doc/conf/c013.txt new file mode 100644 index 00000000..78630cfe --- /dev/null +++ b/doc/conf/c013.txt @@ -0,0 +1,9 @@ +bme280T temp1 0x76 Температура#bmp280 Датчики anydata 1 +bme280P pres1 0x76 Давление#bmp280 Датчики anydata 2 +bme280H hum1 0x76 Влажность#bmp280 Датчики anydata 3 +bme280A altit1 0x76 Высота#bmp280 Датчики anydata 4 +logging temp1 1 100 Температура Датчики 5 +logging press1 1 100 Давление Датчики 6 +logging hum1 1 100 Влажность Датчики 7 + +//Чтение и логгирование датчика bme280. Датчик подключается к шине i2c (esp8266 - gpio 5, 4) \ No newline at end of file diff --git a/doc/conf/c014.txt b/doc/conf/c014.txt new file mode 100644 index 00000000..c850b3e2 --- /dev/null +++ b/doc/conf/c014.txt @@ -0,0 +1,7 @@ +dallas temp1 2 1 Температура Датчики anydata 1 +dallas temp2 2 2 Температура Датчики anydata 2 +logging temp1 1 100 Температура Датчики 3 +logging temp2 1 100 Температура Датчики 4 + +//2 - номер пина датчика +//варианты отображения: anydata, progress-round, progress-line, fillgauge \ No newline at end of file diff --git a/doc/conf/c015.txt b/doc/conf/c015.txt new file mode 100644 index 00000000..6567cf6d --- /dev/null +++ b/doc/conf/c015.txt @@ -0,0 +1,12 @@ +dallas 2 Водонагреватель,#t°C Термостат anydata 1 +logging dallas 5 100 Температура Термостат 2 +inputDigit digit1 При#скольки#выключить? Термостат 40 3 +inputDigit digit2 При#скольки#включить? Термостат 20 4 +button 1 5 Нагреватель Термостат 0 5 +button 2 line1,line2, Автоматический#режим Термостат 1 6 + +//2 - номер пина датчика +//5 - номер пина реле +//это термостат который будет держать температуру между двумя +//установленными в приложении значениями, так же можно выключить +//автоматический режим, и тогда нагреватель будет управляться в ручную \ No newline at end of file diff --git a/doc/conf/c016.txt b/doc/conf/c016.txt new file mode 100644 index 00000000..0b82f2b9 --- /dev/null +++ b/doc/conf/c016.txt @@ -0,0 +1,12 @@ +levelPr p 14 12 Уровень#в#баке,#% Датчики fillgauge 125 25 1 +ultrasonicCm cm 14 12 Дистанция,#см Датчики anydata 2 +inputDigit digit1 При#скольки#выключить? Датчики 95 3 +inputDigit digit2 При#скольки#включить? Датчики 10 4 +button 1 5 Насос Датчики 0 5 +logging p 1 100 Вода#в#баке Датчики 6 + +//125 - это расстояние от датчика до дна бака в сантиметрах +//25 - это расстояние от датчика до поверхности воды когда бак полный в сантиметрах +//distancePr - эта строка выводит процент заполнения бака +//distanceCm - эта строка выводит расстояние в сантиметрах +//варианты отображения: anydata, progress-round, progress-line, fillgauge \ No newline at end of file diff --git a/doc/conf/c017.txt b/doc/conf/c017.txt new file mode 100644 index 00000000..fa0b78ac --- /dev/null +++ b/doc/conf/c017.txt @@ -0,0 +1,11 @@ +button 1 5 Прихожая Освещение 0 1 +inputDigit digit1 Задержка#выключения Освещение 30 2 +switch 1 0 10 + +//0 - номер пина датчика движения +//5 - номер пина реле +//при срабатывании датчика движения включится реле и обратный таймер на 30 сек +//если движение не будет обнаружено повтороно в течении 30 секунд - свет выключится +//если движение повторится в течении 30 секунд то таймер продлится опять на 30 сек +//свет выключится только в том случае если в комнате все замрет на 30 сек +//задержку выключения можно будет настраивать в приложении \ No newline at end of file diff --git a/doc/conf/c018.txt b/doc/conf/c018.txt new file mode 100644 index 00000000..bc7d8192 --- /dev/null +++ b/doc/conf/c018.txt @@ -0,0 +1,12 @@ +switch 1 0 20 +text 1 Вход: Охрана 1 +textSet 1 не#обнаружено-time +button 1 na Сбросить Охрана 0 2 +button 2 line3, Включить#push Охрана 1 3 + +//0 - номер пина датчика +//при срабатывании датчика движения устройство пошлет пуш и в приложении будет +//написано в текстовом поле, что движение было обнаружено +//так же будет зафиксирован момент времени срабатывания датчика +//в приложении можно отключать отправку пуш сообщений на тот случай если дома хозяин +//перевести датчик снова в режим ожидания движения можно нажав кнопку сброса в приложении \ No newline at end of file diff --git a/doc/conf/c019.txt b/doc/conf/c019.txt new file mode 100644 index 00000000..82b41ae2 --- /dev/null +++ b/doc/conf/c019.txt @@ -0,0 +1,17 @@ +stepper 1 12 4 +stepper 2 13 5 +button 1 na Открыть#штору#1 Шторы 0 1 +button 2 na Открыть#штору#2 Шторы 0 2 + +//для подключения необходим драйвер шагового двигателя A4988 + +//stepper 1 12 4 шаговый двигатель с параметрами: 1 - номер шагового двигателя, +//12 - номер пина количества шагов, 4 - номер пина направления + +//stepper 2 13 5 шаговый двигатель с параметрами: 2 - номер шагового двигателя, +//13 - номер пина количества шагов, 5 - номер пина направления + +//stepperSet 1 200 5 - прокрутить шаговик номер 1 на 200 шагов по часовой стрелке +//с задержкой между шагами 5 милисекунд (чем меньше задержка тем больше скорость) +//если поставить -200 то будет вращаться против часовой стрелки +//можно подключить не более двух шаговиков \ No newline at end of file diff --git a/doc/conf/c020.txt b/doc/conf/c020.txt new file mode 100644 index 00000000..5d45aea0 --- /dev/null +++ b/doc/conf/c020.txt @@ -0,0 +1,17 @@ +servo 1 12 50 Мой#сервопривод Сервоприводы 0 100 0 180 1 +servo 2 13 50 Мой#сервопривод Сервоприводы 0 100 0 180 2 +button 1 na Открыть1 Сервоприводы 0 3 +button 2 na Открыть2 Сервоприводы 0 4 + +//Можно создавать не более двух сервоприводов на одном устройстве. +//1 - номер привода +//12 - номер пина +//50 - начальное значение в процентах + +//0 - 100 диапазон ползунка +//0 - 180 диапазон угла + +//Представим ситуацию когда есть некая заслонка и при угле в 30 градусов она закрыта, +//а при угле в 90 градусов открыта. В этом случае необходимо написать +//0 100 30 90 и тогда поставив ползунок в 0 % серва встанет в положение 30 градусов, +//а если поставить ползунок в 100 % серва встанет в положение 90 градусов. \ No newline at end of file diff --git a/doc/conf/c021.txt b/doc/conf/c021.txt new file mode 100644 index 00000000..615742f3 --- /dev/null +++ b/doc/conf/c021.txt @@ -0,0 +1,7 @@ +serialBegin 9600 12 13 +button 1 na Управляется#из#arduino Serial 0 1 +button 2 na Отправить#в#arduino Serial 0 2 +text 1 Текст#из#arduino Serial 3 + +//12 13 это пины uart к которым вы можете подключить arduino. Скетч для arduino выложен в группу. +//команда serialWrite ard-on отправит в arduino текст ard-on \ No newline at end of file diff --git a/doc/conf/c100.txt b/doc/conf/c100.txt new file mode 100644 index 00000000..c943b43b --- /dev/null +++ b/doc/conf/c100.txt @@ -0,0 +1,12 @@ +button 1 na Включить#все Реле 0 1 +button 2 13 Прихожая Реле 0 2 +button 3 14 Кухня Реле 0 3 +pwm 1 3 Яркость#коредор: Реле 1023 4 +pwm 2 4 Яркость#ванная: Реле 510 5 +analog adc 0 Аналоговый#вход Датчики fillgauge 1 1023 1 1023 6 +logging adc 1 100 Аналоговый#вход Датчики 7 + +//Это демо конфигурация. В ней показано как связать кнопки c помощью сценариев +//Кнопка номер 1 связана с кнопкой 2, 3 и с pwm 2 +//Так же продемонстрированна система логгирования данных строкой logging +//1 - это интервал между точками в минутах, 100 это количество точек \ No newline at end of file diff --git a/doc/conf/s001.txt b/doc/conf/s001.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/doc/conf/s001.txt @@ -0,0 +1 @@ + diff --git a/doc/conf/s002.txt b/doc/conf/s002.txt new file mode 100644 index 00000000..5deba589 --- /dev/null +++ b/doc/conf/s002.txt @@ -0,0 +1,6 @@ +timenow = time1 +buttonSet 1 1 +end +timenow = time2 +buttonSet 1 0 +end diff --git a/doc/conf/s003.txt b/doc/conf/s003.txt new file mode 100644 index 00000000..f8ced990 --- /dev/null +++ b/doc/conf/s003.txt @@ -0,0 +1,6 @@ +button1 = 1 +timerStart 1 digit1 sec +end +timer1 = 0 +buttonSet 1 0 +end \ No newline at end of file diff --git a/doc/conf/s004.txt b/doc/conf/s004.txt new file mode 100644 index 00000000..276282c3 --- /dev/null +++ b/doc/conf/s004.txt @@ -0,0 +1,8 @@ +button1 = 1 +pinSet 5 1 +pinSet 13 0 +end +button1 = 0 +pinSet 5 0 +pinSet 13 1 +end \ No newline at end of file diff --git a/doc/conf/s005.txt b/doc/conf/s005.txt new file mode 100644 index 00000000..093de1fe --- /dev/null +++ b/doc/conf/s005.txt @@ -0,0 +1,3 @@ +switch1 = 1 +buttonChange 1 +end \ No newline at end of file diff --git a/doc/conf/s006.txt b/doc/conf/s006.txt new file mode 100644 index 00000000..9eb30933 --- /dev/null +++ b/doc/conf/s006.txt @@ -0,0 +1,8 @@ +button1 = 1 +mqtt 3233662-1589485 buttonSet_1_1 +mqtt 2233662-1589486 buttonSet_1_1 +end +button1 = 0 +mqtt 3233662-1589485 buttonSet_1_0 +mqtt 2233662-1589486 buttonSet_1_0 +end \ No newline at end of file diff --git a/doc/conf/s007.txt b/doc/conf/s007.txt new file mode 100644 index 00000000..0c48cbdf --- /dev/null +++ b/doc/conf/s007.txt @@ -0,0 +1,4 @@ +switch1 = 1 +mqtt 3233662-1589485 buttonChange_1 +mqtt 2233662-1589486 buttonChange_1 +end \ No newline at end of file diff --git a/doc/conf/s008.txt b/doc/conf/s008.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/doc/conf/s008.txt @@ -0,0 +1 @@ + diff --git a/doc/conf/s009.txt b/doc/conf/s009.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/doc/conf/s009.txt @@ -0,0 +1 @@ + diff --git a/doc/conf/s010.txt b/doc/conf/s010.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/doc/conf/s010.txt @@ -0,0 +1 @@ + diff --git a/doc/conf/s011.txt b/doc/conf/s011.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/doc/conf/s011.txt @@ -0,0 +1 @@ + diff --git a/doc/conf/s012.txt b/doc/conf/s012.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/doc/conf/s012.txt @@ -0,0 +1 @@ + diff --git a/doc/conf/s013.txt b/doc/conf/s013.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/doc/conf/s013.txt @@ -0,0 +1 @@ + diff --git a/doc/conf/s014.txt b/doc/conf/s014.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/doc/conf/s014.txt @@ -0,0 +1 @@ + diff --git a/doc/conf/s015.txt b/doc/conf/s015.txt new file mode 100644 index 00000000..60782623 --- /dev/null +++ b/doc/conf/s015.txt @@ -0,0 +1,6 @@ +dallas > digit1 +buttonSet 1 0 +end +dallas < digit2 +buttonSet 1 1 +end \ No newline at end of file diff --git a/doc/conf/s016.txt b/doc/conf/s016.txt new file mode 100644 index 00000000..babd78ab --- /dev/null +++ b/doc/conf/s016.txt @@ -0,0 +1,6 @@ +p > digit1 +buttonSet 1 0 +end +p < digit2 +buttonSet 1 1 +end \ No newline at end of file diff --git a/doc/conf/s017.txt b/doc/conf/s017.txt new file mode 100644 index 00000000..899b7035 --- /dev/null +++ b/doc/conf/s017.txt @@ -0,0 +1,7 @@ +switch1 = 1 +timerStart 1 digit1 sec +buttonSet 1 1 +end +timer1 = 0 +buttonSet 1 0 +end \ No newline at end of file diff --git a/doc/conf/s018.txt b/doc/conf/s018.txt new file mode 100644 index 00000000..f764dc9d --- /dev/null +++ b/doc/conf/s018.txt @@ -0,0 +1,10 @@ +switch1 = 1 +textSet 1 обнаружено#движение-time +end +button1 = 1 +textSet 1 не#обнаружено-time +buttonSet 1 0 +end +switch1 = 1 +push Внимание обнаружено#движение! +end \ No newline at end of file diff --git a/doc/conf/s019.txt b/doc/conf/s019.txt new file mode 100644 index 00000000..16e7cfa6 --- /dev/null +++ b/doc/conf/s019.txt @@ -0,0 +1,12 @@ +button1 = 1 +stepperSet 1 200 1 +end +button1 = 0 +stepperSet 1 -200 1 +end +button2 = 1 +stepperSet 2 200 1 +end +button2 = 0 +stepperSet 2 -200 1 +end \ No newline at end of file diff --git a/doc/conf/s020.txt b/doc/conf/s020.txt new file mode 100644 index 00000000..b4340463 --- /dev/null +++ b/doc/conf/s020.txt @@ -0,0 +1,12 @@ +button1 = 1 +servoSet 1 100 +end +button1 = 0 +servoSet 1 0 +end +button2 = 1 +servoSet 2 100 +end +button2 = 0 +servoSet 2 0 +end \ No newline at end of file diff --git a/doc/conf/s021.txt b/doc/conf/s021.txt new file mode 100644 index 00000000..9ae72453 --- /dev/null +++ b/doc/conf/s021.txt @@ -0,0 +1,6 @@ +button2 = 1 +serialWrite ard-11-1 +end +button2 = 0 +serialWrite ard-11-0 +end \ No newline at end of file diff --git a/doc/conf/s100.txt b/doc/conf/s100.txt new file mode 100644 index 00000000..4927ac1e --- /dev/null +++ b/doc/conf/s100.txt @@ -0,0 +1,13 @@ +button1 = 1 +buttonSet 2 1 +buttonSet 3 1 +pwmSet 2 1024 +end +button1 = 0 +buttonSet 2 0 +buttonSet 3 0 +pwmSet 2 0 +end +adc > 50 +buttonSet 2 1 +end \ No newline at end of file diff --git a/doc/eagle.txt b/doc/eagle.txt new file mode 100644 index 00000000..8a590610 --- /dev/null +++ b/doc/eagle.txt @@ -0,0 +1,24 @@ +eagle.flash.512k0.ld 512K (no SPIFFS) +eagle.flash.512k64.ld 512K (64K SPIFFS) +eagle.flash.512k128.ld 512K (128K SPIFFS) +eagle.flash.1m0.ld 1M (no SPIFFS) +eagle.flash.1m64.ld 1M (64K SPIFFS) +eagle.flash.1m128.ld 1M (128K SPIFFS) +eagle.flash.1m144.ld 1M (144K SPIFFS) +eagle.flash.1m160.ld 1M (160K SPIFFS) +eagle.flash.1m192.ld 1M (192K SPIFFS) +eagle.flash.1m256.ld 1M (256K SPIFFS) +eagle.flash.1m512.ld 1M (512K SPIFFS) +eagle.flash.2m.ld 2M (1M SPIFFS) +eagle.flash.4m1m.ld 4M (1M SPIFFS) +eagle.flash.4m2m.ld 4M (2M SPIFFS) +eagle.flash.4m.ld 4M (3M SPIFFS) +eagle.flash.8m.ld 8M (7M SPIFFS) +eagle.flash.16m.ld 16M (15M SPIFFS) + +# Name, Type, SubType, Offset, Size, Flags +nvs, data, nvs, 0x9000, 0x5000, +otadata, data, ota, 0xe000, 0x2000, +app0, app, ota_0, 0x10000, 0x1F0000, +app1, app, ota_1, 0x200000, 0x1F0000, +spiffs, data, spiffs, 0x3F0000,0x10000, \ No newline at end of file diff --git a/doc/old files/items/analog-adc.txt b/doc/old files/items/analog-adc.txt new file mode 100644 index 00000000..8bc0e914 --- /dev/null +++ b/doc/old files/items/analog-adc.txt @@ -0,0 +1 @@ +0;analog-adc;id;fillgauge;Сенсоры;Аналоговый;order;gol;map[0,1024,0,100];c[1] \ No newline at end of file diff --git a/doc/old files/items/bme280-hum.txt b/doc/old files/items/bme280-hum.txt new file mode 100644 index 00000000..c8afd255 --- /dev/null +++ b/doc/old files/items/bme280-hum.txt @@ -0,0 +1 @@ +0;bme280-hum;id;anydataHum;Сенсоры;Влажность;order;addr[0x76];c[1] \ No newline at end of file diff --git a/doc/old files/items/bme280-press.txt b/doc/old files/items/bme280-press.txt new file mode 100644 index 00000000..f79973e2 --- /dev/null +++ b/doc/old files/items/bme280-press.txt @@ -0,0 +1 @@ +0;bme280-press;id;anydataPress;Сенсоры;Давление;order;addr[0x76];c[1] \ No newline at end of file diff --git a/doc/old files/items/bme280-temp.txt b/doc/old files/items/bme280-temp.txt new file mode 100644 index 00000000..6e5e9003 --- /dev/null +++ b/doc/old files/items/bme280-temp.txt @@ -0,0 +1 @@ +0;bme280-temp;id;anydataTemp;Сенсоры;Температура;order;addr[0x76];c[1] \ No newline at end of file diff --git a/doc/old files/items/bmp280-press.txt b/doc/old files/items/bmp280-press.txt new file mode 100644 index 00000000..44b9e8c9 --- /dev/null +++ b/doc/old files/items/bmp280-press.txt @@ -0,0 +1 @@ +0;bmp280-press;id;anydataPress;Сенсоры;Давление;order;addr[0x76];c[1] \ No newline at end of file diff --git a/doc/old files/items/bmp280-temp.txt b/doc/old files/items/bmp280-temp.txt new file mode 100644 index 00000000..c3cb42eb --- /dev/null +++ b/doc/old files/items/bmp280-temp.txt @@ -0,0 +1 @@ +0;bmp280-temp;id;anydataTemp;Сенсоры;Температура;order;addr[0x76];c[1] \ No newline at end of file diff --git a/doc/old files/items/button-in.txt b/doc/old files/items/button-in.txt new file mode 100644 index 00000000..79d79ec9 --- /dev/null +++ b/doc/old files/items/button-in.txt @@ -0,0 +1 @@ +0;button-in;id;toggle;Кнопки;Освещение;order;pin;db[20] \ No newline at end of file diff --git a/doc/old files/items/button-out.inv.txt b/doc/old files/items/button-out.inv.txt new file mode 100644 index 00000000..5499a108 --- /dev/null +++ b/doc/old files/items/button-out.inv.txt @@ -0,0 +1 @@ +0;button-out;id;toggle;Кнопки;Освещение;order;pin;inv[1] \ No newline at end of file diff --git a/doc/old files/items/button-out.npin.txt b/doc/old files/items/button-out.npin.txt new file mode 100644 index 00000000..ecffd881 --- /dev/null +++ b/doc/old files/items/button-out.npin.txt @@ -0,0 +1 @@ +0;button-out;id;toggle;Кнопки;Освещение;order \ No newline at end of file diff --git a/doc/old files/items/button-out.pin.txt b/doc/old files/items/button-out.pin.txt new file mode 100644 index 00000000..b0645025 --- /dev/null +++ b/doc/old files/items/button-out.pin.txt @@ -0,0 +1 @@ +0;button-out;id;toggle;Кнопки;Освещение;order;pin \ No newline at end of file diff --git a/doc/old files/items/count-down.txt b/doc/old files/items/count-down.txt new file mode 100644 index 00000000..3300573c --- /dev/null +++ b/doc/old files/items/count-down.txt @@ -0,0 +1 @@ +0;count-down;id;anydata;Таймер;Обратный#отчет;order \ No newline at end of file diff --git a/doc/old files/items/dallas-temp.txt b/doc/old files/items/dallas-temp.txt new file mode 100644 index 00000000..0da8bdca --- /dev/null +++ b/doc/old files/items/dallas-temp.txt @@ -0,0 +1 @@ +0;dallas-temp;id;anydataTemp;Сенсоры;Температура;order;sal;index[0];int[10] \ No newline at end of file diff --git a/doc/old files/items/dht11-hum.txt b/doc/old files/items/dht11-hum.txt new file mode 100644 index 00000000..b7d9a820 --- /dev/null +++ b/doc/old files/items/dht11-hum.txt @@ -0,0 +1 @@ +0;dht-hum;id;anydataHum;Сенсоры;Влажность;order;thd;type[dht11];c[1] \ No newline at end of file diff --git a/doc/old files/items/dht11-temp.txt b/doc/old files/items/dht11-temp.txt new file mode 100644 index 00000000..39c5e949 --- /dev/null +++ b/doc/old files/items/dht11-temp.txt @@ -0,0 +1 @@ +0;dht-temp;id;anydataTemp;Сенсоры;Температура;order;thd;type[dht11];c[1] \ No newline at end of file diff --git a/doc/old files/items/dht22-hum.txt b/doc/old files/items/dht22-hum.txt new file mode 100644 index 00000000..ab69cf97 --- /dev/null +++ b/doc/old files/items/dht22-hum.txt @@ -0,0 +1 @@ +0;dht-hum;id;anydataHum;Сенсоры;Влажность;order;thd;type[dht22];c[1] \ No newline at end of file diff --git a/doc/old files/items/dht22-temp.txt b/doc/old files/items/dht22-temp.txt new file mode 100644 index 00000000..d14a434d --- /dev/null +++ b/doc/old files/items/dht22-temp.txt @@ -0,0 +1 @@ +0;dht-temp;id;anydataTemp;Сенсоры;Температура;order;thd;type[dht22];c[1] \ No newline at end of file diff --git a/doc/old files/items/impuls-out.txt b/doc/old files/items/impuls-out.txt new file mode 100644 index 00000000..99994ae5 --- /dev/null +++ b/doc/old files/items/impuls-out.txt @@ -0,0 +1 @@ +0;impuls-out;id;na;na;na;order;pin \ No newline at end of file diff --git a/doc/old files/items/input-digit.txt b/doc/old files/items/input-digit.txt new file mode 100644 index 00000000..7df7260e --- /dev/null +++ b/doc/old files/items/input-digit.txt @@ -0,0 +1 @@ +0;inoutput;id;inputDigit;Ввод;Введите#цифру;order \ No newline at end of file diff --git a/doc/old files/items/input-time.txt b/doc/old files/items/input-time.txt new file mode 100644 index 00000000..3fc078b0 --- /dev/null +++ b/doc/old files/items/input-time.txt @@ -0,0 +1 @@ +0;inoutput;id;inputTime;Ввод;Введите#время;order \ No newline at end of file diff --git a/doc/old files/items/logging.txt b/doc/old files/items/logging.txt new file mode 100644 index 00000000..8253774f --- /dev/null +++ b/doc/old files/items/logging.txt @@ -0,0 +1 @@ +0;logging;id;chart;Графики;История;order;val[any];int[60];cnt[100] \ No newline at end of file diff --git a/doc/old files/items/modbus.txt b/doc/old files/items/modbus.txt new file mode 100644 index 00000000..a782395a --- /dev/null +++ b/doc/old files/items/modbus.txt @@ -0,0 +1 @@ +0;modbus;id;anydata;Modbus;Регистр;order;addr[1];reg[0];c[1] \ No newline at end of file diff --git a/doc/old files/items/output-text.txt b/doc/old files/items/output-text.txt new file mode 100644 index 00000000..65d45284 --- /dev/null +++ b/doc/old files/items/output-text.txt @@ -0,0 +1 @@ +0;inoutput;id;anydata;Вывод;Сигнализация;order \ No newline at end of file diff --git a/doc/old files/items/pwm-out.txt b/doc/old files/items/pwm-out.txt new file mode 100644 index 00000000..2acbb459 --- /dev/null +++ b/doc/old files/items/pwm-out.txt @@ -0,0 +1 @@ +0;pwm-out;id;range;Ползунки;Яркость;order;pin \ No newline at end of file diff --git a/doc/old files/items/uart-button.txt b/doc/old files/items/uart-button.txt new file mode 100644 index 00000000..ee2a6b22 --- /dev/null +++ b/doc/old files/items/uart-button.txt @@ -0,0 +1 @@ +0;button-out;id;toggle;Кнопки;Освещение;order;type[UART] \ No newline at end of file diff --git a/doc/old files/items/uart-widget.txt b/doc/old files/items/uart-widget.txt new file mode 100644 index 00000000..469ab016 --- /dev/null +++ b/doc/old files/items/uart-widget.txt @@ -0,0 +1 @@ +0;inoutput;id;anydata;Вывод;Вывод#uart;order \ No newline at end of file diff --git a/doc/old files/items/ultrasonic-cm.txt b/doc/old files/items/ultrasonic-cm.txt new file mode 100644 index 00000000..c5d518c3 --- /dev/null +++ b/doc/old files/items/ultrasonic-cm.txt @@ -0,0 +1 @@ +0;ultrasonic-cm;id;anydata;Сенсоры;Расстояние;order;cin;map[0,500,0,100];c[1];int[10] \ No newline at end of file diff --git a/doc/old files/items/uptime.txt b/doc/old files/items/uptime.txt new file mode 100644 index 00000000..972241b4 --- /dev/null +++ b/doc/old files/items/uptime.txt @@ -0,0 +1 @@ +0;uptime;id;anydataTime;Системные;%name%#uptime;order \ No newline at end of file diff --git a/doc/old files/presets/1.c.txt b/doc/old files/presets/1.c.txt new file mode 100644 index 00000000..abcd06dc --- /dev/null +++ b/doc/old files/presets/1.c.txt @@ -0,0 +1,5 @@ +0;dallas-temp;temp;anydataTemp;Термостат;Температура;1;pin[2];index[0];int[10] +0;logging;log;chart;Термостат;История;2;val[temp];int[60];cnt[100] +0;inoutput;inputU;inputDigit;Термостат;Верхний#порог;3 +0;inoutput;inputL;inputDigit;Термостат;Нижний#порог;4 +0;button-out;button;toggle;Термостат;Нагрев;5;pin[12] \ No newline at end of file diff --git a/doc/old files/presets/1.s.txt b/doc/old files/presets/1.s.txt new file mode 100644 index 00000000..dc4c8c07 --- /dev/null +++ b/doc/old files/presets/1.s.txt @@ -0,0 +1,8 @@ +temp > inputU +button 0 +telegram нагрев#выключен 1 +end +temp < inputL +button 1 +telegram нагрев#включен 1 +end \ No newline at end of file diff --git a/doc/old files/presets/2.c.txt b/doc/old files/presets/2.c.txt new file mode 100644 index 00000000..d91fa5c7 --- /dev/null +++ b/doc/old files/presets/2.c.txt @@ -0,0 +1,12 @@ +0;dallas-temp;temp;anydataTemp;Термостат;Температура;1;pin[2];index[0];int[60] +0;logging;log;chart;Термостат;История;2;val[temp];int[10];cnt[100] +0;inoutput;threshold;inputDigitTemp;Термостат;Заданная#температура;3 +0;button-out;heater;toggle;Термостат;Нагреватель;7;pin[12] +0;inoutput;time1;inputTimeClock;Расписание;Утренний#период;8 +0;inoutput;threshold1;inputDigitTemp;Расписание;Температура;9 +0;inoutput;time2;inputTimeClock;Расписание;Дневной#период;10 +0;inoutput;threshold2;inputDigitTemp;Расписание;Температура;11 +0;inoutput;time3;inputTimeClock;Расписание;Вечерний#период;12 +0;inoutput;threshold3;inputDigitTemp;Расписание;Температура;13 +0;inoutput;time4;inputTimeClock;Расписание;Ночной#период;14 +0;inoutput;threshold4;inputDigitTemp;Расписание;Температура;15 \ No newline at end of file diff --git a/doc/old files/presets/2.s.txt b/doc/old files/presets/2.s.txt new file mode 100644 index 00000000..5a6f36f1 --- /dev/null +++ b/doc/old files/presets/2.s.txt @@ -0,0 +1,18 @@ +temp > threshold+-2 +heater 0 +end +temp < threshold+-2 +heater 1 +end +timenow = time1 +threshold threshold1 +end +timenow = time2 +threshold threshold2 +end +timenow = time3 +threshold threshold3 +end +timenow = time4 +threshold threshold4 +end \ No newline at end of file diff --git a/doc/old files/presets/3.c.txt b/doc/old files/presets/3.c.txt new file mode 100644 index 00000000..fb2c602b --- /dev/null +++ b/doc/old files/presets/3.c.txt @@ -0,0 +1,5 @@ +0;dht-hum;hum;anydataHum;Теплица;Влажность;1;pin[2];type[dht11];c[1] +0;logging;log;chart;Теплица;История;2;val[hum];int[60];cnt[100] +0;inoutput;inputU;inputDigit;Теплица;Верхний#порог;3 +0;inoutput;inputL;inputDigit;Теплица;Нижний#порог;4 +0;button-out;button;toggle;Теплица;Полив;5;pin[12] \ No newline at end of file diff --git a/doc/old files/presets/3.s.txt b/doc/old files/presets/3.s.txt new file mode 100644 index 00000000..f69cdc54 --- /dev/null +++ b/doc/old files/presets/3.s.txt @@ -0,0 +1,8 @@ +hum > inputU +button 0 +telegram полив#выключен 1 +end +hum < inputL +button 1 +telegram полив#включен 1 +end \ No newline at end of file diff --git a/doc/old files/presets/4.c.txt b/doc/old files/presets/4.c.txt new file mode 100644 index 00000000..3f1ccaa1 --- /dev/null +++ b/doc/old files/presets/4.c.txt @@ -0,0 +1,4 @@ +0;button-out;button1;toggle;Реле;Освещение;1;pin[12] +0;button-out;button2;toggle;Реле;Освещение;2;pin[13] +0;inoutput;T1;inputTime;Реле;Введите#время#включения;3 +0;inoutput;T2;inputTime;Реле;Введите#время#выключения;4 \ No newline at end of file diff --git a/doc/old files/presets/4.s.txt b/doc/old files/presets/4.s.txt new file mode 100644 index 00000000..844d1c5b --- /dev/null +++ b/doc/old files/presets/4.s.txt @@ -0,0 +1,8 @@ +timenow = T1 +button1 1 +button2 0 +end +timenow = T2 +button1 0 +button2 1 +end \ No newline at end of file diff --git a/doc/old files/presets/5.c.txt b/doc/old files/presets/5.c.txt new file mode 100644 index 00000000..359a7a52 --- /dev/null +++ b/doc/old files/presets/5.c.txt @@ -0,0 +1,7 @@ +0;button-out;button-out-1;toggle;Кнопки;Выключить#все;1 +0;button-out;button-out-2;toggle;Кнопки;Гостинная;2;pin[12] +0;button-out;button-out-3;toggle;Кнопки;Спальня;3;pin[13] +0;button-out;button-out-4;toggle;Кнопки;Прихожая;4;pin[14] +0;pwm-out;pwm-out-5;range;Кнопки;Яркость;5;pin[15] +0;pwm-out;pwm-out-6;range;Кнопки;Яркость;6;pin[16] +0;inoutput;output-text-7;anydata;Кнопки;Статус;7 \ No newline at end of file diff --git a/doc/old files/presets/5.s.txt b/doc/old files/presets/5.s.txt new file mode 100644 index 00000000..0424728a --- /dev/null +++ b/doc/old files/presets/5.s.txt @@ -0,0 +1,16 @@ +button-out-1 = 1 +button-out-2 1 +button-out-3 1 +button-out-4 1 +pwm-out-5 200 +pwm-out-6 800 +output-text-7 включено +end +button-out-1 = 0 +button-out-2 0 +button-out-3 0 +button-out-4 0 +pwm-out-5 800 +pwm-out-6 200 +output-text-7 выключено +end \ No newline at end of file diff --git a/doc/old files/presets/6.c.txt b/doc/old files/presets/6.c.txt new file mode 100644 index 00000000..c7fd096a --- /dev/null +++ b/doc/old files/presets/6.c.txt @@ -0,0 +1,3 @@ +0;button-out;button;toggle;Таймер;Освещение;1;pin[12] +0;count-down;count;anydata;Таймер;Обратный#отчет;2 +0;inoutput;input;inputDigit;Таймер;Введите#цифру;3 \ No newline at end of file diff --git a/doc/old files/presets/6.s.txt b/doc/old files/presets/6.s.txt new file mode 100644 index 00000000..06b70a4a --- /dev/null +++ b/doc/old files/presets/6.s.txt @@ -0,0 +1,6 @@ +button = 1 +count input +end +count = 0 +button 0 +end \ No newline at end of file diff --git a/doc/old files/presets/7.c.txt b/doc/old files/presets/7.c.txt new file mode 100644 index 00000000..984c6b8d --- /dev/null +++ b/doc/old files/presets/7.c.txt @@ -0,0 +1,4 @@ +0;inoutput;text;anydataAlarm;Сигнализация;Движение:;1 +0;inoutput;time;anydataTime;Сигнализация;Время:;2 +0;button-in;sensor;na;na;na;3;pin[0];db[20] +0;button-out;reset;toggle;Сигнализация;Сбросить;4 \ No newline at end of file diff --git a/doc/old files/presets/7.s.txt b/doc/old files/presets/7.s.txt new file mode 100644 index 00000000..32d28e78 --- /dev/null +++ b/doc/old files/presets/7.s.txt @@ -0,0 +1,10 @@ +sensor = 1 +text обнаружено +time %date% +telegram text обнаружено#движение 1 +end +reset = 1 +text не#обнаружено +time %date% +reset 0 +end \ No newline at end of file diff --git a/doc/old files/presets/8.c.txt b/doc/old files/presets/8.c.txt new file mode 100644 index 00000000..d18bdd0b --- /dev/null +++ b/doc/old files/presets/8.c.txt @@ -0,0 +1,4 @@ +0;button-in;sensor;na;na;na;1;pin[0];db[20] +0;button-out;light;toggle;Освещение;Освещение;2;pin[13] +0;count-down;count;anydata;Освещение;Обратный#отчет;3 +0;inoutput;period;inputDigit;Освещение;Период#включения;4 \ No newline at end of file diff --git a/doc/old files/presets/8.s.txt b/doc/old files/presets/8.s.txt new file mode 100644 index 00000000..10d55654 --- /dev/null +++ b/doc/old files/presets/8.s.txt @@ -0,0 +1,7 @@ +sensor = 1 +light 1 +count period +end +count = 0 +light 0 +end \ No newline at end of file diff --git a/doc/old files/presets/9.c.txt b/doc/old files/presets/9.c.txt new file mode 100644 index 00000000..502f3ae4 --- /dev/null +++ b/doc/old files/presets/9.c.txt @@ -0,0 +1,2 @@ +0;button-out;light;toggle;Кнопки;Освещение;1;pin[13] +0;button-in;switch;na;na;na;2;pin[0];db[20] \ No newline at end of file diff --git a/doc/old files/presets/9.s.txt b/doc/old files/presets/9.s.txt new file mode 100644 index 00000000..6f6d7dcc --- /dev/null +++ b/doc/old files/presets/9.s.txt @@ -0,0 +1,3 @@ +switch = 1 +light change +end \ No newline at end of file diff --git a/doc/orders.xlsm b/doc/orders.xlsm new file mode 100644 index 00000000..d86f040e Binary files /dev/null and b/doc/orders.xlsm differ diff --git a/doc/pictures/001 iot manager.jpeg b/doc/pictures/001 iot manager.jpeg new file mode 100644 index 00000000..39914774 Binary files /dev/null and b/doc/pictures/001 iot manager.jpeg differ diff --git a/doc/pictures/002 iot manager.jpeg b/doc/pictures/002 iot manager.jpeg new file mode 100644 index 00000000..80b9d67c Binary files /dev/null and b/doc/pictures/002 iot manager.jpeg differ diff --git a/doc/pictures/003 iot manager.jpeg b/doc/pictures/003 iot manager.jpeg new file mode 100644 index 00000000..3f23d111 Binary files /dev/null and b/doc/pictures/003 iot manager.jpeg differ diff --git a/doc/pictures/007 iot manager.jpg b/doc/pictures/007 iot manager.jpg new file mode 100644 index 00000000..2178d634 Binary files /dev/null and b/doc/pictures/007 iot manager.jpg differ diff --git a/include/BufferExecute.h b/include/BufferExecute.h new file mode 100644 index 00000000..28644b59 --- /dev/null +++ b/include/BufferExecute.h @@ -0,0 +1,35 @@ +#pragma once +#include + +extern void loopCmdAdd(const String& cmdStr); +extern void fileCmdExecute(const String& filename); +extern void csvCmdExecute(String& cmdStr); +extern void spaceCmdExecute(String& cmdStr); +extern void loopCmdExecute(); +extern void addKey(String& key, String& keyNumberTable, int number); +extern int getKeyNum(String& key, String& keyNumberTable); + +extern void buttonIn(); +extern void buttonInSet(); + + + +extern void bme280Temp(); +extern void bme280ReadingTemp(); +extern void bme280Hum(); +extern void bme280ReadingHum(); +extern void bme280Press(); +extern void bme280ReadingPress(); + +extern void bmp280Temp(); +extern void bmp280ReadingTemp(); +extern void bmp280Press(); +extern void bmp280ReadingPress(); + +//extern void modbus(); +//extern void modbusReading(); + +extern void sysUptime(); +extern void uptimeReading(); + + diff --git a/include/Bus.h b/include/Bus.h new file mode 100644 index 00000000..11edd50b --- /dev/null +++ b/include/Bus.h @@ -0,0 +1,4 @@ +#pragma once +#include +void busInit(); +String i2c_scan(); \ No newline at end of file diff --git a/include/Class/CallBackTest.h b/include/Class/CallBackTest.h new file mode 100644 index 00000000..6632bfe0 --- /dev/null +++ b/include/Class/CallBackTest.h @@ -0,0 +1,26 @@ +#pragma once +#include +#include +#include + +// Декларируем тип - сигнатуру метода , который мы готовы принять в данном случае это +// должен быть метод без результата и без параметров. +// Новый тип мы называем AsynсActionCb - хотя можешь назвать вообще как нравиться а что значит callBack + +typedef std::function AsyncActionCb; //метод без результата и параметров +typedef std::function AsyncParamActionCb; //метод без результата и параметров + +class CallBackTest { + private: + long count; + AsyncActionCb _cb; + AsyncParamActionCb _pcb; + + + public: + CallBackTest(); + void loop(); + void setCallback(AsyncActionCb cb); + void setCallback(AsyncParamActionCb pcb); +}; +//extern CallBackTest* CB; \ No newline at end of file diff --git a/include/Class/LineParsing.h b/include/Class/LineParsing.h new file mode 100644 index 00000000..f3553ad4 --- /dev/null +++ b/include/Class/LineParsing.h @@ -0,0 +1,253 @@ +#pragma once + +#include + +#include "Global.h" +#include "ItemsList.h" +#include "Utils/JsonUtils.h" + +class LineParsing { + protected: + String _key; + String _file; + String _page; + String _descr; + String _order; + String _addr; + String _reg; + String _pin; + String _map; + String _c; + String _inv; + String _state; + String _db; + String _type; + String _int; + String _cnt; + String _val; + String _index; + + int pinErrors; + + public: + LineParsing() : + + _key{""}, + _file{""}, + _page{""}, + _descr{""}, + _order{""}, + _addr{""}, + _reg{""}, + _pin{""}, + _map{""}, + _c{""}, + _inv{""}, + _state{""}, + _db{""}, + _type{""}, + _int{""}, + _cnt{""}, + _val{""}, + _index{""}, + + pinErrors{0} + + {}; + + void update() { + //String order = sCmd.order(); + //SerialPrint("I","module","create '" + order + "'"); + for (int i = 1; i < 12; i++) { + if (i == 1) _key = sCmd.next(); + if (i == 2) _file = sCmd.next(); + if (i == 3) _page = sCmd.next(); + if (i == 4) _descr = sCmd.next(); + if (i == 5) _order = sCmd.next(); + } + + for (int i = 1; i < 10; i++) { + String arg = sCmd.next(); + if (arg != "") { + if (arg.indexOf("pin[") != -1) { + _pin = extractInner(arg); + } + if (arg.indexOf("inv[") != -1) { + _inv = extractInner(arg); + } + if (arg.indexOf("st[") != -1) { + _state = extractInner(arg); + } + if (arg.indexOf("db[") != -1) { + _db = extractInner(arg); + } + if (arg.indexOf("map[") != -1) { + _map = extractInner(arg); + } + if (arg.indexOf("c[") != -1) { + _c = extractInner(arg); + } + if (arg.indexOf("type[") != -1) { + _type = extractInner(arg); + } + if (arg.indexOf("addr[") != -1) { + _addr = extractInner(arg); + } + if (arg.indexOf("reg[") != -1) { + _reg = extractInner(arg); + } + if (arg.indexOf("int[") != -1) { + _int = extractInner(arg); + } + if (arg.indexOf("cnt[") != -1) { + _cnt = extractInner(arg); + } + if (arg.indexOf("val[") != -1) { + _val = extractInner(arg); + } + if (arg.indexOf("index[") != -1) { + _index = extractInner(arg); + } + } + } + + if (_pin != "") { + if (!isPinExist(_pin.toInt()) || !isDigitStr(_pin)) { + pinErrors++; + Serial.println("'" + _pin + "'"); + _pin = ""; + } + } + + _page.replace("#", " "); + _descr.replace("#", " "); + _descr.replace("%ver%", String(FIRMWARE_VERSION)); + _descr.replace("%name%", jsonReadStr(configSetupJson, F("name"))); + + createWidget(_descr, _page, _order, _file, _key); + } + + String gkey() { + return _key; + } + String gfile() { + return _file; + } + String gpage() { + return _page; + } + String gdescr() { + return _descr; + } + String gorder() { + return _order; + } + String gpin() { + return _pin; + } + String ginv() { + return _inv; + } + String gstate() { + return _state; + } + String gmap() { + return _map; + } + String gc() { + return _c; + } + String gtype() { + return _type; + } + String gaddr() { + return _addr; + } + String gregaddr() { + return _reg; + } + String gint() { + return _int; + } + String gcnt() { + return _cnt; + } + String gval() { + return _val; + } + String gindex() { + return _index; + } + + int getPinErrors() { + return pinErrors; + } + + void clearErrors() { + pinErrors = 0; + } + + void clear() { + _key = ""; + _file = ""; + _page = ""; + _descr = ""; + _order = ""; + _addr = ""; + _reg = ""; + _pin = ""; + _map = ""; + _c = ""; + _inv = ""; + _state = ""; + _db = ""; + _type = ""; + _int = ""; + _cnt = ""; + _val = ""; + _index = ""; + } + + String extractInnerDigit(String str) { + int p1 = str.indexOf("["); + int p2 = str.indexOf("]"); + return str.substring(p1 + 1, p2); + } + + void createWidget(String descr, String page, String order, String filename, String topic) { + if (filename != "na") { + String buf = "{}"; + if (!loadWidget(filename, buf)) { + return; + } + + if (filename.indexOf("chart") != -1) jsonWriteStr(buf, "maxCount", _cnt); + + jsonWriteStr(buf, "page", page); + jsonWriteStr(buf, "order", order); + jsonWriteStr(buf, "descr", descr); + jsonWriteStr(buf, "topic", prex + "/" + topic); + +#ifdef LAYOUT_IN_RAM + all_widgets += widget + "\r\n"; +#else + addFileLn("layout.txt", buf); +#endif + } + } + + bool loadWidget(const String& filename, String& buf) { + buf = readFile(getWidgetFile(filename), 2048); + bool res = !(buf == "Failed" || buf == "Large"); + if (!res) { + //SerialPrint("[E]","module","on load" + filename); + } + return res; + } + + const String getWidgetFile(const String& name) { + return "/widgets/" + name + ".json"; + } +}; + +extern LineParsing myLineParsing; diff --git a/include/Class/NotAsync.h b/include/Class/NotAsync.h new file mode 100644 index 00000000..1d5278cc --- /dev/null +++ b/include/Class/NotAsync.h @@ -0,0 +1,32 @@ +#pragma once +#include +#include + +#include + +typedef std::function NotAsyncCb; + +struct NotAsyncItem { + bool test; + NotAsyncCb cb; + void* cb_arg; + volatile bool is_used = false; +}; + +class NotAsync { + private: + uint8_t size; + uint8_t task = 0; + NotAsyncItem* items = NULL; + void handle(NotAsyncCb f, void* arg); + + public: + NotAsync(uint8_t size); + ~NotAsync(); + + void add(uint8_t i, NotAsyncCb, void* arg); + void make(uint8_t task); + void loop(); +}; + +extern NotAsync* myNotAsyncActions; \ No newline at end of file diff --git a/include/Class/ScenarioClass3.h b/include/Class/ScenarioClass3.h new file mode 100644 index 00000000..9c72a0a8 --- /dev/null +++ b/include/Class/ScenarioClass3.h @@ -0,0 +1,85 @@ +#pragma once +#include + +#include "Cmd.h" +#include "Global.h" + +class Scenario { + public: + void loop() { + if (!jsonReadBool(configSetupJson, "scen")) { + return; + } + String allBlocks = scenario; + allBlocks.replace("\r\n", "\n"); + allBlocks.replace("\r", "\n"); + allBlocks += "\n"; + + String incommingEvent = selectToMarker(eventBuf, ","); + String incommingEventKey = selectToMarker(incommingEvent, " "); + String incommingEventValue = selectToMarkerLast(incommingEvent, " "); + + while (allBlocks.length() > 1) { + String oneBlock = selectToMarker(allBlocks, "end\n"); + String condition = selectToMarker(oneBlock, "\n"); + + String setEventKey = selectFromMarkerToMarker(condition, " ", 0); + + if (incommingEventKey == setEventKey) { + String setEventSign = selectFromMarkerToMarker(condition, " ", 1); + String setEventValue = selectFromMarkerToMarker(condition, " ", 2); + + if (!isDigitDotCommaStr(setEventValue)) { + if (setEventValue.indexOf("+-") != -1) { + String setEventValueName = selectToMarker(setEventValue, "+-"); + String gisteresisValue = selectToMarkerLast(setEventValue, "+-"); + gisteresisValue.replace("+-", ""); + String value = getValue(setEventValueName); + String upValue = String(value.toFloat() + gisteresisValue.toFloat()); + String lowValue = String(value.toFloat() - gisteresisValue.toFloat()); + + if (setEventSign == ">") { + setEventValue = upValue; + } else if (setEventSign == "<") { + setEventValue = lowValue; + } + } else { + setEventValue = getValue(setEventValue); + } + } + + boolean flag = false; + + if (setEventSign == "=") { + flag = incommingEventValue == setEventValue; + } else if (setEventSign == "!=") { + flag = incommingEventValue != setEventValue; + } else if (setEventSign == "<") { + flag = incommingEventValue.toFloat() < setEventValue.toFloat(); + } else if (setEventSign == ">") { + flag = incommingEventValue.toFloat() > setEventValue.toFloat(); + } else if (setEventSign == ">=") { + flag = incommingEventValue.toFloat() >= setEventValue.toFloat(); + } else if (setEventSign == "<=") { + flag = incommingEventValue.toFloat() <= setEventValue.toFloat(); + } + + if (flag) { + //SerialPrint("I", "Scenario", "incomming Event Value: " + incommingEventValue); + //SerialPrint("I", "Scenario", "set Event Value: " + setEventValue); + + oneBlock = deleteBeforeDelimiter(oneBlock, "\n"); + oneBlock.replace("end", ""); + SerialPrint("I", "Scenario", condition + " \n" + oneBlock); + spaceCmdExecute(oneBlock); + } + } + allBlocks = deleteBeforeDelimiter(allBlocks, "end\n"); + } + eventBuf = deleteBeforeDelimiter(eventBuf, ","); + } +}; + +extern Scenario* myScenario; + +extern void streamEventUDP(String event); \ No newline at end of file diff --git a/include/Clock.h b/include/Clock.h new file mode 100644 index 00000000..83ce72dc --- /dev/null +++ b/include/Clock.h @@ -0,0 +1,168 @@ +#pragma once + +#include "Clock.h" +#include "Global.h" +#include "Utils/TimeUtils.h" +#include "Utils\SerialPrint.h" + +extern void clockInit(); + +#ifdef ESP8266 +#include "sntp.h" +#endif + + + +class Clock { + private: + Time_t _time_local; + Time_t _time_utc; + unsigned long _uptime; + unsigned long _unixtime; + int _timezone; + String _ntp; + bool _hasSynced; + bool _configured; + + public: + Clock() : _uptime{0}, _timezone{0}, _ntp{""}, _hasSynced{false}, _configured{false} {}; + + void loop() { + unsigned long passed = millis_since(_uptime); + if (passed < ONE_SECOND_ms) { + return; + } + _uptime += passed; + + // world time + time_t now = getSystemTime(); + time_t estimated = _unixtime + (passed / ONE_SECOND_ms); + double drift = difftime(now, estimated); + if (drift > 1) { + // Обработать ситуации c дрифтом времени на значительные величины + } + + _unixtime = now; + + breakEpochToTime(_unixtime, _time_utc); + + breakEpochToTime(_unixtime + getOffsetInSeconds(_timezone), _time_local); + } + + bool hasSync() { + if (!_hasSynced) { + startSync(); + } + return _hasSynced; + } + + void setNtpPool(String ntp) { + if (!_ntp.equals(ntp)) { + _ntp = ntp; + _configured = false; + } + } + + void setTimezone(int timezone) { + if (_timezone != timezone) { + _timezone = timezone; + _configured = false; + } + } + + void startSync() { + if (!_configured) { + SerialPrint("I", "NTP", "sync to: " + _ntp + " timezone: " + String(_timezone)); + setupSntp(); + _configured = true; + return; + } + _hasSynced = hasTimeSynced(); + if (_hasSynced) { + SerialPrint("I", "NTP", "synced " + getDateDotFormated() + " " + getTime()); + } else { + SerialPrint("E", "NTP", "failed to obtain time"); + } + } + + void setupSntp() { +#ifdef ESP8266 + sntp_setservername(0, _ntp.c_str()); + sntp_setservername(1, "ru.pool.ntp.org"); + sntp_setservername(2, "pool.ntp.org"); + sntp_stop(); + sntp_set_timezone(0); + sntp_init(); +#else + configTime(0, 0, _ntp.c_str(), "ru.pool.ntp.org", "pool.ntp.org"); +#endif + } + + bool hasTimeSynced() const { + return _unixtime > MIN_DATETIME; + } + + time_t getSystemTime() const { + timeval tv{0, 0}; + timezone tz = timezone{0, 0}; + time_t epoch = 0; + if (gettimeofday(&tv, &tz) != -1) { + epoch = tv.tv_sec; + } + return epoch; + } + + const String getTimeUnix() { + return String(_unixtime); + } + + /* + * Локальное время "дд.ММ.гг" + */ + const String getDateDotFormated() { + char buf[32]; + sprintf(buf, "%02d.%02d.%02d", _time_local.day_of_month, _time_local.month, _time_local.year); + return String(buf); + } + + /* + * Локальное дата время "дд.ММ.гг чч.мм.cc" + */ + const String getDateTimeDotFormated() { + char buf[32]; + sprintf(buf, "%02d.%02d.%02d %02d:%02d:%02d", _time_local.day_of_month, _time_local.month, _time_local.year, _time_local.hour, _time_local.minute, _time_local.second); + return String(buf); + } + + /* + * Локальное время "чч:мм:cc" + */ + const String getTime() { + char buf[32]; + sprintf(buf, "%02d:%02d:%02d", _time_local.hour, _time_local.minute, _time_local.second); + return String(buf); + } + + const String getTimeJson() { + char buf[32]; + sprintf(buf, "%02d-%02d-%02d", _time_local.hour, _time_local.minute, _time_local.second); + return String(buf); + } + + /* + * Локальное время "чч:мм" + */ + const String getTimeWOsec() { + char buf[32]; + sprintf(buf, "%02d:%02d", _time_local.hour, _time_local.minute); + return String(buf); + } + + /* + * Время с момента запуска "чч:мм:cc" далее "дд чч:мм" + */ + const String getUptime() { + return prettyMillis(_uptime); + } +}; +extern Clock* timeNow; \ No newline at end of file diff --git a/include/Cmd.h b/include/Cmd.h new file mode 100644 index 00000000..f19f54d1 --- /dev/null +++ b/include/Cmd.h @@ -0,0 +1,64 @@ +#pragma once + +#include + +extern void cmd_init(); + + +//extern void levelPr(); +//extern void ultrasonicCm(); +//extern void ultrasonic_reading(); + +extern void analog_reading1(); +extern void analog_reading2(); +extern void dallas_reading(); +extern void dhtT_reading(); + +//extern void dallas(); + +extern void bmp280T(); +extern void bmp280P(); +extern void bmp280T_reading(); +extern void bmp280P_reading(); + +extern void bme280T(); +extern void bme280P(); +extern void bme280H(); +extern void bme280A(); + +extern void bme280T_reading(); +extern void bme280P_reading(); +extern void bme280H_reading(); +extern void bme280A_reading(); + +//extern void dhtT(); +//extern void dhtH(); +//extern void dhtP(); +//extern void dhtC(); +//extern void dhtD(); +//extern void dhtH_reading(); +//extern void dhtP_reading(); +//extern void dhtC_reading(); +//extern void dhtD_reading(); + +extern void timeInit(); +extern void stepper(); +extern void stepperSet(); +extern void servo_(); +extern void servoSet(); +extern void serialBegin(); +extern void serialWrite(); +extern void logging(); + +extern void button(); +extern void timeSet(); + +extern void mqttOrderSend(); +extern void httpOrderSend(); +extern void firmwareVersion(); +extern void firmwareUpdate(); +extern void loadScenario(); + +extern void fileCmdExecute(const String& filename); +extern void csvCmdExecute(String& cmdStr); +extern void spaceCmdExecute(String& cmdStr); \ No newline at end of file diff --git a/include/Consts.h b/include/Consts.h new file mode 100644 index 00000000..6bb81719 --- /dev/null +++ b/include/Consts.h @@ -0,0 +1,127 @@ +#pragma once + +#define FIRMWARE_VERSION 274 + +#ifdef esp8266_4mb +#define FIRMWARE_NAME "esp8266_4mb" +#define USE_LITTLEFS true +#define USE_OTA true +#define LED_PIN 2 +#endif + +#ifdef esp8266_1mb +#define FIRMWARE_NAME "esp8266_1mb" +#define USE_LITTLEFS false +#define USE_OTA false +#define LED_PIN 2 +#endif + +#ifdef esp32_4mb +#define FIRMWARE_NAME "esp32_4mb" +#define USE_LITTLEFS false +#define USE_OTA true +#define LED_PIN 22 +#endif + +#define NUM_BUTTONS 6 +#define MQTT_RECONNECT_INTERVAL 20000 +#define TELEMETRY_UPDATE_INTERVAL_MIN 60 +#define DEVICE_CONFIG_FILE "s.conf.csv" +#define DEVICE_SCENARIO_FILE "s.scen.txt" +//=========System parts=========================================================================================================================================== +//#define OTA_UPDATES_ENABLED +//#define MDNS_ENABLED +//#define WEBSOCKET_ENABLED +//#define LAYOUT_IN_RAM +//#define UDP_ENABLED +//#define SSDP_ENABLED +#define SensorBme280Enabled +#define SensorBmp280Enabled +#define SensorDhtEnabled +#define PwmOutEnable +#define telegramEnable +#define uartEnable +//================================================================================================================================================================ + + + +enum TimerTask_t { WIFI_SCAN, + WIFI_MQTT_CONNECTION_CHECK, + TIME, + TIME_SYNC, + STATISTICS, + UPTIME, + UDP, + SYGNAL }; + +enum NotAsyncActions { + do_ZERO, + do_UPGRADE, + do_GETLASTVERSION, + do_BUSSCAN, + do_MQTTPARAMSCHANGED, + do_deviceInit, + do_delChoosingItems, + do_addItem, + do_addPreset, + do_sendScenUDP, + do_sendScenMQTT, + do_LAST, +}; + +enum LedStatus_t { + LED_OFF, + LED_ON, + LED_SLOW, + LED_FAST +}; + +enum ConfigType_t { + CT_CONFIG, + CT_SCENARIO +}; + + + + + + + + + + + + + + + + + + + + + +//history +//07.11.2020 (SSDP OFF, UDP OFF) +//RAM: [===== ] 46.8% (used 38376 bytes from 81920 bytes) +//Flash: [===== ] 54.2% (used 566004 bytes from 1044464 bytes) + +//13.11.2020 (SSDP OFF, UDP OFF) +//RAM: [===== ] 46.6% (used 38208 bytes from 81920 bytes) +//Flash: [===== ] 54.2% (used 566388 bytes from 1044464 bytes) + +//15.11.2020 (SSDP OFF, UDP OFF) +//RAM: [===== ] 46.1% (used 37780 bytes from 81920 bytes) +//Flash: [===== ] 54.3% (used 566656 bytes from 1044464 bytes) + +//17.11.2020 (SSDP OFF, UDP OFF) +//RAM: [===== ] 45.7% (used 37476 bytes from 81920 bytes) +//Flash: [===== ] 54.5% (used 569296 bytes from 1044464 bytes) + +//RAM: [===== ] 45.6% (used 37336 bytes from 81920 bytes) +//Flash: [====== ] 55.3% (used 577396 bytes from 1044464 bytes) + +//eventBuf - буфер событий которые проверяются в сценариях, +//и если событие удовлетворяет какому нибудь условию то выполняются указанные команды + +//orderBuf - буфер команд которые выполняются сейчас же \ No newline at end of file diff --git a/include/ESP32.h b/include/ESP32.h new file mode 100644 index 00000000..1662e906 --- /dev/null +++ b/include/ESP32.h @@ -0,0 +1,26 @@ +#pragma once + +#ifdef ESP32 +// don't change order +#include "WiFi.h" +// + +#include "ESPAsyncWebServer.h" +#include "SPIFFSEditor.h" +// don't change order +#include +#include +#include +#include + +// +#include +#include + +#ifdef MDNS_ENABLED +#include +#endif + +extern AsyncUDP udp; + +#endif \ No newline at end of file diff --git a/include/ESP8266.h b/include/ESP8266.h new file mode 100644 index 00000000..76abdc10 --- /dev/null +++ b/include/ESP8266.h @@ -0,0 +1,18 @@ +#pragma once + +#ifdef ESP8266 +#include +#include +#include "ESPAsyncTCP.h" +#include "ESPAsyncWebServer.h" +#include +#include +#include +#include +#ifdef MDNS_ENABLED +#include +#endif + +extern WiFiUDP udp; + +#endif \ No newline at end of file diff --git a/include/FSEditor.h b/include/FSEditor.h new file mode 100644 index 00000000..4fcdef02 --- /dev/null +++ b/include/FSEditor.h @@ -0,0 +1,29 @@ +#pragma once + +#include +#include "FileSystem.h" + +class FSEditor : public AsyncWebHandler { + private: + fs::FS _fs; + String _username; + String _password; + bool _authenticated; + uint32_t _startTime; + + private: + void getDirList(const String& path, String& output); + + public: +#ifdef ESP32 + FSEditor(const fs::FS& fs, const String& username = String(), const String& password = String()); +#else + FSEditor(const String& username = String(), const String& password = String(), const fs::FS& fs = FileFS); +#endif + virtual bool canHandle(AsyncWebServerRequest* request) override final; + virtual void handleRequest(AsyncWebServerRequest* request) override final; + virtual void handleUpload(AsyncWebServerRequest* request, const String& filename, size_t index, uint8_t* data, size_t len, bool final) override final; + virtual bool isRequestHandlerTrivial() override final { + return false; + } +}; \ No newline at end of file diff --git a/include/FileSystem.h b/include/FileSystem.h new file mode 100644 index 00000000..ae31147e --- /dev/null +++ b/include/FileSystem.h @@ -0,0 +1,36 @@ +#pragma once + +#include "Consts.h" + +#define FILE_READ "r" +#define FILE_WRITE "w" +#define FILE_APPEND "a" + +#include + +#ifdef ESP32 +#include +extern FS* filesystem; +#define FileFS SPIFFS +#define FS_NAME "SPIFFS" +#endif + +#ifdef ESP8266 +#if USE_LITTLEFS +#include "LittleFS.h" +extern FS LittleFS; +using littlefs_impl::LittleFSConfig; +extern FS* filesystem; +#define FileFS LittleFS +#define FS_NAME "LittleFS" +#else +extern FS* filesystem; +#define FileFS SPIFFS +#define FS_NAME "SPIFFS" +#endif +#endif + +extern void getFSInfo(); +#ifdef ESP8266 +extern bool getInfo(FSInfo& info); +#endif \ No newline at end of file diff --git a/include/Global.h b/include/Global.h new file mode 100644 index 00000000..67f4c02e --- /dev/null +++ b/include/Global.h @@ -0,0 +1,152 @@ +#pragma once +//===================Libraries=================================================================================================================================================== +#include "Consts.h" + + +#include +#include "CTBot.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "Clock.h" +#include "ESP32.h" +#include "ESP8266.h" +#include "GyverFilters.h" +#include "MqttClient.h" +#include "Upgrade.h" + +#include "Utils/FileUtils.h" +#include "Utils/JsonUtils.h" +#include "Utils/SerialPrint.h" +#include "Utils/StringUtils.h" +#include "Utils/SysUtils.h" +#include "Utils/WiFiUtils.h" + +#ifdef WEBSOCKET_ENABLED +extern AsyncWebSocket ws; +//extern AsyncEventSource events; +#endif + + +extern TickerScheduler ts; +extern WiFiClient espClient; +extern PubSubClient mqtt; +extern StringCommand sCmd; +extern AsyncWebServer server; + +extern boolean but[NUM_BUTTONS]; +extern Bounce* buttons; + +//Global vars +extern boolean just_load; +extern boolean telegramInitBeen; + +// Json +extern String configSetupJson; //все настройки +extern String configLiveJson; //все данные с датчиков (связан с mqtt) +extern String configStoreJson; //все данные которые должны сохраняться +extern String configOptionJson; //для трансфера +extern String telegramMsgJson; +extern String getValue(String& key); + +// Mqtt +extern String chipId; +extern String prex; +extern String all_widgets; +extern String scenario; + +//orders and events +extern String orderBuf; +extern String eventBuf; +extern String itemsFile; +extern String itemsLine; + +//key lists and numbers +//========================================= +extern String impuls_KeyList; +extern int impuls_EnterCounter; +//========================================= +extern String buttonOut_KeyList; +extern int buttonOut_EnterCounter; +//========================================= +extern String inOutput_KeyList; +extern int inOutput_EnterCounter; +//========================================= +extern String pwmOut_KeyList; +extern int pwmOut_EnterCounter; +//========================================= +extern String countDown_KeyList; +extern int countDown_EnterCounter; +//========================================= +extern String logging_KeyList; +extern int logging_EnterCounter; +//========================================= +extern int dht_EnterCounter; +//========================================= + + + +extern String itemName; +extern String presetName; + + +extern int scenario_line_status[40]; +extern int lastVersion; + +// Main +extern void setChipId(); +extern void saveConfig(); +extern void setConfigParam(const char* param, const String& value); + +extern String getURL(const String& urls); +extern void do_fscheck(); +extern void doBusScan(); +extern void servo_(); + +extern void setLedStatus(LedStatus_t); + +//Scenario +extern void eventGen2(String eventName, String eventValue); +extern String add_set(String param_name); + +//Timers +extern void Timer_countdown_init(); +extern void timerStart_(); +extern void addTimer(String number, String time); +extern void timerStop_(); +extern void delTimer(String number); +extern int readTimer(int number); + +extern void upgradeInit(); + +// widget +extern void createWidgetByType(String widget_name, String page_name, String page_number, String file, String topic); +extern void createWidgetParam(String widget_name, String page_name, String page_number, String file, String topic, String name1, String param1, String name2, String param2, String name3, String param3); +extern void createWidget(String widget_name, String page_name, String page_number, String type, String topik); +extern void createChart(String widget_name, String page_name, String page_number, String file, String topic, String maxCount); + +// PushingBox +extern void pushControl(); + +// UDP +//extern void udpInit(); +//extern void do_udp_data_parse(); +//extern void do_mqtt_send_settings_to_udp(); + +extern void do_update(); + +// Init +extern void uptime_init(); + +// Web +extern void web_init(); + +// Upgrade +extern String serverIP; diff --git a/include/HttpServer.h b/include/HttpServer.h new file mode 100644 index 00000000..fa7a5187 --- /dev/null +++ b/include/HttpServer.h @@ -0,0 +1,9 @@ +#pragma once + +#include "Global.h" + +namespace HttpServer { + +void init(); + +} // namespace HttpServer diff --git a/include/Init.h b/include/Init.h new file mode 100644 index 00000000..e7fc3157 --- /dev/null +++ b/include/Init.h @@ -0,0 +1,10 @@ +#pragma once + +extern void loadConfig(); +extern void espInit(); +extern void statistics_init(); +extern void loadScenario(); +extern void deviceInit(); +extern void prsets_init(); +extern void handle_uptime(); +extern void handle_statistics(); diff --git a/include/ItemsList.h b/include/ItemsList.h new file mode 100644 index 00000000..573ad33a --- /dev/null +++ b/include/ItemsList.h @@ -0,0 +1,16 @@ +#pragma once + +#include +#include "Global.h" + +extern void itemsListInit(); +extern void addItem2(int num); +extern void addItem(String name); +extern void addPreset(String name); +extern void addPreset2(int num); +extern void delChoosingItems(); +extern void delAllItems(); +extern uint8_t getNewElementNumber(String file); +extern uint8_t getFreePinAll(); +extern bool isPinExist(unsigned int num); +extern uint8_t getFreePinAnalog(); diff --git a/include/Macro.h b/include/Macro.h new file mode 100644 index 00000000..bf1fe7ce --- /dev/null +++ b/include/Macro.h @@ -0,0 +1,9 @@ +//#pragma once +//#define ST(A) #A +//#define STR(A) ST(A) +// +//#ifdef esp32_4mb +//#pragma message STR(esp32_4mb) +//#endif + +//Serial.println(STR(esp32_4mb)); \ No newline at end of file diff --git a/include/MqttClient.h b/include/MqttClient.h new file mode 100644 index 00000000..88a166d7 --- /dev/null +++ b/include/MqttClient.h @@ -0,0 +1,27 @@ +#pragma once + +#include + +extern String mqttPrefix; +extern String mqttRootDevice; + +void mqttInit(); +boolean mqttConnect(); +void mqttReconnect(); +void mqttLoop(); +void mqttSubscribe(); + +boolean publish(const String& topic, const String& data); +boolean publishData(const String& topic, const String& data); +boolean publishChart(const String& topic, const String& data); +boolean publishControl(String id, String topic, String state); +boolean publishChart_test(const String& topic, const String& data); +boolean publishStatus(const String& topic, const String& data); +boolean publishEvent(const String& topic, const String& data); +boolean publishInfo(const String& topic, const String& data); + +void publishWidgets(); +void publishState(); + +void mqttCallback(char* topic, uint8_t* payload, size_t length); +const String getStateStr(); diff --git a/include/MqttDiscovery.h b/include/MqttDiscovery.h new file mode 100644 index 00000000..282b26fc --- /dev/null +++ b/include/MqttDiscovery.h @@ -0,0 +1,8 @@ +#pragma once + +#include "Utils/SysUtils.h" + +namespace Discovery { + + +} \ No newline at end of file diff --git a/include/RemoteOrdersUdp.h b/include/RemoteOrdersUdp.h new file mode 100644 index 00000000..1500c55e --- /dev/null +++ b/include/RemoteOrdersUdp.h @@ -0,0 +1,9 @@ +#pragma once +#ifdef ESP8266 +#include "ESPAsyncUDP.h" +extern AsyncUDP asyncUdp; +extern void asyncUdpInit(); +extern String uint8tToString(uint8_t* data, size_t len); +extern bool udpPacketValidation(String& data); +extern void udpPacketParse(String& data); +#endif \ No newline at end of file diff --git a/include/SSDP.h b/include/SSDP.h new file mode 100644 index 00000000..353b193c --- /dev/null +++ b/include/SSDP.h @@ -0,0 +1,9 @@ +#pragma once + +#include + +#include "Consts.h" + +#ifdef SSDP_ENABLED +void SsdpInit(); +#endif \ No newline at end of file diff --git a/include/Sensors.h b/include/Sensors.h new file mode 100644 index 00000000..45dcbb04 --- /dev/null +++ b/include/Sensors.h @@ -0,0 +1,3 @@ +#pragma once + + diff --git a/include/Servo/Servos.h b/include/Servo/Servos.h new file mode 100644 index 00000000..db53c01e --- /dev/null +++ b/include/Servo/Servos.h @@ -0,0 +1,29 @@ +#pragma once + +#include +#ifdef ESP8266 +#include +#else +#include +#endif + +struct Servo_t { + uint8_t num; + uint8_t pin; + Servo* obj; + Servo_t(uint8_t num, uint8_t pin) : num{num}, pin{pin}, obj{nullptr} {}; +}; + +class Servos { + public: + Servos(); + Servo* get(uint8_t num); + Servo* create(uint8_t num, uint8_t pin); + + size_t count(); + + private: + std::vector _items; +}; + +extern Servos myServo; \ No newline at end of file diff --git a/include/SoftUART.h b/include/SoftUART.h new file mode 100644 index 00000000..6cd707f9 --- /dev/null +++ b/include/SoftUART.h @@ -0,0 +1,18 @@ +#pragma once +#include "Consts.h" +#ifdef uartEnable +#include "SoftwareSerial.h" + +#ifdef ESP8266 +#include +extern SoftwareSerial* myUART; +#else +#include +extern HardwareSerial* myUART; +#endif + + +extern void uartInit(); +extern void uartHandle(); +extern void parse(String& incStr); +#endif \ No newline at end of file diff --git a/include/Strings_.h b/include/Strings_.h new file mode 100644 index 00000000..21865168 --- /dev/null +++ b/include/Strings_.h @@ -0,0 +1,139 @@ +#pragma once + +//Strings +// #include +#include + +#include +#include + +class char_array { + private: + char *p_stringarray; //initial input array + char *p_inputstring; //holds actual length data + //char **pp_database_string; //allocate data database.cpp + int stringsize; //holds array size to allocate memory + int charinput; //holds array input size + + public: + inline char_array(); //inline so other functions can call on it + inline ~char_array(); + inline void getinput(char *&); //retrieves user input + inline void grabline(char *&); //retrieve line with whitespace included NOT COMPLETE, may not need + inline int sortline(char **&, char *&); //sorts line into an array of strings and returns number of separate strings + inline int arraysize(); //returns size of string array + inline void printinput(); //print input string + inline void changedefaultsize(); //change default input size NOT COMPLETE +}; + +inline char_array::char_array() //constructor +{ + stringsize = 0; + charinput = 64; + p_stringarray = new char[charinput]; +} + +inline char_array::~char_array() //destructor +{ + delete[] p_inputstring; + delete[] p_stringarray; +} + +inline void char_array::getinput(char *&p_stringin) { + stringsize = 0; + + scanf("%63s", p_stringarray); //get input string + + while (p_stringarray[stringsize] != 0) //finding out the size of string array + { + stringsize++; + } + stringsize++; + + p_inputstring = new char[stringsize]; //reallocate memory block and set array inside + for (int i = 0; i < stringsize; i++) { + p_inputstring[i] = p_stringarray[i]; + } + + p_inputstring[stringsize - 1] = '\x00'; + + p_stringin = new char[stringsize]; //set pp_stringin + + p_stringin = p_inputstring; +} + +inline void char_array::grabline(char *&p_stringin) { + stringsize = 0; + std::cin.getline(p_stringarray, charinput); + while (p_stringarray[stringsize] != 0) { + stringsize++; + } + stringsize++; + p_inputstring = new char[stringsize]; + + for (int i = 0; i < stringsize; i++) { + p_inputstring[i] = p_stringarray[i]; + } + + p_stringin = new char[stringsize]; + p_stringin = p_inputstring; +} + +inline int char_array::sortline(char **&pp_stringin, char *&p_string) { + int position = 0; //position in string + int charcount = 1; //how many characters there are + int wordnum; //which word is being processed + int wordcount = 1; //number of words in string + int bookmark = 0; //holds last known position + + while (p_string[position] == ' ') { + position++; + } + + wordnum = position; //borrow wordnum to hold position value + while (p_string[position] != '\x00') //find total inputted string word length + { + if ((p_string[position] == ' ') && ((p_string[position + 1] != ' ') || (p_string[position + 1] != '\x00'))) { + wordcount++; + } + position++; + } + position = wordnum; //set position to original value + for (wordnum = 0; wordnum < wordcount; wordnum++) { + charcount = 1; + while (p_string[position] == ' ') { + position++; + } + while ((p_string[position] != ' ') && (p_string[position] != '\x00')) { + position++; + charcount++; + } + pp_stringin[wordnum] = new char[charcount]; + + for (int i = 0; i < charcount; i++) { + pp_stringin[wordnum][i] = p_string[i + bookmark]; + } + pp_stringin[wordnum][charcount - 1] = '\x00'; + bookmark = position + 1; + } + + return wordcount; +} + +inline int char_array::arraysize() { + if (stringsize != 0) { + return stringsize; + } else { + printf("Array size is set at 0\n"); + return 0; + } +} + +inline void char_array::printinput() { + printf("%s", p_inputstring); +} + +inline void char_array::changedefaultsize() { + printf("Input new default input string size: "); + scanf("%i", charinput); +} diff --git a/include/Telegram.h b/include/Telegram.h new file mode 100644 index 00000000..7b3c656d --- /dev/null +++ b/include/Telegram.h @@ -0,0 +1,13 @@ +#pragma once +#include "Consts.h" +#ifdef telegramEnable +#include "Global.h" + +extern void sendTelegramMsg(); +extern void telegramInit(); +extern void handleTelegram(); +extern bool isTelegramEnabled(); +extern bool isTelegramInputOn(); +extern void telegramMsgParse(String msg); +extern String returnListOfParams(); +#endif \ No newline at end of file diff --git a/include/Tests.h b/include/Tests.h new file mode 100644 index 00000000..cfec2e53 --- /dev/null +++ b/include/Tests.h @@ -0,0 +1,3 @@ +#pragma once + +extern void testsPerform(); \ No newline at end of file diff --git a/include/Upgrade.h b/include/Upgrade.h new file mode 100644 index 00000000..b02adb12 --- /dev/null +++ b/include/Upgrade.h @@ -0,0 +1,10 @@ +#pragma once + +#include + +extern void upgradeInit(); +extern void getLastVersion(); +extern void upgrade_firmware(int type); +extern bool upgradeFS(); +extern bool upgradeBuild(); +extern void restartEsp(); \ No newline at end of file diff --git a/include/Utils/FileHelper.h b/include/Utils/FileHelper.h new file mode 100644 index 00000000..b5ba764c --- /dev/null +++ b/include/Utils/FileHelper.h @@ -0,0 +1,46 @@ +#pragma once +#include + +#include "FileSystem.h" + +class FileHelper { + public: + FileHelper(const String filename); + /* + * Проверить существование + */ + void exists(); + /* + * Удалить файл + */ + void remove(); + /* + * Открыть файл установить позицию @position + */ + File seek(size_t position = 0); + + /* + * Чтение строки с содержащей @substr + */ + String readFileString(const String substr); + + /* + * Добовление строки @str в файл + */ + String appendStr(const String str); + + /* + * Запись строки + */ + String writeStr(const String); + + /* + * Чтение в строку + */ + String readStr(size_t); + + /* + * Размер в байтах + */ + size_t getSize(); +}; \ No newline at end of file diff --git a/include/Utils/FileUtils.h b/include/Utils/FileUtils.h new file mode 100644 index 00000000..686b3a2b --- /dev/null +++ b/include/Utils/FileUtils.h @@ -0,0 +1,62 @@ +#pragma once +#include + +#include "Consts.h" +#include "FileSystem.h" + +/* +* Инициализация ФС +*/ +bool fileSystemInit(); + +/* +* Удалить файл +*/ +void removeFile(const String& filename); + +/* +* Открыть файл на позиции +*/ +File seekFile(const String& filename, size_t position = 0); + +/* +* Чтение строки из файла +* возвращает стоку из файла в которой есть искомое слово found +*/ +const String readFileString(const String& filename, const String& to_find); + +/* +* Добовление строки в файл +*/ +const String addFileLn(const String& filename, const String& str); + +/* +* Добовление строки в файл +*/ +const String addFile(const String& filename, const String& str); + +/* +* Запись строки в файл +*/ +const String writeFile(const String& filename, const String& str); + +/* +* Чтение файла в строку +*/ +const String readFile(const String& filename, size_t max_size); + +/* +* Посчитать +*/ +size_t countLines(const String filename); + +/* +* Размер файла +*/ +size_t getFileSize(const String filename); + +bool copyFile(const String& src, const String& dst, bool overwrite = true); + +const String getFSSizeInfo(); + +const String getConfigFile(uint8_t preset, ConfigType_t type); diff --git a/include/Utils/JsonUtils.h b/include/Utils/JsonUtils.h new file mode 100644 index 00000000..2b19dcc5 --- /dev/null +++ b/include/Utils/JsonUtils.h @@ -0,0 +1,21 @@ +#pragma once + +#include + +String jsonReadStr(String& json, String name); + +int jsonReadInt(String& json, String name); + +boolean jsonReadBool(String& json, String name); + +String jsonWriteStr(String& json, String name, String value); + +String jsonWriteInt(String& json, String name, int value); + +String jsonWriteFloat(String& json, String name, float value); + +String jsonWriteBool(String& json, String name, boolean value); + +void saveConfig(); + +void saveStore(); \ No newline at end of file diff --git a/include/Utils/SerialPrint.h b/include/Utils/SerialPrint.h new file mode 100644 index 00000000..f0d2d79c --- /dev/null +++ b/include/Utils/SerialPrint.h @@ -0,0 +1,3 @@ +#pragma once +#include +void SerialPrint(String errorLevel, String module, String msg); \ No newline at end of file diff --git a/include/Utils/StringUtils.h b/include/Utils/StringUtils.h new file mode 100644 index 00000000..e98a8f76 --- /dev/null +++ b/include/Utils/StringUtils.h @@ -0,0 +1,34 @@ +#pragma once + +#include + +uint8_t hexStringToUint8(String hex); + +uint16_t hexStringToUint16(String hex); + +String selectToMarkerLast(String str, String found); + +String selectToMarker(String str, String found); + +String extractInner(String str); + +String deleteAfterDelimiter(String str, String found); + +String deleteBeforeDelimiter(String str, String found); + +String deleteBeforeDelimiterTo(String str, String found); + +String deleteToMarkerLast(String str, String found); + +String selectFromMarkerToMarker(String str, String found, int number); + +size_t itemsCount2(String str, const String& separator); + +size_t itemsCount(String& str, const char* delim); + +boolean isDigitStr(const String& str); + +boolean isDigitDotCommaStr(const String& str); + +String prettyBytes(size_t size); + diff --git a/include/Utils/SysUtils.h b/include/Utils/SysUtils.h new file mode 100644 index 00000000..de03e287 --- /dev/null +++ b/include/Utils/SysUtils.h @@ -0,0 +1,19 @@ +#pragma once +#include +#include "Global.h" + +uint32_t ESP_getChipId(); + +const String getChipId(); + +void setLedStatus(LedStatus_t status); + +const String getUniqueId(const String& name); + +const String printMemoryStatus(); + +const String getHeapStats(); + +const String getMacAddress(); + +void setChipId(); diff --git a/include/Utils/TimeUtils.h b/include/Utils/TimeUtils.h new file mode 100644 index 00000000..8b4c0739 --- /dev/null +++ b/include/Utils/TimeUtils.h @@ -0,0 +1,69 @@ +#pragma once + +#include + +#include "Consts.h" + +#define ONE_MINUTE_s 60 +#define ONE_HOUR_m 60 +#define ONE_HOUR_s 60 * ONE_MINUTE_s +#define LEAP_YEAR(Y) (((1970 + Y) > 0) && !((1970 + Y) % 4) && (((1970 + Y) % 100) || !((1970 + Y) % 400))) +#define MIN_DATETIME 1575158400 +#define ONE_SECOND_ms 1000 + +/* +* Время (мс) прошедщее с @since +*/ +unsigned long millis_since(unsigned long sinse); + +/* +* Интерввал времени (мс) между @start и @finish +*/ +unsigned long millis_passed(unsigned long start, unsigned long finish); + +/* +* Форматиронное время интервала (мс) +* "чч:мм:cc", +* "дд чч:мм", если > 24 часов +*/ +const String prettyMillis(unsigned long time_ms = millis()); + +/* +* Форматиронное время интервала (c) +* "чч:мм:cc", +* "дд чч:мм", если > 24 часов +*/ +const String prettySeconds(unsigned long time_s); + +/* +* Тайм зона в секундах +*/ +int getOffsetInSeconds(int timezone); + +/* +* Тайм зона в минутах +*/ +int getOffsetInMinutes(int timezone); + +/* +* Разбивает время на составляющие +*/ + +struct Time_t { + uint8_t second; + uint8_t minute; + uint8_t hour; + uint8_t day_of_week; + uint8_t day_of_month; + uint8_t month; + uint16_t day_of_year; + uint16_t year; + unsigned long days; + unsigned long valid; +}; + +void breakEpochToTime(unsigned long epoch, Time_t& tm); + + + +void timeInit(); \ No newline at end of file diff --git a/include/Utils/Timings.h b/include/Utils/Timings.h new file mode 100644 index 00000000..c992eeee --- /dev/null +++ b/include/Utils/Timings.h @@ -0,0 +1,71 @@ +#include + +enum Timings_t { MT_ONE, + MT_TWO, + NUM_TIMINGS }; + +struct Timing { + unsigned long _total_mu; + unsigned long _min_mu; + unsigned long _max_mu; + + Timing() : _total_mu{0}, _min_mu{999999}, _max_mu{0} {}; + + void reset() { + _total_mu = 0; + _min_mu = 999999; + _max_mu = 0; + } + + void add(unsigned long time_mu) { + if (time_mu == 0) return; + + _total_mu += time_mu; + + if (_min_mu > time_mu) { + _min_mu = time_mu; + } + + if (_max_mu < time_mu) { + _max_mu = time_mu; + } + } +}; + +static const char* module_name[NUM_TIMINGS] = {"strings", "boolean"}; + +struct Timings { + Timing mu[NUM_TIMINGS]; + + unsigned long _counter; + unsigned long _start; + unsigned long long _total; + + Timings() : _counter{0}, _start{0} {}; + + void add(size_t module, unsigned long now = micros()) { + unsigned long time = now - _start; + _total += time; + mu[module].add(time); + _start = now; + } + + void count() { + _counter++; + _start = micros(); + } + + void print() { + if (!_counter) { + return; + }; + Serial.printf("lp/ms: %llu ", _counter / _total); + for (size_t i = 0; i < NUM_TIMINGS; i++) { + Serial.printf("%s: %.2f%% ", module_name[i], ((float)mu[i]._total_mu / _total) * 100); + mu[i].reset(); + } + Serial.println(); + _counter = 0; + _total = 0; + }; +}; \ No newline at end of file diff --git a/include/Utils/WebUtils.h b/include/Utils/WebUtils.h new file mode 100644 index 00000000..f9b74587 --- /dev/null +++ b/include/Utils/WebUtils.h @@ -0,0 +1,7 @@ +#pragma once +#include "HttpServer.h" +#include + +extern String getURL(const String& urls); +extern const String getMethodName(AsyncWebServerRequest* request); +extern const String getRequestInfo(AsyncWebServerRequest* request); diff --git a/include/Utils/WiFiUtils.h b/include/Utils/WiFiUtils.h new file mode 100644 index 00000000..7a634009 --- /dev/null +++ b/include/Utils/WiFiUtils.h @@ -0,0 +1,16 @@ +#pragma once + +#include "Global.h" + +boolean isNetworkActive(); + +void routerConnect(); + +bool startAPMode(); + +boolean RouterFind(String ssid); + +uint8_t RSSIquality(); + +extern void wifiSignalInit(); + diff --git a/include/Utils/statUtils.h b/include/Utils/statUtils.h new file mode 100644 index 00000000..c01e0bb8 --- /dev/null +++ b/include/Utils/statUtils.h @@ -0,0 +1,22 @@ +#pragma once +#include +#include "Global.h" + +extern void initSt(); +extern String updateDevicePsn(String lat, String lon, String accur, String geo); +extern String updateDeviceStatus(); +extern String addNewDevice(); + +extern void decide(); +extern void getPsn(); + +extern String getUptimeTotal(); +extern uint8_t getNextNumber(String file); +extern uint8_t getCurrentNumber(String file); + +//extern int plusOneHour(); +//extern void eeWriteInt(int pos, int val); +//extern int eeGetInt(int pos); +//extern void updateDeviceList(); +//extern void saveId(String file, int id); +//extern int getId(String file); \ No newline at end of file diff --git a/include/Web.h b/include/Web.h new file mode 100644 index 00000000..a80a08d2 --- /dev/null +++ b/include/Web.h @@ -0,0 +1,6 @@ +#pragma once +#include "Arduino.h" + + +void web_init(); +void setConfigParam(const char* param, const String& value); diff --git a/include/items/ButtonInClass.h b/include/items/ButtonInClass.h new file mode 100644 index 00000000..1c66b945 --- /dev/null +++ b/include/items/ButtonInClass.h @@ -0,0 +1,61 @@ +#pragma once +#include + +#include "Class/LineParsing.h" +#include "Global.h" + + + +class ButtonInClass : public LineParsing { + protected: + int numberEntering = 0; + int state = _state.toInt(); + + public: + ButtonInClass() : LineParsing(){}; + + void init() { + if (_pin != "") { + int number = numberEntering++; + buttons[number].attach(_pin.toInt()); + buttons[number].interval(_db.toInt()); + but[number] = true; + jsonWriteStr(configOptionJson, "switch_num_" + String(number), _key); + } + } + + void loop() { + static uint8_t switch_number = 1; + if (but[switch_number]) { + buttons[switch_number].update(); + if (buttons[switch_number].fell()) { + String key = jsonReadStr(configOptionJson, "switch_num_" + String(switch_number)); + state = 1; + switchChangeVirtual(key, String(state)); + } + if (buttons[switch_number].rose()) { + String key = jsonReadStr(configOptionJson, "switch_num_" + String(switch_number)); + state = 0; + switchChangeVirtual(key, String(state)); + } + } + switch_number++; + if (switch_number == NUM_BUTTONS) { + switch_number = 0; + } + } + + void switchStateSetDefault() { + if (_state != "") { + switchChangeVirtual(_key, _state); + } + } + + void switchChangeVirtual(String key, String state) { + eventGen2(key, state); + jsonWriteInt(configLiveJson, key, state.toInt()); + publishStatus(key, state); + } +}; + +extern ButtonInClass myButtonIn; \ No newline at end of file diff --git a/include/items/PZEMSensor.cpp b/include/items/PZEMSensor.cpp new file mode 100644 index 00000000..8a073df5 --- /dev/null +++ b/include/items/PZEMSensor.cpp @@ -0,0 +1,309 @@ +#include "PZEMSensor.h" + +#include + +#define REG_VOLTAGE 0x0000 +#define REG_CURRENT_L 0x0001 +#define REG_CURRENT_H 0X0002 +#define REG_POWER_L 0x0003 +#define REG_POWER_H 0x0004 +#define REG_ENERGY_L 0x0005 +#define REG_ENERGY_H 0x0006 +#define REG_FREQUENCY 0x0007 +#define REG_PF 0x0008 +#define REG_ALARM 0x0009 +#define CMD_RHR 0x03 +#define CMD_RIR 0X04 +#define CMD_WSR 0x06 +#define CMD_CAL 0x41 +#define CMD_REST 0x42 +#define WREG_ALARM_THR 0x0001 +#define WREG_ADDR 0x0002 +#define UPDATE_TIME 200 +#define RESPONSE_SIZE 32 +#define READ_TIMEOUT 100 +#define PZEM_BAUD_RATE 9600 + +#define DEBUG +// Debugging function; +void printBuf(uint8_t *buffer, uint16_t len) { +#ifdef DEBUG + for (uint16_t i = 0; i < len; i++) { + char temp[6]; + sprintf(temp, "%.2x ", buffer[i]); + Serial.print(temp); + } + Serial.println(); +#endif +} + +PZEMSensor::PZEMSensor(SoftwareSerial *port, uint16_t addr) { + _serial = port; + _addr = addr; +} + +PZEM_Info *PZEMSensor::values() { + // Update vales if necessary + if (!refresh()) { + _values = PZEM_Info(); + } + return &_values; +} + +/*! + * PZEM004Tv30::sendCmd8 + * + * Prepares the 8 byte command buffer and sends + * + * @param[in] cmd - Command to send (position 1) + * @param[in] rAddr - Register address (postion 2-3) + * @param[in] val - Register value to write (positon 4-5) + * @param[in] check - perform a simple read check after write + * + * @return success +*/ +bool PZEMSensor::sendCmd8(uint8_t cmd, uint16_t rAddr, uint16_t val, bool check, uint16_t slave_addr) { + uint8_t sendBuffer[8]; // Send buffer + uint8_t respBuffer[8]; // Response buffer (only used when check is true) + + if ((slave_addr == 0xFFFF) || + (slave_addr < 0x01) || + (slave_addr > 0xF7)) { + slave_addr = _addr; + } + + sendBuffer[0] = slave_addr; // Set slave address + sendBuffer[1] = cmd; // Set command + + sendBuffer[2] = (rAddr >> 8) & 0xFF; // Set high byte of register address + sendBuffer[3] = (rAddr)&0xFF; // Set low byte =//= + + sendBuffer[4] = (val >> 8) & 0xFF; // Set high byte of register value + sendBuffer[5] = (val)&0xFF; // Set low byte =//= + + setCRC(sendBuffer, 8); // Set CRC of frame + + _serial->write(sendBuffer, 8); // send frame + + if (check) { + if (!recieve(respBuffer, 8)) { // if check enabled, read the response + return false; + } + + // Check if response is same as send + for (uint8_t i = 0; i < 8; i++) { + if (sendBuffer[i] != respBuffer[i]) + return false; + } + } + return true; +} + +bool PZEMSensor::setAddress(uint8_t addr) { + if (addr < 0x01 || addr > 0xF7) // sanity check + return false; + + // Write the new address to the address register + if (!sendCmd8(CMD_WSR, WREG_ADDR, addr, true)) + return false; + + _addr = addr; // If successful, update the current slave address + + return true; +} + +uint8_t PZEMSensor::getAddress() { + return _addr; +} + +bool PZEMSensor::setPowerAlarm(uint16_t watts) { + if (watts > 25000) { // Sanitych check + watts = 25000; + } + + // Write the watts threshold to the Alarm register + if (!sendCmd8(CMD_WSR, WREG_ALARM_THR, watts, true)) + return false; + + return true; +} + +bool PZEMSensor::getPowerAlarm() { + if (!refresh()) // Update vales if necessary + return NAN; // Update did not work, return NAN + + return _values.alarms != 0x0000; +} + +void PZEMSensor::init() { + if (_addr < 0x01 || _addr > 0xF8) { + // Sanity check of address + _addr = PZEM_DEFAULT_ADDR; + } + // Set initial lastRed time so that we read right away + _lastRead = 0; + _lastRead -= UPDATE_TIME; +} + +bool PZEMSensor::refresh() { + static uint8_t response[25]; + if (_lastRead + UPDATE_TIME > millis()) { + return true; + } + // Read 10 registers starting at 0x00 (no check) + sendCmd8(CMD_RIR, 0x00, 0x0A, false); + if (recieve(response, 25) != 25) { // Something went wrong + return false; + } + // Update the current values + _values.voltage = ((uint32_t)response[3] << 8 | // Raw voltage in 0.1V + (uint32_t)response[4]) / + 10.0; + + _values.current = ((uint32_t)response[5] << 8 | // Raw current in 0.001A + (uint32_t)response[6] | + (uint32_t)response[7] << 24 | + (uint32_t)response[8] << 16) / + 1000.0; + + _values.power = ((uint32_t)response[9] << 8 | // Raw power in 0.1W + (uint32_t)response[10] | + (uint32_t)response[11] << 24 | + (uint32_t)response[12] << 16) / + 10.0; + + _values.energy = ((uint32_t)response[13] << 8 | // Raw Energy in 1Wh + (uint32_t)response[14] | + (uint32_t)response[15] << 24 | + (uint32_t)response[16] << 16) / + 1000.0; + + _values.freq = ((uint32_t)response[17] << 8 | // Raw Frequency in 0.1Hz + (uint32_t)response[18]) / + 10.0; + + _values.pf = ((uint32_t)response[19] << 8 | // Raw pf in 0.01 + (uint32_t)response[20]) / + 100.0; + + _values.alarms = ((uint32_t)response[21] << 8 | // Raw alarm value + (uint32_t)response[22]); + + // Record current time as _lastRead + _lastRead = millis(); + return true; +} + +bool PZEMSensor::reset() { + uint8_t buffer[] = {0x00, CMD_REST, 0x00, 0x00}; + uint8_t reply[5]; + buffer[0] = _addr; + + setCRC(buffer, 4); + _serial->write(buffer, 4); + + uint16_t length = recieve(reply, 5); + + if (length == 0 || length == 5) { + return false; + } + + return true; +} + +uint16_t PZEMSensor::recieve(uint8_t *resp, uint16_t len) { + ((SoftwareSerial *)_serial)->listen(); // Start software serial listen + unsigned long startTime = millis(); // Start time for Timeout + uint8_t index = 0; // Bytes we have read + while ((index < len) && (millis() - startTime < READ_TIMEOUT)) { + if (_serial->available() > 0) { + uint8_t c = (uint8_t)_serial->read(); + resp[index++] = c; + } + } + // Check CRC with the number of bytes read + if (!checkCRC(resp, index)) { + return 0; + } + return index; +} + +bool PZEMSensor::checkCRC(const uint8_t *buf, uint16_t len) { + if (len <= 2) // Sanity check + return false; + + uint16_t crc = CRC16(buf, len - 2); // Compute CRC of data + return ((uint16_t)buf[len - 2] | (uint16_t)buf[len - 1] << 8) == crc; +} + +void PZEMSensor::setCRC(uint8_t *buf, uint16_t len) { + if (len <= 2) // Sanity check + return; + + uint16_t crc = CRC16(buf, len - 2); // CRC of data + + // Write high and low byte to last two positions + buf[len - 2] = crc & 0xFF; // Low byte first + buf[len - 1] = (crc >> 8) & 0xFF; // High byte second +} + +// Pre computed CRC table +static const uint16_t crcTable[] PROGMEM = { + 0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241, + 0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440, + 0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40, + 0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841, + 0XD801, 0X18C0, 0X1980, 0XD941, 0X1B00, 0XDBC1, 0XDA81, 0X1A40, + 0X1E00, 0XDEC1, 0XDF81, 0X1F40, 0XDD01, 0X1DC0, 0X1C80, 0XDC41, + 0X1400, 0XD4C1, 0XD581, 0X1540, 0XD701, 0X17C0, 0X1680, 0XD641, + 0XD201, 0X12C0, 0X1380, 0XD341, 0X1100, 0XD1C1, 0XD081, 0X1040, + 0XF001, 0X30C0, 0X3180, 0XF141, 0X3300, 0XF3C1, 0XF281, 0X3240, + 0X3600, 0XF6C1, 0XF781, 0X3740, 0XF501, 0X35C0, 0X3480, 0XF441, + 0X3C00, 0XFCC1, 0XFD81, 0X3D40, 0XFF01, 0X3FC0, 0X3E80, 0XFE41, + 0XFA01, 0X3AC0, 0X3B80, 0XFB41, 0X3900, 0XF9C1, 0XF881, 0X3840, + 0X2800, 0XE8C1, 0XE981, 0X2940, 0XEB01, 0X2BC0, 0X2A80, 0XEA41, + 0XEE01, 0X2EC0, 0X2F80, 0XEF41, 0X2D00, 0XEDC1, 0XEC81, 0X2C40, + 0XE401, 0X24C0, 0X2580, 0XE541, 0X2700, 0XE7C1, 0XE681, 0X2640, + 0X2200, 0XE2C1, 0XE381, 0X2340, 0XE101, 0X21C0, 0X2080, 0XE041, + 0XA001, 0X60C0, 0X6180, 0XA141, 0X6300, 0XA3C1, 0XA281, 0X6240, + 0X6600, 0XA6C1, 0XA781, 0X6740, 0XA501, 0X65C0, 0X6480, 0XA441, + 0X6C00, 0XACC1, 0XAD81, 0X6D40, 0XAF01, 0X6FC0, 0X6E80, 0XAE41, + 0XAA01, 0X6AC0, 0X6B80, 0XAB41, 0X6900, 0XA9C1, 0XA881, 0X6840, + 0X7800, 0XB8C1, 0XB981, 0X7940, 0XBB01, 0X7BC0, 0X7A80, 0XBA41, + 0XBE01, 0X7EC0, 0X7F80, 0XBF41, 0X7D00, 0XBDC1, 0XBC81, 0X7C40, + 0XB401, 0X74C0, 0X7580, 0XB541, 0X7700, 0XB7C1, 0XB681, 0X7640, + 0X7200, 0XB2C1, 0XB381, 0X7340, 0XB101, 0X71C0, 0X7080, 0XB041, + 0X5000, 0X90C1, 0X9181, 0X5140, 0X9301, 0X53C0, 0X5280, 0X9241, + 0X9601, 0X56C0, 0X5780, 0X9741, 0X5500, 0X95C1, 0X9481, 0X5440, + 0X9C01, 0X5CC0, 0X5D80, 0X9D41, 0X5F00, 0X9FC1, 0X9E81, 0X5E40, + 0X5A00, 0X9AC1, 0X9B81, 0X5B40, 0X9901, 0X59C0, 0X5880, 0X9841, + 0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40, + 0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41, + 0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641, + 0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040}; + +uint16_t PZEMSensor::CRC16(const uint8_t *data, uint16_t len) { + uint8_t nTemp; // CRC table index + uint16_t crc = 0xFFFF; // Default value + + while (len--) { + nTemp = *data++ ^ crc; + crc >>= 8; + crc ^= (uint16_t)pgm_read_word(&crcTable[nTemp]); + } + return crc; +} + +void PZEMSensor::search() { + static uint8_t response[7]; + for (uint16_t addr = 0x01; addr <= 0xF8; addr++) { + sendCmd8(CMD_RIR, 0x00, 0x01, false, addr); + if (recieve(response, 7) != 7) { + // Something went wrong + continue; + } else { + Serial.print("Device on addr: "); + Serial.print(addr); + } + } +} diff --git a/include/items/PZEMSensor.h b/include/items/PZEMSensor.h new file mode 100644 index 00000000..55650e84 --- /dev/null +++ b/include/items/PZEMSensor.h @@ -0,0 +1,51 @@ +#pragma once + +#include + +#include + +#define PZEM_DEFAULT_ADDR 0xF8 + +struct PZEM_Info { + float voltage; + float current; + float power; + float energy; + float freq; + float pf; + uint16_t alarms; + PZEM_Info() : voltage{0}, current{0}, power{0}, energy{0}, freq{0}, pf{0}, alarms{0} {}; +}; + +class PZEMSensor { + public: + PZEMSensor(SoftwareSerial *serial, uint16_t addr = PZEM_DEFAULT_ADDR); + + ~PZEMSensor(); + PZEM_Info* values(); + bool setAddress(uint8_t addr); + uint8_t getAddress(); + bool setPowerAlarm(uint16_t watts); + bool getPowerAlarm(); + bool reset(); + void search(); + // Get most up to date values from device registers and cache them + bool refresh(); + + private: + void init(void); + + private: + PZEM_Info _values; // Measured values + Stream *_serial; // Serial interface + bool _isSoft; // Is serial interface software + uint8_t _addr; // Device address + uint64_t _lastRead; // Last time values were updated + + void init(uint8_t addr); // Init common to all constructors + uint16_t recieve(uint8_t *resp, uint16_t len); // Receive len bytes into a buffer + bool sendCmd8(uint8_t cmd, uint16_t rAddr, uint16_t val, bool check = false, uint16_t slave_addr = 0xFFFF); // Send 8 byte command + void setCRC(uint8_t *buf, uint16_t len); // Set the CRC for a buffer + bool checkCRC(const uint8_t *buf, uint16_t len); // Check CRC of buffer + uint16_t CRC16(const uint8_t *data, uint16_t len); // Calculate CRC of buffer +}; diff --git a/include/items/SensorPower.h b/include/items/SensorPower.h new file mode 100644 index 00000000..ed88b33e --- /dev/null +++ b/include/items/SensorPower.h @@ -0,0 +1,32 @@ +#pragma once +#include "Global.h" + +#include "PZEMSensor.h" + +class SensorPZEM { + public: + SensorPZEM(SoftwareSerial* serial, uint32_t addr, uint32_t interval, String key) : _lastUpdate{0}, + _interval{interval}, + _key{key} { + _pzem = new PZEMSensor(serial, addr); + } + + ~SensorPZEM() { + delete _pzem; + } + + void loop(void); + + private: + void readSensor(void); + String getDataKey(const char* param_key); + void post(const char* key, const String& value); + + private: + PZEMSensor* _pzem; + uint32_t _lastUpdate; + uint32_t _interval; + String _key; +}; + +extern SensorPZEM* myPowerSensor; \ No newline at end of file diff --git a/include/items/vButtonOut.h b/include/items/vButtonOut.h new file mode 100644 index 00000000..7a11bc82 --- /dev/null +++ b/include/items/vButtonOut.h @@ -0,0 +1,31 @@ +#pragma once +#include + +#include "Global.h" + +class ButtonOut; + +typedef std::vector MyButtonOutVector; + +class ButtonOut { + public: + + ButtonOut(String pin, boolean inv, String key, String type); + + ~ButtonOut(); + + void execute(String state); + + private: + + String _pin; + boolean _inv; + String _key; + String _type; + +}; + +extern MyButtonOutVector* myButtonOut; + +extern void buttonOut(); +extern void buttonOutExecute(); diff --git a/include/items/vCountDown.h b/include/items/vCountDown.h new file mode 100644 index 00000000..a8d9d46a --- /dev/null +++ b/include/items/vCountDown.h @@ -0,0 +1,34 @@ +#pragma once +#include +#include "Global.h" + +class CountDownClass; + +typedef std::vector MyCountDownVector; + +class CountDownClass { +public: + CountDownClass(String key); + ~CountDownClass(); + + void loop(); + void execute(unsigned int countDownPeriod); + +private: + unsigned long _countDownPeriod = 0; + bool _start = false; + String _key; + + unsigned long currentMillis; + unsigned long prevMillis1; + unsigned long prevMillis2; + unsigned long difference1; + unsigned long difference2; + int sec; + +}; + +extern MyCountDownVector* myCountDown; + +extern void countDown(); +extern void countDownExecute(); \ No newline at end of file diff --git a/include/items/vImpulsOut.h b/include/items/vImpulsOut.h new file mode 100644 index 00000000..2cd806ca --- /dev/null +++ b/include/items/vImpulsOut.h @@ -0,0 +1,31 @@ +#pragma once +#include +#include "Global.h" + +class ImpulsOutClass; + +typedef std::vector MyImpulsOutVector; + +class ImpulsOutClass { + public: + ImpulsOutClass(unsigned int impulsPin); + ~ImpulsOutClass(); + + void loop(); + void execute(unsigned long impulsPeriod, unsigned int impulsCount); + + private: + unsigned long currentMillis; + unsigned long prevMillis; + unsigned long difference; + unsigned long _impulsPeriod = 0; + unsigned int _impulsCount = 0; + unsigned int _impulsCountBuf = 0; + unsigned int _impulsPin = 0; + +}; + +extern MyImpulsOutVector* myImpulsOut; + +extern void impuls(); +extern void impulsExecute(); diff --git a/include/items/vInOutput.h b/include/items/vInOutput.h new file mode 100644 index 00000000..99fe4636 --- /dev/null +++ b/include/items/vInOutput.h @@ -0,0 +1,27 @@ +#pragma once +#include + +#include "Global.h" + +class InOutput; + +typedef std::vector MyInOutputVector; + +class InOutput { + public: + + InOutput(String key, String widget); + ~InOutput(); + + void execute(String value); + + private: + + String _key; + +}; + +extern MyInOutputVector* myInOutput; + +extern void inOutput(); +extern void inOutputExecute(); diff --git a/include/items/vLogging.h b/include/items/vLogging.h new file mode 100644 index 00000000..61a158db --- /dev/null +++ b/include/items/vLogging.h @@ -0,0 +1,39 @@ +#pragma once +#include + +#include "Global.h" + +class LoggingClass; + +typedef std::vector MyLoggingVector; + +class LoggingClass { + public: + + LoggingClass(unsigned long period, unsigned int maxPoints, String loggingValueKey, String key); + ~LoggingClass(); + + void loop(); + void execute(String keyOrValue); + + private: + + unsigned long currentMillis; + unsigned long prevMillis; + unsigned long difference; + unsigned long _period; + unsigned int _maxPoints; + String _loggingValueKey; + String _key; + + +}; + +extern MyLoggingVector* myLogging; + +extern void logging(); +extern void loggingExecute(); +extern void choose_log_date_and_send(); +extern void sendLogData(String file, String topic); +extern void sendLogData2(String file, String topic); +extern void cleanLogAndData(); diff --git a/include/items/vPwmOut.h b/include/items/vPwmOut.h new file mode 100644 index 00000000..0c27d196 --- /dev/null +++ b/include/items/vPwmOut.h @@ -0,0 +1,31 @@ +#pragma once +#include "Consts.h" +#ifdef PwmOutEnable +#include +#include "Global.h" + +class PwmOut; + +typedef std::vector MyPwmOutVector; + +class PwmOut { + public: + + PwmOut(unsigned int pin, String key); + + ~PwmOut(); + + void execute(String state); + + private: + + unsigned int _pin; + String _key; + +}; + +extern MyPwmOutVector* myPwmOut; + +extern void pwmOut(); +extern void pwmOutExecute(); +#endif diff --git a/include/items/vSensorAnalog.h b/include/items/vSensorAnalog.h new file mode 100644 index 00000000..b39c38f3 --- /dev/null +++ b/include/items/vSensorAnalog.h @@ -0,0 +1,41 @@ +#pragma once +#include "Global.h" +#include +#include "GyverFilters.h" + +class SensorAnalog; + +typedef std::vector MySensorAnalogVector; + +class SensorAnalog { +public: + + SensorAnalog(String key, unsigned long interval, unsigned int adcPin, int map1, int map2, int map3, int map4, float c); + ~SensorAnalog(); + + void loop(); + void readAnalog(); + +private: + + unsigned long currentMillis; + unsigned long prevMillis; + unsigned long difference; + + unsigned long _interval; + + String _key; + unsigned int _adcPin; + + int _map1; + int _map2; + int _map3; + int _map4; + + float _c; + +}; + +extern MySensorAnalogVector* mySensorAnalog; + +extern void analogAdc(); \ No newline at end of file diff --git a/include/items/vSensorBme280.h b/include/items/vSensorBme280.h new file mode 100644 index 00000000..76ac1e10 --- /dev/null +++ b/include/items/vSensorBme280.h @@ -0,0 +1,39 @@ +#pragma once +#include +#include + +#include "Global.h" + +extern Adafruit_BME280* bme; + +class SensorBme280; + +typedef std::vector MySensorBme280Vector; + +struct paramsBme { + String key; + String addr; + unsigned long interval; + float c; +}; + +class SensorBme280 { + public: + SensorBme280(const paramsBme& paramsTmp, const paramsBme& paramsHum, const paramsBme& paramsPrs); + ~SensorBme280(); + + void loop(); + void read(); + + private: + paramsBme _paramsTmp; + paramsBme _paramsHum; + paramsBme _paramsPrs; + + unsigned long prevMillis; + unsigned long difference; +}; + +extern MySensorBme280Vector* mySensorBme280; + +extern void bme280Sensor(); \ No newline at end of file diff --git a/include/items/vSensorBmp280.h b/include/items/vSensorBmp280.h new file mode 100644 index 00000000..e681142c --- /dev/null +++ b/include/items/vSensorBmp280.h @@ -0,0 +1,38 @@ +#pragma once +#include +#include + +#include "Global.h" + +extern Adafruit_BMP280* bmp; + +class SensorBmp280; + +typedef std::vector MySensorBmp280Vector; + +struct paramsBmp { + String key; + String addr; + unsigned long interval; + float c; +}; + +class SensorBmp280 { + public: + SensorBmp280(const paramsBmp& paramsTmp, const paramsBmp& paramsPrs); + ~SensorBmp280(); + + void loop(); + void read(); + + private: + paramsBmp _paramsTmp; + paramsBmp _paramsPrs; + + unsigned long prevMillis; + unsigned long difference; +}; + +extern MySensorBmp280Vector* mySensorBmp280; + +extern void bmp280Sensor(); \ No newline at end of file diff --git a/include/items/vSensorDallas.h b/include/items/vSensorDallas.h new file mode 100644 index 00000000..2dff5f04 --- /dev/null +++ b/include/items/vSensorDallas.h @@ -0,0 +1,37 @@ +#pragma once +#include "Global.h" +#include + +extern DallasTemperature sensors; +extern OneWire* oneWire; + +class SensorDallas; + +typedef std::vector MySensorDallasVector; + +class SensorDallas { +public: + + SensorDallas(unsigned long interval, unsigned int pin, unsigned int index, String key); + ~SensorDallas(); + + void loop(); + void readDallas(); + +private: + + unsigned long currentMillis; + unsigned long prevMillis; + unsigned long difference; + unsigned long _interval; + String _key; + unsigned int _pin; + unsigned int _index; + +}; + +extern MySensorDallasVector* mySensorDallas2; + +extern void dallas(); + + diff --git a/include/items/vSensorDht.h b/include/items/vSensorDht.h new file mode 100644 index 00000000..5f57f3b7 --- /dev/null +++ b/include/items/vSensorDht.h @@ -0,0 +1,40 @@ +#pragma once +#include +#include + +#include "Global.h" +#include "GyverFilters.h" + +class SensorDht; + +typedef std::vector MySensorDhtVector; + +struct paramsDht { + String type; + String key; + unsigned long interval; + unsigned int pin; + float c; +}; + +class SensorDht { + public: + SensorDht(const paramsDht& paramsTmp, const paramsDht& paramsHum); + ~SensorDht(); + + DHTesp* dht; + + void loop(); + void readTmpHum(); + + private: + paramsDht _paramsTmp; + paramsDht _paramsHum; + + unsigned long prevMillis; + unsigned long difference; +}; + +extern MySensorDhtVector* mySensorDht; + +extern void dhtSensor(); \ No newline at end of file diff --git a/include/items/vSensorUltrasonic.h b/include/items/vSensorUltrasonic.h new file mode 100644 index 00000000..2195d7c5 --- /dev/null +++ b/include/items/vSensorUltrasonic.h @@ -0,0 +1,44 @@ +#pragma once +#include "Global.h" +#include +#include "GyverFilters.h" + +class SensorUltrasonic; + +typedef std::vector MySensorUltrasonicVector; + +class SensorUltrasonic { +public: + + SensorUltrasonic(String key, unsigned long interval, unsigned int trig, unsigned int echo, int map1, int map2, int map3, int map4, float c); + ~SensorUltrasonic(); + + void loop(); + void readUltrasonic(); + +private: + + unsigned long currentMillis; + unsigned long prevMillis; + unsigned long difference; + + unsigned long _interval; + + String _key; + unsigned int _echo; + unsigned int _trig; + + int _map1; + int _map2; + int _map3; + int _map4; + + float _c; + +}; + +extern MySensorUltrasonicVector* mySensorUltrasonic; + +extern void ultrasonic(); + + diff --git a/lib/ESP8266-StringCommand/StringCommand.cpp b/lib/ESP8266-StringCommand/StringCommand.cpp new file mode 100644 index 00000000..3d53dcd7 --- /dev/null +++ b/lib/ESP8266-StringCommand/StringCommand.cpp @@ -0,0 +1,137 @@ +/** + * SerialCommand - A Wiring/Arduino library to tokenize and parse commands + * received over a serial port. + * + * Copyright (C) 2012 Stefan Rado + * Copyright (C) 2011 Steven Cogswell + * http://husks.wordpress.com + * + * Version 20120522 + * + * This library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this library. If not, see . + */ +#include "StringCommand.h" + +/** + * Constructor makes sure some things are set. + */ +StringCommand::StringCommand() + : commandList(NULL), + commandCount(0), + defaultHandler(NULL), + term('\n'), // default terminator for commands, newline character + last(NULL), + main(NULL) +{ + strcpy(delim, " "); // strtok_r needs a null-terminated string + clearBuffer(); +} + +/** + * Adds a "command" and a handler function to the list of available commands. + * This is used for matching a found token in the buffer, and gives the pointer + * to the handler function to deal with it. + */ +void StringCommand::addCommand(const char *command, void (*function)()) { + #ifdef SERIALCOMMAND_DEBUG + Serial.print("Adding command ("); + Serial.print(commandCount); + Serial.print("): "); + Serial.println(command); + #endif + + commandList = (StringCommandCallback *) realloc(commandList, (commandCount + 1) * sizeof(StringCommandCallback)); + strncpy(commandList[commandCount].command, command, SERIALCOMMAND_MAXCOMMANDLENGTH); + commandList[commandCount].function = function; + commandCount++; +} + +/** + * This sets up a handler to be called in the event that the receveived command string + * isn't in the list of commands. + */ +void StringCommand::setDefaultHandler(void (*function)(const char *)) { + defaultHandler = function; +} + + +/** + * This checks the Serial stream for characters, and assembles them into a buffer. + * When the terminator character (default '\n') is seen, it starts parsing the + * buffer for a prefix command, and calls handlers setup by addCommand() member + */ +void StringCommand::readStr(String sBuffer ) { + sBuffer.toCharArray(buffer, SERIALCOMMAND_BUFFER); + #ifdef SERIALCOMMAND_DEBUG + Serial.print("Received: "); + Serial.println(buffer); + #endif + + char *command = strtok_r(buffer, delim, &last); // Search for command at start of buffer + if (command != NULL) { + boolean matched = false; + for (int i = 0; i < commandCount; i++) { + #ifdef SERIALCOMMAND_DEBUG + Serial.print("Comparing ["); + Serial.print(command); + Serial.print("] to ["); + Serial.print(commandList[i].command); + Serial.println("]"); + #endif + + + + // Compare the found command against the list of known commands for a match + if (strncmp(command, commandList[i].command, SERIALCOMMAND_MAXCOMMANDLENGTH) == 0) { + #ifdef SERIALCOMMAND_DEBUG + Serial.print("Matched Command: "); + Serial.println(command); + #endif + + // Execute the stored handler function for the command + (*commandList[i].function)(); + matched = true; + break; + } + } + + + if (!matched && (defaultHandler != NULL)) { + (*defaultHandler)(command); + } + + + clearBuffer(); + } +} + +/* + * Clear the input buffer. + */ +void StringCommand::clearBuffer() { + buffer[0] = '\0'; + bufPos = 0; +} + +/** + * Retrieve the next token ("word" or "argument") from the command buffer. + * Returns NULL if no more tokens exist. + */ +char *StringCommand::next() { + return strtok_r(NULL, delim, &last); +} + +char *StringCommand::order() { + return strtok_r(buffer, delim, &main); +} diff --git a/lib/ESP8266-StringCommand/StringCommand.h b/lib/ESP8266-StringCommand/StringCommand.h new file mode 100644 index 00000000..b37d5a1a --- /dev/null +++ b/lib/ESP8266-StringCommand/StringCommand.h @@ -0,0 +1,77 @@ +/** + * SerialCommand - A Wiring/Arduino library to tokenize and parse commands + * received over a serial port. + * + * Copyright (C) 2012 Stefan Rado + * Copyright (C) 2011 Steven Cogswell + * http://husks.wordpress.com + * + * Version 20120522 + * + * This library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this library. If not, see . + */ +#ifndef StringCommand_h +#define StringCommand_h + +#if defined(WIRING) && WIRING >= 100 + #include +#elif defined(ARDUINO) && ARDUINO >= 100 + #include +#else + #include +#endif +#include + +// Size of the input buffer in bytes (maximum length of one command plus arguments) +#define SERIALCOMMAND_BUFFER 128 //256 +// Maximum length of a command excluding the terminating null +#define SERIALCOMMAND_MAXCOMMANDLENGTH 16 + +// Uncomment the next line to run the library in debug mode (verbose messages) +//#define SERIALCOMMAND_DEBUG + + +class StringCommand { + public: + StringCommand(); // Constructor + void addCommand(const char *command, void(*function)()); // Add a command to the processing dictionary. + void setDefaultHandler(void (*function)(const char *)); // A handler to call when no valid command received. + + void readStr(String sBuffer ); // Main entry point. + void clearBuffer(); // Clears the input buffer. + char *next(); // Returns pointer to next token found in command buffer (for getting arguments to commands). + char *order(); + + private: + // Command/handler dictionary + struct StringCommandCallback { + char command[SERIALCOMMAND_MAXCOMMANDLENGTH + 1]; + void (*function)(); + }; // Data structure to hold Command/Handler function key-value pairs + StringCommandCallback *commandList; // Actual definition for command/handler array + byte commandCount; + + // Pointer to the default handler function + void (*defaultHandler)(const char *); + + char delim[2]; // null-terminated list of character to be used as delimeters for tokenizing (default " ") + char term; // Character that signals end of command (default '\n') + + char buffer[SERIALCOMMAND_BUFFER + 1]; // Buffer of stored characters while waiting for terminator character + byte bufPos; // Current position in the buffer + char *last; // State variable used by strtok_r during processing + char *main; +}; + +#endif //StringCommand_h diff --git a/lib/ESP8266-StringCommand/keywords.txt b/lib/ESP8266-StringCommand/keywords.txt new file mode 100644 index 00000000..c9799b2c --- /dev/null +++ b/lib/ESP8266-StringCommand/keywords.txt @@ -0,0 +1,23 @@ +####################################### +# Datatypes (KEYWORD1) +####################################### + +StringCommand KEYWORD1 + +####################################### +# Methods and Functions (KEYWORD2) +####################################### + +addCommand KEYWORD2 +setDefaultHandler KEYWORD2 +readString KEYWORD2 +clearBuffer KEYWORD2 +next KEYWORD2 + +####################################### +# Instances (KEYWORD2) +####################################### + +####################################### +# Constants (LITERAL1) +####################################### diff --git a/lib/ESP8266-StringCommand/readme.md b/lib/ESP8266-StringCommand/readme.md new file mode 100644 index 00000000..731ee5e2 --- /dev/null +++ b/lib/ESP8266-StringCommand/readme.md @@ -0,0 +1,5 @@ +StringCommand +============= +Библиотека для ESP8266 позволяющая связать запуск пользовательских функций с строковой переменной. + + diff --git a/lib/ESPAsyncWebServer/.github/scripts/install-arduino-core-esp32.sh b/lib/ESPAsyncWebServer/.github/scripts/install-arduino-core-esp32.sh new file mode 100644 index 00000000..cf1026d6 --- /dev/null +++ b/lib/ESPAsyncWebServer/.github/scripts/install-arduino-core-esp32.sh @@ -0,0 +1,36 @@ +#!/bin/bash + +export ARDUINO_ESP32_PATH="$ARDUINO_USR_PATH/hardware/espressif/esp32" +if [ ! -d "$ARDUINO_ESP32_PATH" ]; then + echo "Installing ESP32 Arduino Core ..." + script_init_path="$PWD" + mkdir -p "$ARDUINO_USR_PATH/hardware/espressif" + cd "$ARDUINO_USR_PATH/hardware/espressif" + + echo "Installing Python Serial ..." + pip install pyserial > /dev/null + + if [ "$OS_IS_WINDOWS" == "1" ]; then + echo "Installing Python Requests ..." + pip install requests > /dev/null + fi + + if [ "$GITHUB_REPOSITORY" == "espressif/arduino-esp32" ]; then + echo "Linking Core..." + ln -s $GITHUB_WORKSPACE esp32 + else + echo "Cloning Core Repository..." + git clone https://github.com/espressif/arduino-esp32.git esp32 > /dev/null 2>&1 + fi + + echo "Updating Submodules ..." + cd esp32 + git submodule update --init --recursive > /dev/null 2>&1 + + echo "Installing Platform Tools ..." + cd tools && python get.py + cd $script_init_path + + echo "ESP32 Arduino has been installed in '$ARDUINO_ESP32_PATH'" + echo "" +fi diff --git a/lib/ESPAsyncWebServer/.github/scripts/install-arduino-core-esp8266.sh b/lib/ESPAsyncWebServer/.github/scripts/install-arduino-core-esp8266.sh new file mode 100644 index 00000000..048cd024 --- /dev/null +++ b/lib/ESPAsyncWebServer/.github/scripts/install-arduino-core-esp8266.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +echo "Installing ESP8266 Arduino Core ..." +script_init_path="$PWD" +mkdir -p "$ARDUINO_USR_PATH/hardware/esp8266com" +cd "$ARDUINO_USR_PATH/hardware/esp8266com" + +echo "Installing Python Serial ..." +pip install pyserial > /dev/null + +if [ "$OS_IS_WINDOWS" == "1" ]; then + echo "Installing Python Requests ..." + pip install requests > /dev/null +fi + +echo "Cloning Core Repository ..." +git clone https://github.com/esp8266/Arduino.git esp8266 > /dev/null 2>&1 + +echo "Updating submodules ..." +cd esp8266 +git submodule update --init --recursive > /dev/null 2>&1 + +echo "Installing Platform Tools ..." +cd tools +python get.py > /dev/null +cd $script_init_path + +echo "ESP8266 Arduino has been installed in '$ARDUINO_USR_PATH/hardware/esp8266com'" +echo "" diff --git a/lib/ESPAsyncWebServer/.github/scripts/install-arduino-ide.sh b/lib/ESPAsyncWebServer/.github/scripts/install-arduino-ide.sh new file mode 100644 index 00000000..ce60cb82 --- /dev/null +++ b/lib/ESPAsyncWebServer/.github/scripts/install-arduino-ide.sh @@ -0,0 +1,228 @@ +#!/bin/bash + +#OSTYPE: 'linux-gnu', ARCH: 'x86_64' => linux64 +#OSTYPE: 'msys', ARCH: 'x86_64' => win32 +#OSTYPE: 'darwin18', ARCH: 'i386' => macos + +OSBITS=`arch` +if [[ "$OSTYPE" == "linux"* ]]; then + export OS_IS_LINUX="1" + ARCHIVE_FORMAT="tar.xz" + if [[ "$OSBITS" == "i686" ]]; then + OS_NAME="linux32" + elif [[ "$OSBITS" == "x86_64" ]]; then + OS_NAME="linux64" + elif [[ "$OSBITS" == "armv7l" || "$OSBITS" == "aarch64" ]]; then + OS_NAME="linuxarm" + else + OS_NAME="$OSTYPE-$OSBITS" + echo "Unknown OS '$OS_NAME'" + exit 1 + fi +elif [[ "$OSTYPE" == "darwin"* ]]; then + export OS_IS_MACOS="1" + ARCHIVE_FORMAT="zip" + OS_NAME="macosx" +elif [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "win32" ]]; then + export OS_IS_WINDOWS="1" + ARCHIVE_FORMAT="zip" + OS_NAME="windows" +else + OS_NAME="$OSTYPE-$OSBITS" + echo "Unknown OS '$OS_NAME'" + exit 1 +fi +export OS_NAME + +ARDUINO_BUILD_DIR="$HOME/.arduino/build.tmp" +ARDUINO_CACHE_DIR="$HOME/.arduino/cache.tmp" + +if [ "$OS_IS_MACOS" == "1" ]; then + export ARDUINO_IDE_PATH="/Applications/Arduino.app/Contents/Java" + export ARDUINO_USR_PATH="$HOME/Documents/Arduino" +elif [ "$OS_IS_WINDOWS" == "1" ]; then + export ARDUINO_IDE_PATH="$HOME/arduino_ide" + export ARDUINO_USR_PATH="$HOME/Documents/Arduino" +else + export ARDUINO_IDE_PATH="$HOME/arduino_ide" + export ARDUINO_USR_PATH="$HOME/Arduino" +fi + +if [ ! -d "$ARDUINO_IDE_PATH" ]; then + echo "Installing Arduino IDE on $OS_NAME ..." + echo "Downloading 'arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..." + if [ "$OS_IS_LINUX" == "1" ]; then + wget -O "arduino.$ARCHIVE_FORMAT" "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1 + echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..." + tar xf "arduino.$ARCHIVE_FORMAT" > /dev/null + mv arduino-nightly "$ARDUINO_IDE_PATH" + else + curl -o "arduino.$ARCHIVE_FORMAT" -L "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1 + echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..." + unzip "arduino.$ARCHIVE_FORMAT" > /dev/null + if [ "$OS_IS_MACOS" == "1" ]; then + mv "Arduino.app" "/Applications/Arduino.app" + else + mv arduino-nightly "$ARDUINO_IDE_PATH" + fi + fi + rm -rf "arduino.$ARCHIVE_FORMAT" + + mkdir -p "$ARDUINO_USR_PATH/libraries" + mkdir -p "$ARDUINO_USR_PATH/hardware" + + echo "Arduino IDE Installed in '$ARDUINO_IDE_PATH'" + echo "" +fi + +function build_sketch(){ # build_sketch [extra-options] + if [ "$#" -lt 2 ]; then + echo "ERROR: Illegal number of parameters" + echo "USAGE: build_sketch [extra-options]" + return 1 + fi + + local fqbn="$1" + local sketch="$2" + local build_flags="$3" + local xtra_opts="$4" + local win_opts="" + if [ "$OS_IS_WINDOWS" == "1" ]; then + local ctags_version=`ls "$ARDUINO_IDE_PATH/tools-builder/ctags/"` + local preprocessor_version=`ls "$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/"` + win_opts="-prefs=runtime.tools.ctags.path=$ARDUINO_IDE_PATH/tools-builder/ctags/$ctags_version -prefs=runtime.tools.arduino-preprocessor.path=$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/$preprocessor_version" + fi + + echo "" + echo "Compiling '"$(basename "$sketch")"' ..." + mkdir -p "$ARDUINO_BUILD_DIR" + mkdir -p "$ARDUINO_CACHE_DIR" + $ARDUINO_IDE_PATH/arduino-builder -compile -logger=human -core-api-version=10810 \ + -fqbn=$fqbn \ + -warnings="all" \ + -tools "$ARDUINO_IDE_PATH/tools-builder" \ + -tools "$ARDUINO_IDE_PATH/tools" \ + -built-in-libraries "$ARDUINO_IDE_PATH/libraries" \ + -hardware "$ARDUINO_IDE_PATH/hardware" \ + -hardware "$ARDUINO_USR_PATH/hardware" \ + -libraries "$ARDUINO_USR_PATH/libraries" \ + -build-cache "$ARDUINO_CACHE_DIR" \ + -build-path "$ARDUINO_BUILD_DIR" \ + -prefs=compiler.cpp.extra_flags="$build_flags" \ + $win_opts $xtra_opts "$sketch" +} + +function count_sketches() # count_sketches +{ + local examples="$1" + rm -rf sketches.txt + if [ ! -d "$examples" ]; then + touch sketches.txt + return 0 + fi + local sketches=$(find $examples -name *.ino) + local sketchnum=0 + for sketch in $sketches; do + local sketchdir=$(dirname $sketch) + local sketchdirname=$(basename $sketchdir) + local sketchname=$(basename $sketch) + if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then + continue + fi; + if [[ -f "$sketchdir/.test.skip" ]]; then + continue + fi + echo $sketch >> sketches.txt + sketchnum=$(($sketchnum + 1)) + done + return $sketchnum +} + +function build_sketches() # build_sketches [extra-options] +{ + local fqbn=$1 + local examples=$2 + local chunk_idex=$3 + local chunks_num=$4 + local xtra_opts=$5 + + if [ "$#" -lt 2 ]; then + echo "ERROR: Illegal number of parameters" + echo "USAGE: build_sketches [ ] [extra-options]" + return 1 + fi + + if [ "$#" -lt 4 ]; then + chunk_idex="0" + chunks_num="1" + xtra_opts=$3 + fi + + if [ "$chunks_num" -le 0 ]; then + echo "ERROR: Chunks count must be positive number" + return 1 + fi + if [ "$chunk_idex" -ge "$chunks_num" ]; then + echo "ERROR: Chunk index must be less than chunks count" + return 1 + fi + + set +e + count_sketches "$examples" + local sketchcount=$? + set -e + local sketches=$(cat sketches.txt) + rm -rf sketches.txt + + local chunk_size=$(( $sketchcount / $chunks_num )) + local all_chunks=$(( $chunks_num * $chunk_size )) + if [ "$all_chunks" -lt "$sketchcount" ]; then + chunk_size=$(( $chunk_size + 1 )) + fi + + local start_index=$(( $chunk_idex * $chunk_size )) + if [ "$sketchcount" -le "$start_index" ]; then + echo "Skipping job" + return 0 + fi + + local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size )) + if [ "$end_index" -gt "$sketchcount" ]; then + end_index=$sketchcount + fi + + local start_num=$(( $start_index + 1 )) + echo "Found $sketchcount Sketches"; + echo "Chunk Count : $chunks_num" + echo "Chunk Size : $chunk_size" + echo "Start Sketch: $start_num" + echo "End Sketch : $end_index" + + local sketchnum=0 + for sketch in $sketches; do + local sketchdir=$(dirname $sketch) + local sketchdirname=$(basename $sketchdir) + local sketchname=$(basename $sketch) + if [ "${sketchdirname}.ino" != "$sketchname" ] \ + || [ -f "$sketchdir/.test.skip" ]; then + continue + fi + sketchnum=$(($sketchnum + 1)) + if [ "$sketchnum" -le "$start_index" ] \ + || [ "$sketchnum" -gt "$end_index" ]; then + continue + fi + local sketchBuildFlags="" + if [ -f "$sketchdir/.test.build_flags" ]; then + while read line; do + sketchBuildFlags="$sketchBuildFlags $line" + done < "$sketchdir/.test.build_flags" + fi + build_sketch "$fqbn" "$sketch" "$sketchBuildFlags" "$xtra_opts" + local result=$? + if [ $result -ne 0 ]; then + return $result + fi + done + return 0 +} diff --git a/lib/ESPAsyncWebServer/.github/scripts/install-platformio.sh b/lib/ESPAsyncWebServer/.github/scripts/install-platformio.sh new file mode 100644 index 00000000..594948ea --- /dev/null +++ b/lib/ESPAsyncWebServer/.github/scripts/install-platformio.sh @@ -0,0 +1,140 @@ +#!/bin/bash + +echo "Installing Python Wheel ..." +pip install wheel > /dev/null 2>&1 + +echo "Installing PlatformIO ..." +pip install -U platformio > /dev/null 2>&1 + +echo "PlatformIO has been installed" +echo "" + + +function build_pio_sketch(){ # build_pio_sketch + if [ "$#" -lt 3 ]; then + echo "ERROR: Illegal number of parameters" + echo "USAGE: build_pio_sketch " + return 1 + fi + + local board="$1" + local sketch="$2" + local buildFlags="$3" + local sketch_dir=$(dirname "$sketch") + echo "" + echo "Compiling '"$(basename "$sketch")"' ..." + python -m platformio ci -l '.' --board "$board" "$sketch_dir" --project-option="board_build.partitions = huge_app.csv" --project-option="build_flags=$buildFlags" +} + +function count_sketches() # count_sketches +{ + local examples="$1" + rm -rf sketches.txt + if [ ! -d "$examples" ]; then + touch sketches.txt + return 0 + fi + local sketches=$(find $examples -name *.ino) + local sketchnum=0 + for sketch in $sketches; do + local sketchdir=$(dirname $sketch) + local sketchdirname=$(basename $sketchdir) + local sketchname=$(basename $sketch) + if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then + continue + fi; + if [[ -f "$sketchdir/.test.skip" ]]; then + continue + fi + echo $sketch >> sketches.txt + sketchnum=$(($sketchnum + 1)) + done + return $sketchnum +} + +function build_pio_sketches() # build_pio_sketches +{ + if [ "$#" -lt 2 ]; then + echo "ERROR: Illegal number of parameters" + echo "USAGE: build_pio_sketches [ ]" + return 1 + fi + + local board=$1 + local examples=$2 + local chunk_idex=$3 + local chunks_num=$4 + + if [ "$#" -lt 4 ]; then + chunk_idex="0" + chunks_num="1" + fi + + if [ "$chunks_num" -le 0 ]; then + echo "ERROR: Chunks count must be positive number" + return 1 + fi + if [ "$chunk_idex" -ge "$chunks_num" ]; then + echo "ERROR: Chunk index must be less than chunks count" + return 1 + fi + + set +e + count_sketches "$examples" + local sketchcount=$? + set -e + local sketches=$(cat sketches.txt) + rm -rf sketches.txt + + local chunk_size=$(( $sketchcount / $chunks_num )) + local all_chunks=$(( $chunks_num * $chunk_size )) + if [ "$all_chunks" -lt "$sketchcount" ]; then + chunk_size=$(( $chunk_size + 1 )) + fi + + local start_index=$(( $chunk_idex * $chunk_size )) + if [ "$sketchcount" -le "$start_index" ]; then + echo "Skipping job" + return 0 + fi + + local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size )) + if [ "$end_index" -gt "$sketchcount" ]; then + end_index=$sketchcount + fi + + local start_num=$(( $start_index + 1 )) + echo "Found $sketchcount Sketches"; + echo "Chunk Count : $chunks_num" + echo "Chunk Size : $chunk_size" + echo "Start Sketch: $start_num" + echo "End Sketch : $end_index" + + local sketchnum=0 + for sketch in $sketches; do + local sketchdir=$(dirname $sketch) + local sketchdirname=$(basename $sketchdir) + local sketchname=$(basename $sketch) + if [ "${sketchdirname}.ino" != "$sketchname" ] \ + || [ -f "$sketchdir/.test.skip" ]; then + continue + fi + local sketchBuildFlags="" + if [ -f "$sketchdir/.test.build_flags" ]; then + while read line; do + sketchBuildFlags="$sketchBuildFlags $line" + done < "$sketchdir/.test.build_flags" + fi + sketchnum=$(($sketchnum + 1)) + if [ "$sketchnum" -le "$start_index" ] \ + || [ "$sketchnum" -gt "$end_index" ]; then + continue + fi + build_pio_sketch "$board" "$sketch" "$sketchBuildFlags" + local result=$? + if [ $result -ne 0 ]; then + return $result + fi + done + return 0 +} diff --git a/lib/ESPAsyncWebServer/.github/scripts/on-push.sh b/lib/ESPAsyncWebServer/.github/scripts/on-push.sh new file mode 100644 index 00000000..96fff573 --- /dev/null +++ b/lib/ESPAsyncWebServer/.github/scripts/on-push.sh @@ -0,0 +1,71 @@ +#!/bin/bash + +set -e + +if [ ! -z "$TRAVIS_BUILD_DIR" ]; then + export GITHUB_WORKSPACE="$TRAVIS_BUILD_DIR" + export GITHUB_REPOSITORY="$TRAVIS_REPO_SLUG" +elif [ -z "$GITHUB_WORKSPACE" ]; then + export GITHUB_WORKSPACE="$PWD" + export GITHUB_REPOSITORY="me-no-dev/ESPAsyncWebServer" +fi + +TARGET_PLATFORM="$1" +CHUNK_INDEX=$2 +CHUNKS_CNT=$3 +BUILD_PIO=0 +if [ "$#" -lt 1 ]; then + TARGET_PLATFORM="esp32" +fi +if [ "$#" -lt 3 ] || [ "$CHUNKS_CNT" -le 0 ]; then + CHUNK_INDEX=0 + CHUNKS_CNT=1 +elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ]; then + CHUNK_INDEX=$CHUNKS_CNT +elif [ "$CHUNK_INDEX" -eq "$CHUNKS_CNT" ]; then + BUILD_PIO=1 +fi + +if [ "$BUILD_PIO" -eq 0 ]; then + # ArduinoIDE Test + source ./.github/scripts/install-arduino-ide.sh + + echo "Installing ESPAsyncWebServer ..." + cp -rf "$GITHUB_WORKSPACE" "$ARDUINO_USR_PATH/libraries/ESPAsyncWebServer" + echo "Installing ArduinoJson ..." + git clone https://github.com/bblanchon/ArduinoJson "$ARDUINO_USR_PATH/libraries/ArduinoJson" > /dev/null 2>&1 + + if [[ "$TARGET_PLATFORM" == "esp32" ]]; then + echo "Installing AsyncTCP ..." + git clone https://github.com/me-no-dev/AsyncTCP "$ARDUINO_USR_PATH/libraries/AsyncTCP" > /dev/null 2>&1 + FQBN="espressif:esp32:esp32:PSRAM=enabled,PartitionScheme=huge_app" + source ./.github/scripts/install-arduino-core-esp32.sh + echo "BUILDING ESP32 EXAMPLES" + else + echo "Installing ESPAsyncTCP ..." + git clone https://github.com/me-no-dev/ESPAsyncTCP "$ARDUINO_USR_PATH/libraries/ESPAsyncTCP" > /dev/null 2>&1 + FQBN="esp8266com:esp8266:generic:eesz=4M1M,ip=lm2f" + source ./.github/scripts/install-arduino-core-esp8266.sh + echo "BUILDING ESP8266 EXAMPLES" + fi + build_sketches "$FQBN" "$GITHUB_WORKSPACE/examples" "$CHUNK_INDEX" "$CHUNKS_CNT" +else + # PlatformIO Test + source ./.github/scripts/install-platformio.sh + + python -m platformio lib --storage-dir "$GITHUB_WORKSPACE" install + echo "Installing ArduinoJson ..." + python -m platformio lib -g install https://github.com/bblanchon/ArduinoJson.git > /dev/null 2>&1 + if [[ "$TARGET_PLATFORM" == "esp32" ]]; then + BOARD="esp32dev" + echo "Installing AsyncTCP ..." + python -m platformio lib -g install https://github.com/me-no-dev/AsyncTCP.git > /dev/null 2>&1 + echo "BUILDING ESP32 EXAMPLES" + else + BOARD="esp12e" + echo "Installing ESPAsyncTCP ..." + python -m platformio lib -g install https://github.com/me-no-dev/ESPAsyncTCP.git > /dev/null 2>&1 + echo "BUILDING ESP8266 EXAMPLES" + fi + build_pio_sketches "$BOARD" "$GITHUB_WORKSPACE/examples" +fi diff --git a/lib/ESPAsyncWebServer/.github/stale.yml b/lib/ESPAsyncWebServer/.github/stale.yml new file mode 100644 index 00000000..ce7a8e3f --- /dev/null +++ b/lib/ESPAsyncWebServer/.github/stale.yml @@ -0,0 +1,31 @@ +# Configuration for probot-stale - https://github.com/probot/stale + +daysUntilStale: 60 +daysUntilClose: 14 +limitPerRun: 30 +staleLabel: stale +exemptLabels: + - pinned + - security + - "to be implemented" + - "for reference" + - "move to PR" + - "enhancement" + +only: issues +onlyLabels: [] +exemptProjects: false +exemptMilestones: false +exemptAssignees: false + +markComment: > + [STALE_SET] This issue has been automatically marked as stale because it has not had + recent activity. It will be closed in 14 days if no further activity occurs. Thank you + for your contributions. + +unmarkComment: > + [STALE_CLR] This issue has been removed from the stale queue. Please ensure activity to keep it openin the future. + +closeComment: > + [STALE_DEL] This stale issue has been automatically closed. Thank you for your contributions. + diff --git a/lib/ESPAsyncWebServer/.github/workflows/push.yml b/lib/ESPAsyncWebServer/.github/workflows/push.yml new file mode 100644 index 00000000..abdea462 --- /dev/null +++ b/lib/ESPAsyncWebServer/.github/workflows/push.yml @@ -0,0 +1,34 @@ +name: ESP Async Web Server CI + +on: + push: + branches: + - master + - release/* + pull_request: + +jobs: + + build-arduino: + name: Arduino for ${{ matrix.board }} on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macOS-latest] + board: [esp32, esp8266] + steps: + - uses: actions/checkout@v1 + - name: Build Tests + run: bash ./.github/scripts/on-push.sh ${{ matrix.board }} 0 1 + + build-pio: + name: PlatformIO for ${{ matrix.board }} on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macOS-latest] + board: [esp32, esp8266] + steps: + - uses: actions/checkout@v1 + - name: Build Tests + run: bash ./.github/scripts/on-push.sh ${{ matrix.board }} 1 1 diff --git a/lib/ESPAsyncWebServer/.gitignore b/lib/ESPAsyncWebServer/.gitignore new file mode 100644 index 00000000..a0f0e538 --- /dev/null +++ b/lib/ESPAsyncWebServer/.gitignore @@ -0,0 +1,2 @@ +.vscode +.DS_Store diff --git a/lib/ESPAsyncWebServer/.travis.yml b/lib/ESPAsyncWebServer/.travis.yml new file mode 100644 index 00000000..e1b70352 --- /dev/null +++ b/lib/ESPAsyncWebServer/.travis.yml @@ -0,0 +1,46 @@ +sudo: false + +language: python + +os: + - linux + +git: + depth: false + +stages: + - build + +jobs: + include: + + - name: "Build Arduino ESP32" + if: tag IS blank AND (type = pull_request OR (type = push AND branch = master)) + stage: build + script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh esp32 + + - name: "Build Arduino ESP8266" + if: tag IS blank AND (type = pull_request OR (type = push AND branch = master)) + stage: build + script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh esp8266 + + - name: "Build Platformio ESP32" + if: tag IS blank AND (type = pull_request OR (type = push AND branch = master)) + stage: build + script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh esp32 1 1 + + - name: "Build Platformio ESP8266" + if: tag IS blank AND (type = pull_request OR (type = push AND branch = master)) + stage: build + script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh esp8266 1 1 + +notifications: + email: + on_success: change + on_failure: change + webhooks: + urls: + - https://webhooks.gitter.im/e/60e65d0c78ea0a920347 + on_success: change # options: [always|never|change] default: always + on_failure: always # options: [always|never|change] default: always + on_start: never # options: [always|never|change] default: always diff --git a/lib/ESPAsyncWebServer/CMakeLists.txt b/lib/ESPAsyncWebServer/CMakeLists.txt new file mode 100644 index 00000000..64292eca --- /dev/null +++ b/lib/ESPAsyncWebServer/CMakeLists.txt @@ -0,0 +1,17 @@ +set(COMPONENT_SRCDIRS + "src" +) + +set(COMPONENT_ADD_INCLUDEDIRS + "src" +) + +set(COMPONENT_REQUIRES + "arduino-esp32" + "AsyncTCP" +) + +register_component() + +target_compile_definitions(${COMPONENT_TARGET} PUBLIC -DESP32) +target_compile_options(${COMPONENT_TARGET} PRIVATE -fno-rtti) diff --git a/lib/ESPAsyncWebServer/README.md b/lib/ESPAsyncWebServer/README.md new file mode 100644 index 00000000..d6dd3206 --- /dev/null +++ b/lib/ESPAsyncWebServer/README.md @@ -0,0 +1,1521 @@ +# ESPAsyncWebServer +[![Build Status](https://travis-ci.org/me-no-dev/ESPAsyncWebServer.svg?branch=master)](https://travis-ci.org/me-no-dev/ESPAsyncWebServer) ![](https://github.com/me-no-dev/ESPAsyncWebServer/workflows/ESP%20Async%20Web%20Server%20CI/badge.svg) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/395dd42cfc674e6ca2e326af3af80ffc)](https://www.codacy.com/manual/me-no-dev/ESPAsyncWebServer?utm_source=github.com&utm_medium=referral&utm_content=me-no-dev/ESPAsyncWebServer&utm_campaign=Badge_Grade) + +For help and support [![Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer](https://badges.gitter.im/me-no-dev/ESPAsyncWebServer.svg)](https://gitter.im/me-no-dev/ESPAsyncWebServer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +Async HTTP and WebSocket Server for ESP8266 Arduino + +For ESP8266 it requires [ESPAsyncTCP](https://github.com/me-no-dev/ESPAsyncTCP) +To use this library you might need to have the latest git versions of [ESP8266](https://github.com/esp8266/Arduino) Arduino Core + +For ESP32 it requires [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) to work +To use this library you might need to have the latest git versions of [ESP32](https://github.com/espressif/arduino-esp32) Arduino Core + +## Table of contents +- [ESPAsyncWebServer](#espasyncwebserver) + - [Table of contents](#table-of-contents) + - [Installation](#installation) + - [Using PlatformIO](#using-platformio) + - [Why should you care](#why-should-you-care) + - [Important things to remember](#important-things-to-remember) + - [Principles of operation](#principles-of-operation) + - [The Async Web server](#the-async-web-server) + - [Request Life Cycle](#request-life-cycle) + - [Rewrites and how do they work](#rewrites-and-how-do-they-work) + - [Handlers and how do they work](#handlers-and-how-do-they-work) + - [Responses and how do they work](#responses-and-how-do-they-work) + - [Template processing](#template-processing) + - [Libraries and projects that use AsyncWebServer](#libraries-and-projects-that-use-asyncwebserver) + - [Request Variables](#request-variables) + - [Common Variables](#common-variables) + - [Headers](#headers) + - [GET, POST and FILE parameters](#get-post-and-file-parameters) + - [FILE Upload handling](#file-upload-handling) + - [Body data handling](#body-data-handling) + - [JSON body handling with ArduinoJson](#json-body-handling-with-arduinojson) + - [Responses](#responses) + - [Redirect to another URL](#redirect-to-another-url) + - [Basic response with HTTP Code](#basic-response-with-http-code) + - [Basic response with HTTP Code and extra headers](#basic-response-with-http-code-and-extra-headers) + - [Basic response with string content](#basic-response-with-string-content) + - [Basic response with string content and extra headers](#basic-response-with-string-content-and-extra-headers) + - [Send large webpage from PROGMEM](#send-large-webpage-from-progmem) + - [Send large webpage from PROGMEM and extra headers](#send-large-webpage-from-progmem-and-extra-headers) + - [Send large webpage from PROGMEM containing templates](#send-large-webpage-from-progmem-containing-templates) + - [Send large webpage from PROGMEM containing templates and extra headers](#send-large-webpage-from-progmem-containing-templates-and-extra-headers) + - [Send binary content from PROGMEM](#send-binary-content-from-progmem) + - [Respond with content coming from a Stream](#respond-with-content-coming-from-a-stream) + - [Respond with content coming from a Stream and extra headers](#respond-with-content-coming-from-a-stream-and-extra-headers) + - [Respond with content coming from a Stream containing templates](#respond-with-content-coming-from-a-stream-containing-templates) + - [Respond with content coming from a Stream containing templates and extra headers](#respond-with-content-coming-from-a-stream-containing-templates-and-extra-headers) + - [Respond with content coming from a File](#respond-with-content-coming-from-a-file) + - [Respond with content coming from a File and extra headers](#respond-with-content-coming-from-a-file-and-extra-headers) + - [Respond with content coming from a File containing templates](#respond-with-content-coming-from-a-file-containing-templates) + - [Respond with content using a callback](#respond-with-content-using-a-callback) + - [Respond with content using a callback and extra headers](#respond-with-content-using-a-callback-and-extra-headers) + - [Respond with content using a callback containing templates](#respond-with-content-using-a-callback-containing-templates) + - [Respond with content using a callback containing templates and extra headers](#respond-with-content-using-a-callback-containing-templates-and-extra-headers) + - [Chunked Response](#chunked-response) + - [Chunked Response containing templates](#chunked-response-containing-templates) + - [Print to response](#print-to-response) + - [ArduinoJson Basic Response](#arduinojson-basic-response) + - [ArduinoJson Advanced Response](#arduinojson-advanced-response) + - [Serving static files](#serving-static-files) + - [Serving specific file by name](#serving-specific-file-by-name) + - [Serving files in directory](#serving-files-in-directory) + - [Serving static files with authentication](#serving-static-files-with-authentication) + - [Specifying Cache-Control header](#specifying-cache-control-header) + - [Specifying Date-Modified header](#specifying-date-modified-header) + - [Specifying Template Processor callback](#specifying-template-processor-callback) + - [Param Rewrite With Matching](#param-rewrite-with-matching) + - [Using filters](#using-filters) + - [Serve different site files in AP mode](#serve-different-site-files-in-ap-mode) + - [Rewrite to different index on AP](#rewrite-to-different-index-on-ap) + - [Serving different hosts](#serving-different-hosts) + - [Determine interface inside callbacks](#determine-interface-inside-callbacks) + - [Bad Responses](#bad-responses) + - [Respond with content using a callback without content length to HTTP/1.0 clients](#respond-with-content-using-a-callback-without-content-length-to-http10-clients) + - [Async WebSocket Plugin](#async-websocket-plugin) + - [Async WebSocket Event](#async-websocket-event) + - [Methods for sending data to a socket client](#methods-for-sending-data-to-a-socket-client) + - [Direct access to web socket message buffer](#direct-access-to-web-socket-message-buffer) + - [Limiting the number of web socket clients](#limiting-the-number-of-web-socket-clients) + - [Async Event Source Plugin](#async-event-source-plugin) + - [Setup Event Source on the server](#setup-event-source-on-the-server) + - [Setup Event Source in the browser](#setup-event-source-in-the-browser) + - [Scanning for available WiFi Networks](#scanning-for-available-wifi-networks) + - [Remove handlers and rewrites](#remove-handlers-and-rewrites) + - [Setting up the server](#setting-up-the-server) + - [Setup global and class functions as request handlers](#setup-global-and-class-functions-as-request-handlers) + - [Methods for controlling websocket connections](#methods-for-controlling-websocket-connections) + - [Adding Default Headers](#adding-default-headers) + - [Path variable](#path-variable) + +## Installation + +### Using PlatformIO + +[PlatformIO](http://platformio.org) is an open source ecosystem for IoT development with cross platform build system, library manager and full support for Espressif ESP8266/ESP32 development. It works on the popular host OS: Mac OS X, Windows, Linux 32/64, Linux ARM (like Raspberry Pi, BeagleBone, CubieBoard). + +1. Install [PlatformIO IDE](http://platformio.org/platformio-ide) +2. Create new project using "PlatformIO Home > New Project" +3. Update dev/platform to staging version: + - [Instruction for Espressif 8266](http://docs.platformio.org/en/latest/platforms/espressif8266.html#using-arduino-framework-with-staging-version) + - [Instruction for Espressif 32](http://docs.platformio.org/en/latest/platforms/espressif32.html#using-arduino-framework-with-staging-version) + 4. Add "ESP Async WebServer" to project using [Project Configuration File `platformio.ini`](http://docs.platformio.org/page/projectconf.html) and [lib_deps](http://docs.platformio.org/page/projectconf/section_env_library.html#lib-deps) option: + +```ini +[env:myboard] +platform = espressif... +board = ... +framework = arduino + +# using the latest stable version +lib_deps = ESP Async WebServer + +# or using GIT Url (the latest development version) +lib_deps = https://github.com/me-no-dev/ESPAsyncWebServer.git +``` + 5. Happy coding with PlatformIO! + +## Why should you care +- Using asynchronous network means that you can handle more than one connection at the same time +- You are called once the request is ready and parsed +- When you send the response, you are immediately ready to handle other connections + while the server is taking care of sending the response in the background +- Speed is OMG +- Easy to use API, HTTP Basic and Digest MD5 Authentication (default), ChunkedResponse +- Easily extendible to handle any type of content +- Supports Continue 100 +- Async WebSocket plugin offering different locations without extra servers or ports +- Async EventSource (Server-Sent Events) plugin to send events to the browser +- URL Rewrite plugin for conditional and permanent url rewrites +- ServeStatic plugin that supports cache, Last-Modified, default index and more +- Simple template processing engine to handle templates + +## Important things to remember +- This is fully asynchronous server and as such does not run on the loop thread. +- You can not use yield or delay or any function that uses them inside the callbacks +- The server is smart enough to know when to close the connection and free resources +- You can not send more than one response to a single request + +## Principles of operation + +### The Async Web server +- Listens for connections +- Wraps the new clients into ```Request``` +- Keeps track of clients and cleans memory +- Manages ```Rewrites``` and apply them on the request url +- Manages ```Handlers``` and attaches them to Requests + +### Request Life Cycle +- TCP connection is received by the server +- The connection is wrapped inside ```Request``` object +- When the request head is received (type, url, get params, http version and host), + the server goes through all ```Rewrites``` (in the order they were added) to rewrite the url and inject query parameters, + next, it goes through all attached ```Handlers```(in the order they were added) trying to find one + that ```canHandle``` the given request. If none are found, the default(catch-all) handler is attached. +- The rest of the request is received, calling the ```handleUpload``` or ```handleBody``` methods of the ```Handler``` if they are needed (POST+File/Body) +- When the whole request is parsed, the result is given to the ```handleRequest``` method of the ```Handler``` and is ready to be responded to +- In the ```handleRequest``` method, to the ```Request``` is attached a ```Response``` object (see below) that will serve the response data back to the client +- When the ```Response``` is sent, the client is closed and freed from the memory + +### Rewrites and how do they work +- The ```Rewrites``` are used to rewrite the request url and/or inject get parameters for a specific request url path. +- All ```Rewrites``` are evaluated on the request in the order they have been added to the server. +- The ```Rewrite``` will change the request url only if the request url (excluding get parameters) is fully match + the rewrite url, and when the optional ```Filter``` callback return true. +- Setting a ```Filter``` to the ```Rewrite``` enables to control when to apply the rewrite, decision can be based on + request url, http version, request host/port/target host, get parameters or the request client's localIP or remoteIP. +- Two filter callbacks are provided: ```ON_AP_FILTER``` to execute the rewrite when request is made to the AP interface, + ```ON_STA_FILTER``` to execute the rewrite when request is made to the STA interface. +- The ```Rewrite``` can specify a target url with optional get parameters, e.g. ```/to-url?with=params``` + +### Handlers and how do they work +- The ```Handlers``` are used for executing specific actions to particular requests +- One ```Handler``` instance can be attached to any request and lives together with the server +- Setting a ```Filter``` to the ```Handler``` enables to control when to apply the handler, decision can be based on + request url, http version, request host/port/target host, get parameters or the request client's localIP or remoteIP. +- Two filter callbacks are provided: ```ON_AP_FILTER``` to execute the rewrite when request is made to the AP interface, + ```ON_STA_FILTER``` to execute the rewrite when request is made to the STA interface. +- The ```canHandle``` method is used for handler specific control on whether the requests can be handled + and for declaring any interesting headers that the ```Request``` should parse. Decision can be based on request + method, request url, http version, request host/port/target host and get parameters +- Once a ```Handler``` is attached to given ```Request``` (```canHandle``` returned true) + that ```Handler``` takes care to receive any file/data upload and attach a ```Response``` + once the ```Request``` has been fully parsed +- ```Handlers``` are evaluated in the order they are attached to the server. The ```canHandle``` is called only + if the ```Filter``` that was set to the ```Handler``` return true. +- The first ```Handler``` that can handle the request is selected, not further ```Filter``` and ```canHandle``` are called. + +### Responses and how do they work +- The ```Response``` objects are used to send the response data back to the client +- The ```Response``` object lives with the ```Request``` and is freed on end or disconnect +- Different techniques are used depending on the response type to send the data in packets + returning back almost immediately and sending the next packet when this one is received. + Any time in between is spent to run the user loop and handle other network packets +- Responding asynchronously is probably the most difficult thing for most to understand +- Many different options exist for the user to make responding a background task + +### Template processing +- ESPAsyncWebserver contains simple template processing engine. +- Template processing can be added to most response types. +- Currently it supports only replacing template placeholders with actual values. No conditional processing, cycles, etc. +- Placeholders are delimited with ```%``` symbols. Like this: ```%TEMPLATE_PLACEHOLDER%```. +- It works by extracting placeholder name from response text and passing it to user provided function which should return actual value to be used instead of placeholder. +- Since it's user provided function, it is possible for library users to implement conditional processing and cycles themselves. +- Since it's impossible to know the actual response size after template processing step in advance (and, therefore, to include it in response headers), the response becomes [chunked](#chunked-response). + +## Libraries and projects that use AsyncWebServer +- [WebSocketToSerial](https://github.com/hallard/WebSocketToSerial) - Debug serial devices through the web browser +- [Sattrack](https://github.com/Hopperpop/Sattrack) - Track the ISS with ESP8266 +- [ESP Radio](https://github.com/Edzelf/Esp-radio) - Icecast radio based on ESP8266 and VS1053 +- [VZero](https://github.com/andig/vzero) - the Wireless zero-config controller for volkszaehler.org +- [ESPurna](https://bitbucket.org/xoseperez/espurna) - ESPurna ("spark" in Catalan) is a custom C firmware for ESP8266 based smart switches. It was originally developed with the ITead Sonoff in mind. +- [fauxmoESP](https://bitbucket.org/xoseperez/fauxmoesp) - Belkin WeMo emulator library for ESP8266. +- [ESP-RFID](https://github.com/omersiar/esp-rfid) - MFRC522 RFID Access Control Management project for ESP8266. + +## Request Variables + +### Common Variables +```cpp +request->version(); // uint8_t: 0 = HTTP/1.0, 1 = HTTP/1.1 +request->method(); // enum: HTTP_GET, HTTP_POST, HTTP_DELETE, HTTP_PUT, HTTP_PATCH, HTTP_HEAD, HTTP_OPTIONS +request->url(); // String: URL of the request (not including host, port or GET parameters) +request->host(); // String: The requested host (can be used for virtual hosting) +request->contentType(); // String: ContentType of the request (not avaiable in Handler::canHandle) +request->contentLength(); // size_t: ContentLength of the request (not avaiable in Handler::canHandle) +request->multipart(); // bool: True if the request has content type "multipart" +``` + +### Headers +```cpp +//List all collected headers +int headers = request->headers(); +int i; +for(i=0;igetHeader(i); + Serial.printf("HEADER[%s]: %s\n", h->name().c_str(), h->value().c_str()); +} + +//get specific header by name +if(request->hasHeader("MyHeader")){ + AsyncWebHeader* h = request->getHeader("MyHeader"); + Serial.printf("MyHeader: %s\n", h->value().c_str()); +} + +//List all collected headers (Compatibility) +int headers = request->headers(); +int i; +for(i=0;iheaderName(i).c_str(), request->header(i).c_str()); +} + +//get specific header by name (Compatibility) +if(request->hasHeader("MyHeader")){ + Serial.printf("MyHeader: %s\n", request->header("MyHeader").c_str()); +} +``` + +### GET, POST and FILE parameters +```cpp +//List all parameters +int params = request->params(); +for(int i=0;igetParam(i); + if(p->isFile()){ //p->isPost() is also true + Serial.printf("FILE[%s]: %s, size: %u\n", p->name().c_str(), p->value().c_str(), p->size()); + } else if(p->isPost()){ + Serial.printf("POST[%s]: %s\n", p->name().c_str(), p->value().c_str()); + } else { + Serial.printf("GET[%s]: %s\n", p->name().c_str(), p->value().c_str()); + } +} + +//Check if GET parameter exists +if(request->hasParam("download")) + AsyncWebParameter* p = request->getParam("download"); + +//Check if POST (but not File) parameter exists +if(request->hasParam("download", true)) + AsyncWebParameter* p = request->getParam("download", true); + +//Check if FILE was uploaded +if(request->hasParam("download", true, true)) + AsyncWebParameter* p = request->getParam("download", true, true); + +//List all parameters (Compatibility) +int args = request->args(); +for(int i=0;iargName(i).c_str(), request->arg(i).c_str()); +} + +//Check if parameter exists (Compatibility) +if(request->hasArg("download")) + String arg = request->arg("download"); +``` + +### FILE Upload handling +```cpp +void handleUpload(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final){ + if(!index){ + Serial.printf("UploadStart: %s\n", filename.c_str()); + } + for(size_t i=0; i(); + // ... +}); +server.addHandler(handler); +``` + +## Responses +### Redirect to another URL +```cpp +//to local url +request->redirect("/login"); + +//to external url +request->redirect("http://esp8266.com"); +``` + +### Basic response with HTTP Code +```cpp +request->send(404); //Sends 404 File Not Found +``` + +### Basic response with HTTP Code and extra headers +```cpp +AsyncWebServerResponse *response = request->beginResponse(404); //Sends 404 File Not Found +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Basic response with string content +```cpp +request->send(200, "text/plain", "Hello World!"); +``` + +### Basic response with string content and extra headers +```cpp +AsyncWebServerResponse *response = request->beginResponse(200, "text/plain", "Hello World!"); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Send large webpage from PROGMEM +```cpp +const char index_html[] PROGMEM = "..."; // large char array, tested with 14k +request->send_P(200, "text/html", index_html); +``` + +### Send large webpage from PROGMEM and extra headers +```cpp +const char index_html[] PROGMEM = "..."; // large char array, tested with 14k +AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", index_html); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Send large webpage from PROGMEM containing templates +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +const char index_html[] PROGMEM = "..."; // large char array, tested with 14k +request->send_P(200, "text/html", index_html, processor); +``` + +### Send large webpage from PROGMEM containing templates and extra headers +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +const char index_html[] PROGMEM = "..."; // large char array, tested with 14k +AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", index_html, processor); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Send binary content from PROGMEM +```cpp + +//File: favicon.ico.gz, Size: 726 +#define favicon_ico_gz_len 726 +const uint8_t favicon_ico_gz[] PROGMEM = { + 0x1F, 0x8B, 0x08, 0x08, 0x0B, 0x87, 0x90, 0x57, 0x00, 0x03, 0x66, 0x61, 0x76, 0x69, 0x63, 0x6F, + 0x6E, 0x2E, 0x69, 0x63, 0x6F, 0x00, 0xCD, 0x53, 0x5F, 0x48, 0x9A, 0x51, 0x14, 0xBF, 0x62, 0x6D, + 0x86, 0x96, 0xA9, 0x64, 0xD3, 0xFE, 0xA8, 0x99, 0x65, 0x1A, 0xB4, 0x8A, 0xA8, 0x51, 0x54, 0x23, + 0xA8, 0x11, 0x49, 0x51, 0x8A, 0x34, 0x62, 0x93, 0x85, 0x31, 0x58, 0x44, 0x12, 0x45, 0x2D, 0x58, + 0xF5, 0x52, 0x41, 0x10, 0x23, 0x82, 0xA0, 0x20, 0x98, 0x2F, 0xC1, 0x26, 0xED, 0xA1, 0x20, 0x89, + 0x04, 0xD7, 0x83, 0x58, 0x20, 0x28, 0x04, 0xAB, 0xD1, 0x9B, 0x8C, 0xE5, 0xC3, 0x60, 0x32, 0x64, + 0x0E, 0x56, 0xBF, 0x9D, 0xEF, 0xF6, 0x30, 0x82, 0xED, 0xAD, 0x87, 0xDD, 0x8F, 0xF3, 0xDD, 0x8F, + 0x73, 0xCF, 0xEF, 0x9C, 0xDF, 0x39, 0xBF, 0xFB, 0x31, 0x26, 0xA2, 0x27, 0x37, 0x97, 0xD1, 0x5B, + 0xCF, 0x9E, 0x67, 0x30, 0xA6, 0x66, 0x8C, 0x99, 0xC9, 0xC8, 0x45, 0x9E, 0x6B, 0x3F, 0x5F, 0x74, + 0xA6, 0x94, 0x5E, 0xDB, 0xFF, 0xB2, 0xE6, 0xE7, 0xE7, 0xF9, 0xDE, 0xD6, 0xD6, 0x96, 0xDB, 0xD8, + 0xD8, 0x78, 0xBF, 0xA1, 0xA1, 0xC1, 0xDA, 0xDC, 0xDC, 0x2C, 0xEB, 0xED, 0xED, 0x15, 0x9B, 0xCD, + 0xE6, 0x4A, 0x83, 0xC1, 0xE0, 0x2E, 0x29, 0x29, 0x99, 0xD6, 0x6A, 0xB5, 0x4F, 0x75, 0x3A, 0x9D, + 0x61, 0x75, 0x75, 0x95, 0xB5, 0xB7, 0xB7, 0xDF, 0xC8, 0xD1, 0xD4, 0xD4, 0xF4, 0xB0, 0xBA, 0xBA, + 0xFA, 0x83, 0xD5, 0x6A, 0xFD, 0x5A, 0x5E, 0x5E, 0x9E, 0x28, 0x2D, 0x2D, 0x0D, 0x10, 0xC6, 0x4B, + 0x98, 0x78, 0x5E, 0x5E, 0xDE, 0x95, 0x42, 0xA1, 0x40, 0x4E, 0x4E, 0xCE, 0x65, 0x76, 0x76, 0xF6, + 0x47, 0xB5, 0x5A, 0x6D, 0x4F, 0x26, 0x93, 0xA2, 0xD6, 0xD6, 0x56, 0x8E, 0x6D, 0x69, 0x69, 0xD1, + 0x11, 0x36, 0x62, 0xB1, 0x58, 0x60, 0x32, 0x99, 0xA0, 0xD7, 0xEB, 0x51, 0x58, 0x58, 0x88, 0xFC, + 0xFC, 0x7C, 0x10, 0x16, 0x02, 0x56, 0x2E, 0x97, 0x43, 0x2A, 0x95, 0x42, 0x2C, 0x16, 0x23, 0x33, + 0x33, 0x33, 0xAE, 0x52, 0xA9, 0x1E, 0x64, 0x65, 0x65, 0x71, 0x7C, 0x7D, 0x7D, 0xBD, 0x93, 0xEA, + 0xFE, 0x30, 0x1A, 0x8D, 0xE8, 0xEC, 0xEC, 0xC4, 0xE2, 0xE2, 0x22, 0x6A, 0x6A, 0x6A, 0x40, 0x39, + 0x41, 0xB5, 0x38, 0x4E, 0xC8, 0x33, 0x3C, 0x3C, 0x0C, 0x87, 0xC3, 0xC1, 0x6B, 0x54, 0x54, 0x54, + 0xBC, 0xE9, 0xEB, 0xEB, 0x93, 0x5F, 0x5C, 0x5C, 0x30, 0x8A, 0x9D, 0x2E, 0x2B, 0x2B, 0xBB, 0xA2, + 0x3E, 0x41, 0xBD, 0x21, 0x1E, 0x8F, 0x63, 0x6A, 0x6A, 0x0A, 0x81, 0x40, 0x00, 0x94, 0x1B, 0x3D, + 0x3D, 0x3D, 0x42, 0x3C, 0x96, 0x96, 0x96, 0x70, 0x7E, 0x7E, 0x8E, 0xE3, 0xE3, 0x63, 0xF8, 0xFD, + 0xFE, 0xB4, 0xD7, 0xEB, 0xF5, 0x8F, 0x8F, 0x8F, 0x5B, 0x68, 0x5E, 0x6F, 0x05, 0xCE, 0xB4, 0xE3, + 0xE8, 0xE8, 0x08, 0x27, 0x27, 0x27, 0xD8, 0xDF, 0xDF, 0xC7, 0xD9, 0xD9, 0x19, 0x6C, 0x36, 0x1B, + 0x36, 0x36, 0x36, 0x38, 0x9F, 0x85, 0x85, 0x05, 0xAC, 0xAF, 0xAF, 0x23, 0x1A, 0x8D, 0x22, 0x91, + 0x48, 0x20, 0x16, 0x8B, 0xFD, 0xDA, 0xDA, 0xDA, 0x7A, 0x41, 0x33, 0x7E, 0x57, 0x50, 0x50, 0x80, + 0x89, 0x89, 0x09, 0x84, 0xC3, 0x61, 0x6C, 0x6F, 0x6F, 0x23, 0x12, 0x89, 0xE0, 0xE0, 0xE0, 0x00, + 0x43, 0x43, 0x43, 0x58, 0x5E, 0x5E, 0xE6, 0x9C, 0x7D, 0x3E, 0x1F, 0x46, 0x47, 0x47, 0x79, 0xBE, + 0xBD, 0xBD, 0x3D, 0xE1, 0x3C, 0x1D, 0x0C, 0x06, 0x9F, 0x10, 0xB7, 0xC7, 0x84, 0x4F, 0xF6, 0xF7, + 0xF7, 0x63, 0x60, 0x60, 0x00, 0x83, 0x83, 0x83, 0x18, 0x19, 0x19, 0xC1, 0xDC, 0xDC, 0x1C, 0x8F, + 0x17, 0x7C, 0xA4, 0x27, 0xE7, 0x34, 0x39, 0x39, 0x89, 0x9D, 0x9D, 0x1D, 0x6E, 0x54, 0xE3, 0x13, + 0xE5, 0x34, 0x11, 0x37, 0x49, 0x51, 0x51, 0xD1, 0x4B, 0xA5, 0x52, 0xF9, 0x45, 0x26, 0x93, 0x5D, + 0x0A, 0xF3, 0x92, 0x48, 0x24, 0xA0, 0x6F, 0x14, 0x17, 0x17, 0xA3, 0xB6, 0xB6, 0x16, 0x5D, 0x5D, + 0x5D, 0x7C, 0x1E, 0xBB, 0xBB, 0xBB, 0x9C, 0xD7, 0xE1, 0xE1, 0x21, 0x42, 0xA1, 0xD0, 0x6B, 0xD2, + 0x45, 0x4C, 0x33, 0x12, 0x34, 0xCC, 0xA0, 0x19, 0x54, 0x92, 0x56, 0x0E, 0xD2, 0xD9, 0x43, 0xF8, + 0xCF, 0x82, 0x56, 0xC2, 0xDC, 0xEB, 0xEA, 0xEA, 0x38, 0x7E, 0x6C, 0x6C, 0x4C, 0xE0, 0xFE, 0x9D, + 0xB8, 0xBF, 0xA7, 0xFA, 0xAF, 0x56, 0x56, 0x56, 0xEE, 0x6D, 0x6E, 0x6E, 0xDE, 0xB8, 0x47, 0x55, + 0x55, 0x55, 0x6C, 0x66, 0x66, 0x46, 0x44, 0xDA, 0x3B, 0x34, 0x1A, 0x4D, 0x94, 0xB0, 0x3F, 0x09, + 0x7B, 0x45, 0xBD, 0xA5, 0x5D, 0x2E, 0x57, 0x8C, 0x7A, 0x73, 0xD9, 0xED, 0xF6, 0x3B, 0x84, 0xFF, + 0xE7, 0x7D, 0xA6, 0x3A, 0x2C, 0x95, 0x4A, 0xB1, 0x8E, 0x8E, 0x0E, 0x6D, 0x77, 0x77, 0xB7, 0xCD, + 0xE9, 0x74, 0x3E, 0x73, 0xBB, 0xDD, 0x8F, 0x3C, 0x1E, 0x8F, 0xE6, 0xF4, 0xF4, 0x94, 0xAD, 0xAD, + 0xAD, 0xDD, 0xDE, 0xCF, 0x73, 0x0B, 0x0B, 0xB8, 0xB6, 0xE0, 0x5D, 0xC6, 0x66, 0xC5, 0xE4, 0x10, + 0x4C, 0xF4, 0xF7, 0xD8, 0x59, 0xF2, 0x7F, 0xA3, 0xB8, 0xB4, 0xFC, 0x0F, 0xEE, 0x37, 0x70, 0xEC, + 0x16, 0x4A, 0x7E, 0x04, 0x00, 0x00 +}; + +AsyncWebServerResponse *response = request->beginResponse_P(200, "image/x-icon", favicon_ico_gz, favicon_ico_gz_len); +response->addHeader("Content-Encoding", "gzip"); +request->send(response); +``` + +### Respond with content coming from a Stream +```cpp +//read 12 bytes from Serial and send them as Content Type text/plain +request->send(Serial, "text/plain", 12); +``` + +### Respond with content coming from a Stream and extra headers +```cpp +//read 12 bytes from Serial and send them as Content Type text/plain +AsyncWebServerResponse *response = request->beginResponse(Serial, "text/plain", 12); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Respond with content coming from a Stream containing templates +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//read 12 bytes from Serial and send them as Content Type text/plain +request->send(Serial, "text/plain", 12, processor); +``` + +### Respond with content coming from a Stream containing templates and extra headers +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//read 12 bytes from Serial and send them as Content Type text/plain +AsyncWebServerResponse *response = request->beginResponse(Serial, "text/plain", 12, processor); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Respond with content coming from a File +```cpp +//Send index.htm with default content type +request->send(SPIFFS, "/index.htm"); + +//Send index.htm as text +request->send(SPIFFS, "/index.htm", "text/plain"); + +//Download index.htm +request->send(SPIFFS, "/index.htm", String(), true); +``` + +### Respond with content coming from a File and extra headers +```cpp +//Send index.htm with default content type +AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/index.htm"); + +//Send index.htm as text +AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/index.htm", "text/plain"); + +//Download index.htm +AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/index.htm", String(), true); + +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Respond with content coming from a File containing templates +Internally uses [Chunked Response](#chunked-response). + +Index.htm contents: +``` +%HELLO_FROM_TEMPLATE% +``` + +Somewhere in source files: +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//Send index.htm with template processor function +request->send(SPIFFS, "/index.htm", String(), false, processor); +``` + +### Respond with content using a callback +```cpp +//send 128 bytes as plain text +request->send("text/plain", 128, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will not be asked for more bytes once the content length has been reached. + //Keep in mind that you can not delay or yield waiting for more data! + //Send what you currently have and you will be asked for more again + return mySource.read(buffer, maxLen); +}); +``` + +### Respond with content using a callback and extra headers +```cpp +//send 128 bytes as plain text +AsyncWebServerResponse *response = request->beginResponse("text/plain", 128, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will not be asked for more bytes once the content length has been reached. + //Keep in mind that you can not delay or yield waiting for more data! + //Send what you currently have and you will be asked for more again + return mySource.read(buffer, maxLen); +}); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Respond with content using a callback containing templates +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//send 128 bytes as plain text +request->send("text/plain", 128, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will not be asked for more bytes once the content length has been reached. + //Keep in mind that you can not delay or yield waiting for more data! + //Send what you currently have and you will be asked for more again + return mySource.read(buffer, maxLen); +}, processor); +``` + +### Respond with content using a callback containing templates and extra headers +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//send 128 bytes as plain text +AsyncWebServerResponse *response = request->beginResponse("text/plain", 128, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will not be asked for more bytes once the content length has been reached. + //Keep in mind that you can not delay or yield waiting for more data! + //Send what you currently have and you will be asked for more again + return mySource.read(buffer, maxLen); +}, processor); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Chunked Response +Used when content length is unknown. Works best if the client supports HTTP/1.1 +```cpp +AsyncWebServerResponse *response = request->beginChunkedResponse("text/plain", [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will be asked for more data until 0 is returned + //Keep in mind that you can not delay or yield waiting for more data! + return mySource.read(buffer, maxLen); +}); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Chunked Response containing templates +Used when content length is unknown. Works best if the client supports HTTP/1.1 +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +AsyncWebServerResponse *response = request->beginChunkedResponse("text/plain", [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will be asked for more data until 0 is returned + //Keep in mind that you can not delay or yield waiting for more data! + return mySource.read(buffer, maxLen); +}, processor); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Print to response +```cpp +AsyncResponseStream *response = request->beginResponseStream("text/html"); +response->addHeader("Server","ESP Async Web Server"); +response->printf("Webpage at %s", request->url().c_str()); + +response->print("

Hello "); +response->print(request->client()->remoteIP()); +response->print("

"); + +response->print("

General

"); +response->print("
    "); +response->printf("
  • Version: HTTP/1.%u
    • ", request->version()); +response->printf("
  • Method: %s
    • ", request->methodToString()); +response->printf("
  • URL: %s
    • ", request->url().c_str()); +response->printf("
  • Host: %s
    • ", request->host().c_str()); +response->printf("
  • ContentType: %s
    • ", request->contentType().c_str()); +response->printf("
  • ContentLength: %u
    • ", request->contentLength()); +response->printf("
  • Multipart: %s
    • ", request->multipart()?"true":"false"); +response->print("
"); + +response->print("

Headers

"); +response->print("
    "); +int headers = request->headers(); +for(int i=0;igetHeader(i); + response->printf("
  • %s: %s
    • ", h->name().c_str(), h->value().c_str()); +} +response->print("
"); + +response->print("

Parameters

"); +response->print("
    "); +int params = request->params(); +for(int i=0;igetParam(i); + if(p->isFile()){ + response->printf("
  • FILE[%s]: %s, size: %u
    • ", p->name().c_str(), p->value().c_str(), p->size()); + } else if(p->isPost()){ + response->printf("
  • POST[%s]: %s
    • ", p->name().c_str(), p->value().c_str()); + } else { + response->printf("
  • GET[%s]: %s
    • ", p->name().c_str(), p->value().c_str()); + } +} +response->print("
"); + +response->print(""); +//send the response last +request->send(response); +``` + +### ArduinoJson Basic Response +This way of sending Json is great for when the result is below 4KB +```cpp +#include "AsyncJson.h" +#include "ArduinoJson.h" + + +AsyncResponseStream *response = request->beginResponseStream("application/json"); +DynamicJsonBuffer jsonBuffer; +JsonObject &root = jsonBuffer.createObject(); +root["heap"] = ESP.getFreeHeap(); +root["ssid"] = WiFi.SSID(); +root.printTo(*response); +request->send(response); +``` + +### ArduinoJson Advanced Response +This response can handle really large Json objects (tested to 40KB) +There isn't any noticeable speed decrease for small results with the method above +Since ArduinoJson does not allow reading parts of the string, the whole Json has to +be passed every time a chunks needs to be sent, which shows speed decrease proportional +to the resulting json packets +```cpp +#include "AsyncJson.h" +#include "ArduinoJson.h" + + +AsyncJsonResponse * response = new AsyncJsonResponse(); +response->addHeader("Server","ESP Async Web Server"); +JsonObject& root = response->getRoot(); +root["heap"] = ESP.getFreeHeap(); +root["ssid"] = WiFi.SSID(); +response->setLength(); +request->send(response); +``` + +## Serving static files +In addition to serving files from SPIFFS as described above, the server provide a dedicated handler that optimize the +performance of serving files from SPIFFS - ```AsyncStaticWebHandler```. Use ```server.serveStatic()``` function to +initialize and add a new instance of ```AsyncStaticWebHandler``` to the server. +The Handler will not handle the request if the file does not exists, e.g. the server will continue to look for another +handler that can handle the request. +Notice that you can chain setter functions to setup the handler, or keep a pointer to change it at a later time. + +### Serving specific file by name +```cpp +// Serve the file "/www/page.htm" when request url is "/page.htm" +server.serveStatic("/page.htm", SPIFFS, "/www/page.htm"); +``` + +### Serving files in directory +To serve files in a directory, the path to the files should specify a directory in SPIFFS and ends with "/". +```cpp +// Serve files in directory "/www/" when request url starts with "/" +// Request to the root or none existing files will try to server the defualt +// file name "index.htm" if exists +server.serveStatic("/", SPIFFS, "/www/"); + +// Server with different default file +server.serveStatic("/", SPIFFS, "/www/").setDefaultFile("default.html"); +``` + +### Serving static files with authentication + +```cpp +server + .serveStatic("/", SPIFFS, "/www/") + .setDefaultFile("default.html") + .setAuthentication("user", "pass"); +``` + +### Specifying Cache-Control header +It is possible to specify Cache-Control header value to reduce the number of calls to the server once the client loaded +the files. For more information on Cache-Control values see [Cache-Control](https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) +```cpp +// Cache responses for 10 minutes (600 seconds) +server.serveStatic("/", SPIFFS, "/www/").setCacheControl("max-age=600"); + +//*** Change Cache-Control after server setup *** + +// During setup - keep a pointer to the handler +AsyncStaticWebHandler* handler = &server.serveStatic("/", SPIFFS, "/www/").setCacheControl("max-age=600"); + +// At a later event - change Cache-Control +handler->setCacheControl("max-age=30"); +``` + +### Specifying Date-Modified header +It is possible to specify Date-Modified header to enable the server to return Not-Modified (304) response for requests +with "If-Modified-Since" header with the same value, instead of responding with the actual file content. +```cpp +// Update the date modified string every time files are updated +server.serveStatic("/", SPIFFS, "/www/").setLastModified("Mon, 20 Jun 2016 14:00:00 GMT"); + +//*** Chage last modified value at a later stage *** + +// During setup - read last modified value from config or EEPROM +String date_modified = loadDateModified(); +AsyncStaticWebHandler* handler = &server.serveStatic("/", SPIFFS, "/www/"); +handler->setLastModified(date_modified); + +// At a later event when files are updated +String date_modified = getNewDateModfied(); +saveDateModified(date_modified); // Save for next reset +handler->setLastModified(date_modified); +``` + +### Specifying Template Processor callback +It is possible to specify template processor for static files. For information on template processor see +[Respond with content coming from a File containing templates](#respond-with-content-coming-from-a-file-containing-templates). +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +server.serveStatic("/", SPIFFS, "/www/").setTemplateProcessor(processor); +``` + +## Param Rewrite With Matching +It is possible to rewrite the request url with parameter matchg. Here is an example with one parameter: +Rewrite for example "/radio/{frequence}" -> "/radio?f={frequence}" + +```cpp +class OneParamRewrite : public AsyncWebRewrite +{ + protected: + String _urlPrefix; + int _paramIndex; + String _paramsBackup; + + public: + OneParamRewrite(const char* from, const char* to) + : AsyncWebRewrite(from, to) { + + _paramIndex = _from.indexOf('{'); + + if( _paramIndex >=0 && _from.endsWith("}")) { + _urlPrefix = _from.substring(0, _paramIndex); + int index = _params.indexOf('{'); + if(index >= 0) { + _params = _params.substring(0, index); + } + } else { + _urlPrefix = _from; + } + _paramsBackup = _params; + } + + bool match(AsyncWebServerRequest *request) override { + if(request->url().startsWith(_urlPrefix)) { + if(_paramIndex >= 0) { + _params = _paramsBackup + request->url().substring(_paramIndex); + } else { + _params = _paramsBackup; + } + return true; + + } else { + return false; + } + } +}; +``` + +Usage: + +```cpp + server.addRewrite( new OneParamRewrite("/radio/{frequence}", "/radio?f={frequence}") ); +``` + +## Using filters +Filters can be set to `Rewrite` or `Handler` in order to control when to apply the rewrite and consider the handler. +A filter is a callback function that evaluates the request and return a boolean `true` to include the item +or `false` to exclude it. +Two filter callback are provided for convince: +* `ON_STA_FILTER` - return true when requests are made to the STA (station mode) interface. +* `ON_AP_FILTER` - return true when requests are made to the AP (access point) interface. + +### Serve different site files in AP mode +```cpp +server.serveStatic("/", SPIFFS, "/www/").setFilter(ON_STA_FILTER); +server.serveStatic("/", SPIFFS, "/ap/").setFilter(ON_AP_FILTER); +``` + +### Rewrite to different index on AP +```cpp +// Serve the file "/www/index-ap.htm" in AP, and the file "/www/index.htm" on STA +server.rewrite("/", "index.htm"); +server.rewrite("/index.htm", "index-ap.htm").setFilter(ON_AP_FILTER); +server.serveStatic("/", SPIFFS, "/www/"); +``` + +### Serving different hosts +```cpp +// Filter callback using request host +bool filterOnHost1(AsyncWebServerRequest *request) { return request->host() == "host1"; } + +// Server setup: server files in "/host1/" to requests for "host1", and files in "/www/" otherwise. +server.serveStatic("/", SPIFFS, "/host1/").setFilter(filterOnHost1); +server.serveStatic("/", SPIFFS, "/www/"); +``` + +### Determine interface inside callbacks +```cpp + String RedirectUrl = "http://"; + if (ON_STA_FILTER(request)) { + RedirectUrl += WiFi.localIP().toString(); + } else { + RedirectUrl += WiFi.softAPIP().toString(); + } + RedirectUrl += "/index.htm"; + request->redirect(RedirectUrl); +``` + +## Bad Responses +Some responses are implemented, but you should not use them, because they do not conform to HTTP. +The following example will lead to unclean close of the connection and more time wasted +than providing the length of the content + +### Respond with content using a callback without content length to HTTP/1.0 clients +```cpp +//This is used as fallback for chunked responses to HTTP/1.0 Clients +request->send("text/plain", 0, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //You will be asked for more data until 0 is returned + //Keep in mind that you can not delay or yield waiting for more data! + return mySource.read(buffer, maxLen); +}); +``` + +## Async WebSocket Plugin +The server includes a web socket plugin which lets you define different WebSocket locations to connect to +without starting another listening service or using different port + +### Async WebSocket Event +```cpp + +void onEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){ + if(type == WS_EVT_CONNECT){ + //client connected + os_printf("ws[%s][%u] connect\n", server->url(), client->id()); + client->printf("Hello Client %u :)", client->id()); + client->ping(); + } else if(type == WS_EVT_DISCONNECT){ + //client disconnected + os_printf("ws[%s][%u] disconnect: %u\n", server->url(), client->id()); + } else if(type == WS_EVT_ERROR){ + //error was received from the other end + os_printf("ws[%s][%u] error(%u): %s\n", server->url(), client->id(), *((uint16_t*)arg), (char*)data); + } else if(type == WS_EVT_PONG){ + //pong message was received (in response to a ping request maybe) + os_printf("ws[%s][%u] pong[%u]: %s\n", server->url(), client->id(), len, (len)?(char*)data:""); + } else if(type == WS_EVT_DATA){ + //data packet + AwsFrameInfo * info = (AwsFrameInfo*)arg; + if(info->final && info->index == 0 && info->len == len){ + //the whole message is in a single frame and we got all of it's data + os_printf("ws[%s][%u] %s-message[%llu]: ", server->url(), client->id(), (info->opcode == WS_TEXT)?"text":"binary", info->len); + if(info->opcode == WS_TEXT){ + data[len] = 0; + os_printf("%s\n", (char*)data); + } else { + for(size_t i=0; i < info->len; i++){ + os_printf("%02x ", data[i]); + } + os_printf("\n"); + } + if(info->opcode == WS_TEXT) + client->text("I got your text message"); + else + client->binary("I got your binary message"); + } else { + //message is comprised of multiple frames or the frame is split into multiple packets + if(info->index == 0){ + if(info->num == 0) + os_printf("ws[%s][%u] %s-message start\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary"); + os_printf("ws[%s][%u] frame[%u] start[%llu]\n", server->url(), client->id(), info->num, info->len); + } + + os_printf("ws[%s][%u] frame[%u] %s[%llu - %llu]: ", server->url(), client->id(), info->num, (info->message_opcode == WS_TEXT)?"text":"binary", info->index, info->index + len); + if(info->message_opcode == WS_TEXT){ + data[len] = 0; + os_printf("%s\n", (char*)data); + } else { + for(size_t i=0; i < len; i++){ + os_printf("%02x ", data[i]); + } + os_printf("\n"); + } + + if((info->index + len) == info->len){ + os_printf("ws[%s][%u] frame[%u] end[%llu]\n", server->url(), client->id(), info->num, info->len); + if(info->final){ + os_printf("ws[%s][%u] %s-message end\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary"); + if(info->message_opcode == WS_TEXT) + client->text("I got your text message"); + else + client->binary("I got your binary message"); + } + } + } + } +} +``` + +### Methods for sending data to a socket client +```cpp + + + +//Server methods +AsyncWebSocket ws("/ws"); +//printf to a client +ws.printf((uint32_t)client_id, arguments...); +//printf to all clients +ws.printfAll(arguments...); +//printf_P to a client +ws.printf_P((uint32_t)client_id, PSTR(format), arguments...); +//printfAll_P to all clients +ws.printfAll_P(PSTR(format), arguments...); +//send text to a client +ws.text((uint32_t)client_id, (char*)text); +ws.text((uint32_t)client_id, (uint8_t*)text, (size_t)len); +//send text from PROGMEM to a client +ws.text((uint32_t)client_id, PSTR("text")); +const char flash_text[] PROGMEM = "Text to send" +ws.text((uint32_t)client_id, FPSTR(flash_text)); +//send text to all clients +ws.textAll((char*)text); +ws.textAll((uint8_t*)text, (size_t)len); +//send binary to a client +ws.binary((uint32_t)client_id, (char*)binary); +ws.binary((uint32_t)client_id, (uint8_t*)binary, (size_t)len); +//send binary from PROGMEM to a client +const uint8_t flash_binary[] PROGMEM = { 0x01, 0x02, 0x03, 0x04 }; +ws.binary((uint32_t)client_id, flash_binary, 4); +//send binary to all clients +ws.binaryAll((char*)binary); +ws.binaryAll((uint8_t*)binary, (size_t)len); +//HTTP Authenticate before switch to Websocket protocol +ws.setAuthentication("user", "pass"); + +//client methods +AsyncWebSocketClient * client; +//printf +client->printf(arguments...); +//printf_P +client->printf_P(PSTR(format), arguments...); +//send text +client->text((char*)text); +client->text((uint8_t*)text, (size_t)len); +//send text from PROGMEM +client->text(PSTR("text")); +const char flash_text[] PROGMEM = "Text to send"; +client->text(FPSTR(flash_text)); +//send binary +client->binary((char*)binary); +client->binary((uint8_t*)binary, (size_t)len); +//send binary from PROGMEM +const uint8_t flash_binary[] PROGMEM = { 0x01, 0x02, 0x03, 0x04 }; +client->binary(flash_binary, 4); +``` + +### Direct access to web socket message buffer +When sending a web socket message using the above methods a buffer is created. Under certain circumstances you might want to manipulate or populate this buffer directly from your application, for example to prevent unnecessary duplications of the data. This example below shows how to create a buffer and print data to it from an ArduinoJson object then send it. + +```cpp +void sendDataWs(AsyncWebSocketClient * client) +{ + DynamicJsonBuffer jsonBuffer; + JsonObject& root = jsonBuffer.createObject(); + root["a"] = "abc"; + root["b"] = "abcd"; + root["c"] = "abcde"; + root["d"] = "abcdef"; + root["e"] = "abcdefg"; + size_t len = root.measureLength(); + AsyncWebSocketMessageBuffer * buffer = ws.makeBuffer(len); // creates a buffer (len + 1) for you. + if (buffer) { + root.printTo((char *)buffer->get(), len + 1); + if (client) { + client->text(buffer); + } else { + ws.textAll(buffer); + } + } +} +``` + +### Limiting the number of web socket clients +Browsers sometimes do not correctly close the websocket connection, even when the close() function is called in javascript. This will eventually exhaust the web server's resources and will cause the server to crash. Periodically calling the cleanClients() function from the main loop() function limits the number of clients by closing the oldest client when the maximum number of clients has been exceeded. This can called be every cycle, however, if you wish to use less power, then calling as infrequently as once per second is sufficient. + +```cpp +void loop(){ + ws.cleanupClients(); +} +``` + + +## Async Event Source Plugin +The server includes EventSource (Server-Sent Events) plugin which can be used to send short text events to the browser. +Difference between EventSource and WebSockets is that EventSource is single direction, text-only protocol. + +### Setup Event Source on the server +```cpp +AsyncWebServer server(80); +AsyncEventSource events("/events"); + +void setup(){ + // setup ...... + events.onConnect([](AsyncEventSourceClient *client){ + if(client->lastId()){ + Serial.printf("Client reconnected! Last message ID that it gat is: %u\n", client->lastId()); + } + //send event with message "hello!", id current millis + // and set reconnect delay to 1 second + client->send("hello!",NULL,millis(),1000); + }); + //HTTP Basic authentication + events.setAuthentication("user", "pass"); + server.addHandler(&events); + // setup ...... +} + +void loop(){ + if(eventTriggered){ // your logic here + //send event "myevent" + events.send("my event content","myevent",millis()); + } +} +``` + +### Setup Event Source in the browser +```javascript +if (!!window.EventSource) { + var source = new EventSource('/events'); + + source.addEventListener('open', function(e) { + console.log("Events Connected"); + }, false); + + source.addEventListener('error', function(e) { + if (e.target.readyState != EventSource.OPEN) { + console.log("Events Disconnected"); + } + }, false); + + source.addEventListener('message', function(e) { + console.log("message", e.data); + }, false); + + source.addEventListener('myevent', function(e) { + console.log("myevent", e.data); + }, false); +} +``` + +## Scanning for available WiFi Networks +```cpp +//First request will return 0 results unless you start scan from somewhere else (loop/setup) +//Do not request more often than 3-5 seconds +server.on("/scan", HTTP_GET, [](AsyncWebServerRequest *request){ + String json = "["; + int n = WiFi.scanComplete(); + if(n == -2){ + WiFi.scanNetworks(true); + } else if(n){ + for (int i = 0; i < n; ++i){ + if(i) json += ","; + json += "{"; + json += "\"rssi\":"+String(WiFi.RSSI(i)); + json += ",\"ssid\":\""+WiFi.SSID(i)+"\""; + json += ",\"bssid\":\""+WiFi.BSSIDstr(i)+"\""; + json += ",\"channel\":"+String(WiFi.channel(i)); + json += ",\"secure\":"+String(WiFi.encryptionType(i)); + json += ",\"hidden\":"+String(WiFi.isHidden(i)?"true":"false"); + json += "}"; + } + WiFi.scanDelete(); + if(WiFi.scanComplete() == -2){ + WiFi.scanNetworks(true); + } + } + json += "]"; + request->send(200, "application/json", json); + json = String(); +}); +``` + +## Remove handlers and rewrites + +Server goes through handlers in same order as they were added. You can't simple add handler with same path to override them. +To remove handler: +```arduino +// save callback for particular URL path +auto handler = server.on("/some/path", [](AsyncWebServerRequest *request){ + //do something useful +}); +// when you don't need handler anymore remove it +server.removeHandler(&handler); + +// same with rewrites +server.removeRewrite(&someRewrite); + +server.onNotFound([](AsyncWebServerRequest *request){ + request->send(404); +}); + +// remove server.onNotFound handler +server.onNotFound(NULL); + +// remove all rewrites, handlers and onNotFound/onFileUpload/onRequestBody callbacks +server.reset(); +``` + +## Setting up the server +```cpp +#include "ESPAsyncTCP.h" +#include "ESPAsyncWebServer.h" + +AsyncWebServer server(80); +AsyncWebSocket ws("/ws"); // access at ws://[esp ip]/ws +AsyncEventSource events("/events"); // event source (Server-Sent events) + +const char* ssid = "your-ssid"; +const char* password = "your-pass"; +const char* http_username = "admin"; +const char* http_password = "admin"; + +//flag to use from web update to reboot the ESP +bool shouldReboot = false; + +void onRequest(AsyncWebServerRequest *request){ + //Handle Unknown Request + request->send(404); +} + +void onBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total){ + //Handle body +} + +void onUpload(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final){ + //Handle upload +} + +void onEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){ + //Handle WebSocket event +} + +void setup(){ + Serial.begin(115200); + WiFi.mode(WIFI_STA); + WiFi.begin(ssid, password); + if (WiFi.waitForConnectResult() != WL_CONNECTED) { + Serial.printf("WiFi Failed!\n"); + return; + } + + // attach AsyncWebSocket + ws.onEvent(onEvent); + server.addHandler(&ws); + + // attach AsyncEventSource + server.addHandler(&events); + + // respond to GET requests on URL /heap + server.on("/heap", HTTP_GET, [](AsyncWebServerRequest *request){ + request->send(200, "text/plain", String(ESP.getFreeHeap())); + }); + + // upload a file to /upload + server.on("/upload", HTTP_POST, [](AsyncWebServerRequest *request){ + request->send(200); + }, onUpload); + + // send a file when /index is requested + server.on("/index", HTTP_ANY, [](AsyncWebServerRequest *request){ + request->send(SPIFFS, "/index.htm"); + }); + + // HTTP basic authentication + server.on("/login", HTTP_GET, [](AsyncWebServerRequest *request){ + if(!request->authenticate(http_username, http_password)) + return request->requestAuthentication(); + request->send(200, "text/plain", "Login Success!"); + }); + + // Simple Firmware Update Form + server.on("/update", HTTP_GET, [](AsyncWebServerRequest *request){ + request->send(200, "text/html", "
"); + }); + server.on("/update", HTTP_POST, [](AsyncWebServerRequest *request){ + shouldReboot = !Update.hasError(); + AsyncWebServerResponse *response = request->beginResponse(200, "text/plain", shouldReboot?"OK":"FAIL"); + response->addHeader("Connection", "close"); + request->send(response); + },[](AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final){ + if(!index){ + Serial.printf("Update Start: %s\n", filename.c_str()); + Update.runAsync(true); + if(!Update.begin((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000)){ + Update.printError(Serial); + } + } + if(!Update.hasError()){ + if(Update.write(data, len) != len){ + Update.printError(Serial); + } + } + if(final){ + if(Update.end(true)){ + Serial.printf("Update Success: %uB\n", index+len); + } else { + Update.printError(Serial); + } + } + }); + + // attach filesystem root at URL /fs + server.serveStatic("/fs", SPIFFS, "/"); + + // Catch-All Handlers + // Any request that can not find a Handler that canHandle it + // ends in the callbacks below. + server.onNotFound(onRequest); + server.onFileUpload(onUpload); + server.onRequestBody(onBody); + + server.begin(); +} + +void loop(){ + if(shouldReboot){ + Serial.println("Rebooting..."); + delay(100); + ESP.restart(); + } + static char temp[128]; + sprintf(temp, "Seconds since boot: %u", millis()/1000); + events.send(temp, "time"); //send event "time" +} +``` + +### Setup global and class functions as request handlers + +```cpp +#include +#include +#include +#include + +void handleRequest(AsyncWebServerRequest *request){} + +class WebClass { +public : + AsyncWebServer classWebServer = AsyncWebServer(81); + + WebClass(){}; + + void classRequest (AsyncWebServerRequest *request){} + + void begin(){ + // attach global request handler + classWebServer.on("/example", HTTP_ANY, handleRequest); + + // attach class request handler + classWebServer.on("/example", HTTP_ANY, std::bind(&WebClass::classRequest, this, std::placeholders::_1)); + } +}; + +AsyncWebServer globalWebServer(80); +WebClass webClassInstance; + +void setup() { + // attach global request handler + globalWebServer.on("/example", HTTP_ANY, handleRequest); + + // attach class request handler + globalWebServer.on("/example", HTTP_ANY, std::bind(&WebClass::classRequest, webClassInstance, std::placeholders::_1)); +} + +void loop() { + +} +``` + +### Methods for controlling websocket connections + +```cpp + // Disable client connections if it was activated + if ( ws.enabled() ) + ws.enable(false); + + // enable client connections if it was disabled + if ( !ws.enabled() ) + ws.enable(true); +``` + +Example of OTA code + +```cpp + // OTA callbacks + ArduinoOTA.onStart([]() { + // Clean SPIFFS + SPIFFS.end(); + + // Disable client connections + ws.enable(false); + + // Advertise connected clients what's going on + ws.textAll("OTA Update Started"); + + // Close them + ws.closeAll(); + + }); + +``` + +### Adding Default Headers + +In some cases, such as when working with CORS, or with some sort of custom authentication system, +you might need to define a header that should get added to all responses (including static, websocket and EventSource). +The DefaultHeaders singleton allows you to do this. + +Example: + +```cpp +DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", "*"); +webServer.begin(); +``` + +*NOTE*: You will still need to respond to the OPTIONS method for CORS pre-flight in most cases. (unless you are only using GET) + +This is one option: + +```cpp +webServer.onNotFound([](AsyncWebServerRequest *request) { + if (request->method() == HTTP_OPTIONS) { + request->send(200); + } else { + request->send(404); + } +}); +``` + +### Path variable + +With path variable you can create a custom regex rule for a specific parameter in a route. +For example we want a `sensorId` parameter in a route rule to match only a integer. + +```cpp + server.on("^\\/sensor\\/([0-9]+)$", HTTP_GET, [] (AsyncWebServerRequest *request) { + String sensorId = request->pathArg(0); + }); +``` +*NOTE*: All regex patterns starts with `^` and ends with `$` + +To enable the `Path variable` support, you have to define the buildflag `-DASYNCWEBSERVER_REGEX`. + + +For Arduino IDE create/update `platform.local.txt`: + +`Windows`: C:\Users\(username)\AppData\Local\Arduino15\packages\\`{espxxxx}`\hardware\\`espxxxx`\\`{version}`\platform.local.txt + +`Linux`: ~/.arduino15/packages/`{espxxxx}`/hardware/`{espxxxx}`/`{version}`/platform.local.txt + +Add/Update the following line: +``` + compiler.cpp.extra_flags=-DDASYNCWEBSERVER_REGEX +``` + +For platformio modify `platformio.ini`: +```ini +[env:myboard] +build_flags = + -DASYNCWEBSERVER_REGEX +``` +*NOTE*: By enabling `ASYNCWEBSERVER_REGEX`, `` will be included. This will add an 100k to your binary. diff --git a/lib/ESPAsyncWebServer/_config.yml b/lib/ESPAsyncWebServer/_config.yml new file mode 100644 index 00000000..c4192631 --- /dev/null +++ b/lib/ESPAsyncWebServer/_config.yml @@ -0,0 +1 @@ +theme: jekyll-theme-cayman \ No newline at end of file diff --git a/lib/ESPAsyncWebServer/component.mk b/lib/ESPAsyncWebServer/component.mk new file mode 100644 index 00000000..bb5bb161 --- /dev/null +++ b/lib/ESPAsyncWebServer/component.mk @@ -0,0 +1,3 @@ +COMPONENT_ADD_INCLUDEDIRS := src +COMPONENT_SRCDIRS := src +CXXFLAGS += -fno-rtti diff --git a/lib/ESPAsyncWebServer/examples/CaptivePortal/CaptivePortal.ino b/lib/ESPAsyncWebServer/examples/CaptivePortal/CaptivePortal.ino new file mode 100644 index 00000000..f97f142a --- /dev/null +++ b/lib/ESPAsyncWebServer/examples/CaptivePortal/CaptivePortal.ino @@ -0,0 +1,47 @@ +#include +#ifdef ESP32 +#include +#include +#elif defined(ESP8266) +#include +#include +#endif +#include "ESPAsyncWebServer.h" + +DNSServer dnsServer; +AsyncWebServer server(80); + +class CaptiveRequestHandler : public AsyncWebHandler { +public: + CaptiveRequestHandler() {} + virtual ~CaptiveRequestHandler() {} + + bool canHandle(AsyncWebServerRequest *request){ + //request->addInterestingHeader("ANY"); + return true; + } + + void handleRequest(AsyncWebServerRequest *request) { + AsyncResponseStream *response = request->beginResponseStream("text/html"); + response->print("Captive Portal"); + response->print("

This is out captive portal front page.

"); + response->printf("

You were trying to reach: http://%s%s

", request->host().c_str(), request->url().c_str()); + response->printf("

Try opening this link instead

", WiFi.softAPIP().toString().c_str()); + response->print(""); + request->send(response); + } +}; + + +void setup(){ + //your other setup stuff... + WiFi.softAP("esp-captive"); + dnsServer.start(53, "*", WiFi.softAPIP()); + server.addHandler(new CaptiveRequestHandler()).setFilter(ON_AP_FILTER);//only when requested from AP + //more handlers... + server.begin(); +} + +void loop(){ + dnsServer.processNextRequest(); +} diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/ESP_AsyncFSBrowser.ino b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/ESP_AsyncFSBrowser.ino new file mode 100644 index 00000000..bf42d003 --- /dev/null +++ b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/ESP_AsyncFSBrowser.ino @@ -0,0 +1,221 @@ +#include +#ifdef ESP32 +#include +#include +#include +#include +#include +#elif defined(ESP8266) +#include +#include +#include +#endif +#include +#include + +// SKETCH BEGIN +AsyncWebServer server(80); +AsyncWebSocket ws("/ws"); +AsyncEventSource events("/events"); + +void onWsEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){ + if(type == WS_EVT_CONNECT){ + Serial.printf("ws[%s][%u] connect\n", server->url(), client->id()); + client->printf("Hello Client %u :)", client->id()); + client->ping(); + } else if(type == WS_EVT_DISCONNECT){ + Serial.printf("ws[%s][%u] disconnect\n", server->url(), client->id()); + } else if(type == WS_EVT_ERROR){ + Serial.printf("ws[%s][%u] error(%u): %s\n", server->url(), client->id(), *((uint16_t*)arg), (char*)data); + } else if(type == WS_EVT_PONG){ + Serial.printf("ws[%s][%u] pong[%u]: %s\n", server->url(), client->id(), len, (len)?(char*)data:""); + } else if(type == WS_EVT_DATA){ + AwsFrameInfo * info = (AwsFrameInfo*)arg; + String msg = ""; + if(info->final && info->index == 0 && info->len == len){ + //the whole message is in a single frame and we got all of it's data + Serial.printf("ws[%s][%u] %s-message[%llu]: ", server->url(), client->id(), (info->opcode == WS_TEXT)?"text":"binary", info->len); + + if(info->opcode == WS_TEXT){ + for(size_t i=0; i < info->len; i++) { + msg += (char) data[i]; + } + } else { + char buff[3]; + for(size_t i=0; i < info->len; i++) { + sprintf(buff, "%02x ", (uint8_t) data[i]); + msg += buff ; + } + } + Serial.printf("%s\n",msg.c_str()); + + if(info->opcode == WS_TEXT) + client->text("I got your text message"); + else + client->binary("I got your binary message"); + } else { + //message is comprised of multiple frames or the frame is split into multiple packets + if(info->index == 0){ + if(info->num == 0) + Serial.printf("ws[%s][%u] %s-message start\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary"); + Serial.printf("ws[%s][%u] frame[%u] start[%llu]\n", server->url(), client->id(), info->num, info->len); + } + + Serial.printf("ws[%s][%u] frame[%u] %s[%llu - %llu]: ", server->url(), client->id(), info->num, (info->message_opcode == WS_TEXT)?"text":"binary", info->index, info->index + len); + + if(info->opcode == WS_TEXT){ + for(size_t i=0; i < len; i++) { + msg += (char) data[i]; + } + } else { + char buff[3]; + for(size_t i=0; i < len; i++) { + sprintf(buff, "%02x ", (uint8_t) data[i]); + msg += buff ; + } + } + Serial.printf("%s\n",msg.c_str()); + + if((info->index + len) == info->len){ + Serial.printf("ws[%s][%u] frame[%u] end[%llu]\n", server->url(), client->id(), info->num, info->len); + if(info->final){ + Serial.printf("ws[%s][%u] %s-message end\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary"); + if(info->message_opcode == WS_TEXT) + client->text("I got your text message"); + else + client->binary("I got your binary message"); + } + } + } + } +} + + +const char* ssid = "*******"; +const char* password = "*******"; +const char * hostName = "esp-async"; +const char* http_username = "admin"; +const char* http_password = "admin"; + +void setup(){ + Serial.begin(115200); + Serial.setDebugOutput(true); + WiFi.mode(WIFI_AP_STA); + WiFi.softAP(hostName); + WiFi.begin(ssid, password); + if (WiFi.waitForConnectResult() != WL_CONNECTED) { + Serial.printf("STA: Failed!\n"); + WiFi.disconnect(false); + delay(1000); + WiFi.begin(ssid, password); + } + + //Send OTA events to the browser + ArduinoOTA.onStart([]() { events.send("Update Start", "ota"); }); + ArduinoOTA.onEnd([]() { events.send("Update End", "ota"); }); + ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) { + char p[32]; + sprintf(p, "Progress: %u%%\n", (progress/(total/100))); + events.send(p, "ota"); + }); + ArduinoOTA.onError([](ota_error_t error) { + if(error == OTA_AUTH_ERROR) events.send("Auth Failed", "ota"); + else if(error == OTA_BEGIN_ERROR) events.send("Begin Failed", "ota"); + else if(error == OTA_CONNECT_ERROR) events.send("Connect Failed", "ota"); + else if(error == OTA_RECEIVE_ERROR) events.send("Recieve Failed", "ota"); + else if(error == OTA_END_ERROR) events.send("End Failed", "ota"); + }); + ArduinoOTA.setHostname(hostName); + ArduinoOTA.begin(); + + MDNS.addService("http","tcp",80); + + SPIFFS.begin(); + + ws.onEvent(onWsEvent); + server.addHandler(&ws); + + events.onConnect([](AsyncEventSourceClient *client){ + client->send("hello!",NULL,millis(),1000); + }); + server.addHandler(&events); + +#ifdef ESP32 + server.addHandler(new SPIFFSEditor(SPIFFS, http_username,http_password)); +#elif defined(ESP8266) + server.addHandler(new SPIFFSEditor(http_username,http_password)); +#endif + + server.on("/heap", HTTP_GET, [](AsyncWebServerRequest *request){ + request->send(200, "text/plain", String(ESP.getFreeHeap())); + }); + + server.serveStatic("/", SPIFFS, "/").setDefaultFile("index.htm"); + + server.onNotFound([](AsyncWebServerRequest *request){ + Serial.printf("NOT_FOUND: "); + if(request->method() == HTTP_GET) + Serial.printf("GET"); + else if(request->method() == HTTP_POST) + Serial.printf("POST"); + else if(request->method() == HTTP_DELETE) + Serial.printf("DELETE"); + else if(request->method() == HTTP_PUT) + Serial.printf("PUT"); + else if(request->method() == HTTP_PATCH) + Serial.printf("PATCH"); + else if(request->method() == HTTP_HEAD) + Serial.printf("HEAD"); + else if(request->method() == HTTP_OPTIONS) + Serial.printf("OPTIONS"); + else + Serial.printf("UNKNOWN"); + Serial.printf(" http://%s%s\n", request->host().c_str(), request->url().c_str()); + + if(request->contentLength()){ + Serial.printf("_CONTENT_TYPE: %s\n", request->contentType().c_str()); + Serial.printf("_CONTENT_LENGTH: %u\n", request->contentLength()); + } + + int headers = request->headers(); + int i; + for(i=0;igetHeader(i); + Serial.printf("_HEADER[%s]: %s\n", h->name().c_str(), h->value().c_str()); + } + + int params = request->params(); + for(i=0;igetParam(i); + if(p->isFile()){ + Serial.printf("_FILE[%s]: %s, size: %u\n", p->name().c_str(), p->value().c_str(), p->size()); + } else if(p->isPost()){ + Serial.printf("_POST[%s]: %s\n", p->name().c_str(), p->value().c_str()); + } else { + Serial.printf("_GET[%s]: %s\n", p->name().c_str(), p->value().c_str()); + } + } + + request->send(404); + }); + server.onFileUpload([](AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final){ + if(!index) + Serial.printf("UploadStart: %s\n", filename.c_str()); + Serial.printf("%s", (const char*)data); + if(final) + Serial.printf("UploadEnd: %s (%u)\n", filename.c_str(), index+len); + }); + server.onRequestBody([](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total){ + if(!index) + Serial.printf("BodyStart: %u\n", total); + Serial.printf("%s", (const char*)data); + if(index + len == total) + Serial.printf("BodyEnd: %u\n", total); + }); + server.begin(); +} + +void loop(){ + ArduinoOTA.handle(); + ws.cleanupClients(); +} diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/.exclude.files b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/.exclude.files new file mode 100644 index 00000000..955397fa --- /dev/null +++ b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/.exclude.files @@ -0,0 +1,2 @@ +/*.js.gz +/.exclude.files diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/ace.js.gz b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/ace.js.gz new file mode 100644 index 00000000..7b175c1c Binary files /dev/null and b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/ace.js.gz differ diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/ext-searchbox.js.gz b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/ext-searchbox.js.gz new file mode 100644 index 00000000..cf5b49f6 Binary files /dev/null and b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/ext-searchbox.js.gz differ diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/favicon.ico b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/favicon.ico new file mode 100644 index 00000000..71b25fe6 Binary files /dev/null and b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/favicon.ico differ diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/index.htm b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/index.htm new file mode 100644 index 00000000..28f47e99 --- /dev/null +++ b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/index.htm @@ -0,0 +1,131 @@ + + + + + + WebSocketTester + + + + + 

+    

+      $
+    

+  
+
diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-css.js.gz b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-css.js.gz
new file mode 100644
index 00000000..ebd6fe94
Binary files /dev/null and b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-css.js.gz differ
diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-html.js.gz b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-html.js.gz
new file mode 100644
index 00000000..26b53532
Binary files /dev/null and b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-html.js.gz differ
diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-javascript.js.gz b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-javascript.js.gz
new file mode 100644
index 00000000..c0451c1c
Binary files /dev/null and b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/mode-javascript.js.gz differ
diff --git a/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/worker-html.js.gz b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/worker-html.js.gz
new file mode 100644
index 00000000..ec8aa87a
Binary files /dev/null and b/lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/worker-html.js.gz differ
diff --git a/lib/ESPAsyncWebServer/examples/regex_patterns/.test.build_flags b/lib/ESPAsyncWebServer/examples/regex_patterns/.test.build_flags
new file mode 100644
index 00000000..9ea3bb74
--- /dev/null
+++ b/lib/ESPAsyncWebServer/examples/regex_patterns/.test.build_flags
@@ -0,0 +1 @@
+-DASYNCWEBSERVER_REGEX=1
diff --git a/lib/ESPAsyncWebServer/examples/regex_patterns/regex_patterns.ino b/lib/ESPAsyncWebServer/examples/regex_patterns/regex_patterns.ino
new file mode 100644
index 00000000..fb013063
--- /dev/null
+++ b/lib/ESPAsyncWebServer/examples/regex_patterns/regex_patterns.ino
@@ -0,0 +1,77 @@
+//
+// A simple server implementation with regex routes:
+//  * serve static messages
+//  * read GET and POST parameters
+//  * handle missing pages / 404s
+//
+
+// Add buildflag ASYNCWEBSERVER_REGEX to enable the regex support
+
+// For platformio: platformio.ini:
+//  build_flags = 
+//      -DASYNCWEBSERVER_REGEX
+
+// For arduino IDE: create/update platform.local.txt
+// Windows: C:\Users\(username)\AppData\Local\Arduino15\packages\espxxxx\hardware\espxxxx\{version}\platform.local.txt
+// Linux: ~/.arduino15/packages/espxxxx/hardware/espxxxx/{version}/platform.local.txt
+//
+// compiler.cpp.extra_flags=-DASYNCWEBSERVER_REGEX=1
+
+#include 
+#ifdef ESP32
+#include 
+#include 
+#elif defined(ESP8266)
+#include 
+#include 
+#endif
+#include 
+
+AsyncWebServer server(80);
+
+const char* ssid = "YOUR_SSID";
+const char* password = "YOUR_PASSWORD";
+
+const char* PARAM_MESSAGE = "message";
+
+void notFound(AsyncWebServerRequest *request) {
+    request->send(404, "text/plain", "Not found");
+}
+
+void setup() {
+
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.printf("WiFi Failed!\n");
+        return;
+    }
+
+    Serial.print("IP Address: ");
+    Serial.println(WiFi.localIP());
+
+    server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
+        request->send(200, "text/plain", "Hello, world");
+    });
+
+    // Send a GET request to /sensor/
+    server.on("^\\/sensor\\/([0-9]+)$", HTTP_GET, [] (AsyncWebServerRequest *request) {
+        String sensorNumber = request->pathArg(0);
+        request->send(200, "text/plain", "Hello, sensor: " + sensorNumber);
+    });
+	
+	// Send a GET request to /sensor//action/
+    server.on("^\\/sensor\\/([0-9]+)\\/action\\/([a-zA-Z0-9]+)$", HTTP_GET, [] (AsyncWebServerRequest *request) {
+        String sensorNumber = request->pathArg(0);
+        String action = request->pathArg(1);
+        request->send(200, "text/plain", "Hello, sensor: " + sensorNumber + ", with action: " + action);
+    });
+
+    server.onNotFound(notFound);
+
+    server.begin();
+}
+
+void loop() {
+}
diff --git a/lib/ESPAsyncWebServer/examples/simple_server/simple_server.ino b/lib/ESPAsyncWebServer/examples/simple_server/simple_server.ino
new file mode 100644
index 00000000..bdbcf60d
--- /dev/null
+++ b/lib/ESPAsyncWebServer/examples/simple_server/simple_server.ino
@@ -0,0 +1,74 @@
+//
+// A simple server implementation showing how to:
+//  * serve static messages
+//  * read GET and POST parameters
+//  * handle missing pages / 404s
+//
+
+#include 
+#ifdef ESP32
+#include 
+#include 
+#elif defined(ESP8266)
+#include 
+#include 
+#endif
+#include 
+
+AsyncWebServer server(80);
+
+const char* ssid = "YOUR_SSID";
+const char* password = "YOUR_PASSWORD";
+
+const char* PARAM_MESSAGE = "message";
+
+void notFound(AsyncWebServerRequest *request) {
+    request->send(404, "text/plain", "Not found");
+}
+
+void setup() {
+
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.printf("WiFi Failed!\n");
+        return;
+    }
+
+    Serial.print("IP Address: ");
+    Serial.println(WiFi.localIP());
+
+    server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
+        request->send(200, "text/plain", "Hello, world");
+    });
+
+    // Send a GET request to /get?message=
+    server.on("/get", HTTP_GET, [] (AsyncWebServerRequest *request) {
+        String message;
+        if (request->hasParam(PARAM_MESSAGE)) {
+            message = request->getParam(PARAM_MESSAGE)->value();
+        } else {
+            message = "No message sent";
+        }
+        request->send(200, "text/plain", "Hello, GET: " + message);
+    });
+
+    // Send a POST request to /post with a form field message set to 
+    server.on("/post", HTTP_POST, [](AsyncWebServerRequest *request){
+        String message;
+        if (request->hasParam(PARAM_MESSAGE, true)) {
+            message = request->getParam(PARAM_MESSAGE, true)->value();
+        } else {
+            message = "No message sent";
+        }
+        request->send(200, "text/plain", "Hello, POST: " + message);
+    });
+
+    server.onNotFound(notFound);
+
+    server.begin();
+}
+
+void loop() {
+}
\ No newline at end of file
diff --git a/lib/ESPAsyncWebServer/keywords.txt b/lib/ESPAsyncWebServer/keywords.txt
new file mode 100644
index 00000000..c391e6c4
--- /dev/null
+++ b/lib/ESPAsyncWebServer/keywords.txt
@@ -0,0 +1,3 @@
+JsonArray	KEYWORD1
+add	KEYWORD2
+createArray	KEYWORD3
diff --git a/lib/ESPAsyncWebServer/library.json b/lib/ESPAsyncWebServer/library.json
new file mode 100644
index 00000000..55659279
--- /dev/null
+++ b/lib/ESPAsyncWebServer/library.json
@@ -0,0 +1,33 @@
+{
+  "name":"ESP Async WebServer",
+  "description":"Asynchronous HTTP and WebSocket Server Library for ESP8266 and ESP32",
+  "keywords":"http,async,websocket,webserver",
+  "authors":
+  {
+    "name": "Hristo Gochkov",
+    "maintainer": true
+  },
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/me-no-dev/ESPAsyncWebServer.git"
+  },
+  "version": "1.2.3",
+  "license": "LGPL-3.0",
+  "frameworks": "arduino",
+  "platforms": ["espressif8266", "espressif32"],
+  "dependencies": [
+    {
+      "name": "ESPAsyncTCP",
+      "platforms": "espressif8266"
+    },
+    {
+      "name": "AsyncTCP",
+      "platforms": "espressif32"
+    },
+    {
+      "name": "Hash",
+      "platforms": "espressif8266"
+    }
+  ]
+}
diff --git a/lib/ESPAsyncWebServer/library.properties b/lib/ESPAsyncWebServer/library.properties
new file mode 100644
index 00000000..401b0417
--- /dev/null
+++ b/lib/ESPAsyncWebServer/library.properties
@@ -0,0 +1,9 @@
+name=ESP Async WebServer
+version=1.2.3
+author=Me-No-Dev
+maintainer=Me-No-Dev
+sentence=Async Web Server for ESP8266 and ESP31B
+paragraph=Async Web Server for ESP8266 and ESP31B
+category=Other
+url=https://github.com/me-no-dev/ESPAsyncWebServer
+architectures=*
diff --git a/lib/ESPAsyncWebServer/src/AsyncEventSource.cpp b/lib/ESPAsyncWebServer/src/AsyncEventSource.cpp
new file mode 100644
index 00000000..f2914df5
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/AsyncEventSource.cpp
@@ -0,0 +1,368 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "Arduino.h"
+#include "AsyncEventSource.h"
+
+static String generateEventMessage(const char *message, const char *event, uint32_t id, uint32_t reconnect){
+  String ev = "";
+
+  if(reconnect){
+    ev += "retry: ";
+    ev += String(reconnect);
+    ev += "\r\n";
+  }
+
+  if(id){
+    ev += "id: ";
+    ev += String(id);
+    ev += "\r\n";
+  }
+
+  if(event != NULL){
+    ev += "event: ";
+    ev += String(event);
+    ev += "\r\n";
+  }
+
+  if(message != NULL){
+    size_t messageLen = strlen(message);
+    char * lineStart = (char *)message;
+    char * lineEnd;
+    do {
+      char * nextN = strchr(lineStart, '\n');
+      char * nextR = strchr(lineStart, '\r');
+      if(nextN == NULL && nextR == NULL){
+        size_t llen = ((char *)message + messageLen) - lineStart;
+        char * ldata = (char *)malloc(llen+1);
+        if(ldata != NULL){
+          memcpy(ldata, lineStart, llen);
+          ldata[llen] = 0;
+          ev += "data: ";
+          ev += ldata;
+          ev += "\r\n\r\n";
+          free(ldata);
+        }
+        lineStart = (char *)message + messageLen;
+      } else {
+        char * nextLine = NULL;
+        if(nextN != NULL && nextR != NULL){
+          if(nextR < nextN){
+            lineEnd = nextR;
+            if(nextN == (nextR + 1))
+              nextLine = nextN + 1;
+            else
+              nextLine = nextR + 1;
+          } else {
+            lineEnd = nextN;
+            if(nextR == (nextN + 1))
+              nextLine = nextR + 1;
+            else
+              nextLine = nextN + 1;
+          }
+        } else if(nextN != NULL){
+          lineEnd = nextN;
+          nextLine = nextN + 1;
+        } else {
+          lineEnd = nextR;
+          nextLine = nextR + 1;
+        }
+
+        size_t llen = lineEnd - lineStart;
+        char * ldata = (char *)malloc(llen+1);
+        if(ldata != NULL){
+          memcpy(ldata, lineStart, llen);
+          ldata[llen] = 0;
+          ev += "data: ";
+          ev += ldata;
+          ev += "\r\n";
+          free(ldata);
+        }
+        lineStart = nextLine;
+        if(lineStart == ((char *)message + messageLen))
+          ev += "\r\n";
+      }
+    } while(lineStart < ((char *)message + messageLen));
+  }
+
+  return ev;
+}
+
+// Message
+
+AsyncEventSourceMessage::AsyncEventSourceMessage(const char * data, size_t len)
+: _data(nullptr), _len(len), _sent(0), _acked(0)
+{
+  _data = (uint8_t*)malloc(_len+1);
+  if(_data == nullptr){
+    _len = 0;
+  } else {
+    memcpy(_data, data, len);
+    _data[_len] = 0;
+  }
+}
+
+AsyncEventSourceMessage::~AsyncEventSourceMessage() {
+     if(_data != NULL)
+        free(_data);
+}
+
+size_t AsyncEventSourceMessage::ack(size_t len, uint32_t time) {
+  (void)time;
+  // If the whole message is now acked...
+  if(_acked + len > _len){
+     // Return the number of extra bytes acked (they will be carried on to the next message)
+     const size_t extra = _acked + len - _len;
+     _acked = _len;
+     return extra;
+  }
+  // Return that no extra bytes left.
+  _acked += len;
+  return 0;
+}
+
+size_t AsyncEventSourceMessage::send(AsyncClient *client) {
+  const size_t len = _len - _sent;
+  if(client->space() < len){
+    return 0;
+  }
+  size_t sent = client->add((const char *)_data, len);
+  if(client->canSend())
+    client->send();
+  _sent += sent;
+  return sent; 
+}
+
+// Client
+
+AsyncEventSourceClient::AsyncEventSourceClient(AsyncWebServerRequest *request, AsyncEventSource *server)
+: _messageQueue(LinkedList([](AsyncEventSourceMessage *m){ delete  m; }))
+{
+  _client = request->client();
+  _server = server;
+  _lastId = 0;
+  if(request->hasHeader("Last-Event-ID"))
+    _lastId = atoi(request->getHeader("Last-Event-ID")->value().c_str());
+    
+  _client->setRxTimeout(0);
+  _client->onError(NULL, NULL);
+  _client->onAck([](void *r, AsyncClient* c, size_t len, uint32_t time){ (void)c; ((AsyncEventSourceClient*)(r))->_onAck(len, time); }, this);
+  _client->onPoll([](void *r, AsyncClient* c){ (void)c; ((AsyncEventSourceClient*)(r))->_onPoll(); }, this);
+  _client->onData(NULL, NULL);
+  _client->onTimeout([this](void *r, AsyncClient* c __attribute__((unused)), uint32_t time){ ((AsyncEventSourceClient*)(r))->_onTimeout(time); }, this);
+  _client->onDisconnect([this](void *r, AsyncClient* c){ ((AsyncEventSourceClient*)(r))->_onDisconnect(); delete c; }, this);
+
+  _server->_addClient(this);
+  delete request;
+}
+
+AsyncEventSourceClient::~AsyncEventSourceClient(){
+   _messageQueue.free();
+  close();
+}
+
+void AsyncEventSourceClient::_queueMessage(AsyncEventSourceMessage *dataMessage){
+  if(dataMessage == NULL)
+    return;
+  if(!connected()){
+    delete dataMessage;
+    return;
+  }
+  if(_messageQueue.length() >= SSE_MAX_QUEUED_MESSAGES){
+      ets_printf("ERROR: Too many messages queued\n");
+      delete dataMessage;
+  } else {
+      _messageQueue.add(dataMessage);
+  }
+  if(_client->canSend())
+    _runQueue();
+}
+
+void AsyncEventSourceClient::_onAck(size_t len, uint32_t time){
+  while(len && !_messageQueue.isEmpty()){
+    len = _messageQueue.front()->ack(len, time);
+    if(_messageQueue.front()->finished())
+      _messageQueue.remove(_messageQueue.front());
+  }
+
+  _runQueue();
+}
+
+void AsyncEventSourceClient::_onPoll(){
+  if(!_messageQueue.isEmpty()){
+    _runQueue();
+  }
+}
+
+
+void AsyncEventSourceClient::_onTimeout(uint32_t time __attribute__((unused))){
+  _client->close(true);
+}
+
+void AsyncEventSourceClient::_onDisconnect(){
+  _client = NULL;
+  _server->_handleDisconnect(this);
+}
+
+void AsyncEventSourceClient::close(){
+  if(_client != NULL)
+    _client->close();
+}
+
+void AsyncEventSourceClient::write(const char * message, size_t len){
+  _queueMessage(new AsyncEventSourceMessage(message, len));
+}
+
+void AsyncEventSourceClient::send(const char *message, const char *event, uint32_t id, uint32_t reconnect){
+  String ev = generateEventMessage(message, event, id, reconnect);
+  _queueMessage(new AsyncEventSourceMessage(ev.c_str(), ev.length()));
+}
+
+void AsyncEventSourceClient::_runQueue(){
+  while(!_messageQueue.isEmpty() && _messageQueue.front()->finished()){
+    _messageQueue.remove(_messageQueue.front());
+  }
+
+  for(auto i = _messageQueue.begin(); i != _messageQueue.end(); ++i)
+  {
+    if(!(*i)->sent())
+      (*i)->send(_client);
+  }
+}
+
+
+// Handler
+
+AsyncEventSource::AsyncEventSource(const String& url)
+  : _url(url)
+  , _clients(LinkedList([](AsyncEventSourceClient *c){ delete c; }))
+  , _connectcb(NULL)
+{}
+
+AsyncEventSource::~AsyncEventSource(){
+  close();
+}
+
+void AsyncEventSource::onConnect(ArEventHandlerFunction cb){
+  _connectcb = cb;
+}
+
+void AsyncEventSource::_addClient(AsyncEventSourceClient * client){
+  /*char * temp = (char *)malloc(2054);
+  if(temp != NULL){
+    memset(temp+1,' ',2048);
+    temp[0] = ':';
+    temp[2049] = '\r';
+    temp[2050] = '\n';
+    temp[2051] = '\r';
+    temp[2052] = '\n';
+    temp[2053] = 0;
+    client->write((const char *)temp, 2053);
+    free(temp);
+  }*/
+  
+  _clients.add(client);
+  if(_connectcb)
+    _connectcb(client);
+}
+
+void AsyncEventSource::_handleDisconnect(AsyncEventSourceClient * client){
+  _clients.remove(client);
+}
+
+void AsyncEventSource::close(){
+  for(const auto &c: _clients){
+    if(c->connected())
+      c->close();
+  }
+}
+
+// pmb fix
+size_t AsyncEventSource::avgPacketsWaiting() const {
+  if(_clients.isEmpty())
+    return 0;
+  
+  size_t    aql=0;
+  uint32_t  nConnectedClients=0;
+  
+  for(const auto &c: _clients){
+    if(c->connected()) {
+      aql+=c->packetsWaiting();
+      ++nConnectedClients;
+    }
+  }
+//  return aql / nConnectedClients;
+  return ((aql) + (nConnectedClients/2))/(nConnectedClients); // round up
+}
+
+void AsyncEventSource::send(const char *message, const char *event, uint32_t id, uint32_t reconnect){
+
+
+  String ev = generateEventMessage(message, event, id, reconnect);
+  for(const auto &c: _clients){
+    if(c->connected()) {
+      c->write(ev.c_str(), ev.length());
+    }
+  }
+}
+
+size_t AsyncEventSource::count() const {
+  return _clients.count_if([](AsyncEventSourceClient *c){
+    return c->connected();
+  });
+}
+
+bool AsyncEventSource::canHandle(AsyncWebServerRequest *request){
+  if(request->method() != HTTP_GET || !request->url().equals(_url)) {
+    return false;
+  }
+  request->addInterestingHeader("Last-Event-ID");
+  return true;
+}
+
+void AsyncEventSource::handleRequest(AsyncWebServerRequest *request){
+  if((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+    return request->requestAuthentication();
+  request->send(new AsyncEventSourceResponse(this));
+}
+
+// Response
+
+AsyncEventSourceResponse::AsyncEventSourceResponse(AsyncEventSource *server){
+  _server = server;
+  _code = 200;
+  _contentType = "text/event-stream";
+  _sendContentLength = false;
+  addHeader("Cache-Control", "no-cache");
+  addHeader("Connection","keep-alive");
+}
+
+void AsyncEventSourceResponse::_respond(AsyncWebServerRequest *request){
+  String out = _assembleHead(request->version());
+  request->client()->write(out.c_str(), _headLength);
+  _state = RESPONSE_WAIT_ACK;
+}
+
+size_t AsyncEventSourceResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time __attribute__((unused))){
+  if(len){
+    new AsyncEventSourceClient(request, _server);
+  }
+  return 0;
+}
+
diff --git a/lib/ESPAsyncWebServer/src/AsyncEventSource.h b/lib/ESPAsyncWebServer/src/AsyncEventSource.h
new file mode 100644
index 00000000..b097fa62
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/AsyncEventSource.h
@@ -0,0 +1,133 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef ASYNCEVENTSOURCE_H_
+#define ASYNCEVENTSOURCE_H_
+
+#include 
+#ifdef ESP32
+#include 
+#define SSE_MAX_QUEUED_MESSAGES 32
+#else
+#include 
+#define SSE_MAX_QUEUED_MESSAGES 8
+#endif
+#include 
+
+#include "AsyncWebSynchronization.h"
+
+#ifdef ESP8266
+#include 
+#ifdef CRYPTO_HASH_h // include Hash.h from espressif framework if the first include was from the crypto library
+#include <../src/Hash.h>
+#endif
+#endif
+
+#ifdef ESP32
+#define DEFAULT_MAX_SSE_CLIENTS 8
+#else
+#define DEFAULT_MAX_SSE_CLIENTS 4
+#endif
+
+class AsyncEventSource;
+class AsyncEventSourceResponse;
+class AsyncEventSourceClient;
+typedef std::function ArEventHandlerFunction;
+
+class AsyncEventSourceMessage {
+  private:
+    uint8_t * _data; 
+    size_t _len;
+    size_t _sent;
+    //size_t _ack;
+    size_t _acked; 
+  public:
+    AsyncEventSourceMessage(const char * data, size_t len);
+    ~AsyncEventSourceMessage();
+    size_t ack(size_t len, uint32_t time __attribute__((unused)));
+    size_t send(AsyncClient *client);
+    bool finished(){ return _acked == _len; }
+    bool sent() { return _sent == _len; }
+};
+
+class AsyncEventSourceClient {
+  private:
+    AsyncClient *_client;
+    AsyncEventSource *_server;
+    uint32_t _lastId;
+    LinkedList _messageQueue;
+    void _queueMessage(AsyncEventSourceMessage *dataMessage);
+    void _runQueue();
+
+  public:
+
+    AsyncEventSourceClient(AsyncWebServerRequest *request, AsyncEventSource *server);
+    ~AsyncEventSourceClient();
+
+    AsyncClient* client(){ return _client; }
+    void close();
+    void write(const char * message, size_t len);
+    void send(const char *message, const char *event=NULL, uint32_t id=0, uint32_t reconnect=0);
+    bool connected() const { return (_client != NULL) && _client->connected(); }
+    uint32_t lastId() const { return _lastId; }
+    size_t  packetsWaiting() const { return _messageQueue.length(); }
+
+    //system callbacks (do not call)
+    void _onAck(size_t len, uint32_t time);
+    void _onPoll(); 
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+};
+
+class AsyncEventSource: public AsyncWebHandler {
+  private:
+    String _url;
+    LinkedList _clients;
+    ArEventHandlerFunction _connectcb;
+  public:
+    AsyncEventSource(const String& url);
+    ~AsyncEventSource();
+
+    const char * url() const { return _url.c_str(); }
+    void close();
+    void onConnect(ArEventHandlerFunction cb);
+    void send(const char *message, const char *event=NULL, uint32_t id=0, uint32_t reconnect=0);
+    size_t count() const; //number clinets connected
+    size_t  avgPacketsWaiting() const;
+
+    //system callbacks (do not call)
+    void _addClient(AsyncEventSourceClient * client);
+    void _handleDisconnect(AsyncEventSourceClient * client);
+    virtual bool canHandle(AsyncWebServerRequest *request) override final;
+    virtual void handleRequest(AsyncWebServerRequest *request) override final;
+};
+
+class AsyncEventSourceResponse: public AsyncWebServerResponse {
+  private:
+    String _content;
+    AsyncEventSource *_server;
+  public:
+    AsyncEventSourceResponse(AsyncEventSource *server);
+    void _respond(AsyncWebServerRequest *request);
+    size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+
+#endif /* ASYNCEVENTSOURCE_H_ */
diff --git a/lib/ESPAsyncWebServer/src/AsyncJson.h b/lib/ESPAsyncWebServer/src/AsyncJson.h
new file mode 100644
index 00000000..27b4a26f
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/AsyncJson.h
@@ -0,0 +1,252 @@
+// AsyncJson.h
+/*
+  Async Response to use with ArduinoJson and AsyncWebServer
+  Written by Andrew Melvin (SticilFace) with help from me-no-dev and BBlanchon.
+
+  Example of callback in use
+
+   server.on("/json", HTTP_ANY, [](AsyncWebServerRequest * request) {
+
+    AsyncJsonResponse * response = new AsyncJsonResponse();
+    JsonObject& root = response->getRoot();
+    root["key1"] = "key number one";
+    JsonObject& nested = root.createNestedObject("nested");
+    nested["key1"] = "key number one";
+
+    response->setLength();
+    request->send(response);
+  });
+
+  --------------------
+
+  Async Request to use with ArduinoJson and AsyncWebServer
+  Written by Arsène von Wyss (avonwyss)
+
+  Example
+
+  AsyncCallbackJsonWebHandler* handler = new AsyncCallbackJsonWebHandler("/rest/endpoint");
+  handler->onRequest([](AsyncWebServerRequest *request, JsonVariant &json) {
+    JsonObject& jsonObj = json.as();
+    // ...
+  });
+  server.addHandler(handler);
+  
+*/
+#ifndef ASYNC_JSON_H_
+#define ASYNC_JSON_H_
+#include 
+#include 
+#include 
+
+#if ARDUINOJSON_VERSION_MAJOR == 5
+  #define ARDUINOJSON_5_COMPATIBILITY
+#else
+  #define DYNAMIC_JSON_DOCUMENT_SIZE  1024
+#endif
+
+constexpr const char* JSON_MIMETYPE = "application/json";
+
+/*
+ * Json Response
+ * */
+
+class ChunkPrint : public Print {
+  private:
+    uint8_t* _destination;
+    size_t _to_skip;
+    size_t _to_write;
+    size_t _pos;
+  public:
+    ChunkPrint(uint8_t* destination, size_t from, size_t len)
+      : _destination(destination), _to_skip(from), _to_write(len), _pos{0} {}
+    virtual ~ChunkPrint(){}
+    size_t write(uint8_t c){
+      if (_to_skip > 0) {
+        _to_skip--;
+        return 1;
+      } else if (_to_write > 0) {
+        _to_write--;
+        _destination[_pos++] = c;
+        return 1;
+      }
+      return 0;
+    }
+    size_t write(const uint8_t *buffer, size_t size)
+    {
+      return this->Print::write(buffer, size);
+    }
+};
+
+class AsyncJsonResponse: public AsyncAbstractResponse {
+  protected:
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+    DynamicJsonBuffer _jsonBuffer;
+#else
+    DynamicJsonDocument _jsonBuffer;
+#endif
+
+    JsonVariant _root;
+    bool _isValid;
+
+  public:    
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+    AsyncJsonResponse(bool isArray=false): _isValid{false} {
+      _code = 200;
+      _contentType = JSON_MIMETYPE;
+      if(isArray)
+        _root = _jsonBuffer.createArray();
+      else
+        _root = _jsonBuffer.createObject();
+    }
+#else
+    AsyncJsonResponse(bool isArray=false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE) : _jsonBuffer(maxJsonBufferSize), _isValid{false} {
+      _code = 200;
+      _contentType = JSON_MIMETYPE;
+      if(isArray)
+        _root = _jsonBuffer.createNestedArray();
+      else
+        _root = _jsonBuffer.createNestedObject();
+    }
+#endif
+
+    ~AsyncJsonResponse() {}
+    JsonVariant & getRoot() { return _root; }
+    bool _sourceValid() const { return _isValid; }
+    size_t setLength() {
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY      
+      _contentLength = _root.measureLength();
+#else
+      _contentLength = measureJson(_root);
+#endif
+
+      if (_contentLength) { _isValid = true; }
+      return _contentLength;
+    }
+
+   size_t getSize() { return _jsonBuffer.size(); }
+
+    size_t _fillBuffer(uint8_t *data, size_t len){
+      ChunkPrint dest(data, _sentLength, len);
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY      
+      _root.printTo( dest ) ;
+#else
+      serializeJson(_root, dest);
+#endif
+      return len;
+    }
+};
+
+class PrettyAsyncJsonResponse: public AsyncJsonResponse {	
+public:
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+	PrettyAsyncJsonResponse (bool isArray=false) : AsyncJsonResponse{isArray} {}
+#else
+	PrettyAsyncJsonResponse (bool isArray=false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE) : AsyncJsonResponse{isArray, maxJsonBufferSize} {}
+#endif
+	size_t setLength () {
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+		_contentLength = _root.measurePrettyLength ();
+#else
+		_contentLength = measureJsonPretty(_root);
+#endif
+		if (_contentLength) {_isValid = true;}
+		return _contentLength;
+	}
+	size_t _fillBuffer (uint8_t *data, size_t len) {
+		ChunkPrint dest (data, _sentLength, len);
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+		_root.prettyPrintTo (dest);
+#else
+		serializeJsonPretty(_root, dest);
+#endif
+		return len;
+	}
+};
+
+typedef std::function ArJsonRequestHandlerFunction;
+
+class AsyncCallbackJsonWebHandler: public AsyncWebHandler {
+private:
+protected:
+  const String _uri;
+  WebRequestMethodComposite _method;
+  ArJsonRequestHandlerFunction _onRequest;
+  size_t _contentLength;
+#ifndef ARDUINOJSON_5_COMPATIBILITY   
+  const size_t maxJsonBufferSize;
+#endif
+  size_t _maxContentLength;
+public:
+#ifdef ARDUINOJSON_5_COMPATIBILITY      
+  AsyncCallbackJsonWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest) 
+  : _uri(uri), _method(HTTP_POST|HTTP_PUT|HTTP_PATCH), _onRequest(onRequest), _maxContentLength(16384) {}
+#else
+  AsyncCallbackJsonWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest, size_t maxJsonBufferSize=DYNAMIC_JSON_DOCUMENT_SIZE) 
+  : _uri(uri), _method(HTTP_POST|HTTP_PUT|HTTP_PATCH), _onRequest(onRequest), maxJsonBufferSize(maxJsonBufferSize), _maxContentLength(16384) {}
+#endif
+  
+  void setMethod(WebRequestMethodComposite method){ _method = method; }
+  void setMaxContentLength(int maxContentLength){ _maxContentLength = maxContentLength; }
+  void onRequest(ArJsonRequestHandlerFunction fn){ _onRequest = fn; }
+
+  virtual bool canHandle(AsyncWebServerRequest *request) override final{
+    if(!_onRequest)
+      return false;
+
+    if(!(_method & request->method()))
+      return false;
+
+    if(_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri+"/")))
+      return false;
+
+    if ( !request->contentType().equalsIgnoreCase(JSON_MIMETYPE) )
+      return false;
+
+    request->addInterestingHeader("ANY");
+    return true;
+  }
+
+  virtual void handleRequest(AsyncWebServerRequest *request) override final {
+    if(_onRequest) {
+      if (request->_tempObject != NULL) {
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY    
+        DynamicJsonBuffer jsonBuffer;
+        JsonVariant json = jsonBuffer.parse((uint8_t*)(request->_tempObject));
+        if (json.success()) {
+#else
+        DynamicJsonDocument jsonBuffer(this->maxJsonBufferSize);
+        DeserializationError error = deserializeJson(jsonBuffer, (uint8_t*)(request->_tempObject));
+        if(!error) {
+          JsonVariant json = jsonBuffer.as();
+#endif
+
+          _onRequest(request, json);
+          return;
+        }
+      }
+      request->send(_contentLength > _maxContentLength ? 413 : 400);
+    } else {
+      request->send(500);
+    }
+  }
+  virtual void handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final) override final {
+  }
+  virtual void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override final {
+    if (_onRequest) {
+      _contentLength = total;
+      if (total > 0 && request->_tempObject == NULL && total < _maxContentLength) {
+        request->_tempObject = malloc(total);
+      }
+      if (request->_tempObject != NULL) {
+        memcpy((uint8_t*)(request->_tempObject) + index, data, len);
+      }
+    }
+  }
+  virtual bool isRequestHandlerTrivial() override final {return _onRequest ? false : true;}
+};
+#endif
diff --git a/lib/ESPAsyncWebServer/src/AsyncWebSocket.cpp b/lib/ESPAsyncWebServer/src/AsyncWebSocket.cpp
new file mode 100644
index 00000000..52dcd75f
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/AsyncWebSocket.cpp
@@ -0,0 +1,1303 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "Arduino.h"
+#include "AsyncWebSocket.h"
+
+#include 
+
+#ifndef ESP8266
+extern "C" {
+typedef struct {
+    uint32_t state[5];
+    uint32_t count[2];
+    unsigned char buffer[64];
+} SHA1_CTX;
+
+void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]);
+void SHA1Init(SHA1_CTX* context);
+void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len);
+void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
+}
+#else
+#include 
+#endif
+
+#define MAX_PRINTF_LEN 64
+
+size_t webSocketSendFrameWindow(AsyncClient *client){
+  if(!client->canSend())
+    return 0;
+  size_t space = client->space();
+  if(space < 9)
+    return 0;
+  return space - 8;
+}
+
+size_t webSocketSendFrame(AsyncClient *client, bool final, uint8_t opcode, bool mask, uint8_t *data, size_t len){
+  if(!client->canSend())
+    return 0;
+  size_t space = client->space();
+  if(space < 2)
+    return 0;
+  uint8_t mbuf[4] = {0,0,0,0};
+  uint8_t headLen = 2;
+  if(len && mask){
+    headLen += 4;
+    mbuf[0] = rand() % 0xFF;
+    mbuf[1] = rand() % 0xFF;
+    mbuf[2] = rand() % 0xFF;
+    mbuf[3] = rand() % 0xFF;
+  }
+  if(len > 125)
+    headLen += 2;
+  if(space < headLen)
+    return 0;
+  space -= headLen;
+
+  if(len > space) len = space;
+
+  uint8_t *buf = (uint8_t*)malloc(headLen);
+  if(buf == NULL){
+    //os_printf("could not malloc %u bytes for frame header\n", headLen);
+    return 0;
+  }
+
+  buf[0] = opcode & 0x0F;
+  if(final)
+    buf[0] |= 0x80;
+  if(len < 126)
+    buf[1] = len & 0x7F;
+  else {
+    buf[1] = 126;
+    buf[2] = (uint8_t)((len >> 8) & 0xFF);
+    buf[3] = (uint8_t)(len & 0xFF);
+  }
+  if(len && mask){
+    buf[1] |= 0x80;
+    memcpy(buf + (headLen - 4), mbuf, 4);
+  }
+  if(client->add((const char *)buf, headLen) != headLen){
+    //os_printf("error adding %lu header bytes\n", headLen);
+    free(buf);
+    return 0;
+  }
+  free(buf);
+
+  if(len){
+    if(len && mask){
+      size_t i;
+      for(i=0;iadd((const char *)data, len) != len){
+      //os_printf("error adding %lu data bytes\n", len);
+      return 0;
+    }
+  }
+  if(!client->send()){
+    //os_printf("error sending frame: %lu\n", headLen+len);
+    return 0;
+  }
+  return len;
+}
+
+
+/*
+ *    AsyncWebSocketMessageBuffer
+ */
+
+
+
+AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer()
+  :_data(nullptr)
+  ,_len(0)
+  ,_lock(false)
+  ,_count(0)
+{
+
+}
+
+AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer(uint8_t * data, size_t size) 
+  :_data(nullptr)
+  ,_len(size)
+  ,_lock(false)
+  ,_count(0)
+{
+
+  if (!data) {
+    return; 
+  }
+
+  _data = new uint8_t[_len + 1];
+
+  if (_data) {
+    memcpy(_data, data, _len);
+    _data[_len] = 0; 
+  }
+}
+
+
+AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer(size_t size)
+  :_data(nullptr)
+  ,_len(size)
+  ,_lock(false)
+  ,_count(0)
+{
+  _data = new uint8_t[_len + 1]; 
+
+  if (_data) {
+    _data[_len] = 0; 
+  }
+  
+}
+
+AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer & copy)
+  :_data(nullptr)
+  ,_len(0)
+  ,_lock(false)
+  ,_count(0)
+{
+  _len = copy._len;
+  _lock = copy._lock;
+  _count = 0;
+
+  if (_len) {
+    _data = new uint8_t[_len + 1]; 
+    _data[_len] = 0; 
+  } 
+
+  if (_data) {
+    memcpy(_data, copy._data, _len);
+    _data[_len] = 0; 
+  }
+
+}
+
+AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer(AsyncWebSocketMessageBuffer && copy)
+  :_data(nullptr)
+  ,_len(0)
+  ,_lock(false)
+  ,_count(0)
+{
+  _len = copy._len;
+  _lock = copy._lock;
+  _count = 0;
+
+  if (copy._data) {
+    _data = copy._data; 
+    copy._data = nullptr; 
+  } 
+
+}
+
+AsyncWebSocketMessageBuffer::~AsyncWebSocketMessageBuffer()
+{
+    if (_data) {
+      delete[] _data; 
+    }
+}
+
+bool AsyncWebSocketMessageBuffer::reserve(size_t size) 
+{
+  _len = size; 
+
+  if (_data) {
+    delete[] _data;
+    _data = nullptr; 
+  }
+
+  _data = new uint8_t[_len + 1];
+
+  if (_data) {
+    _data[_len] = 0;
+    return true; 
+  } else {
+    return false; 
+  }
+
+}
+
+
+
+/*
+ * Control Frame
+ */
+
+class AsyncWebSocketControl {
+  private:
+    uint8_t _opcode;
+    uint8_t *_data;
+    size_t _len;
+    bool _mask;
+    bool _finished;
+  public:
+    AsyncWebSocketControl(uint8_t opcode, uint8_t *data=NULL, size_t len=0, bool mask=false)
+      :_opcode(opcode)
+      ,_len(len)
+      ,_mask(len && mask)
+      ,_finished(false)
+  {
+      if(data == NULL)
+        _len = 0;
+      if(_len){
+        if(_len > 125)
+          _len = 125;
+        _data = (uint8_t*)malloc(_len);
+        if(_data == NULL)
+          _len = 0;
+        else memcpy(_data, data, len);
+      } else _data = NULL;
+    }
+    virtual ~AsyncWebSocketControl(){
+      if(_data != NULL)
+        free(_data);
+    }
+    virtual bool finished() const { return _finished; }
+    uint8_t opcode(){ return _opcode; }
+    uint8_t len(){ return _len + 2; }
+    size_t send(AsyncClient *client){
+      _finished = true;
+      return webSocketSendFrame(client, true, _opcode & 0x0F, _mask, _data, _len);
+    }
+};
+
+/*
+ * Basic Buffered Message
+ */
+
+
+AsyncWebSocketBasicMessage::AsyncWebSocketBasicMessage(const char * data, size_t len, uint8_t opcode, bool mask)
+  :_len(len)
+  ,_sent(0)
+  ,_ack(0)
+  ,_acked(0)
+{
+  _opcode = opcode & 0x07;
+  _mask = mask;
+  _data = (uint8_t*)malloc(_len+1);
+  if(_data == NULL){
+    _len = 0;
+    _status = WS_MSG_ERROR;
+  } else {
+    _status = WS_MSG_SENDING;
+    memcpy(_data, data, _len);
+    _data[_len] = 0;
+  }
+}
+AsyncWebSocketBasicMessage::AsyncWebSocketBasicMessage(uint8_t opcode, bool mask)
+  :_len(0)
+  ,_sent(0)
+  ,_ack(0)
+  ,_acked(0)
+  ,_data(NULL)
+{
+  _opcode = opcode & 0x07;
+  _mask = mask;
+  
+}
+
+
+AsyncWebSocketBasicMessage::~AsyncWebSocketBasicMessage() {
+  if(_data != NULL)
+    free(_data);
+}
+
+ void AsyncWebSocketBasicMessage::ack(size_t len, uint32_t time)  {
+   (void)time;
+  _acked += len;
+  if(_sent == _len && _acked == _ack){
+    _status = WS_MSG_SENT;
+  }
+}
+ size_t AsyncWebSocketBasicMessage::send(AsyncClient *client)  {
+  if(_status != WS_MSG_SENDING)
+    return 0;
+  if(_acked < _ack){
+    return 0;
+  }
+  if(_sent == _len){
+    if(_acked == _ack)
+      _status = WS_MSG_SENT;
+    return 0;
+  }
+  if(_sent > _len){
+      _status = WS_MSG_ERROR;
+      return 0;
+  }
+
+  size_t toSend = _len - _sent;
+  size_t window = webSocketSendFrameWindow(client);
+
+  if(window < toSend) {
+      toSend = window;
+  }
+
+  _sent += toSend;
+  _ack += toSend + ((toSend < 126)?2:4) + (_mask * 4);
+
+  bool final = (_sent == _len);
+  uint8_t* dPtr = (uint8_t*)(_data + (_sent - toSend));
+  uint8_t opCode = (toSend && _sent == toSend)?_opcode:(uint8_t)WS_CONTINUATION;
+
+  size_t sent = webSocketSendFrame(client, final, opCode, _mask, dPtr, toSend);
+  _status = WS_MSG_SENDING;
+  if(toSend && sent != toSend){
+      _sent -= (toSend - sent);
+      _ack -= (toSend - sent);
+  }
+  return sent;
+}
+
+// bool AsyncWebSocketBasicMessage::reserve(size_t size) { 
+//   if (size) {
+//     _data = (uint8_t*)malloc(size +1);
+//     if (_data) {
+//       memset(_data, 0, size); 
+//       _len = size; 
+//       _status = WS_MSG_SENDING;
+//       return true; 
+//     }
+//   }
+//   return false; 
+//  }
+
+
+/*
+ * AsyncWebSocketMultiMessage Message
+ */
+
+
+AsyncWebSocketMultiMessage::AsyncWebSocketMultiMessage(AsyncWebSocketMessageBuffer * buffer, uint8_t opcode, bool mask)
+  :_len(0)
+  ,_sent(0)
+  ,_ack(0)
+  ,_acked(0)
+  ,_WSbuffer(nullptr)
+{
+
+  _opcode = opcode & 0x07;
+  _mask = mask;
+
+  if (buffer) {
+    _WSbuffer = buffer; 
+    (*_WSbuffer)++; 
+    _data = buffer->get(); 
+    _len = buffer->length(); 
+    _status = WS_MSG_SENDING;
+    //ets_printf("M: %u\n", _len);
+  } else {
+    _status = WS_MSG_ERROR;
+  }
+  
+} 
+
+
+AsyncWebSocketMultiMessage::~AsyncWebSocketMultiMessage() {
+  if (_WSbuffer) {
+    (*_WSbuffer)--; // decreases the counter. 
+  }
+}
+
+ void AsyncWebSocketMultiMessage::ack(size_t len, uint32_t time)  {
+   (void)time;
+  _acked += len;
+  if(_sent >= _len && _acked >= _ack){
+    _status = WS_MSG_SENT;
+  }
+  //ets_printf("A: %u\n", len);
+}
+ size_t AsyncWebSocketMultiMessage::send(AsyncClient *client)  {
+  if(_status != WS_MSG_SENDING)
+    return 0;
+  if(_acked < _ack){
+    return 0;
+  }
+  if(_sent == _len){
+    _status = WS_MSG_SENT;
+    return 0;
+  }
+  if(_sent > _len){
+      _status = WS_MSG_ERROR;
+      //ets_printf("E: %u > %u\n", _sent, _len);
+      return 0;
+  }
+
+  size_t toSend = _len - _sent;
+  size_t window = webSocketSendFrameWindow(client);
+
+  if(window < toSend) {
+      toSend = window;
+  }
+
+  _sent += toSend;
+  _ack += toSend + ((toSend < 126)?2:4) + (_mask * 4);
+
+  //ets_printf("W: %u %u\n", _sent - toSend, toSend);
+
+  bool final = (_sent == _len);
+  uint8_t* dPtr = (uint8_t*)(_data + (_sent - toSend));
+  uint8_t opCode = (toSend && _sent == toSend)?_opcode:(uint8_t)WS_CONTINUATION;
+
+  size_t sent = webSocketSendFrame(client, final, opCode, _mask, dPtr, toSend);
+  _status = WS_MSG_SENDING;
+  if(toSend && sent != toSend){
+      //ets_printf("E: %u != %u\n", toSend, sent);
+      _sent -= (toSend - sent);
+      _ack -= (toSend - sent);
+  }
+  //ets_printf("S: %u %u\n", _sent, sent);
+  return sent;
+}
+
+
+/*
+ * Async WebSocket Client
+ */
+ const char * AWSC_PING_PAYLOAD = "ESPAsyncWebServer-PING";
+ const size_t AWSC_PING_PAYLOAD_LEN = 22;
+
+AsyncWebSocketClient::AsyncWebSocketClient(AsyncWebServerRequest *request, AsyncWebSocket *server)
+  : _controlQueue(LinkedList([](AsyncWebSocketControl *c){ delete  c; }))
+  , _messageQueue(LinkedList([](AsyncWebSocketMessage *m){ delete  m; }))
+  , _tempObject(NULL)
+{
+  _client = request->client();
+  _server = server;
+  _clientId = _server->_getNextId();
+  _status = WS_CONNECTED;
+  _pstate = 0;
+  _lastMessageTime = millis();
+  _keepAlivePeriod = 0;
+  _client->setRxTimeout(0);
+  _client->onError([](void *r, AsyncClient* c, int8_t error){ (void)c; ((AsyncWebSocketClient*)(r))->_onError(error); }, this);
+  _client->onAck([](void *r, AsyncClient* c, size_t len, uint32_t time){ (void)c; ((AsyncWebSocketClient*)(r))->_onAck(len, time); }, this);
+  _client->onDisconnect([](void *r, AsyncClient* c){ ((AsyncWebSocketClient*)(r))->_onDisconnect(); delete c; }, this);
+  _client->onTimeout([](void *r, AsyncClient* c, uint32_t time){ (void)c; ((AsyncWebSocketClient*)(r))->_onTimeout(time); }, this);
+  _client->onData([](void *r, AsyncClient* c, void *buf, size_t len){ (void)c; ((AsyncWebSocketClient*)(r))->_onData(buf, len); }, this);
+  _client->onPoll([](void *r, AsyncClient* c){ (void)c; ((AsyncWebSocketClient*)(r))->_onPoll(); }, this);
+  _server->_addClient(this);
+  _server->_handleEvent(this, WS_EVT_CONNECT, request, NULL, 0);
+  delete request;
+}
+
+AsyncWebSocketClient::~AsyncWebSocketClient(){
+  _messageQueue.free();
+  _controlQueue.free();
+  _server->_handleEvent(this, WS_EVT_DISCONNECT, NULL, NULL, 0);
+}
+
+void AsyncWebSocketClient::_onAck(size_t len, uint32_t time){
+  _lastMessageTime = millis();
+  if(!_controlQueue.isEmpty()){
+    auto head = _controlQueue.front();
+    if(head->finished()){
+      len -= head->len();
+      if(_status == WS_DISCONNECTING && head->opcode() == WS_DISCONNECT){
+        _controlQueue.remove(head);
+        _status = WS_DISCONNECTED;
+        _client->close(true);
+        return;
+      }
+      _controlQueue.remove(head);
+    }
+  }
+  if(len && !_messageQueue.isEmpty()){
+    _messageQueue.front()->ack(len, time);
+  }
+  _server->_cleanBuffers(); 
+  _runQueue();
+}
+
+void AsyncWebSocketClient::_onPoll(){
+  if(_client->canSend() && (!_controlQueue.isEmpty() || !_messageQueue.isEmpty())){
+    _runQueue();
+  } else if(_keepAlivePeriod > 0 && _controlQueue.isEmpty() && _messageQueue.isEmpty() && (millis() - _lastMessageTime) >= _keepAlivePeriod){
+    ping((uint8_t *)AWSC_PING_PAYLOAD, AWSC_PING_PAYLOAD_LEN);
+  }
+}
+
+void AsyncWebSocketClient::_runQueue(){
+  while(!_messageQueue.isEmpty() && _messageQueue.front()->finished()){
+    _messageQueue.remove(_messageQueue.front());
+  }
+
+  if(!_controlQueue.isEmpty() && (_messageQueue.isEmpty() || _messageQueue.front()->betweenFrames()) && webSocketSendFrameWindow(_client) > (size_t)(_controlQueue.front()->len() - 1)){
+    _controlQueue.front()->send(_client);
+  } else if(!_messageQueue.isEmpty() && _messageQueue.front()->betweenFrames() && webSocketSendFrameWindow(_client)){
+    _messageQueue.front()->send(_client);
+  }
+}
+
+bool AsyncWebSocketClient::queueIsFull(){
+  if((_messageQueue.length() >= WS_MAX_QUEUED_MESSAGES) || (_status != WS_CONNECTED) ) return true;
+  return false;
+}
+
+void AsyncWebSocketClient::_queueMessage(AsyncWebSocketMessage *dataMessage){
+  if(dataMessage == NULL)
+    return;
+  if(_status != WS_CONNECTED){
+    delete dataMessage;
+    return;
+  }
+  if(_messageQueue.length() >= WS_MAX_QUEUED_MESSAGES){
+      ets_printf("ERROR: Too many messages queued\n");
+      delete dataMessage;
+  } else {
+      _messageQueue.add(dataMessage);
+  }
+  if(_client->canSend())
+    _runQueue();
+}
+
+void AsyncWebSocketClient::_queueControl(AsyncWebSocketControl *controlMessage){
+  if(controlMessage == NULL)
+    return;
+  _controlQueue.add(controlMessage);
+  if(_client->canSend())
+    _runQueue();
+}
+
+void AsyncWebSocketClient::close(uint16_t code, const char * message){
+  if(_status != WS_CONNECTED)
+    return;
+  if(code){
+    uint8_t packetLen = 2;
+    if(message != NULL){
+      size_t mlen = strlen(message);
+      if(mlen > 123) mlen = 123;
+      packetLen += mlen;
+    }
+    char * buf = (char*)malloc(packetLen);
+    if(buf != NULL){
+      buf[0] = (uint8_t)(code >> 8);
+      buf[1] = (uint8_t)(code & 0xFF);
+      if(message != NULL){
+        memcpy(buf+2, message, packetLen -2);
+      }
+      _queueControl(new AsyncWebSocketControl(WS_DISCONNECT,(uint8_t*)buf,packetLen));
+      free(buf);
+      return;
+    }
+  }
+  _queueControl(new AsyncWebSocketControl(WS_DISCONNECT));
+}
+
+void AsyncWebSocketClient::ping(uint8_t *data, size_t len){
+  if(_status == WS_CONNECTED)
+    _queueControl(new AsyncWebSocketControl(WS_PING, data, len));
+}
+
+void AsyncWebSocketClient::_onError(int8_t){}
+
+void AsyncWebSocketClient::_onTimeout(uint32_t time){
+  (void)time;
+  _client->close(true);
+}
+
+void AsyncWebSocketClient::_onDisconnect(){
+  _client = NULL;
+  _server->_handleDisconnect(this);
+}
+
+void AsyncWebSocketClient::_onData(void *pbuf, size_t plen){
+  _lastMessageTime = millis();
+  uint8_t *data = (uint8_t*)pbuf;
+  while(plen > 0){
+    if(!_pstate){
+      const uint8_t *fdata = data;
+      _pinfo.index = 0;
+      _pinfo.final = (fdata[0] & 0x80) != 0;
+      _pinfo.opcode = fdata[0] & 0x0F;
+      _pinfo.masked = (fdata[1] & 0x80) != 0;
+      _pinfo.len = fdata[1] & 0x7F;
+      data += 2;
+      plen -= 2;
+      if(_pinfo.len == 126){
+        _pinfo.len = fdata[3] | (uint16_t)(fdata[2]) << 8;
+        data += 2;
+        plen -= 2;
+      } else if(_pinfo.len == 127){
+        _pinfo.len = fdata[9] | (uint16_t)(fdata[8]) << 8 | (uint32_t)(fdata[7]) << 16 | (uint32_t)(fdata[6]) << 24 | (uint64_t)(fdata[5]) << 32 | (uint64_t)(fdata[4]) << 40 | (uint64_t)(fdata[3]) << 48 | (uint64_t)(fdata[2]) << 56;
+        data += 8;
+        plen -= 8;
+      }
+
+      if(_pinfo.masked){
+        memcpy(_pinfo.mask, data, 4);
+        data += 4;
+        plen -= 4;
+      }
+    }
+
+    const size_t datalen = std::min((size_t)(_pinfo.len - _pinfo.index), plen);
+    const auto datalast = data[datalen];
+
+    if(_pinfo.masked){
+      for(size_t i=0;i_handleEvent(this, WS_EVT_DATA, (void *)&_pinfo, (uint8_t*)data, datalen);
+
+      _pinfo.index += datalen;
+    } else if((datalen + _pinfo.index) == _pinfo.len){
+      _pstate = 0;
+      if(_pinfo.opcode == WS_DISCONNECT){
+        if(datalen){
+          uint16_t reasonCode = (uint16_t)(data[0] << 8) + data[1];
+          char * reasonString = (char*)(data+2);
+          if(reasonCode > 1001){
+            _server->_handleEvent(this, WS_EVT_ERROR, (void *)&reasonCode, (uint8_t*)reasonString, strlen(reasonString));
+          }
+        }
+        if(_status == WS_DISCONNECTING){
+          _status = WS_DISCONNECTED;
+          _client->close(true);
+        } else {
+          _status = WS_DISCONNECTING;
+          _client->ackLater();
+          _queueControl(new AsyncWebSocketControl(WS_DISCONNECT, data, datalen));
+        }
+      } else if(_pinfo.opcode == WS_PING){
+        _queueControl(new AsyncWebSocketControl(WS_PONG, data, datalen));
+      } else if(_pinfo.opcode == WS_PONG){
+        if(datalen != AWSC_PING_PAYLOAD_LEN || memcmp(AWSC_PING_PAYLOAD, data, AWSC_PING_PAYLOAD_LEN) != 0)
+          _server->_handleEvent(this, WS_EVT_PONG, NULL, data, datalen);
+      } else if(_pinfo.opcode < 8){//continuation or text/binary frame
+        _server->_handleEvent(this, WS_EVT_DATA, (void *)&_pinfo, data, datalen);
+      }
+    } else {
+      //os_printf("frame error: len: %u, index: %llu, total: %llu\n", datalen, _pinfo.index, _pinfo.len);
+      //what should we do?
+      break;
+    }
+
+    // restore byte as _handleEvent may have added a null terminator i.e., data[len] = 0;
+    if (datalen > 0)
+      data[datalen] = datalast;
+
+    data += datalen;
+    plen -= datalen;
+  }
+}
+
+size_t AsyncWebSocketClient::printf(const char *format, ...) {
+  va_list arg;
+  va_start(arg, format);
+  char* temp = new char[MAX_PRINTF_LEN];
+  if(!temp){
+    va_end(arg);
+    return 0;
+  }
+  char* buffer = temp;
+  size_t len = vsnprintf(temp, MAX_PRINTF_LEN, format, arg);
+  va_end(arg);
+
+  if (len > (MAX_PRINTF_LEN - 1)) {
+    buffer = new char[len + 1];
+    if (!buffer) {
+   	  delete[] temp;
+      return 0;
+    }
+    va_start(arg, format);
+    vsnprintf(buffer, len + 1, format, arg);
+    va_end(arg);
+  }
+  text(buffer, len);
+  if (buffer != temp) {
+    delete[] buffer;
+  }
+  delete[] temp;
+  return len;
+}
+
+#ifndef ESP32
+size_t AsyncWebSocketClient::printf_P(PGM_P formatP, ...) {
+  va_list arg;
+  va_start(arg, formatP);
+  char* temp = new char[MAX_PRINTF_LEN];
+  if(!temp){
+    va_end(arg);
+    return 0;
+  }
+  char* buffer = temp;
+  size_t len = vsnprintf_P(temp, MAX_PRINTF_LEN, formatP, arg);
+  va_end(arg);
+
+  if (len > (MAX_PRINTF_LEN - 1)) {
+    buffer = new char[len + 1];
+    if (!buffer) {
+   	  delete[] temp;
+      return 0;
+    }
+    va_start(arg, formatP);
+    vsnprintf_P(buffer, len + 1, formatP, arg);
+    va_end(arg);
+  }
+  text(buffer, len);
+  if (buffer != temp) {
+    delete[] buffer;
+  }
+  delete[] temp;
+  return len;
+}
+#endif
+
+void AsyncWebSocketClient::text(const char * message, size_t len){
+  _queueMessage(new AsyncWebSocketBasicMessage(message, len));
+}
+void AsyncWebSocketClient::text(const char * message){
+  text(message, strlen(message));
+}
+void AsyncWebSocketClient::text(uint8_t * message, size_t len){
+  text((const char *)message, len);
+}
+void AsyncWebSocketClient::text(char * message){
+  text(message, strlen(message));
+}
+void AsyncWebSocketClient::text(const String &message){
+  text(message.c_str(), message.length());
+}
+void AsyncWebSocketClient::text(const __FlashStringHelper *data){
+  PGM_P p = reinterpret_cast(data);
+  size_t n = 0;
+  while (1) {
+    if (pgm_read_byte(p+n) == 0) break;
+      n += 1;
+  }
+  char * message = (char*) malloc(n+1);
+  if(message){
+    for(size_t b=0; b(data);
+  char * message = (char*) malloc(len);
+  if(message){
+    for(size_t b=0; bremoteIP();
+}
+
+uint16_t AsyncWebSocketClient::remotePort() {
+    if(!_client) {
+        return 0;
+    }
+    return _client->remotePort();
+}
+
+
+
+/*
+ * Async Web Socket - Each separate socket location
+ */
+
+AsyncWebSocket::AsyncWebSocket(const String& url)
+  :_url(url)
+  ,_clients(LinkedList([](AsyncWebSocketClient *c){ delete c; }))
+  ,_cNextId(1)
+  ,_enabled(true)
+  ,_buffers(LinkedList([](AsyncWebSocketMessageBuffer *b){ delete b; }))
+{
+  _eventHandler = NULL;
+}
+
+AsyncWebSocket::~AsyncWebSocket(){}
+
+void AsyncWebSocket::_handleEvent(AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){
+  if(_eventHandler != NULL){
+    _eventHandler(this, client, type, arg, data, len);
+  }
+}
+
+void AsyncWebSocket::_addClient(AsyncWebSocketClient * client){
+  _clients.add(client);
+}
+
+void AsyncWebSocket::_handleDisconnect(AsyncWebSocketClient * client){
+  
+  _clients.remove_first([=](AsyncWebSocketClient * c){
+    return c->id() == client->id();
+  });
+}
+
+bool AsyncWebSocket::availableForWriteAll(){
+  for(const auto& c: _clients){
+    if(c->queueIsFull()) return false;
+  }
+  return true;
+}
+
+bool AsyncWebSocket::availableForWrite(uint32_t id){
+  for(const auto& c: _clients){
+    if(c->queueIsFull() && (c->id() == id )) return false;
+  }
+  return true;
+}
+
+size_t AsyncWebSocket::count() const {
+  return _clients.count_if([](AsyncWebSocketClient * c){
+    return c->status() == WS_CONNECTED;
+  });
+}
+
+AsyncWebSocketClient * AsyncWebSocket::client(uint32_t id){
+  for(const auto &c: _clients){
+    if(c->id() == id && c->status() == WS_CONNECTED){
+      return c;
+    }
+  }
+  return nullptr;
+}
+
+
+void AsyncWebSocket::close(uint32_t id, uint16_t code, const char * message){
+  AsyncWebSocketClient * c = client(id);
+  if(c)
+    c->close(code, message);
+}
+
+void AsyncWebSocket::closeAll(uint16_t code, const char * message){
+  for(const auto& c: _clients){
+    if(c->status() == WS_CONNECTED)
+      c->close(code, message);
+  }
+}
+
+void AsyncWebSocket::cleanupClients(uint16_t maxClients)
+{
+  if (count() > maxClients){
+    _clients.front()->close();
+  }
+}
+
+void AsyncWebSocket::ping(uint32_t id, uint8_t *data, size_t len){
+  AsyncWebSocketClient * c = client(id);
+  if(c)
+    c->ping(data, len);
+}
+
+void AsyncWebSocket::pingAll(uint8_t *data, size_t len){
+  for(const auto& c: _clients){
+    if(c->status() == WS_CONNECTED)
+      c->ping(data, len);
+  }
+}
+
+void AsyncWebSocket::text(uint32_t id, const char * message, size_t len){
+  AsyncWebSocketClient * c = client(id);
+  if(c)
+    c->text(message, len);
+}
+
+void AsyncWebSocket::textAll(AsyncWebSocketMessageBuffer * buffer){
+  if (!buffer) return;
+  buffer->lock(); 
+  for(const auto& c: _clients){
+    if(c->status() == WS_CONNECTED){
+        c->text(buffer);
+    }
+  }
+  buffer->unlock();
+  _cleanBuffers(); 
+}
+
+
+void AsyncWebSocket::textAll(const char * message, size_t len){
+  AsyncWebSocketMessageBuffer * WSBuffer = makeBuffer((uint8_t *)message, len); 
+    textAll(WSBuffer); 
+}
+
+void AsyncWebSocket::binary(uint32_t id, const char * message, size_t len){
+  AsyncWebSocketClient * c = client(id);
+  if(c)
+    c->binary(message, len);
+}
+
+void AsyncWebSocket::binaryAll(const char * message, size_t len){
+  AsyncWebSocketMessageBuffer * buffer = makeBuffer((uint8_t *)message, len); 
+  binaryAll(buffer); 
+}
+
+void AsyncWebSocket::binaryAll(AsyncWebSocketMessageBuffer * buffer)
+{
+  if (!buffer) return;
+  buffer->lock(); 
+    for(const auto& c: _clients){
+    if(c->status() == WS_CONNECTED)
+      c->binary(buffer);
+  }
+  buffer->unlock(); 
+  _cleanBuffers(); 
+}
+
+void AsyncWebSocket::message(uint32_t id, AsyncWebSocketMessage *message){
+  AsyncWebSocketClient * c = client(id);
+  if(c)
+    c->message(message);
+}
+
+void AsyncWebSocket::messageAll(AsyncWebSocketMultiMessage *message){
+  for(const auto& c: _clients){
+    if(c->status() == WS_CONNECTED)
+      c->message(message);
+  }
+  _cleanBuffers(); 
+}
+
+size_t AsyncWebSocket::printf(uint32_t id, const char *format, ...){
+  AsyncWebSocketClient * c = client(id);
+  if(c){
+    va_list arg;
+    va_start(arg, format);
+    size_t len = c->printf(format, arg);
+    va_end(arg);
+    return len;
+  }
+  return 0;
+}
+
+size_t AsyncWebSocket::printfAll(const char *format, ...) {
+  va_list arg;
+  char* temp = new char[MAX_PRINTF_LEN];
+  if(!temp){
+    return 0;
+  }
+  va_start(arg, format);
+  size_t len = vsnprintf(temp, MAX_PRINTF_LEN, format, arg);
+  va_end(arg);
+  delete[] temp;
+  
+  AsyncWebSocketMessageBuffer * buffer = makeBuffer(len); 
+  if (!buffer) {
+    return 0;
+  }
+
+  va_start(arg, format);
+  vsnprintf( (char *)buffer->get(), len + 1, format, arg);
+  va_end(arg);
+
+  textAll(buffer);
+  return len;
+}
+
+#ifndef ESP32
+size_t AsyncWebSocket::printf_P(uint32_t id, PGM_P formatP, ...){
+  AsyncWebSocketClient * c = client(id);
+  if(c != NULL){
+    va_list arg;
+    va_start(arg, formatP);
+    size_t len = c->printf_P(formatP, arg);
+    va_end(arg);
+    return len;
+  }
+  return 0;
+}
+#endif
+
+size_t AsyncWebSocket::printfAll_P(PGM_P formatP, ...) {
+  va_list arg;
+  char* temp = new char[MAX_PRINTF_LEN];
+  if(!temp){
+    return 0;
+  }
+  va_start(arg, formatP);
+  size_t len = vsnprintf_P(temp, MAX_PRINTF_LEN, formatP, arg);
+  va_end(arg);
+  delete[] temp;
+  
+  AsyncWebSocketMessageBuffer * buffer = makeBuffer(len + 1); 
+  if (!buffer) {
+    return 0;
+  }
+
+  va_start(arg, formatP);
+  vsnprintf_P((char *)buffer->get(), len + 1, formatP, arg);
+  va_end(arg);
+
+  textAll(buffer);
+  return len;
+}
+
+void AsyncWebSocket::text(uint32_t id, const char * message){
+  text(id, message, strlen(message));
+}
+void AsyncWebSocket::text(uint32_t id, uint8_t * message, size_t len){
+  text(id, (const char *)message, len);
+}
+void AsyncWebSocket::text(uint32_t id, char * message){
+  text(id, message, strlen(message));
+}
+void AsyncWebSocket::text(uint32_t id, const String &message){
+  text(id, message.c_str(), message.length());
+}
+void AsyncWebSocket::text(uint32_t id, const __FlashStringHelper *message){
+  AsyncWebSocketClient * c = client(id);
+  if(c != NULL)
+    c->text(message);
+}
+void AsyncWebSocket::textAll(const char * message){
+  textAll(message, strlen(message));
+}
+void AsyncWebSocket::textAll(uint8_t * message, size_t len){
+  textAll((const char *)message, len);
+}
+void AsyncWebSocket::textAll(char * message){
+  textAll(message, strlen(message));
+}
+void AsyncWebSocket::textAll(const String &message){
+  textAll(message.c_str(), message.length());
+}
+void AsyncWebSocket::textAll(const __FlashStringHelper *message){
+  for(const auto& c: _clients){
+    if(c->status() == WS_CONNECTED)
+      c->text(message);
+  }
+}
+void AsyncWebSocket::binary(uint32_t id, const char * message){
+  binary(id, message, strlen(message));
+}
+void AsyncWebSocket::binary(uint32_t id, uint8_t * message, size_t len){
+  binary(id, (const char *)message, len);
+}
+void AsyncWebSocket::binary(uint32_t id, char * message){
+  binary(id, message, strlen(message));
+}
+void AsyncWebSocket::binary(uint32_t id, const String &message){
+  binary(id, message.c_str(), message.length());
+}
+void AsyncWebSocket::binary(uint32_t id, const __FlashStringHelper *message, size_t len){
+  AsyncWebSocketClient * c = client(id);
+  if(c != NULL)
+    c-> binary(message, len);
+}
+void AsyncWebSocket::binaryAll(const char * message){
+  binaryAll(message, strlen(message));
+}
+void AsyncWebSocket::binaryAll(uint8_t * message, size_t len){
+  binaryAll((const char *)message, len);
+}
+void AsyncWebSocket::binaryAll(char * message){
+  binaryAll(message, strlen(message));
+}
+void AsyncWebSocket::binaryAll(const String &message){
+  binaryAll(message.c_str(), message.length());
+}
+void AsyncWebSocket::binaryAll(const __FlashStringHelper *message, size_t len){
+  for(const auto& c: _clients){
+    if(c->status() == WS_CONNECTED)
+      c-> binary(message, len);
+  }
+ }
+
+const char * WS_STR_CONNECTION = "Connection";
+const char * WS_STR_UPGRADE = "Upgrade";
+const char * WS_STR_ORIGIN = "Origin";
+const char * WS_STR_VERSION = "Sec-WebSocket-Version";
+const char * WS_STR_KEY = "Sec-WebSocket-Key";
+const char * WS_STR_PROTOCOL = "Sec-WebSocket-Protocol";
+const char * WS_STR_ACCEPT = "Sec-WebSocket-Accept";
+const char * WS_STR_UUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+bool AsyncWebSocket::canHandle(AsyncWebServerRequest *request){
+  if(!_enabled)
+    return false;
+  
+  if(request->method() != HTTP_GET || !request->url().equals(_url) || !request->isExpectedRequestedConnType(RCT_WS))
+    return false;
+
+  request->addInterestingHeader(WS_STR_CONNECTION);
+  request->addInterestingHeader(WS_STR_UPGRADE);
+  request->addInterestingHeader(WS_STR_ORIGIN);
+  request->addInterestingHeader(WS_STR_VERSION);
+  request->addInterestingHeader(WS_STR_KEY);
+  request->addInterestingHeader(WS_STR_PROTOCOL);
+  return true;
+}
+
+void AsyncWebSocket::handleRequest(AsyncWebServerRequest *request){
+  if(!request->hasHeader(WS_STR_VERSION) || !request->hasHeader(WS_STR_KEY)){
+    request->send(400);
+    return;
+  }
+  if((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str())){
+    return request->requestAuthentication();
+  }
+  AsyncWebHeader* version = request->getHeader(WS_STR_VERSION);
+  if(version->value().toInt() != 13){
+    AsyncWebServerResponse *response = request->beginResponse(400);
+    response->addHeader(WS_STR_VERSION,"13");
+    request->send(response);
+    return;
+  }
+  AsyncWebHeader* key = request->getHeader(WS_STR_KEY);
+  AsyncWebServerResponse *response = new AsyncWebSocketResponse(key->value(), this);
+  if(request->hasHeader(WS_STR_PROTOCOL)){
+    AsyncWebHeader* protocol = request->getHeader(WS_STR_PROTOCOL);
+    //ToDo: check protocol
+    response->addHeader(WS_STR_PROTOCOL, protocol->value());
+  }
+  request->send(response);
+}
+
+AsyncWebSocketMessageBuffer * AsyncWebSocket::makeBuffer(size_t size)
+{
+  AsyncWebSocketMessageBuffer * buffer = new AsyncWebSocketMessageBuffer(size); 
+  if (buffer) {
+    AsyncWebLockGuard l(_lock);
+    _buffers.add(buffer);
+  }
+  return buffer; 
+}
+
+AsyncWebSocketMessageBuffer * AsyncWebSocket::makeBuffer(uint8_t * data, size_t size)
+{
+  AsyncWebSocketMessageBuffer * buffer = new AsyncWebSocketMessageBuffer(data, size); 
+  
+  if (buffer) {
+    AsyncWebLockGuard l(_lock);
+    _buffers.add(buffer);
+  }
+
+  return buffer; 
+}
+
+void AsyncWebSocket::_cleanBuffers()
+{
+  AsyncWebLockGuard l(_lock);
+
+  for(AsyncWebSocketMessageBuffer * c: _buffers){
+    if(c && c->canDelete()){
+        _buffers.remove(c);
+    }
+  }
+}
+
+AsyncWebSocket::AsyncWebSocketClientLinkedList AsyncWebSocket::getClients() const {
+  return _clients;
+}
+
+/*
+ * Response to Web Socket request - sends the authorization and detaches the TCP Client from the web server
+ * Authentication code from https://github.com/Links2004/arduinoWebSockets/blob/master/src/WebSockets.cpp#L480
+ */
+
+AsyncWebSocketResponse::AsyncWebSocketResponse(const String& key, AsyncWebSocket *server){
+  _server = server;
+  _code = 101;
+  _sendContentLength = false;
+
+  uint8_t * hash = (uint8_t*)malloc(20);
+  if(hash == NULL){
+    _state = RESPONSE_FAILED;
+    return;
+  }
+  char * buffer = (char *) malloc(33);
+  if(buffer == NULL){
+    free(hash);
+    _state = RESPONSE_FAILED;
+    return;
+  }
+#ifdef ESP8266
+  sha1(key + WS_STR_UUID, hash);
+#else
+  (String&)key += WS_STR_UUID;
+  SHA1_CTX ctx;
+  SHA1Init(&ctx);
+  SHA1Update(&ctx, (const unsigned char*)key.c_str(), key.length());
+  SHA1Final(hash, &ctx);
+#endif
+  base64_encodestate _state;
+  base64_init_encodestate(&_state);
+  int len = base64_encode_block((const char *) hash, 20, buffer, &_state);
+  len = base64_encode_blockend((buffer + len), &_state);
+  addHeader(WS_STR_CONNECTION, WS_STR_UPGRADE);
+  addHeader(WS_STR_UPGRADE, "websocket");
+  addHeader(WS_STR_ACCEPT,buffer);
+  free(buffer);
+  free(hash);
+}
+
+void AsyncWebSocketResponse::_respond(AsyncWebServerRequest *request){
+  if(_state == RESPONSE_FAILED){
+    request->client()->close(true);
+    return;
+  }
+  String out = _assembleHead(request->version());
+  request->client()->write(out.c_str(), _headLength);
+  _state = RESPONSE_WAIT_ACK;
+}
+
+size_t AsyncWebSocketResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){
+  (void)time;
+  if(len){
+    new AsyncWebSocketClient(request, _server);
+  }
+  return 0;
+}
diff --git a/lib/ESPAsyncWebServer/src/AsyncWebSocket.h b/lib/ESPAsyncWebServer/src/AsyncWebSocket.h
new file mode 100644
index 00000000..5b03aceb
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/AsyncWebSocket.h
@@ -0,0 +1,350 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef ASYNCWEBSOCKET_H_
+#define ASYNCWEBSOCKET_H_
+
+#include 
+#ifdef ESP32
+#include 
+#define WS_MAX_QUEUED_MESSAGES 32
+#else
+#include 
+#define WS_MAX_QUEUED_MESSAGES 8
+#endif
+#include 
+
+#include "AsyncWebSynchronization.h"
+
+#ifdef ESP8266
+#include 
+#ifdef CRYPTO_HASH_h // include Hash.h from espressif framework if the first include was from the crypto library
+#include <../src/Hash.h>
+#endif
+#endif
+
+#ifdef ESP32
+#define DEFAULT_MAX_WS_CLIENTS 8
+#else
+#define DEFAULT_MAX_WS_CLIENTS 4
+#endif
+
+class AsyncWebSocket;
+class AsyncWebSocketResponse;
+class AsyncWebSocketClient;
+class AsyncWebSocketControl;
+
+typedef struct {
+    /** Message type as defined by enum AwsFrameType.
+     * Note: Applications will only see WS_TEXT and WS_BINARY.
+     * All other types are handled by the library. */
+    uint8_t message_opcode;
+    /** Frame number of a fragmented message. */
+    uint32_t num;
+    /** Is this the last frame in a fragmented message ?*/
+    uint8_t final;
+    /** Is this frame masked? */
+    uint8_t masked;
+    /** Message type as defined by enum AwsFrameType.
+     * This value is the same as message_opcode for non-fragmented
+     * messages, but may also be WS_CONTINUATION in a fragmented message. */
+    uint8_t opcode;
+    /** Length of the current frame.
+     * This equals the total length of the message if num == 0 && final == true */
+    uint64_t len;
+    /** Mask key */
+    uint8_t mask[4];
+    /** Offset of the data inside the current frame. */
+    uint64_t index;
+} AwsFrameInfo;
+
+typedef enum { WS_DISCONNECTED, WS_CONNECTED, WS_DISCONNECTING } AwsClientStatus;
+typedef enum { WS_CONTINUATION, WS_TEXT, WS_BINARY, WS_DISCONNECT = 0x08, WS_PING, WS_PONG } AwsFrameType;
+typedef enum { WS_MSG_SENDING, WS_MSG_SENT, WS_MSG_ERROR } AwsMessageStatus;
+typedef enum { WS_EVT_CONNECT, WS_EVT_DISCONNECT, WS_EVT_PONG, WS_EVT_ERROR, WS_EVT_DATA } AwsEventType;
+
+class AsyncWebSocketMessageBuffer {
+  private:
+    uint8_t * _data;
+    size_t _len;
+    bool _lock; 
+    uint32_t _count;  
+
+  public:
+    AsyncWebSocketMessageBuffer();
+    AsyncWebSocketMessageBuffer(size_t size);
+    AsyncWebSocketMessageBuffer(uint8_t * data, size_t size); 
+    AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer &); 
+    AsyncWebSocketMessageBuffer(AsyncWebSocketMessageBuffer &&); 
+    ~AsyncWebSocketMessageBuffer(); 
+    void operator ++(int i) { (void)i; _count++; }
+    void operator --(int i) { (void)i; if (_count > 0) { _count--; } ;  }
+    bool reserve(size_t size);
+    void lock() { _lock = true; }
+    void unlock() { _lock = false; }
+    uint8_t * get() { return _data; }
+    size_t length() { return _len; }
+    uint32_t count() { return _count; }
+    bool canDelete() { return (!_count && !_lock); } 
+
+    friend AsyncWebSocket; 
+
+};
+
+class AsyncWebSocketMessage {
+  protected:
+    uint8_t _opcode;
+    bool _mask;
+    AwsMessageStatus _status;
+  public:
+    AsyncWebSocketMessage():_opcode(WS_TEXT),_mask(false),_status(WS_MSG_ERROR){}
+    virtual ~AsyncWebSocketMessage(){}
+    virtual void ack(size_t len __attribute__((unused)), uint32_t time __attribute__((unused))){}
+    virtual size_t send(AsyncClient *client __attribute__((unused))){ return 0; }
+    virtual bool finished(){ return _status != WS_MSG_SENDING; }
+    virtual bool betweenFrames() const { return false; }
+};
+
+class AsyncWebSocketBasicMessage: public AsyncWebSocketMessage {
+  private:
+    size_t _len;
+    size_t _sent;
+    size_t _ack;
+    size_t _acked;
+    uint8_t * _data;
+public:
+    AsyncWebSocketBasicMessage(const char * data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false);
+    AsyncWebSocketBasicMessage(uint8_t opcode=WS_TEXT, bool mask=false);
+    virtual ~AsyncWebSocketBasicMessage() override;
+    virtual bool betweenFrames() const override { return _acked == _ack; }
+    virtual void ack(size_t len, uint32_t time) override ;
+    virtual size_t send(AsyncClient *client) override ;
+};
+
+class AsyncWebSocketMultiMessage: public AsyncWebSocketMessage {
+  private:
+    uint8_t * _data;
+    size_t _len;
+    size_t _sent;
+    size_t _ack;
+    size_t _acked;
+    AsyncWebSocketMessageBuffer * _WSbuffer; 
+public:
+    AsyncWebSocketMultiMessage(AsyncWebSocketMessageBuffer * buffer, uint8_t opcode=WS_TEXT, bool mask=false); 
+    virtual ~AsyncWebSocketMultiMessage() override;
+    virtual bool betweenFrames() const override { return _acked == _ack; }
+    virtual void ack(size_t len, uint32_t time) override ;
+    virtual size_t send(AsyncClient *client) override ;
+};
+
+class AsyncWebSocketClient {
+  private:
+    AsyncClient *_client;
+    AsyncWebSocket *_server;
+    uint32_t _clientId;
+    AwsClientStatus _status;
+
+    LinkedList _controlQueue;
+    LinkedList _messageQueue;
+
+    uint8_t _pstate;
+    AwsFrameInfo _pinfo;
+
+    uint32_t _lastMessageTime;
+    uint32_t _keepAlivePeriod;
+
+    void _queueMessage(AsyncWebSocketMessage *dataMessage);
+    void _queueControl(AsyncWebSocketControl *controlMessage);
+    void _runQueue();
+
+  public:
+    void *_tempObject;
+
+    AsyncWebSocketClient(AsyncWebServerRequest *request, AsyncWebSocket *server);
+    ~AsyncWebSocketClient();
+
+    //client id increments for the given server
+    uint32_t id(){ return _clientId; }
+    AwsClientStatus status(){ return _status; }
+    AsyncClient* client(){ return _client; }
+    AsyncWebSocket *server(){ return _server; }
+    AwsFrameInfo const &pinfo() const { return _pinfo; }
+
+    IPAddress remoteIP();
+    uint16_t  remotePort();
+
+    //control frames
+    void close(uint16_t code=0, const char * message=NULL);
+    void ping(uint8_t *data=NULL, size_t len=0);
+
+    //set auto-ping period in seconds. disabled if zero (default)
+    void keepAlivePeriod(uint16_t seconds){
+      _keepAlivePeriod = seconds * 1000;
+    }
+    uint16_t keepAlivePeriod(){
+      return (uint16_t)(_keepAlivePeriod / 1000);
+    }
+
+    //data packets
+    void message(AsyncWebSocketMessage *message){ _queueMessage(message); }
+    bool queueIsFull();
+
+    size_t printf(const char *format, ...)  __attribute__ ((format (printf, 2, 3)));
+#ifndef ESP32
+    size_t printf_P(PGM_P formatP, ...)  __attribute__ ((format (printf, 2, 3)));
+#endif
+    void text(const char * message, size_t len);
+    void text(const char * message);
+    void text(uint8_t * message, size_t len);
+    void text(char * message);
+    void text(const String &message);
+    void text(const __FlashStringHelper *data);
+    void text(AsyncWebSocketMessageBuffer *buffer); 
+
+    void binary(const char * message, size_t len);
+    void binary(const char * message);
+    void binary(uint8_t * message, size_t len);
+    void binary(char * message);
+    void binary(const String &message);
+    void binary(const __FlashStringHelper *data, size_t len);
+    void binary(AsyncWebSocketMessageBuffer *buffer); 
+
+    bool canSend() { return _messageQueue.length() < WS_MAX_QUEUED_MESSAGES; }
+
+    //system callbacks (do not call)
+    void _onAck(size_t len, uint32_t time);
+    void _onError(int8_t);
+    void _onPoll();
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+    void _onData(void *pbuf, size_t plen);
+};
+
+typedef std::function AwsEventHandler;
+
+//WebServer Handler implementation that plays the role of a socket server
+class AsyncWebSocket: public AsyncWebHandler {
+  public:
+    typedef LinkedList AsyncWebSocketClientLinkedList;
+  private:
+    String _url;
+    AsyncWebSocketClientLinkedList _clients;
+    uint32_t _cNextId;
+    AwsEventHandler _eventHandler;
+    bool _enabled;
+    AsyncWebLock _lock;
+
+  public:
+    AsyncWebSocket(const String& url);
+    ~AsyncWebSocket();
+    const char * url() const { return _url.c_str(); }
+    void enable(bool e){ _enabled = e; }
+    bool enabled() const { return _enabled; }
+    bool availableForWriteAll();
+    bool availableForWrite(uint32_t id);
+
+    size_t count() const;
+    AsyncWebSocketClient * client(uint32_t id);
+    bool hasClient(uint32_t id){ return client(id) != NULL; }
+
+    void close(uint32_t id, uint16_t code=0, const char * message=NULL);
+    void closeAll(uint16_t code=0, const char * message=NULL);
+    void cleanupClients(uint16_t maxClients = DEFAULT_MAX_WS_CLIENTS);
+
+    void ping(uint32_t id, uint8_t *data=NULL, size_t len=0);
+    void pingAll(uint8_t *data=NULL, size_t len=0); //  done
+
+    void text(uint32_t id, const char * message, size_t len);
+    void text(uint32_t id, const char * message);
+    void text(uint32_t id, uint8_t * message, size_t len);
+    void text(uint32_t id, char * message);
+    void text(uint32_t id, const String &message);
+    void text(uint32_t id, const __FlashStringHelper *message);
+
+    void textAll(const char * message, size_t len);
+    void textAll(const char * message);
+    void textAll(uint8_t * message, size_t len);
+    void textAll(char * message);
+    void textAll(const String &message);
+    void textAll(const __FlashStringHelper *message); //  need to convert
+    void textAll(AsyncWebSocketMessageBuffer * buffer); 
+
+    void binary(uint32_t id, const char * message, size_t len);
+    void binary(uint32_t id, const char * message);
+    void binary(uint32_t id, uint8_t * message, size_t len);
+    void binary(uint32_t id, char * message);
+    void binary(uint32_t id, const String &message);
+    void binary(uint32_t id, const __FlashStringHelper *message, size_t len);
+
+    void binaryAll(const char * message, size_t len);
+    void binaryAll(const char * message);
+    void binaryAll(uint8_t * message, size_t len);
+    void binaryAll(char * message);
+    void binaryAll(const String &message);
+    void binaryAll(const __FlashStringHelper *message, size_t len);
+    void binaryAll(AsyncWebSocketMessageBuffer * buffer); 
+
+    void message(uint32_t id, AsyncWebSocketMessage *message);
+    void messageAll(AsyncWebSocketMultiMessage *message);
+
+    size_t printf(uint32_t id, const char *format, ...)  __attribute__ ((format (printf, 3, 4)));
+    size_t printfAll(const char *format, ...)  __attribute__ ((format (printf, 2, 3)));
+#ifndef ESP32
+    size_t printf_P(uint32_t id, PGM_P formatP, ...)  __attribute__ ((format (printf, 3, 4)));
+#endif
+    size_t printfAll_P(PGM_P formatP, ...)  __attribute__ ((format (printf, 2, 3)));
+
+    //event listener
+    void onEvent(AwsEventHandler handler){
+      _eventHandler = handler;
+    }
+
+    //system callbacks (do not call)
+    uint32_t _getNextId(){ return _cNextId++; }
+    void _addClient(AsyncWebSocketClient * client);
+    void _handleDisconnect(AsyncWebSocketClient * client);
+    void _handleEvent(AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len);
+    virtual bool canHandle(AsyncWebServerRequest *request) override final;
+    virtual void handleRequest(AsyncWebServerRequest *request) override final;
+
+
+    //  messagebuffer functions/objects. 
+    AsyncWebSocketMessageBuffer * makeBuffer(size_t size = 0); 
+    AsyncWebSocketMessageBuffer * makeBuffer(uint8_t * data, size_t size); 
+    LinkedList _buffers;
+    void _cleanBuffers(); 
+
+    AsyncWebSocketClientLinkedList getClients() const;
+};
+
+//WebServer response to authenticate the socket and detach the tcp client from the web server request
+class AsyncWebSocketResponse: public AsyncWebServerResponse {
+  private:
+    String _content;
+    AsyncWebSocket *_server;
+  public:
+    AsyncWebSocketResponse(const String& key, AsyncWebSocket *server);
+    void _respond(AsyncWebServerRequest *request);
+    size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+
+#endif /* ASYNCWEBSOCKET_H_ */
diff --git a/lib/ESPAsyncWebServer/src/AsyncWebSynchronization.h b/lib/ESPAsyncWebServer/src/AsyncWebSynchronization.h
new file mode 100644
index 00000000..f36c52dc
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/AsyncWebSynchronization.h
@@ -0,0 +1,87 @@
+#ifndef ASYNCWEBSYNCHRONIZATION_H_
+#define ASYNCWEBSYNCHRONIZATION_H_
+
+// Synchronisation is only available on ESP32, as the ESP8266 isn't using FreeRTOS by default
+
+#include 
+
+#ifdef ESP32
+
+// This is the ESP32 version of the Sync Lock, using the FreeRTOS Semaphore
+class AsyncWebLock
+{
+private:
+  SemaphoreHandle_t _lock;
+  mutable void *_lockedBy;
+
+public:
+  AsyncWebLock() {
+    _lock = xSemaphoreCreateBinary();
+    _lockedBy = NULL;
+    xSemaphoreGive(_lock);
+  }
+
+  ~AsyncWebLock() {
+    vSemaphoreDelete(_lock);
+  }
+
+  bool lock() const {
+    extern void *pxCurrentTCB;
+    if (_lockedBy != pxCurrentTCB) {
+      xSemaphoreTake(_lock, portMAX_DELAY);
+      _lockedBy = pxCurrentTCB;
+      return true;
+    }
+    return false;
+  }
+
+  void unlock() const {
+    _lockedBy = NULL;
+    xSemaphoreGive(_lock);
+  }
+};
+
+#else
+
+// This is the 8266 version of the Sync Lock which is currently unimplemented
+class AsyncWebLock
+{
+
+public:
+  AsyncWebLock() {
+  }
+
+  ~AsyncWebLock() {
+  }
+
+  bool lock() const {
+    return false;
+  }
+
+  void unlock() const {
+  }
+};
+#endif
+
+class AsyncWebLockGuard
+{
+private:
+  const AsyncWebLock *_lock;
+
+public:
+  AsyncWebLockGuard(const AsyncWebLock &l) {
+    if (l.lock()) {
+      _lock = &l;
+    } else {
+      _lock = NULL;
+    }
+  }
+
+  ~AsyncWebLockGuard() {
+    if (_lock) {
+      _lock->unlock();
+    }
+  }
+};
+
+#endif // ASYNCWEBSYNCHRONIZATION_H_
\ No newline at end of file
diff --git a/lib/ESPAsyncWebServer/src/ESPAsyncWebServer.h b/lib/ESPAsyncWebServer/src/ESPAsyncWebServer.h
new file mode 100644
index 00000000..3b2fbd96
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/ESPAsyncWebServer.h
@@ -0,0 +1,501 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef _ESPAsyncWebServer_H_
+#define _ESPAsyncWebServer_H_
+
+#include 
+
+#include "Arduino.h"
+#include "FS.h"
+#include "StringArray.h"
+
+#ifdef ESP32
+#include 
+#include 
+#elif defined(ESP8266)
+#include 
+#include 
+#else
+#error Platform not supported
+#endif
+
+#ifdef ASYNCWEBSERVER_REGEX
+#define ASYNCWEBSERVER_REGEX_ATTRIBUTE
+#else
+#define ASYNCWEBSERVER_REGEX_ATTRIBUTE __attribute__((warning("ASYNCWEBSERVER_REGEX not defined")))
+#endif
+
+#define DEBUGF(...)  //Serial.printf(__VA_ARGS__)
+
+class AsyncWebServer;
+class AsyncWebServerRequest;
+class AsyncWebServerResponse;
+class AsyncWebHeader;
+class AsyncWebParameter;
+class AsyncWebRewrite;
+class AsyncWebHandler;
+class AsyncStaticWebHandler;
+class AsyncCallbackWebHandler;
+class AsyncResponseStream;
+
+#ifdef ESP32
+#ifdef WEBSERVER_H
+#define HTTP_ENUM
+#endif
+#elif defined(ESP8266)
+#ifdef ESP8266WEBSERVER_H
+#define HTTP_ENUM
+#endif
+#endif
+
+#ifndef HTTP_ENUM
+typedef enum { HTTP_GET = 0b00000001,
+               HTTP_POST = 0b00000010,
+               HTTP_DELETE = 0b00000100,
+               HTTP_PUT = 0b00001000,
+               HTTP_PATCH = 0b00010000,
+               HTTP_HEAD = 0b00100000,
+               HTTP_OPTIONS = 0b01000000,
+               HTTP_ANY = 0b01111111,
+} WebRequestMethod;
+#endif
+
+//if this value is returned when asked for data, packet will not be sent and you will be asked for data again
+#define RESPONSE_TRY_AGAIN 0xFFFFFFFF
+
+typedef uint8_t WebRequestMethodComposite;
+typedef std::function ArDisconnectHandler;
+
+/*
+ * PARAMETER :: Chainable object to hold GET/POST and FILE parameters
+ * */
+
+class AsyncWebParameter {
+   private:
+    String _name;
+    String _value;
+    size_t _size;
+    bool _isForm;
+    bool _isFile;
+
+   public:
+    AsyncWebParameter(const String& name, const String& value, bool form = false, bool file = false, size_t size = 0) : _name(name), _value(value), _size(size), _isForm(form), _isFile(file) {}
+    const String& name() const { return _name; }
+    const String& value() const { return _value; }
+    size_t size() const { return _size; }
+    bool isPost() const { return _isForm; }
+    bool isFile() const { return _isFile; }
+};
+
+/*
+ * HEADER :: Chainable object to hold the headers
+ * */
+
+class AsyncWebHeader {
+   private:
+    String _name;
+    String _value;
+
+   public:
+    AsyncWebHeader(const String& name, const String& value) : _name(name), _value(value) {}
+    AsyncWebHeader(const String& data) : _name(), _value() {
+        if (!data) return;
+        int index = data.indexOf(':');
+        if (index < 0) return;
+        _name = data.substring(0, index);
+        _value = data.substring(index + 2);
+    }
+    ~AsyncWebHeader() {}
+    const String& name() const { return _name; }
+    const String& value() const { return _value; }
+    String toString() const { return String(_name + ": " + _value + "\r\n"); }
+};
+
+/*
+ * REQUEST :: Each incoming Client is wrapped inside a Request and both live together until disconnect
+ * */
+
+typedef enum { RCT_NOT_USED = -1,
+               RCT_DEFAULT = 0,
+               RCT_HTTP,
+               RCT_WS,
+               RCT_EVENT,
+               RCT_MAX } RequestedConnectionType;
+
+typedef std::function AwsResponseFiller;
+typedef std::function AwsTemplateProcessor;
+
+class AsyncWebServerRequest {
+    using File = fs::File;
+    using FS = fs::FS;
+    friend class AsyncWebServer;
+    friend class AsyncCallbackWebHandler;
+
+   private:
+    AsyncClient* _client;
+    AsyncWebServer* _server;
+    AsyncWebHandler* _handler;
+    AsyncWebServerResponse* _response;
+    StringArray _interestingHeaders;
+    ArDisconnectHandler _onDisconnectfn;
+
+    String _temp;
+    uint8_t _parseState;
+
+    uint8_t _version;
+    WebRequestMethodComposite _method;
+    String _url;
+    String _host;
+    String _contentType;
+    String _boundary;
+    String _authorization;
+    RequestedConnectionType _reqconntype;
+    void _removeNotInterestingHeaders();
+    bool _isDigest;
+    bool _isMultipart;
+    bool _isPlainPost;
+    bool _expectingContinue;
+    size_t _contentLength;
+    size_t _parsedLength;
+
+    LinkedList _headers;
+    LinkedList _params;
+    LinkedList _pathParams;
+
+    uint8_t _multiParseState;
+    uint8_t _boundaryPosition;
+    size_t _itemStartIndex;
+    size_t _itemSize;
+    String _itemName;
+    String _itemFilename;
+    String _itemType;
+    String _itemValue;
+    uint8_t* _itemBuffer;
+    size_t _itemBufferIndex;
+    bool _itemIsFile;
+
+    void _onPoll();
+    void _onAck(size_t len, uint32_t time);
+    void _onError(int8_t error);
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+    void _onData(void* buf, size_t len);
+
+    void _addParam(AsyncWebParameter*);
+    void _addPathParam(const char* param);
+
+    bool _parseReqHead();
+    bool _parseReqHeader();
+    void _parseLine();
+    void _parsePlainPostChar(uint8_t data);
+    void _parseMultipartPostByte(uint8_t data, bool last);
+    void _addGetParams(const String& params);
+
+    void _handleUploadStart();
+    void _handleUploadByte(uint8_t data, bool last);
+    void _handleUploadEnd();
+
+   public:
+    File _tempFile;
+    void* _tempObject;
+
+    AsyncWebServerRequest(AsyncWebServer*, AsyncClient*);
+    ~AsyncWebServerRequest();
+
+    AsyncClient* client() { return _client; }
+    uint8_t version() const { return _version; }
+    WebRequestMethodComposite method() const { return _method; }
+    const String& url() const { return _url; }
+    const String& host() const { return _host; }
+    const String& contentType() const { return _contentType; }
+    size_t contentLength() const { return _contentLength; }
+    bool multipart() const { return _isMultipart; }
+    const char* methodToString() const;
+    const char* requestedConnTypeToString() const;
+    RequestedConnectionType requestedConnType() const { return _reqconntype; }
+    bool isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED);
+    void onDisconnect(ArDisconnectHandler fn);
+
+    //hash is the string representation of:
+    // base64(user:pass) for basic or
+    // user:realm:md5(user:realm:pass) for digest
+    bool authenticate(const char* hash);
+    bool authenticate(const char* username, const char* password, const char* realm = NULL, bool passwordIsHash = false);
+    void requestAuthentication(const char* realm = NULL, bool isDigest = true);
+
+    void setHandler(AsyncWebHandler* handler) { _handler = handler; }
+    void addInterestingHeader(const String& name);
+
+    void redirect(const String& url);
+
+    void send(AsyncWebServerResponse* response);
+    void send(int code, const String& contentType = String(), const String& content = String());
+    void send(FS& fs, const String& path, const String& contentType = String(), bool download = false, AwsTemplateProcessor callback = nullptr);
+    void send(File content, const String& path, const String& contentType = String(), bool download = false, AwsTemplateProcessor callback = nullptr);
+    void send(Stream& stream, const String& contentType, size_t len, AwsTemplateProcessor callback = nullptr);
+    void send(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    void sendChunked(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    void send_P(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr);
+    void send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback = nullptr);
+
+    AsyncWebServerResponse* beginResponse(int code, const String& contentType = String(), const String& content = String());
+    AsyncWebServerResponse* beginResponse(FS& fs, const String& path, const String& contentType = String(), bool download = false, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(File content, const String& path, const String& contentType = String(), bool download = false, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(Stream& stream, const String& contentType, size_t len, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    AsyncWebServerResponse* beginChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    AsyncResponseStream* beginResponseStream(const String& contentType, size_t bufferSize = 1460);
+    AsyncWebServerResponse* beginResponse_P(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback = nullptr);
+
+    size_t headers() const;                                 // get header count
+    bool hasHeader(const String& name) const;               // check if header exists
+    bool hasHeader(const __FlashStringHelper* data) const;  // check if header exists
+
+    AsyncWebHeader* getHeader(const String& name) const;
+    AsyncWebHeader* getHeader(const __FlashStringHelper* data) const;
+    AsyncWebHeader* getHeader(size_t num) const;
+
+    size_t params() const;  // get arguments count
+    bool hasParam(const String& name, bool post = false, bool file = false) const;
+    bool hasParam(const __FlashStringHelper* data, bool post = false, bool file = false) const;
+
+    AsyncWebParameter* getParam(const String& name, bool post = false, bool file = false) const;
+    AsyncWebParameter* getParam(const __FlashStringHelper* data, bool post, bool file) const;
+    AsyncWebParameter* getParam(size_t num) const;
+
+    size_t args() const { return params(); }                   // get arguments count
+    const String& arg(const String& name) const;               // get request argument value by name
+    const String& arg(const __FlashStringHelper* data) const;  // get request argument value by F(name)
+    const String& arg(size_t i) const;                         // get request argument value by number
+    const String& argName(size_t i) const;                     // get request argument name by number
+    bool hasArg(const char* name) const;                       // check if argument exists
+    bool hasArg(const __FlashStringHelper* data) const;        // check if F(argument) exists
+
+    const String& ASYNCWEBSERVER_REGEX_ATTRIBUTE pathArg(size_t i) const;
+
+    const String& header(const char* name) const;                 // get request header value by name
+    const String& header(const __FlashStringHelper* data) const;  // get request header value by F(name)
+    const String& header(size_t i) const;                         // get request header value by number
+    const String& headerName(size_t i) const;                     // get request header name by number
+    String urlDecode(const String& text) const;
+};
+
+/*
+ * FILTER :: Callback to filter AsyncWebRewrite and AsyncWebHandler (done by the Server)
+ * */
+
+typedef std::function ArRequestFilterFunction;
+
+bool ON_STA_FILTER(AsyncWebServerRequest* request);
+
+bool ON_AP_FILTER(AsyncWebServerRequest* request);
+
+/*
+ * REWRITE :: One instance can be handle any Request (done by the Server)
+ * */
+
+class AsyncWebRewrite {
+   protected:
+    String _from;
+    String _toUrl;
+    String _params;
+    ArRequestFilterFunction _filter;
+
+   public:
+    AsyncWebRewrite(const char* from, const char* to) : _from(from), _toUrl(to), _params(String()), _filter(NULL) {
+        int index = _toUrl.indexOf('?');
+        if (index > 0) {
+            _params = _toUrl.substring(index + 1);
+            _toUrl = _toUrl.substring(0, index);
+        }
+    }
+    virtual ~AsyncWebRewrite() {}
+    AsyncWebRewrite& setFilter(ArRequestFilterFunction fn) {
+        _filter = fn;
+        return *this;
+    }
+    bool filter(AsyncWebServerRequest* request) const { return _filter == NULL || _filter(request); }
+    const String& from(void) const { return _from; }
+    const String& toUrl(void) const { return _toUrl; }
+    const String& params(void) const { return _params; }
+    virtual bool match(AsyncWebServerRequest* request) { return from() == request->url() && filter(request); }
+};
+
+/*
+ * HANDLER :: One instance can be attached to any Request (done by the Server)
+ * */
+
+class AsyncWebHandler {
+   protected:
+    ArRequestFilterFunction _filter;
+    String _username;
+    String _password;
+
+   public:
+    AsyncWebHandler() : _username(""), _password("") {}
+    AsyncWebHandler& setFilter(ArRequestFilterFunction fn) {
+        _filter = fn;
+        return *this;
+    }
+    AsyncWebHandler& setAuthentication(const char* username, const char* password) {
+        _username = String(username);
+        _password = String(password);
+        return *this;
+    };
+    bool filter(AsyncWebServerRequest* request) { return _filter == NULL || _filter(request); }
+    virtual ~AsyncWebHandler() {}
+    virtual bool canHandle(AsyncWebServerRequest* request __attribute__((unused))) {
+        return false;
+    }
+    virtual void handleRequest(AsyncWebServerRequest* request __attribute__((unused))) {}
+    virtual void handleUpload(AsyncWebServerRequest* request __attribute__((unused)), const String& filename __attribute__((unused)), size_t index __attribute__((unused)), uint8_t* data __attribute__((unused)), size_t len __attribute__((unused)), bool final __attribute__((unused))) {}
+    virtual void handleBody(AsyncWebServerRequest* request __attribute__((unused)), uint8_t* data __attribute__((unused)), size_t len __attribute__((unused)), size_t index __attribute__((unused)), size_t total __attribute__((unused))) {}
+    virtual bool isRequestHandlerTrivial() { return true; }
+};
+
+/*
+ * RESPONSE :: One instance is created for each Request (attached by the Handler)
+ * */
+
+typedef enum {
+    RESPONSE_SETUP,
+    RESPONSE_HEADERS,
+    RESPONSE_CONTENT,
+    RESPONSE_WAIT_ACK,
+    RESPONSE_END,
+    RESPONSE_FAILED
+} WebResponseState;
+
+class AsyncWebServerResponse {
+   protected:
+    int _code;
+    LinkedList _headers;
+    String _contentType;
+    size_t _contentLength;
+    bool _sendContentLength;
+    bool _chunked;
+    size_t _headLength;
+    size_t _sentLength;
+    size_t _ackedLength;
+    size_t _writtenLength;
+    WebResponseState _state;
+    const char* _responseCodeToString(int code);
+
+   public:
+    AsyncWebServerResponse();
+    virtual ~AsyncWebServerResponse();
+    virtual void setCode(int code);
+    virtual void setContentLength(size_t len);
+    virtual void setContentType(const String& type);
+    virtual void addHeader(const String& name, const String& value);
+    virtual String _assembleHead(uint8_t version);
+    virtual bool _started() const;
+    virtual bool _finished() const;
+    virtual bool _failed() const;
+    virtual bool _sourceValid() const;
+    virtual void _respond(AsyncWebServerRequest* request);
+    virtual size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time);
+};
+
+/*
+ * SERVER :: One instance
+ * */
+
+typedef std::function ArRequestHandlerFunction;
+typedef std::function ArUploadHandlerFunction;
+typedef std::function ArBodyHandlerFunction;
+
+class AsyncWebServer {
+   protected:
+    AsyncServer _server;
+    LinkedList _rewrites;
+    LinkedList _handlers;
+    AsyncCallbackWebHandler* _catchAllHandler;
+
+   public:
+    AsyncWebServer(uint16_t port);
+    ~AsyncWebServer();
+
+    void begin();
+    void end();
+
+#if ASYNC_TCP_SSL_ENABLED
+    void onSslFileRequest(AcSSlFileHandler cb, void* arg);
+    void beginSecure(const char* cert, const char* private_key_file, const char* password);
+#endif
+
+    AsyncWebRewrite& addRewrite(AsyncWebRewrite* rewrite);
+    bool removeRewrite(AsyncWebRewrite* rewrite);
+    AsyncWebRewrite& rewrite(const char* from, const char* to);
+
+    AsyncWebHandler& addHandler(AsyncWebHandler* handler);
+    bool removeHandler(AsyncWebHandler* handler);
+
+    AsyncCallbackWebHandler& on(const char* uri, ArRequestHandlerFunction onRequest);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody);
+
+    AsyncStaticWebHandler& serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control = NULL);
+
+    void onNotFound(ArRequestHandlerFunction fn);   //called when handler is not assigned
+    void onFileUpload(ArUploadHandlerFunction fn);  //handle file uploads
+    void onRequestBody(ArBodyHandlerFunction fn);   //handle posts with plain body content (JSON often transmitted this way as a request)
+
+    void reset();  //remove all writers and handlers, with onNotFound/onFileUpload/onRequestBody
+
+    void _handleDisconnect(AsyncWebServerRequest* request);
+    void _attachHandler(AsyncWebServerRequest* request);
+    void _rewriteRequest(AsyncWebServerRequest* request);
+};
+
+class DefaultHeaders {
+    using headers_t = LinkedList;
+    headers_t _headers;
+
+    DefaultHeaders()
+        : _headers(headers_t([](AsyncWebHeader* h) { delete h; })) {}
+
+   public:
+    using ConstIterator = headers_t::ConstIterator;
+
+    void addHeader(const String& name, const String& value) {
+        _headers.add(new AsyncWebHeader(name, value));
+    }
+
+    ConstIterator begin() const { return _headers.begin(); }
+    ConstIterator end() const { return _headers.end(); }
+
+    DefaultHeaders(DefaultHeaders const&) = delete;
+    DefaultHeaders& operator=(DefaultHeaders const&) = delete;
+    static DefaultHeaders& Instance() {
+        static DefaultHeaders instance;
+        return instance;
+    }
+};
+
+#include "AsyncEventSource.h"
+#include "AsyncWebSocket.h"
+#include "WebHandlerImpl.h"
+#include "WebResponseImpl.h"
+
+#endif /* _AsyncWebServer_H_ */
diff --git a/lib/ESPAsyncWebServer/src/SPIFFSEditor.cpp b/lib/ESPAsyncWebServer/src/SPIFFSEditor.cpp
new file mode 100644
index 00000000..a84fa87d
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/SPIFFSEditor.cpp
@@ -0,0 +1,544 @@
+#include "SPIFFSEditor.h"
+#include 
+
+//File: edit.htm.gz, Size: 4151
+#define edit_htm_gz_len 4151
+const uint8_t edit_htm_gz[] PROGMEM = {
+ 0x1F, 0x8B, 0x08, 0x08, 0xB8, 0x94, 0xB1, 0x59, 0x00, 0x03, 0x65, 0x64, 0x69, 0x74, 0x2E, 0x68,
+ 0x74, 0x6D, 0x00, 0xB5, 0x3A, 0x0B, 0x7B, 0xDA, 0xB8, 0xB2, 0x7F, 0xC5, 0x71, 0xCF, 0x66, 0xED,
+ 0x83, 0x31, 0x90, 0xA4, 0xD9, 0xD6, 0xC4, 0xC9, 0x42, 0x92, 0x36, 0x6D, 0xF3, 0x6A, 0x80, 0xB6,
+ 0x69, 0x4F, 0xEE, 0x7E, 0xC2, 0x16, 0xA0, 0xC6, 0x96, 0x5D, 0x5B, 0x0E, 0x49, 0x59, 0xFE, 0xFB,
+ 0x9D, 0x91, 0x6C, 0xB0, 0x09, 0x69, 0x77, 0xCF, 0xBD, 0xBB, 0xDD, 0x2D, 0x92, 0x46, 0x33, 0x9A,
+ 0x19, 0xCD, 0x53, 0xDE, 0xBD, 0x8D, 0xA3, 0x8B, 0xC3, 0xFE, 0xF5, 0xE5, 0xB1, 0x36, 0x11, 0x61,
+ 0xB0, 0xBF, 0x87, 0x7F, 0x6B, 0x01, 0xE1, 0x63, 0x97, 0xF2, 0xFD, 0x3D, 0xC1, 0x44, 0x40, 0xF7,
+ 0x8F, 0x7B, 0x97, 0xDA, 0xB1, 0xCF, 0x44, 0x94, 0xEC, 0x35, 0xD4, 0xCA, 0x5E, 0x2A, 0x1E, 0x02,
+ 0xAA, 0x85, 0xD4, 0x67, 0xC4, 0x4D, 0xBD, 0x84, 0xC2, 0x66, 0xDB, 0x0B, 0x67, 0xDF, 0xEB, 0x8C,
+ 0xFB, 0xF4, 0xDE, 0xD9, 0x6E, 0x36, 0xDB, 0x71, 0x94, 0x32, 0xC1, 0x22, 0xEE, 0x90, 0x61, 0x1A,
+ 0x05, 0x99, 0xA0, 0xED, 0x80, 0x8E, 0x84, 0xF3, 0x3C, 0xBE, 0x6F, 0x0F, 0xA3, 0xC4, 0xA7, 0x89,
+ 0xD3, 0x8A, 0xEF, 0x35, 0x00, 0x31, 0x5F, 0x7B, 0xB6, 0xB3, 0xB3, 0xD3, 0x1E, 0x12, 0xEF, 0x76,
+ 0x9C, 0x44, 0x19, 0xF7, 0xEB, 0x5E, 0x14, 0x44, 0x89, 0xF3, 0x6C, 0xF4, 0x1C, 0xFF, 0xB4, 0x7D,
+ 0x96, 0xC6, 0x01, 0x79, 0x70, 0x78, 0xC4, 0x29, 0xE0, 0xDE, 0xD7, 0xD3, 0x09, 0xF1, 0xA3, 0xA9,
+ 0xD3, 0xD4, 0x9A, 0x5A, 0xAB, 0x09, 0x44, 0x92, 0xF1, 0x90, 0x18, 0x4D, 0x0B, 0xFF, 0xD8, 0x3B,
+ 0x66, 0x7B, 0x14, 0x71, 0x51, 0x4F, 0xD9, 0x77, 0xEA, 0xB4, 0xB6, 0xE0, 0x34, 0x39, 0x1D, 0x91,
+ 0x90, 0x05, 0x0F, 0x4E, 0x4A, 0x78, 0x5A, 0x4F, 0x69, 0xC2, 0x46, 0x6A, 0x79, 0x4A, 0xD9, 0x78,
+ 0x22, 0x9C, 0xDF, 0x9A, 0xCD, 0x39, 0xF0, 0xAF, 0x65, 0xC1, 0x2C, 0x60, 0x29, 0x20, 0xA3, 0x78,
+ 0xEA, 0x3C, 0x11, 0xC5, 0x4E, 0x53, 0xB1, 0xDE, 0x6C, 0x87, 0x24, 0x19, 0x33, 0x0E, 0x83, 0x98,
+ 0xF8, 0x3E, 0xE3, 0x63, 0x47, 0xA1, 0x05, 0x6C, 0xB6, 0x90, 0x36, 0xA1, 0x01, 0x11, 0xEC, 0x8E,
+ 0xB6, 0x43, 0xC6, 0xEB, 0x53, 0xE6, 0x8B, 0x89, 0xB3, 0x0B, 0x3C, 0xB6, 0xBD, 0x2C, 0x49, 0x41,
+ 0xA6, 0x38, 0x62, 0x5C, 0xD0, 0x44, 0xA2, 0xA5, 0x31, 0xE1, 0xB3, 0x5C, 0x54, 0x54, 0x40, 0x21,
+ 0x27, 0xE3, 0x01, 0xE3, 0xB4, 0x3E, 0x0C, 0x22, 0xEF, 0x76, 0x71, 0xD2, 0x6E, 0x7C, 0x9F, 0x9F,
+ 0xE5, 0x4C, 0xA2, 0x3B, 0x9A, 0xCC, 0x96, 0xEA, 0x92, 0xD8, 0x15, 0x60, 0x85, 0x34, 0xA5, 0x74,
+ 0x6E, 0x8B, 0xBB, 0x0C, 0xA0, 0x96, 0xFC, 0x05, 0x29, 0x17, 0xFC, 0x2F, 0x45, 0x5A, 0x11, 0x5C,
+ 0xA1, 0x30, 0x1E, 0x67, 0x62, 0xF6, 0xF8, 0x2A, 0xA3, 0x98, 0x78, 0x4C, 0x3C, 0xA0, 0xFC, 0xB0,
+ 0x6D, 0x86, 0xBA, 0x04, 0xAC, 0x24, 0x24, 0x81, 0x86, 0x3A, 0xD7, 0x3E, 0xD0, 0xC4, 0x27, 0x9C,
+ 0x58, 0x9D, 0x84, 0x91, 0xC0, 0xEA, 0x2D, 0xB5, 0x5E, 0x0F, 0xA3, 0xEF, 0xF5, 0x0C, 0xC6, 0x30,
+ 0x0F, 0xA8, 0x27, 0x94, 0x92, 0xE1, 0x1E, 0x86, 0xB7, 0x4C, 0x3C, 0x06, 0x3C, 0x5A, 0x28, 0xA9,
+ 0x4B, 0x2A, 0x69, 0xA2, 0x2E, 0xB0, 0x25, 0xD5, 0x83, 0x1C, 0x4B, 0xC9, 0x95, 0x50, 0xF5, 0x61,
+ 0x24, 0x44, 0x14, 0x4A, 0x93, 0x5B, 0x08, 0xAC, 0x49, 0xAB, 0x79, 0xF1, 0xE8, 0x46, 0xD6, 0x6B,
+ 0xBF, 0x44, 0xBE, 0x0D, 0x7A, 0x15, 0xCC, 0x23, 0x41, 0x9D, 0x04, 0x6C, 0xCC, 0x9D, 0x90, 0xF9,
+ 0x7E, 0x40, 0x4B, 0x56, 0xEB, 0x64, 0x49, 0x60, 0xF8, 0x44, 0x10, 0x87, 0x85, 0x64, 0x4C, 0x1B,
+ 0x31, 0x1F, 0x03, 0x34, 0xA5, 0xBB, 0x3B, 0x16, 0xFB, 0xD0, 0xBD, 0xB8, 0x9A, 0x36, 0xDF, 0xBD,
+ 0x1E, 0x47, 0x1D, 0xF8, 0xE7, 0xBC, 0x37, 0x98, 0x1C, 0x0F, 0xC6, 0x30, 0xEA, 0xE2, 0xB4, 0xF3,
+ 0xFE, 0xB0, 0xF3, 0x1E, 0x7E, 0x0E, 0x5B, 0xB5, 0xAF, 0xA3, 0x6F, 0xB8, 0xD0, 0x7D, 0xED, 0x77,
+ 0xFB, 0x83, 0xE3, 0x4E, 0xE7, 0x5D, 0xE3, 0xCD, 0xF9, 0xF4, 0xE3, 0xBB, 0x5D, 0x04, 0x77, 0x83,
+ 0xE6, 0xD5, 0x87, 0x49, 0x73, 0xB0, 0xF5, 0x32, 0xF4, 0x4F, 0xFC, 0x89, 0x17, 0x0E, 0x3A, 0xEF,
+ 0x3F, 0x5E, 0xDD, 0x5D, 0x87, 0x83, 0x71, 0xEF, 0x63, 0x6B, 0xF2, 0x79, 0xEB, 0x43, 0xEF, 0xF3,
+ 0xC7, 0x57, 0xB7, 0xF4, 0xD3, 0xC9, 0xDB, 0xCF, 0xFD, 0x29, 0x20, 0x1C, 0x45, 0xBD, 0xC1, 0x55,
+ 0xF7, 0x43, 0x77, 0xFC, 0xB9, 0xEB, 0x1D, 0xDF, 0x0F, 0x83, 0xF3, 0xEE, 0xEB, 0xCE, 0xB0, 0xB3,
+ 0xE5, 0x51, 0x3A, 0xEE, 0x5F, 0x75, 0xB3, 0x37, 0xEF, 0x2E, 0xC6, 0x8C, 0x4D, 0x7A, 0x9F, 0xCF,
+ 0xFB, 0xDE, 0xE1, 0xF3, 0xD3, 0xC1, 0x49, 0x87, 0x4D, 0xCE, 0xDF, 0x5E, 0x35, 0x6F, 0x5F, 0xBF,
+ 0x3B, 0x3C, 0xF2, 0xAE, 0xDF, 0x5E, 0xEF, 0x1E, 0x6D, 0x37, 0x7E, 0xFB, 0xED, 0xCC, 0xBF, 0x60,
+ 0xBC, 0x7F, 0xF7, 0xBD, 0x33, 0x3E, 0x9C, 0xBE, 0x78, 0x48, 0xFB, 0x93, 0x37, 0x77, 0xBC, 0xF1,
+ 0x21, 0xFA, 0xFA, 0xE6, 0xE1, 0x0C, 0xFE, 0xBB, 0xBC, 0xAC, 0x0D, 0x7B, 0xAD, 0x74, 0xF0, 0xFE,
+ 0xCD, 0x87, 0xAD, 0xF4, 0xE5, 0xF3, 0xB8, 0x7B, 0x74, 0x74, 0x17, 0x0E, 0x2F, 0x1B, 0xA1, 0x7F,
+ 0x3B, 0x12, 0x2F, 0xB6, 0x45, 0x7C, 0x3D, 0xCE, 0x3E, 0x7F, 0x7B, 0xFE, 0x76, 0xD2, 0xB8, 0xA0,
+ 0xE4, 0x7A, 0x52, 0x7B, 0xF8, 0xFE, 0xF0, 0x62, 0xD2, 0x3F, 0xB9, 0x3B, 0x0F, 0xC8, 0xFD, 0xF9,
+ 0xB9, 0xF7, 0x3D, 0xAC, 0x05, 0xE4, 0xE5, 0x45, 0x3F, 0x20, 0x49, 0x6B, 0xE0, 0x77, 0x1A, 0xB5,
+ 0xC3, 0xAD, 0xCE, 0x8E, 0x48, 0xAE, 0x0E, 0xF9, 0xD1, 0xF6, 0xD7, 0xDE, 0x8B, 0x6E, 0xB7, 0x15,
+ 0x0D, 0xBF, 0x6D, 0xBD, 0xBE, 0xDD, 0x7D, 0x3D, 0xD8, 0x7D, 0x3F, 0x7C, 0xDF, 0xE9, 0xED, 0x74,
+ 0x07, 0xE4, 0xBA, 0xF7, 0xBE, 0x33, 0xDA, 0x19, 0x4E, 0x26, 0xEF, 0xDE, 0xF5, 0x5F, 0xF9, 0x9D,
+ 0xEF, 0x49, 0xE7, 0x62, 0xDA, 0xB9, 0x3F, 0x1E, 0x74, 0x4E, 0x6A, 0xEF, 0x8E, 0xCF, 0x9A, 0xAD,
+ 0xDE, 0xF5, 0xF6, 0xF8, 0x6C, 0x77, 0xDA, 0x4D, 0x8F, 0x3B, 0xEF, 0xBB, 0xCD, 0xF1, 0xDB, 0x5A,
+ 0x48, 0x3E, 0x47, 0x87, 0xDB, 0xE3, 0x37, 0xBB, 0xEC, 0xF2, 0x9A, 0x74, 0xDE, 0x74, 0xDF, 0xA6,
+ 0xEC, 0x2A, 0x3C, 0x19, 0x34, 0x3B, 0x9D, 0xD3, 0x0B, 0xFA, 0xEA, 0x70, 0x9B, 0xBC, 0xDB, 0xF2,
+ 0x3E, 0x82, 0xFE, 0x07, 0x9F, 0xE8, 0x6F, 0xB5, 0xCE, 0xF4, 0xA2, 0x19, 0x78, 0x2F, 0x69, 0xFF,
+ 0xE4, 0xBA, 0x2F, 0x6F, 0xE7, 0x38, 0x78, 0xD5, 0xBF, 0xED, 0x65, 0xEF, 0xC3, 0xC3, 0x43, 0x53,
+ 0xE3, 0x51, 0x3D, 0xA1, 0x31, 0x25, 0xA2, 0x1C, 0xAE, 0x16, 0xFE, 0x01, 0xB6, 0xB5, 0xB4, 0xC2,
+ 0xDC, 0x4F, 0x05, 0xBD, 0x17, 0x75, 0x9F, 0x7A, 0x51, 0x42, 0xE4, 0x1E, 0x40, 0xA0, 0x09, 0x9A,
+ 0xD8, 0xFC, 0x77, 0x19, 0x3F, 0x35, 0x15, 0x3F, 0x35, 0xC2, 0x7D, 0xCD, 0x28, 0x1C, 0x01, 0x83,
+ 0x87, 0x4F, 0xEF, 0x98, 0x47, 0xEB, 0x31, 0xBB, 0xA7, 0x41, 0x5D, 0x22, 0x3B, 0x4D, 0x73, 0x26,
+ 0xFD, 0xAD, 0xD8, 0x46, 0x38, 0x98, 0x9A, 0xA4, 0x5A, 0x2C, 0xF8, 0x5F, 0x89, 0x47, 0x21, 0xB0,
+ 0x81, 0xCB, 0x84, 0xF8, 0xAB, 0x7C, 0x27, 0x4A, 0xEA, 0xC3, 0x6C, 0x3C, 0x62, 0xF7, 0xE0, 0xD0,
+ 0x23, 0xC6, 0x99, 0xA0, 0x5A, 0x2B, 0x9D, 0xFF, 0x5E, 0x90, 0xB9, 0xA5, 0x0F, 0xA3, 0x84, 0x84,
+ 0x34, 0xD5, 0xFE, 0x22, 0x99, 0xD9, 0x28, 0x89, 0xC2, 0x65, 0x10, 0x99, 0x8B, 0xA8, 0x34, 0x99,
+ 0xCF, 0x9F, 0x65, 0x71, 0x10, 0x11, 0x10, 0x73, 0x4D, 0xE4, 0x50, 0xF1, 0x34, 0x91, 0x6E, 0xB5,
+ 0x88, 0xAB, 0xB9, 0x9B, 0x6D, 0xA1, 0x5B, 0x96, 0xDD, 0x7A, 0x6B, 0x67, 0xE9, 0xBA, 0x75, 0xB9,
+ 0x17, 0xE3, 0xFD, 0x9A, 0x4C, 0x81, 0xF1, 0xA0, 0x14, 0xEE, 0x9E, 0x09, 0x50, 0xE9, 0x13, 0x87,
+ 0xCB, 0x43, 0xF2, 0xC8, 0xB0, 0x60, 0x40, 0x05, 0xEA, 0x96, 0x8C, 0xD4, 0x85, 0x24, 0xB0, 0x6F,
+ 0xFE, 0x8C, 0xCA, 0xBC, 0x67, 0x3D, 0x8B, 0x13, 0xB8, 0x0D, 0x3A, 0xFD, 0x11, 0xCD, 0x42, 0xA6,
+ 0x2A, 0x6D, 0x45, 0x53, 0x65, 0xBC, 0x5C, 0x84, 0x65, 0xDA, 0x93, 0xBC, 0x16, 0xA4, 0x1F, 0x4B,
+ 0x05, 0xE0, 0x05, 0x37, 0xCF, 0x91, 0x9B, 0x1F, 0x6A, 0x75, 0x7B, 0xF7, 0x97, 0x9C, 0x87, 0x9D,
+ 0xE6, 0x2F, 0x73, 0x3B, 0xDF, 0x5B, 0xA4, 0xE4, 0x56, 0x13, 0xFE, 0x29, 0x32, 0xEF, 0x8B, 0x25,
+ 0x0B, 0xC3, 0xE7, 0xF8, 0xA7, 0x60, 0x10, 0xE9, 0x94, 0x80, 0xDB, 0x3B, 0x2F, 0x5F, 0xF8, 0xC3,
+ 0x02, 0x98, 0x0B, 0xF6, 0x24, 0x3C, 0x21, 0x3E, 0xCB, 0x52, 0xE7, 0x79, 0xF3, 0x97, 0x5C, 0x9F,
+ 0x5B, 0x3B, 0x28, 0xFB, 0xE2, 0x2E, 0x71, 0xB2, 0xB4, 0xD8, 0x34, 0x66, 0x5C, 0xDB, 0x4A, 0x35,
+ 0xBC, 0x6F, 0x92, 0x2C, 0x0C, 0xB3, 0x92, 0xED, 0xE7, 0xBF, 0x2F, 0x4D, 0x13, 0xF7, 0xCF, 0x9A,
+ 0xBF, 0xCC, 0x44, 0x02, 0xD9, 0x64, 0x04, 0xB9, 0xC6, 0x49, 0x22, 0x41, 0x04, 0x35, 0x9A, 0xE6,
+ 0x1C, 0x84, 0x5B, 0x03, 0xD8, 0xDE, 0x6D, 0xFA, 0x74, 0x6C, 0xCE, 0xE7, 0x7B, 0x0D, 0x99, 0xD7,
+ 0xA0, 0x6C, 0xF1, 0x12, 0x16, 0x8B, 0xFD, 0x51, 0xC6, 0x3D, 0xE4, 0x41, 0x1B, 0x53, 0x83, 0x9A,
+ 0xB3, 0x84, 0x8A, 0x2C, 0xE1, 0x9A, 0x1F, 0x79, 0x19, 0x1A, 0xBB, 0x3D, 0xA6, 0xE2, 0x58, 0xD9,
+ 0x7D, 0xF7, 0xE1, 0x8D, 0x0F, 0x3B, 0xE6, 0x0B, 0x04, 0x6F, 0x2D, 0x02, 0x38, 0x30, 0x9C, 0x97,
+ 0xE3, 0x54, 0xF6, 0x43, 0x82, 0x01, 0x22, 0xEF, 0xE8, 0x83, 0x41, 0x2D, 0xB1, 0x40, 0xA4, 0x36,
+ 0xAE, 0x1B, 0xC5, 0x2E, 0x80, 0x71, 0x73, 0x76, 0x07, 0x4A, 0x20, 0x2E, 0xFD, 0x22, 0x6E, 0x2C,
+ 0xE6, 0x72, 0xF8, 0x69, 0xE7, 0xBB, 0xC9, 0x1E, 0x3B, 0xA8, 0xB7, 0x1C, 0xB2, 0xCF, 0x0E, 0x5A,
+ 0xE0, 0x5E, 0x65, 0x6E, 0xE4, 0xB9, 0xAF, 0x58, 0x40, 0x07, 0xB9, 0xC3, 0xE1, 0x31, 0x48, 0x6C,
+ 0xB1, 0x85, 0x28, 0xE2, 0x5B, 0xCD, 0xE6, 0x86, 0x4B, 0x0F, 0x48, 0x00, 0x39, 0xCC, 0xD0, 0x8F,
+ 0xAF, 0xAE, 0x2E, 0xAE, 0xBE, 0xE8, 0x35, 0x5A, 0xD3, 0x6F, 0x1C, 0x4D, 0xAF, 0x71, 0xD3, 0x11,
+ 0x76, 0x42, 0x47, 0x09, 0x4D, 0x27, 0x97, 0x44, 0x4C, 0x8C, 0xD4, 0xBE, 0x23, 0x41, 0x56, 0x16,
+ 0x84, 0xA1, 0xDC, 0xC8, 0xA2, 0x70, 0x39, 0x9D, 0x6A, 0xAF, 0x40, 0xCD, 0x47, 0x90, 0xEA, 0xDA,
+ 0xC2, 0x26, 0x71, 0x4C, 0xB9, 0x6F, 0xE8, 0x31, 0x20, 0xEA, 0x16, 0x35, 0xAD, 0x84, 0x7E, 0xCB,
+ 0x68, 0x2A, 0x52, 0x1B, 0x2C, 0xD7, 0xD0, 0x2F, 0x07, 0x7D, 0xDD, 0xD2, 0x1B, 0xE8, 0x47, 0x3A,
+ 0xF0, 0x46, 0xCC, 0x39, 0x52, 0x89, 0x5C, 0xD0, 0xA4, 0x3E, 0xCC, 0xC0, 0xA0, 0xB8, 0x6E, 0xB6,
+ 0x23, 0x9B, 0x71, 0x4E, 0x93, 0x93, 0xFE, 0xD9, 0xA9, 0xAB, 0x5F, 0x29, 0x46, 0xB4, 0x53, 0x28,
+ 0x48, 0x74, 0x4B, 0x5E, 0x51, 0x7E, 0xC8, 0xE1, 0x84, 0x05, 0xBE, 0x11, 0x99, 0x6D, 0x24, 0xE1,
+ 0x49, 0x12, 0xB2, 0x40, 0x01, 0x0A, 0x9E, 0x2D, 0x1E, 0x62, 0xEA, 0xEA, 0x23, 0x50, 0x86, 0x6E,
+ 0x79, 0x76, 0x98, 0x05, 0x82, 0xC5, 0x01, 0x75, 0x37, 0x5A, 0x30, 0xE3, 0x60, 0x41, 0xAE, 0x8E,
+ 0xB9, 0x19, 0x61, 0xCC, 0x77, 0x75, 0x15, 0xA1, 0xF2, 0xB8, 0xB6, 0xEE, 0x14, 0x4F, 0x9D, 0x92,
+ 0x56, 0x4E, 0x49, 0xCB, 0xB8, 0x4A, 0xE0, 0x34, 0x3F, 0x18, 0xC3, 0x3C, 0xCE, 0xD4, 0x51, 0x05,
+ 0xCC, 0xA7, 0x23, 0x02, 0x9C, 0x7C, 0x40, 0x6D, 0xBA, 0x7A, 0x63, 0xDD, 0x41, 0xA9, 0x3A, 0xC8,
+ 0xAF, 0x6A, 0xC4, 0x2F, 0x6B, 0x44, 0xDD, 0xEE, 0x3A, 0x64, 0x5F, 0x21, 0x07, 0x55, 0xE4, 0xA0,
+ 0x8C, 0x7C, 0x28, 0x8D, 0x64, 0x1D, 0x72, 0xA0, 0x90, 0x93, 0x8A, 0x88, 0x89, 0x14, 0x51, 0x85,
+ 0xBD, 0x3A, 0x6A, 0x13, 0x05, 0xD2, 0xAD, 0xA4, 0x22, 0x66, 0x62, 0x83, 0x97, 0x92, 0x61, 0x40,
+ 0x7D, 0x77, 0xA3, 0x09, 0x33, 0x2C, 0xB6, 0xDD, 0xAD, 0xE6, 0x9A, 0x33, 0x12, 0x75, 0x46, 0x56,
+ 0x65, 0x30, 0x2B, 0x33, 0xA8, 0xF5, 0xC8, 0x1D, 0xD5, 0xD6, 0x31, 0x98, 0x99, 0x56, 0x60, 0x47,
+ 0xDC, 0x0B, 0x98, 0x77, 0xEB, 0x2E, 0xBD, 0xC5, 0x9C, 0xB1, 0x85, 0x85, 0x5A, 0x5C, 0x06, 0xBA,
+ 0x01, 0x94, 0x5E, 0x8B, 0xA5, 0x7C, 0x80, 0xFA, 0x9E, 0x5B, 0xD9, 0x5A, 0x02, 0xDC, 0xA6, 0xF7,
+ 0xD4, 0x3B, 0x8C, 0xC2, 0x90, 0xA0, 0xED, 0xA6, 0xC0, 0x41, 0x3E, 0xD1, 0xCD, 0xB9, 0x15, 0xAD,
+ 0xC5, 0x79, 0xC2, 0x45, 0x2C, 0x7F, 0x3D, 0x8B, 0x23, 0x03, 0x5C, 0xCE, 0xF5, 0x6C, 0xD4, 0x61,
+ 0x6A, 0x83, 0x1E, 0xC7, 0x62, 0xF2, 0x13, 0x17, 0x2A, 0x0C, 0x54, 0xA2, 0x7C, 0x69, 0xDE, 0x58,
+ 0x0B, 0x91, 0x56, 0x7C, 0xEA, 0xA2, 0xB7, 0xE2, 0x54, 0xA8, 0xBC, 0x8A, 0x5D, 0x9A, 0x4B, 0x1D,
+ 0x94, 0x61, 0xB9, 0xBD, 0x2F, 0xA0, 0xFA, 0x7C, 0x0E, 0xE7, 0x01, 0xFF, 0x13, 0x68, 0xF9, 0xE8,
+ 0x5F, 0x17, 0x60, 0xC9, 0xA3, 0x34, 0x78, 0x8B, 0xBB, 0x0D, 0xE3, 0xC0, 0xF9, 0x8F, 0x6D, 0x7C,
+ 0xF9, 0x1F, 0xFB, 0xA6, 0x66, 0x9A, 0x07, 0xFF, 0x6A, 0x48, 0x0D, 0x1B, 0xC2, 0xFC, 0xD2, 0xBA,
+ 0xB1, 0x08, 0x80, 0xED, 0x7F, 0x9B, 0xFF, 0xB1, 0x25, 0xB8, 0x02, 0x6B, 0xDF, 0x45, 0x90, 0x49,
+ 0xF0, 0x24, 0x34, 0xB0, 0x68, 0xA4, 0x91, 0xCD, 0x4D, 0x43, 0xB8, 0xA4, 0x72, 0x8D, 0x35, 0x51,
+ 0xD3, 0x6D, 0x88, 0x53, 0x50, 0x5B, 0xAC, 0x04, 0xBF, 0x3E, 0x24, 0x7A, 0x15, 0x5B, 0x17, 0x00,
+ 0xC9, 0x3D, 0xCA, 0x0C, 0x3D, 0x22, 0x97, 0x52, 0xCB, 0x0C, 0x02, 0x42, 0xA7, 0x89, 0xE7, 0x2A,
+ 0xAD, 0x1D, 0x14, 0x30, 0x17, 0xA2, 0xE0, 0xBC, 0x1C, 0x2D, 0x15, 0xEA, 0xAA, 0xFD, 0x17, 0x0A,
+ 0xA3, 0xD6, 0x12, 0x8A, 0x04, 0x31, 0xAD, 0xD8, 0x79, 0xC6, 0x72, 0x75, 0x4C, 0x59, 0xBA, 0x35,
+ 0x59, 0x5D, 0x96, 0xAD, 0x04, 0xAE, 0x2F, 0x8D, 0xFE, 0xD7, 0x3D, 0x16, 0x8E, 0xB5, 0x12, 0x3F,
+ 0xF8, 0x97, 0xFB, 0x2B, 0x46, 0xE4, 0xCD, 0x3F, 0xBC, 0x21, 0x70, 0x05, 0xA6, 0x41, 0x6D, 0x1E,
+ 0x4D, 0x0D, 0xB3, 0xF6, 0xAB, 0xAE, 0x49, 0x8A, 0xAE, 0x1E, 0x92, 0xFB, 0xBC, 0xA7, 0xC4, 0x8C,
+ 0xD7, 0xD6, 0x70, 0x5E, 0xB4, 0x28, 0xF9, 0x82, 0xEC, 0xE6, 0x48, 0x26, 0xA2, 0xB6, 0x56, 0x64,
+ 0x52, 0xD5, 0xCA, 0xE8, 0x5A, 0x63, 0xFF, 0xD7, 0x4A, 0x40, 0xB7, 0x98, 0xBA, 0x4E, 0x15, 0x8C,
+ 0xB3, 0x00, 0x1C, 0x93, 0x3E, 0x1D, 0x69, 0x03, 0x26, 0x03, 0x75, 0x35, 0x46, 0x5A, 0x81, 0xC1,
+ 0xCC, 0x03, 0xC3, 0x2B, 0xFB, 0xF3, 0x1E, 0x16, 0xBF, 0xFB, 0x97, 0xAA, 0xAA, 0x81, 0xD4, 0x8B,
+ 0x33, 0x5D, 0x59, 0x59, 0xD5, 0x4B, 0xE0, 0xD2, 0x08, 0xA0, 0x5B, 0x8B, 0x3C, 0x3A, 0x8C, 0xFC,
+ 0x87, 0x52, 0xF6, 0x4D, 0xBB, 0x0F, 0x87, 0x01, 0x49, 0xD3, 0x73, 0xB8, 0x01, 0x43, 0xF7, 0x42,
+ 0x50, 0xB8, 0xB2, 0xC2, 0xFD, 0xE6, 0xE6, 0x66, 0x15, 0x29, 0xA1, 0x21, 0x14, 0xDB, 0x8A, 0x2B,
+ 0xF0, 0x49, 0xD3, 0xF1, 0x81, 0x30, 0x18, 0xD2, 0x1A, 0xC6, 0xF0, 0x25, 0xE3, 0x47, 0x5C, 0x71,
+ 0xF4, 0xF4, 0x22, 0xA6, 0xFC, 0x33, 0xDC, 0x95, 0x32, 0xCB, 0x1A, 0xAD, 0xA6, 0x68, 0xFA, 0x8F,
+ 0xD8, 0x3E, 0xCA, 0x0D, 0x76, 0xC1, 0x7A, 0xBA, 0x56, 0xA1, 0xFC, 0x9F, 0x61, 0xB9, 0x94, 0x28,
+ 0xD6, 0x70, 0x9C, 0x40, 0x80, 0x5A, 0xC3, 0x31, 0xC4, 0x1A, 0x41, 0x17, 0xFC, 0x26, 0x6B, 0xF9,
+ 0xCD, 0xFE, 0x19, 0x7E, 0x97, 0x76, 0x1E, 0x15, 0x25, 0x91, 0xAA, 0xAF, 0x50, 0x02, 0x9F, 0xDD,
+ 0xE9, 0xA6, 0x15, 0xB9, 0x55, 0x0A, 0x50, 0x1B, 0x46, 0x41, 0xD0, 0x8F, 0xE2, 0x83, 0x27, 0xD6,
+ 0x9D, 0xC5, 0x7A, 0x31, 0xC8, 0xD9, 0x5C, 0x6E, 0xB1, 0xBC, 0xB5, 0x44, 0x4F, 0xA1, 0xEC, 0x5F,
+ 0x4B, 0x15, 0x01, 0x3F, 0x23, 0x8B, 0x7B, 0xAC, 0xD4, 0xA5, 0x36, 0x28, 0x0F, 0x56, 0x3F, 0xD5,
+ 0x3C, 0xCB, 0x5F, 0xCC, 0xAE, 0x6B, 0x51, 0x9B, 0xC0, 0x38, 0x57, 0x92, 0x8B, 0x4A, 0xB2, 0xC8,
+ 0x13, 0x01, 0xA8, 0x58, 0xC7, 0x2E, 0xC4, 0x4D, 0x6B, 0x7A, 0x7C, 0xBF, 0x5C, 0x83, 0xC2, 0xDF,
+ 0xF5, 0xD5, 0x12, 0x33, 0x08, 0xC4, 0xD3, 0x95, 0x4B, 0x29, 0x5F, 0x37, 0x29, 0x8A, 0x0E, 0x62,
+ 0x47, 0xA3, 0x51, 0x4A, 0xC5, 0x47, 0x0C, 0x49, 0x56, 0xB2, 0x98, 0x9F, 0xC8, 0x90, 0x04, 0x8C,
+ 0x45, 0x3C, 0x8C, 0xB2, 0x94, 0x46, 0x99, 0xA8, 0xA4, 0x16, 0x63, 0x21, 0xCC, 0x5E, 0xFA, 0xE7,
+ 0x9F, 0x8B, 0xC9, 0x7E, 0x5A, 0x0B, 0x96, 0xD3, 0xEB, 0x3D, 0xBF, 0x34, 0xD9, 0xF7, 0x6B, 0x89,
+ 0xB9, 0x7A, 0xE9, 0xFF, 0x67, 0x4B, 0x21, 0x65, 0x4B, 0xF1, 0xB0, 0x54, 0x2E, 0x62, 0x62, 0x29,
+ 0xE6, 0xC9, 0x82, 0x91, 0x97, 0x7C, 0x16, 0x0D, 0x1A, 0x2B, 0x25, 0x55, 0x9E, 0x97, 0x7D, 0x95,
+ 0x43, 0x40, 0x59, 0x71, 0xE5, 0x35, 0x11, 0x06, 0x34, 0xE0, 0x63, 0x64, 0xF2, 0x41, 0xEB, 0xA7,
+ 0xD1, 0x94, 0x26, 0x87, 0x24, 0xA5, 0x06, 0x24, 0xCD, 0x65, 0xDC, 0x41, 0xA8, 0xE9, 0x04, 0xEB,
+ 0x76, 0x6D, 0x6E, 0x12, 0x05, 0xCE, 0x33, 0x77, 0xC4, 0xB1, 0x26, 0x03, 0xF9, 0xB2, 0xCA, 0x09,
+ 0xD4, 0xC6, 0xBE, 0x12, 0xA4, 0x3E, 0x52, 0x25, 0xA8, 0x61, 0x5A, 0xD0, 0x76, 0xC0, 0x35, 0x5F,
+ 0x26, 0x51, 0x4C, 0xC6, 0xB2, 0x07, 0x83, 0x35, 0x74, 0x0F, 0xA4, 0x66, 0x6D, 0x34, 0x91, 0x60,
+ 0xA9, 0x73, 0x29, 0xFC, 0x66, 0xD9, 0xC2, 0x70, 0x4B, 0x57, 0xC9, 0xB0, 0xBD, 0xF4, 0xA5, 0x35,
+ 0x59, 0x83, 0xE0, 0x0B, 0x6C, 0x62, 0xE0, 0x1E, 0x68, 0x64, 0xF2, 0x7B, 0x00, 0x77, 0x6B, 0xB6,
+ 0xA3, 0x3D, 0xD6, 0x8E, 0x6A, 0x35, 0x53, 0x55, 0xE9, 0xAE, 0x0B, 0x6D, 0x4E, 0x74, 0x23, 0x0B,
+ 0x4B, 0x10, 0xAA, 0x9A, 0x59, 0x0C, 0x38, 0x1B, 0x81, 0xAA, 0xBA, 0xC0, 0x11, 0xD6, 0x98, 0x66,
+ 0xA9, 0x23, 0xF1, 0x97, 0x1D, 0xC9, 0x13, 0xB5, 0x07, 0x95, 0xF5, 0x05, 0xD4, 0x31, 0xAB, 0x25,
+ 0x86, 0x30, 0xD3, 0x29, 0x13, 0xDE, 0x04, 0x03, 0x90, 0x07, 0x5A, 0xD5, 0x05, 0x14, 0xB5, 0x8E,
+ 0x1C, 0x4D, 0x44, 0xB8, 0x1C, 0x05, 0xF9, 0xF0, 0x6B, 0x9A, 0x0F, 0xBC, 0xB4, 0x18, 0xDD, 0x97,
+ 0x80, 0x50, 0xD2, 0xE6, 0xE0, 0x88, 0x8F, 0xF2, 0x21, 0xF4, 0xB2, 0x05, 0x9D, 0x02, 0x58, 0xFC,
+ 0xC6, 0x71, 0x3E, 0x8A, 0x27, 0xC5, 0x68, 0x42, 0xEF, 0x17, 0x78, 0x51, 0x01, 0xF5, 0xA9, 0xEE,
+ 0x28, 0x1B, 0xDB, 0x68, 0xCE, 0xF3, 0x41, 0x6B, 0x29, 0x7F, 0xF0, 0xFF, 0x28, 0x7F, 0xCC, 0xC7,
+ 0x85, 0x34, 0x71, 0x31, 0x1A, 0xB3, 0x42, 0x96, 0x61, 0x18, 0xFF, 0x90, 0x93, 0xA4, 0xD4, 0x13,
+ 0x97, 0x7A, 0x5A, 0xF1, 0xB3, 0xB6, 0x53, 0x98, 0x8E, 0x31, 0xAA, 0xF8, 0xE3, 0xC8, 0xF6, 0xF0,
+ 0xF7, 0x3C, 0xF2, 0x65, 0x6D, 0x69, 0x5A, 0xA1, 0x31, 0x82, 0x3A, 0x57, 0x37, 0xCB, 0x7E, 0x9A,
+ 0xFD, 0xB7, 0xAD, 0xE8, 0xD1, 0xF1, 0xE9, 0x71, 0xFF, 0xB8, 0x5C, 0x38, 0x23, 0xE7, 0x25, 0x93,
+ 0x8A, 0x2B, 0x5D, 0xFA, 0xB2, 0x22, 0x80, 0x02, 0x1B, 0x45, 0x01, 0x7B, 0xDD, 0xDC, 0x54, 0x7E,
+ 0xF1, 0xB6, 0x77, 0x71, 0x6E, 0xC7, 0x24, 0x01, 0x8F, 0x24, 0x15, 0xE6, 0xC2, 0x82, 0x44, 0xF9,
+ 0xE0, 0xD7, 0xC7, 0xA5, 0x72, 0x5D, 0x7E, 0x61, 0x70, 0xC4, 0xDC, 0x52, 0xA7, 0xA9, 0x7E, 0x78,
+ 0xE2, 0x62, 0x5D, 0x99, 0xBF, 0x04, 0x41, 0x72, 0x1A, 0x2D, 0x13, 0x55, 0x11, 0x67, 0x46, 0xE5,
+ 0x30, 0x2F, 0xEE, 0xB2, 0x75, 0x0D, 0xD3, 0xC8, 0xB4, 0xC4, 0x84, 0xA5, 0xE5, 0x46, 0xA5, 0x12,
+ 0x14, 0xFE, 0xA2, 0xB6, 0xE7, 0x8B, 0x91, 0x24, 0xB7, 0x5A, 0x73, 0xAB, 0x6F, 0x41, 0x2A, 0x3E,
+ 0x58, 0x04, 0x23, 0x66, 0x39, 0xDB, 0x16, 0x77, 0xA3, 0x43, 0xEE, 0x61, 0x5C, 0x7F, 0xBA, 0x35,
+ 0x78, 0xD2, 0x3C, 0x79, 0x61, 0x9E, 0xFC, 0xB1, 0x7B, 0x2E, 0x1C, 0x45, 0xF9, 0xDA, 0xE2, 0x98,
+ 0xF6, 0x10, 0x58, 0xBB, 0x6D, 0x2F, 0x7D, 0x18, 0x20, 0xD2, 0x83, 0xCB, 0x00, 0xF4, 0x63, 0x58,
+ 0xFF, 0x4A, 0xEE, 0x88, 0x7A, 0x09, 0xAA, 0xA2, 0xAD, 0x73, 0x54, 0xD8, 0xEE, 0xFD, 0x81, 0xA3,
+ 0xF2, 0xCE, 0x65, 0x18, 0x48, 0x97, 0xC3, 0x92, 0x37, 0x8B, 0x75, 0xC1, 0x61, 0x19, 0x31, 0x64,
+ 0x6C, 0x00, 0xE3, 0xCD, 0x5D, 0x49, 0x13, 0xD5, 0x1C, 0xB4, 0xF0, 0x1B, 0x08, 0x8A, 0x4F, 0x39,
+ 0xCE, 0x9A, 0x38, 0xAD, 0x62, 0x72, 0xC5, 0x23, 0xC8, 0x4A, 0x67, 0x89, 0xC0, 0x6E, 0x10, 0x0D,
+ 0x0D, 0x7C, 0x64, 0x9A, 0xA1, 0xB6, 0x1D, 0x3E, 0x37, 0xD7, 0xBC, 0xD9, 0x54, 0xFA, 0x4B, 0x62,
+ 0x79, 0xD5, 0xB0, 0x8B, 0x1C, 0x56, 0xCC, 0x75, 0x7D, 0x1F, 0xF4, 0xA3, 0x4E, 0x29, 0xAF, 0x48,
+ 0xA4, 0x53, 0xD1, 0x83, 0xC4, 0x86, 0xA2, 0x41, 0xBE, 0x91, 0x40, 0x44, 0x72, 0x4A, 0x33, 0x5D,
+ 0xC7, 0xCA, 0xD2, 0x0B, 0x28, 0x49, 0x7A, 0xB2, 0x73, 0x95, 0x49, 0x6B, 0x25, 0x06, 0xFE, 0xC8,
+ 0xD7, 0xF0, 0xC7, 0xA1, 0xD0, 0xA3, 0x83, 0x9B, 0x49, 0x2B, 0x83, 0xA4, 0x23, 0x64, 0x83, 0xA9,
+ 0x37, 0xE4, 0xBB, 0xA8, 0x2D, 0x2F, 0xCB, 0xB4, 0x16, 0x50, 0x70, 0x71, 0x83, 0xBB, 0x11, 0x30,
+ 0x52, 0x5A, 0xC4, 0x9E, 0x94, 0xA8, 0xC7, 0x8F, 0x10, 0x1F, 0x53, 0x4A, 0x20, 0x06, 0x20, 0xA6,
+ 0x40, 0xD0, 0xA7, 0x42, 0x8A, 0x54, 0xE6, 0x92, 0x53, 0x2A, 0x20, 0xCA, 0x48, 0xCD, 0xE2, 0xC1,
+ 0x85, 0x78, 0xD4, 0x46, 0xD6, 0x80, 0xFD, 0xDC, 0xBD, 0x73, 0x33, 0xDE, 0x90, 0x68, 0x09, 0x56,
+ 0x36, 0x3D, 0x9A, 0xA6, 0x52, 0x5C, 0x54, 0xC7, 0x19, 0xF8, 0xA8, 0xA1, 0x03, 0x5A, 0x23, 0x84,
+ 0x11, 0x1E, 0x84, 0x8A, 0x01, 0x40, 0x7F, 0x42, 0xC3, 0x1C, 0x22, 0x70, 0x08, 0x20, 0x82, 0xA0,
+ 0x7F, 0x49, 0x0D, 0xF7, 0x64, 0x05, 0xC9, 0xF8, 0xD8, 0x6D, 0x35, 0xF0, 0x9D, 0x66, 0x95, 0xEC,
+ 0x20, 0xA5, 0xBD, 0x68, 0x24, 0xFA, 0x64, 0x98, 0x1A, 0x50, 0x00, 0xAC, 0xD9, 0x01, 0xA0, 0x1E,
+ 0x24, 0x5E, 0x63, 0x2B, 0x3F, 0xEF, 0x04, 0x2A, 0xBB, 0x00, 0xAB, 0xBB, 0x8E, 0x87, 0x5F, 0x39,
+ 0x4F, 0x19, 0xA7, 0x39, 0x26, 0x00, 0x7B, 0x93, 0x68, 0x7A, 0x99, 0x30, 0x2E, 0xCE, 0x64, 0x1B,
+ 0x6A, 0x6C, 0xB4, 0xE4, 0xF5, 0xA9, 0x87, 0x15, 0x79, 0x3F, 0xC5, 0x8B, 0xCB, 0x0C, 0xF3, 0xBA,
+ 0x53, 0x79, 0x77, 0xB1, 0x86, 0x70, 0x21, 0x50, 0x66, 0x38, 0xB3, 0x29, 0x74, 0xB0, 0xFA, 0xA1,
+ 0x48, 0x82, 0x7A, 0x4F, 0xB7, 0x42, 0xE2, 0xC1, 0x44, 0xED, 0x81, 0xF9, 0xDC, 0xC2, 0xD8, 0xE1,
+ 0x94, 0x83, 0x5A, 0x0A, 0xB5, 0x02, 0x45, 0xC6, 0x95, 0xCD, 0x98, 0x35, 0x1D, 0x6A, 0x58, 0x88,
+ 0x61, 0xE0, 0xAF, 0xFE, 0x05, 0x0F, 0x1E, 0x1C, 0xC8, 0x55, 0x3F, 0xE1, 0x23, 0xE3, 0x7E, 0xF4,
+ 0x23, 0x3E, 0x3E, 0xAF, 0xF0, 0xF1, 0x79, 0x1D, 0x1F, 0xB4, 0xAA, 0x3C, 0x98, 0x0C, 0x80, 0xEC,
+ 0x19, 0xE1, 0x64, 0x4C, 0x13, 0x58, 0xC0, 0x43, 0x50, 0x25, 0x7F, 0x8B, 0xB3, 0x84, 0xFE, 0x98,
+ 0xB3, 0xDE, 0x84, 0x8D, 0xC4, 0x23, 0xFE, 0x8A, 0xD5, 0xFF, 0x82, 0x4B, 0x3C, 0x70, 0x3D, 0x97,
+ 0x79, 0x6D, 0x5A, 0x49, 0x28, 0x3F, 0x7E, 0x2B, 0x91, 0x7E, 0xE4, 0x42, 0x78, 0xA9, 0x38, 0xC8,
+ 0xDF, 0xB7, 0xF4, 0x00, 0xBC, 0x11, 0xF8, 0x29, 0x35, 0x75, 0xBC, 0x0B, 0xA5, 0xFC, 0x29, 0x30,
+ 0x64, 0xA8, 0xC0, 0x47, 0xDD, 0xD9, 0xDC, 0x12, 0xAE, 0x01, 0x8A, 0xF1, 0xA3, 0x29, 0xB0, 0xEA,
+ 0xC9, 0x02, 0xD7, 0x9E, 0x40, 0x26, 0x04, 0x91, 0xE0, 0x48, 0xC8, 0xA7, 0x8D, 0x2F, 0x07, 0x9B,
+ 0x37, 0x35, 0xC8, 0x43, 0x2E, 0xFC, 0x98, 0x2E, 0x0C, 0x36, 0x6F, 0xFE, 0x6D, 0x36, 0xC6, 0xCC,
+ 0x5A, 0x76, 0xA4, 0x96, 0x4C, 0xF6, 0xF4, 0x0B, 0xBF, 0x71, 0x09, 0x48, 0x5D, 0x49, 0x78, 0x45,
+ 0x34, 0x03, 0x6B, 0x43, 0x61, 0xE1, 0x07, 0xFF, 0x47, 0x09, 0xF8, 0x91, 0x9E, 0x07, 0xCE, 0xBD,
+ 0xE6, 0x3D, 0x5E, 0x2F, 0x3E, 0x85, 0xE9, 0x56, 0xE9, 0xC1, 0x4A, 0xC7, 0xEF, 0x53, 0x3A, 0x76,
+ 0x59, 0xA2, 0x14, 0x4A, 0x14, 0x59, 0x88, 0x1A, 0x6A, 0x50, 0x0E, 0x51, 0x98, 0x89, 0x17, 0xCD,
+ 0x81, 0x02, 0x9B, 0x73, 0x34, 0x5B, 0x3A, 0x02, 0x0F, 0xF4, 0xF5, 0x45, 0xEE, 0xFC, 0x74, 0x76,
+ 0x7A, 0x22, 0x44, 0x7C, 0xA5, 0x62, 0x22, 0xD0, 0xAA, 0x2E, 0x2C, 0x2F, 0xCF, 0x9C, 0x89, 0xE4,
+ 0xA1, 0x28, 0x75, 0x30, 0x31, 0x28, 0x87, 0xFE, 0x74, 0x31, 0xFC, 0x0A, 0x71, 0xD6, 0xD0, 0xCF,
+ 0x52, 0x48, 0x58, 0x5B, 0x36, 0xA2, 0xF7, 0xFB, 0x97, 0xF6, 0xAE, 0xDD, 0x84, 0xBA, 0x00, 0xB4,
+ 0x0A, 0x69, 0x19, 0xEE, 0x7D, 0xFE, 0xB7, 0x90, 0xB7, 0xFF, 0x1E, 0x32, 0x83, 0xA8, 0x95, 0x42,
+ 0x58, 0x2A, 0xF0, 0xAB, 0xB8, 0x93, 0x24, 0x9A, 0x4A, 0xB4, 0xE3, 0x24, 0xC1, 0x4B, 0xE9, 0x43,
+ 0x85, 0xA2, 0x0D, 0x61, 0x31, 0xA5, 0x89, 0xE6, 0x47, 0x34, 0xD5, 0x78, 0x24, 0xB4, 0x34, 0x8B,
+ 0x63, 0x68, 0x5C, 0x56, 0xF4, 0x61, 0xEB, 0xC5, 0xEB, 0xCB, 0xFB, 0x8C, 0x66, 0xD4, 0xCF, 0x97,
+ 0x69, 0x52, 0xD1, 0x0B, 0x56, 0x50, 0xDF, 0x10, 0xEE, 0x7E, 0xB9, 0xC9, 0xEB, 0xA9, 0x8C, 0x73,
+ 0x8C, 0xA2, 0x1B, 0x2D, 0x35, 0x07, 0xE9, 0x26, 0x40, 0xD5, 0xE5, 0x59, 0x10, 0xCC, 0xDB, 0x2B,
+ 0xB4, 0xA0, 0xF1, 0x8A, 0x44, 0x24, 0x9F, 0xCB, 0x67, 0x7F, 0xE4, 0xC9, 0xA9, 0xE2, 0x82, 0x50,
+ 0xF2, 0x54, 0xA9, 0x36, 0xAD, 0x0D, 0x63, 0x83, 0x6A, 0x8C, 0xA7, 0x82, 0x70, 0x0F, 0xAF, 0x51,
+ 0xE9, 0xC2, 0x2C, 0x6A, 0x29, 0xDC, 0xDE, 0x46, 0x5F, 0xCB, 0x6D, 0xE9, 0x89, 0x7C, 0x2A, 0x25,
+ 0xE3, 0xAE, 0xAE, 0x63, 0x55, 0x45, 0xB1, 0x3E, 0x25, 0x61, 0x5A, 0x26, 0x5B, 0x54, 0x06, 0x26,
+ 0x77, 0x0B, 0x70, 0x9B, 0x06, 0x29, 0x1C, 0xBD, 0x7E, 0x7F, 0xCE, 0x46, 0xD1, 0xCE, 0x11, 0x80,
+ 0x69, 0xC5, 0x3E, 0x93, 0xD7, 0xE0, 0x24, 0xCC, 0x73, 0x07, 0x32, 0xE9, 0x4A, 0x03, 0x0E, 0xA9,
+ 0x98, 0x44, 0xFE, 0x81, 0x7E, 0xA0, 0x3B, 0x3A, 0xFC, 0xBB, 0x09, 0x35, 0x47, 0xCD, 0xA5, 0xD0,
+ 0xA4, 0xFA, 0x74, 0x70, 0xF5, 0x06, 0xC2, 0x53, 0x0C, 0xA5, 0x01, 0x17, 0x50, 0x34, 0xD7, 0x74,
+ 0x7C, 0x7A, 0x7D, 0x0C, 0x29, 0xC8, 0x7F, 0x21, 0x37, 0x66, 0xBB, 0xAA, 0x6C, 0xB8, 0xF3, 0xEA,
+ 0x75, 0x56, 0x2E, 0x03, 0x7A, 0x61, 0x8C, 0x58, 0x0F, 0x29, 0x7E, 0xFB, 0x7B, 0xF4, 0x9E, 0x8D,
+ 0x15, 0xD2, 0x6A, 0x5D, 0x6F, 0xCE, 0x76, 0x90, 0x67, 0x89, 0xD5, 0x43, 0x2C, 0x70, 0x97, 0x1F,
+ 0x29, 0x59, 0x95, 0x35, 0xDC, 0xF6, 0x48, 0x10, 0xE0, 0xC7, 0x5A, 0x03, 0x1B, 0x6A, 0x22, 0xB2,
+ 0xD4, 0x42, 0x22, 0x29, 0x08, 0x90, 0xD2, 0x3E, 0x84, 0x39, 0xD3, 0x92, 0x65, 0x86, 0xB2, 0xA1,
+ 0xBC, 0xFF, 0xC5, 0x9A, 0xA3, 0x64, 0x46, 0xE8, 0xCE, 0xF9, 0x6C, 0x73, 0x53, 0xD8, 0x85, 0x99,
+ 0x18, 0x05, 0x52, 0x8A, 0x01, 0x1C, 0x9A, 0x7D, 0x68, 0x2D, 0x8C, 0xB2, 0x90, 0x58, 0xAB, 0x3D,
+ 0xD2, 0xB6, 0x51, 0x55, 0x03, 0x54, 0x7C, 0x46, 0x01, 0x03, 0xCE, 0xB2, 0x24, 0x80, 0xA8, 0x8B,
+ 0x39, 0xBA, 0xB2, 0x2D, 0xC5, 0xBA, 0xD0, 0x84, 0x0E, 0xEC, 0x67, 0xC8, 0x12, 0x95, 0x97, 0xAD,
+ 0xA2, 0x27, 0x12, 0xC5, 0x77, 0x95, 0x9E, 0xC8, 0x6F, 0xE5, 0x84, 0xAA, 0xC8, 0x77, 0x88, 0x2F,
+ 0x13, 0x5C, 0xD4, 0xD1, 0x13, 0xA0, 0x24, 0x83, 0x52, 0x34, 0x60, 0x2A, 0x2C, 0x37, 0xEE, 0xEB,
+ 0xD3, 0xE9, 0xB4, 0x8E, 0xDF, 0x6A, 0xEB, 0x70, 0x82, 0xB2, 0x02, 0x5F, 0x5F, 0xC7, 0x21, 0x47,
+ 0x15, 0x58, 0xF8, 0x6E, 0xE1, 0xAC, 0xBA, 0xE8, 0x42, 0x7F, 0x2B, 0xDE, 0xD4, 0xAA, 0xD2, 0x59,
+ 0xE1, 0x73, 0x79, 0xDB, 0x7B, 0x3B, 0x2B, 0x20, 0x32, 0xC4, 0xAF, 0xB2, 0x90, 0x69, 0x20, 0x0D,
+ 0x3B, 0xE5, 0x46, 0x56, 0x25, 0x85, 0x65, 0x5C, 0xB0, 0xE3, 0x2C, 0x9D, 0x18, 0x33, 0x60, 0xDD,
+ 0x11, 0x96, 0xD2, 0x95, 0x43, 0x2D, 0x65, 0xB7, 0x0E, 0xB7, 0x0A, 0xFB, 0x70, 0x30, 0x83, 0x94,
+ 0x79, 0xFB, 0xF3, 0x4F, 0x39, 0x5B, 0xDE, 0xF6, 0x92, 0x62, 0x71, 0xE1, 0xF3, 0xFC, 0xA9, 0x35,
+ 0xAF, 0x69, 0xA5, 0xD1, 0xAF, 0xC4, 0x97, 0xBD, 0x46, 0xFE, 0x19, 0x3B, 0xFF, 0x9C, 0xAD, 0x81,
+ 0xB1, 0x43, 0x23, 0x2A, 0xDC, 0x4C, 0x8C, 0xEA, 0x2F, 0x34, 0xE6, 0x63, 0x79, 0x29, 0xBF, 0x2D,
+ 0xA0, 0x54, 0xA9, 0xD3, 0x68, 0x78, 0x3E, 0xFF, 0x9A, 0x42, 0x19, 0x1D, 0x65, 0xFE, 0x28, 0x20,
+ 0x09, 0xC5, 0x82, 0xA3, 0x41, 0xBE, 0x92, 0xFB, 0x46, 0xC0, 0x86, 0x69, 0x03, 0x93, 0x6D, 0xCB,
+ 0xDE, 0xB2, 0x77, 0x71, 0x64, 0x7F, 0x4D, 0xF7, 0x57, 0x4F, 0xD8, 0x5F, 0x34, 0x69, 0x58, 0x0B,
+ 0xE7, 0xB5, 0xAB, 0x8A, 0x4D, 0x6A, 0x83, 0xFB, 0xC4, 0xA7, 0x70, 0x3D, 0x6F, 0xB3, 0xCC, 0xB6,
+ 0x1A, 0xE4, 0x5F, 0x60, 0xD4, 0x31, 0xBA, 0x95, 0x2F, 0x92, 0xF4, 0x81, 0x7B, 0x18, 0x5B, 0x17,
+ 0x54, 0x26, 0x70, 0x49, 0xD5, 0x87, 0x34, 0xB9, 0xD3, 0x9C, 0x2F, 0x39, 0xC3, 0xB7, 0x3C, 0xA8,
+ 0x03, 0xE4, 0x37, 0x9C, 0x72, 0x39, 0xB0, 0xBF, 0x07, 0x5D, 0x33, 0x2A, 0x41, 0x79, 0xB1, 0x26,
+ 0x9B, 0xE6, 0x7C, 0x02, 0x82, 0x01, 0x70, 0xB1, 0xA3, 0x48, 0xCD, 0x2B, 0xCB, 0x98, 0x9B, 0x57,
+ 0x96, 0x54, 0xE2, 0x5F, 0x59, 0xCC, 0xDB, 0x9F, 0xFC, 0xDB, 0x4C, 0xF9, 0x7F, 0x5B, 0x28, 0x36,
+ 0x32, 0xF9, 0xE1, 0x09, 0xF7, 0x56, 0x3F, 0x45, 0xAD, 0x47, 0x51, 0xBB, 0xF7, 0xFF, 0x17, 0x53,
+ 0xE8, 0x9D, 0x36, 0x92, 0x29, 0x00, 0x00
+};
+
+#define SPIFFS_MAXLENGTH_FILEPATH 32
+const char *excludeListFile = "/.exclude.files";
+
+typedef struct ExcludeListS {
+    char *item;
+    ExcludeListS *next;
+} ExcludeList;
+
+static ExcludeList *excludes = NULL;
+
+static bool matchWild(const char *pattern, const char *testee) {
+  const char *nxPat = NULL, *nxTst = NULL;
+
+  while (*testee) {
+    if (( *pattern == '?' ) || (*pattern == *testee)){
+      pattern++;testee++;
+      continue;
+    }
+    if (*pattern=='*'){
+      nxPat=pattern++; nxTst=testee;
+      continue;
+    }
+    if (nxPat){ 
+      pattern = nxPat+1; testee=++nxTst;
+      continue;
+    }
+    return false;
+  }
+  while (*pattern=='*'){pattern++;}  
+  return (*pattern == 0);
+}
+
+static bool addExclude(const char *item){
+    size_t len = strlen(item);
+    if(!len){
+        return false;
+    }
+    ExcludeList *e = (ExcludeList *)malloc(sizeof(ExcludeList));
+    if(!e){
+        return false;
+    }
+    e->item = (char *)malloc(len+1);
+    if(!e->item){
+        free(e);
+        return false;
+    }
+    memcpy(e->item, item, len+1);
+    e->next = excludes;
+    excludes = e;
+    return true;
+}
+
+static void loadExcludeList(fs::FS &_fs, const char *filename){
+    static char linebuf[SPIFFS_MAXLENGTH_FILEPATH];
+    fs::File excludeFile=_fs.open(filename, "r");
+    if(!excludeFile){
+        //addExclude("/*.js.gz");
+        return;
+    }
+#ifdef ESP32
+    if(excludeFile.isDirectory()){
+      excludeFile.close();
+      return;
+    }
+#endif
+    if (excludeFile.size() > 0){
+      uint8_t idx;
+      bool isOverflowed = false;
+      while (excludeFile.available()){
+        linebuf[0] = '\0';
+        idx = 0;
+        int lastChar;
+        do {
+          lastChar = excludeFile.read();
+          if(lastChar != '\r'){
+            linebuf[idx++] = (char) lastChar;
+          }
+        } while ((lastChar >= 0) && (lastChar != '\n') && (idx < SPIFFS_MAXLENGTH_FILEPATH));
+
+        if(isOverflowed){
+          isOverflowed = (lastChar != '\n');
+          continue;
+        }
+        isOverflowed = (idx >= SPIFFS_MAXLENGTH_FILEPATH);
+        linebuf[idx-1] = '\0';
+        if(!addExclude(linebuf)){
+            excludeFile.close();
+            return;
+        }
+      }
+    }
+    excludeFile.close();
+}
+
+static bool isExcluded(fs::FS &_fs, const char *filename) {
+  if(excludes == NULL){
+      loadExcludeList(_fs, excludeListFile);
+  }
+  ExcludeList *e = excludes;
+  while(e){
+    if (matchWild(e->item, filename)){
+      return true;
+    }
+    e = e->next;
+  }
+  return false;
+}
+
+// WEB HANDLER IMPLEMENTATION
+
+#ifdef ESP32
+SPIFFSEditor::SPIFFSEditor(const fs::FS& fs, const String& username, const String& password)
+#else
+SPIFFSEditor::SPIFFSEditor(const String& username, const String& password, const fs::FS& fs)
+#endif
+:_fs(fs)
+,_username(username)
+,_password(password)
+,_authenticated(false)
+,_startTime(0)
+{}
+
+bool SPIFFSEditor::canHandle(AsyncWebServerRequest *request){
+  if(request->url().equalsIgnoreCase("/edit")){
+    if(request->method() == HTTP_GET){
+      if(request->hasParam("list"))
+        return true;
+      if(request->hasParam("edit")){
+        request->_tempFile = _fs.open(request->arg("edit"), "r");
+        if(!request->_tempFile){
+          return false;
+        }
+#ifdef ESP32
+        if(request->_tempFile.isDirectory()){
+          request->_tempFile.close();
+          return false;
+        }
+#endif
+      }
+      if(request->hasParam("download")){
+        request->_tempFile = _fs.open(request->arg("download"), "r");
+        if(!request->_tempFile){
+          return false;
+        }
+#ifdef ESP32
+        if(request->_tempFile.isDirectory()){
+          request->_tempFile.close();
+          return false;
+        }
+#endif
+      }
+      request->addInterestingHeader("If-Modified-Since");
+      return true;
+    }
+    else if(request->method() == HTTP_POST)
+      return true;
+    else if(request->method() == HTTP_DELETE)
+      return true;
+    else if(request->method() == HTTP_PUT)
+      return true;
+
+  }
+  return false;
+}
+
+
+void SPIFFSEditor::handleRequest(AsyncWebServerRequest *request){
+  if(_username.length() && _password.length() && !request->authenticate(_username.c_str(), _password.c_str()))
+    return request->requestAuthentication();
+
+  if(request->method() == HTTP_GET){
+    if(request->hasParam("list")){
+      String path = request->getParam("list")->value();
+#ifdef ESP32
+      File dir = _fs.open(path);
+#else
+      Dir dir = _fs.openDir(path);
+#endif
+      path = String();
+      String output = "[";
+#ifdef ESP32
+      File entry = dir.openNextFile();
+      while(entry){
+#else
+      while(dir.next()){
+        fs::File entry = dir.openFile("r");
+#endif
+        if (isExcluded(_fs, entry.name())) {
+#ifdef ESP32
+            entry = dir.openNextFile();
+#endif
+            continue;
+        }
+        if (output != "[") output += ',';
+        output += "{\"type\":\"";
+        output += "file";
+        output += "\",\"name\":\"";
+        output += String(entry.name());
+        output += "\",\"size\":";
+        output += String(entry.size());
+        output += "}";
+#ifdef ESP32
+        entry = dir.openNextFile();
+#else
+        entry.close();
+#endif
+      }
+#ifdef ESP32
+      dir.close();
+#endif
+      output += "]";
+      request->send(200, "application/json", output);
+      output = String();
+    }
+    else if(request->hasParam("edit") || request->hasParam("download")){
+      request->send(request->_tempFile, request->_tempFile.name(), String(), request->hasParam("download"));
+    }
+    else {
+      const char * buildTime = __DATE__ " " __TIME__ " GMT";
+      if (request->header("If-Modified-Since").equals(buildTime)) {
+        request->send(304);
+      } else {
+        AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", edit_htm_gz, edit_htm_gz_len);
+        response->addHeader("Content-Encoding", "gzip");
+        response->addHeader("Last-Modified", buildTime);
+        request->send(response);
+      }
+    }
+  } else if(request->method() == HTTP_DELETE){
+    if(request->hasParam("path", true)){
+        _fs.remove(request->getParam("path", true)->value());
+      request->send(200, "", "DELETE: "+request->getParam("path", true)->value());
+    } else
+      request->send(404);
+  } else if(request->method() == HTTP_POST){
+    if(request->hasParam("data", true, true) && _fs.exists(request->getParam("data", true, true)->value()))
+      request->send(200, "", "UPLOADED: "+request->getParam("data", true, true)->value());
+    else
+      request->send(500);
+  } else if(request->method() == HTTP_PUT){
+    if(request->hasParam("path", true)){
+      String filename = request->getParam("path", true)->value();
+      if(_fs.exists(filename)){
+        request->send(200);
+      } else {
+        fs::File f = _fs.open(filename, "w");
+        if(f){
+          f.write((uint8_t)0x00);
+          f.close();
+          request->send(200, "", "CREATE: "+filename);
+        } else {
+          request->send(500);
+        }
+      }
+    } else
+      request->send(400);
+  }
+}
+
+void SPIFFSEditor::handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final){
+  if(!index){
+    if(!_username.length() || request->authenticate(_username.c_str(),_password.c_str())){
+      _authenticated = true;
+      request->_tempFile = _fs.open(filename, "w");
+      _startTime = millis();
+    }
+  }
+  if(_authenticated && request->_tempFile){
+    if(len){
+      request->_tempFile.write(data,len);
+    }
+    if(final){
+      request->_tempFile.close();
+    }
+  }
+}
diff --git a/lib/ESPAsyncWebServer/src/SPIFFSEditor.h b/lib/ESPAsyncWebServer/src/SPIFFSEditor.h
new file mode 100644
index 00000000..00e87293
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/SPIFFSEditor.h
@@ -0,0 +1,29 @@
+#ifndef SPIFFSEditor_H_
+#define SPIFFSEditor_H_
+#include 
+
+#ifdef ESP8266
+#include 
+#endif
+
+class SPIFFSEditor : public AsyncWebHandler {
+   private:
+    fs::FS _fs;
+    String _username;
+    String _password;
+    bool _authenticated;
+    uint32_t _startTime;
+
+   public:
+#ifdef ESP32
+    SPIFFSEditor(const fs::FS& fs, const String& username = String(), const String& password = String());
+#else
+    SPIFFSEditor(const String& username = String(), const String& password = String(), const fs::FS& fs = LittleFS);
+#endif
+    virtual bool canHandle(AsyncWebServerRequest* request) override final;
+    virtual void handleRequest(AsyncWebServerRequest* request) override final;
+    virtual void handleUpload(AsyncWebServerRequest* request, const String& filename, size_t index, uint8_t* data, size_t len, bool final) override final;
+    virtual bool isRequestHandlerTrivial() override final { return false; }
+};
+
+#endif
diff --git a/lib/ESPAsyncWebServer/src/StringArray.h b/lib/ESPAsyncWebServer/src/StringArray.h
new file mode 100644
index 00000000..4c0aa701
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/StringArray.h
@@ -0,0 +1,193 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef STRINGARRAY_H_
+#define STRINGARRAY_H_
+
+#include "stddef.h"
+#include "WString.h"
+
+template 
+class LinkedListNode {
+    T _value;
+  public:
+    LinkedListNode* next;
+    LinkedListNode(const T val): _value(val), next(nullptr) {}
+    ~LinkedListNode(){}
+    const T& value() const { return _value; };
+    T& value(){ return _value; }
+};
+
+template  class Item = LinkedListNode>
+class LinkedList {
+  public:
+    typedef Item ItemType;
+    typedef std::function OnRemove;
+    typedef std::function Predicate;
+  private:
+    ItemType* _root;
+    OnRemove _onRemove;
+
+    class Iterator {
+      ItemType* _node;
+    public:
+      Iterator(ItemType* current = nullptr) : _node(current) {}
+      Iterator(const Iterator& i) : _node(i._node) {}
+      Iterator& operator ++() { _node = _node->next; return *this; }
+      bool operator != (const Iterator& i) const { return _node != i._node; }
+      const T& operator * () const { return _node->value(); }
+      const T* operator -> () const { return &_node->value(); }
+    };
+    
+  public:
+    typedef const Iterator ConstIterator;
+    ConstIterator begin() const { return ConstIterator(_root); }
+    ConstIterator end() const { return ConstIterator(nullptr); }
+
+    LinkedList(OnRemove onRemove) : _root(nullptr), _onRemove(onRemove) {}
+    ~LinkedList(){}
+    void add(const T& t){
+      auto it = new ItemType(t);
+      if(!_root){
+        _root = it;
+      } else {
+        auto i = _root;
+        while(i->next) i = i->next;
+        i->next = it;
+      }
+    }
+    T& front() const {
+      return _root->value();
+    }
+    
+    bool isEmpty() const {
+      return _root == nullptr;
+    }
+    size_t length() const {
+      size_t i = 0;
+      auto it = _root;
+      while(it){
+        i++;
+        it = it->next;
+      }
+      return i;
+    }
+    size_t count_if(Predicate predicate) const {
+      size_t i = 0;
+      auto it = _root;
+      while(it){
+        if (!predicate){
+          i++;
+        }
+        else if (predicate(it->value())) {
+          i++;
+        }
+        it = it->next;
+      }
+      return i;
+    }
+    const T* nth(size_t N) const {
+      size_t i = 0;
+      auto it = _root;
+      while(it){
+        if(i++ == N)
+          return &(it->value());
+        it = it->next;
+      }
+      return nullptr;
+    }
+    bool remove(const T& t){
+      auto it = _root;
+      auto pit = _root;
+      while(it){
+        if(it->value() == t){
+          if(it == _root){
+            _root = _root->next;
+          } else {
+            pit->next = it->next;
+          }
+          
+          if (_onRemove) {
+            _onRemove(it->value());
+          }
+          
+          delete it;
+          return true;
+        }
+        pit = it;
+        it = it->next;
+      }
+      return false;
+    }
+    bool remove_first(Predicate predicate){
+      auto it = _root;
+      auto pit = _root;
+      while(it){
+        if(predicate(it->value())){
+          if(it == _root){
+            _root = _root->next;
+          } else {
+            pit->next = it->next;
+          }
+          if (_onRemove) {
+            _onRemove(it->value());
+          }
+          delete it;
+          return true;
+        }
+        pit = it;
+        it = it->next;
+      }
+      return false;
+    }
+    
+    void free(){
+      while(_root != nullptr){
+        auto it = _root;
+        _root = _root->next;
+        if (_onRemove) {
+          _onRemove(it->value());
+        }
+        delete it;
+      }
+      _root = nullptr;
+    }
+};
+
+
+class StringArray : public LinkedList {
+public:
+  
+  StringArray() : LinkedList(nullptr) {}
+  
+  bool containsIgnoreCase(const String& str){
+    for (const auto& s : *this) {
+      if (str.equalsIgnoreCase(s)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+
+
+
+#endif /* STRINGARRAY_H_ */
diff --git a/lib/ESPAsyncWebServer/src/WebAuthentication.cpp b/lib/ESPAsyncWebServer/src/WebAuthentication.cpp
new file mode 100644
index 00000000..2feca542
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/WebAuthentication.cpp
@@ -0,0 +1,235 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "WebAuthentication.h"
+#include 
+#ifdef ESP32
+#include "mbedtls/md5.h"
+#else
+#include "md5.h"
+#endif
+
+
+// Basic Auth hash = base64("username:password")
+
+bool checkBasicAuthentication(const char * hash, const char * username, const char * password){
+  if(username == NULL || password == NULL || hash == NULL)
+    return false;
+
+  size_t toencodeLen = strlen(username)+strlen(password)+1;
+  size_t encodedLen = base64_encode_expected_len(toencodeLen);
+  if(strlen(hash) != encodedLen)
+    return false;
+
+  char *toencode = new char[toencodeLen+1];
+  if(toencode == NULL){
+    return false;
+  }
+  char *encoded = new char[base64_encode_expected_len(toencodeLen)+1];
+  if(encoded == NULL){
+    delete[] toencode;
+    return false;
+  }
+  sprintf(toencode, "%s:%s", username, password);
+  if(base64_encode_chars(toencode, toencodeLen, encoded) > 0 && memcmp(hash, encoded, encodedLen) == 0){
+    delete[] toencode;
+    delete[] encoded;
+    return true;
+  }
+  delete[] toencode;
+  delete[] encoded;
+  return false;
+}
+
+static bool getMD5(uint8_t * data, uint16_t len, char * output){//33 bytes or more
+#ifdef ESP32
+    mbedtls_md5_context _ctx;
+#else
+    md5_context_t _ctx;
+#endif
+  uint8_t i;
+  uint8_t * _buf = (uint8_t*)malloc(16);
+  if(_buf == NULL)
+    return false;
+  memset(_buf, 0x00, 16);
+#ifdef ESP32
+  mbedtls_md5_init(&_ctx);
+  mbedtls_md5_starts(&_ctx);
+  mbedtls_md5_update(&_ctx, data, len);
+  mbedtls_md5_finish(&_ctx, _buf);
+#else
+  MD5Init(&_ctx);
+  MD5Update(&_ctx, data, len);
+  MD5Final(_buf, &_ctx);
+#endif
+  for(i = 0; i < 16; i++) {
+    sprintf(output + (i * 2), "%02x", _buf[i]);
+  }
+  free(_buf);
+  return true;
+}
+
+static String genRandomMD5(){
+#ifdef ESP8266
+  uint32_t r = RANDOM_REG32;
+#else
+  uint32_t r = rand();
+#endif
+  char * out = (char*)malloc(33);
+  if(out == NULL || !getMD5((uint8_t*)(&r), 4, out))
+    return "";
+  String res = String(out);
+  free(out);
+  return res;
+}
+
+static String stringMD5(const String& in){
+  char * out = (char*)malloc(33);
+  if(out == NULL || !getMD5((uint8_t*)(in.c_str()), in.length(), out))
+    return "";
+  String res = String(out);
+  free(out);
+  return res;
+}
+
+String generateDigestHash(const char * username, const char * password, const char * realm){
+  if(username == NULL || password == NULL || realm == NULL){
+    return "";
+  }
+  char * out = (char*)malloc(33);
+  String res = String(username);
+  res.concat(":");
+  res.concat(realm);
+  res.concat(":");
+  String in = res;
+  in.concat(password);
+  if(out == NULL || !getMD5((uint8_t*)(in.c_str()), in.length(), out))
+    return "";
+  res.concat(out);
+  free(out);
+  return res;
+}
+
+String requestDigestAuthentication(const char * realm){
+  String header = "realm=\"";
+  if(realm == NULL)
+    header.concat("asyncesp");
+  else
+    header.concat(realm);
+  header.concat( "\", qop=\"auth\", nonce=\"");
+  header.concat(genRandomMD5());
+  header.concat("\", opaque=\"");
+  header.concat(genRandomMD5());
+  header.concat("\"");
+  return header;
+}
+
+bool checkDigestAuthentication(const char * header, const char * method, const char * username, const char * password, const char * realm, bool passwordIsHash, const char * nonce, const char * opaque, const char * uri){
+  if(username == NULL || password == NULL || header == NULL || method == NULL){
+    //os_printf("AUTH FAIL: missing requred fields\n");
+    return false;
+  }
+
+  String myHeader = String(header);
+  int nextBreak = myHeader.indexOf(",");
+  if(nextBreak < 0){
+    //os_printf("AUTH FAIL: no variables\n");
+    return false;
+  }
+
+  String myUsername = String();
+  String myRealm = String();
+  String myNonce = String();
+  String myUri = String();
+  String myResponse = String();
+  String myQop = String();
+  String myNc = String();
+  String myCnonce = String();
+
+  myHeader += ", ";
+  do {
+    String avLine = myHeader.substring(0, nextBreak);
+    avLine.trim();
+    myHeader = myHeader.substring(nextBreak+1);
+    nextBreak = myHeader.indexOf(",");
+
+    int eqSign = avLine.indexOf("=");
+    if(eqSign < 0){
+      //os_printf("AUTH FAIL: no = sign\n");
+      return false;
+    }
+    String varName = avLine.substring(0, eqSign);
+    avLine = avLine.substring(eqSign + 1);
+    if(avLine.startsWith("\"")){
+      avLine = avLine.substring(1, avLine.length() - 1);
+    }
+
+    if(varName.equals("username")){
+      if(!avLine.equals(username)){
+        //os_printf("AUTH FAIL: username\n");
+        return false;
+      }
+      myUsername = avLine;
+    } else if(varName.equals("realm")){
+      if(realm != NULL && !avLine.equals(realm)){
+        //os_printf("AUTH FAIL: realm\n");
+        return false;
+      }
+      myRealm = avLine;
+    } else if(varName.equals("nonce")){
+      if(nonce != NULL && !avLine.equals(nonce)){
+        //os_printf("AUTH FAIL: nonce\n");
+        return false;
+      }
+      myNonce = avLine;
+    } else if(varName.equals("opaque")){
+      if(opaque != NULL && !avLine.equals(opaque)){
+        //os_printf("AUTH FAIL: opaque\n");
+        return false;
+      }
+    } else if(varName.equals("uri")){
+      if(uri != NULL && !avLine.equals(uri)){
+        //os_printf("AUTH FAIL: uri\n");
+        return false;
+      }
+      myUri = avLine;
+    } else if(varName.equals("response")){
+      myResponse = avLine;
+    } else if(varName.equals("qop")){
+      myQop = avLine;
+    } else if(varName.equals("nc")){
+      myNc = avLine;
+    } else if(varName.equals("cnonce")){
+      myCnonce = avLine;
+    }
+  } while(nextBreak > 0);
+
+  String ha1 = (passwordIsHash) ? String(password) : stringMD5(myUsername + ":" + myRealm + ":" + String(password));
+  String ha2 = String(method) + ":" + myUri;
+  String response = ha1 + ":" + myNonce + ":" + myNc + ":" + myCnonce + ":" + myQop + ":" + stringMD5(ha2);
+
+  if(myResponse.equals(stringMD5(response))){
+    //os_printf("AUTH SUCCESS\n");
+    return true;
+  }
+
+  //os_printf("AUTH FAIL: password\n");
+  return false;
+}
diff --git a/lib/ESPAsyncWebServer/src/WebAuthentication.h b/lib/ESPAsyncWebServer/src/WebAuthentication.h
new file mode 100644
index 00000000..ff68265d
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/WebAuthentication.h
@@ -0,0 +1,34 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef WEB_AUTHENTICATION_H_
+#define WEB_AUTHENTICATION_H_
+
+#include "Arduino.h"
+
+bool checkBasicAuthentication(const char * header, const char * username, const char * password);
+String requestDigestAuthentication(const char * realm);
+bool checkDigestAuthentication(const char * header, const char * method, const char * username, const char * password, const char * realm, bool passwordIsHash, const char * nonce, const char * opaque, const char * uri);
+
+//for storing hashed versions on the device that can be authenticated against
+String generateDigestHash(const char * username, const char * password, const char * realm);
+
+#endif
diff --git a/lib/ESPAsyncWebServer/src/WebHandlerImpl.h b/lib/ESPAsyncWebServer/src/WebHandlerImpl.h
new file mode 100644
index 00000000..d121fa7a
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/WebHandlerImpl.h
@@ -0,0 +1,138 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef ASYNCWEBSERVERHANDLERIMPL_H_
+#define ASYNCWEBSERVERHANDLERIMPL_H_
+
+#include 
+#ifdef ASYNCWEBSERVER_REGEX
+#include 
+#endif
+
+#include "stddef.h"
+#include 
+
+class AsyncStaticWebHandler: public AsyncWebHandler {
+   using File = fs::File;
+   using FS = fs::FS;
+  private:
+    bool _getFile(AsyncWebServerRequest *request);
+    bool _fileExists(AsyncWebServerRequest *request, const String& path);
+    uint8_t _countBits(const uint8_t value) const;
+  protected:
+    FS _fs;
+    String _uri;
+    String _path;
+    String _default_file;
+    String _cache_control;
+    String _last_modified;
+    AwsTemplateProcessor _callback;
+    bool _isDir;
+    bool _gzipFirst;
+    uint8_t _gzipStats;
+  public:
+    AsyncStaticWebHandler(const char* uri, FS& fs, const char* path, const char* cache_control);
+    virtual bool canHandle(AsyncWebServerRequest *request) override final;
+    virtual void handleRequest(AsyncWebServerRequest *request) override final;
+    AsyncStaticWebHandler& setIsDir(bool isDir);
+    AsyncStaticWebHandler& setDefaultFile(const char* filename);
+    AsyncStaticWebHandler& setCacheControl(const char* cache_control);
+    AsyncStaticWebHandler& setLastModified(const char* last_modified);
+    AsyncStaticWebHandler& setLastModified(struct tm* last_modified);
+  #ifdef ESP8266
+    AsyncStaticWebHandler& setLastModified(time_t last_modified);
+    AsyncStaticWebHandler& setLastModified(); //sets to current time. Make sure sntp is runing and time is updated
+  #endif
+    AsyncStaticWebHandler& setTemplateProcessor(AwsTemplateProcessor newCallback) {_callback = newCallback; return *this;}
+};
+
+class AsyncCallbackWebHandler: public AsyncWebHandler {
+  private:
+  protected:
+    String _uri;
+    WebRequestMethodComposite _method;
+    ArRequestHandlerFunction _onRequest;
+    ArUploadHandlerFunction _onUpload;
+    ArBodyHandlerFunction _onBody;
+    bool _isRegex;
+  public:
+    AsyncCallbackWebHandler() : _uri(), _method(HTTP_ANY), _onRequest(NULL), _onUpload(NULL), _onBody(NULL), _isRegex(false) {}
+    void setUri(const String& uri){ 
+      _uri = uri; 
+      _isRegex = uri.startsWith("^") && uri.endsWith("$");
+    }
+    void setMethod(WebRequestMethodComposite method){ _method = method; }
+    void onRequest(ArRequestHandlerFunction fn){ _onRequest = fn; }
+    void onUpload(ArUploadHandlerFunction fn){ _onUpload = fn; }
+    void onBody(ArBodyHandlerFunction fn){ _onBody = fn; }
+
+    virtual bool canHandle(AsyncWebServerRequest *request) override final{
+
+      if(!_onRequest)
+        return false;
+
+      if(!(_method & request->method()))
+        return false;
+
+#ifdef ASYNCWEBSERVER_REGEX
+      if (_isRegex) {
+        std::regex pattern(_uri.c_str());
+        std::smatch matches;
+        std::string s(request->url().c_str());
+        if(std::regex_search(s, matches, pattern)) {
+          for (size_t i = 1; i < matches.size(); ++i) { // start from 1
+            request->_addPathParam(matches[i].str().c_str());
+          }
+        } else {
+          return false;
+        }
+      } else 
+#endif
+      if (_uri.length() && _uri.endsWith("*")) {
+        String uriTemplate = String(_uri);
+	uriTemplate = uriTemplate.substring(0, uriTemplate.length() - 1);
+        if (!request->url().startsWith(uriTemplate))
+          return false;
+      }
+      else if(_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri+"/")))
+        return false;
+
+      request->addInterestingHeader("ANY");
+      return true;
+    }
+  
+    virtual void handleRequest(AsyncWebServerRequest *request) override final {
+      if(_onRequest)
+        _onRequest(request);
+      else
+        request->send(500);
+    }
+    virtual void handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final) override final {
+      if(_onUpload)
+        _onUpload(request, filename, index, data, len, final);
+    }
+    virtual void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override final {
+      if(_onBody)
+        _onBody(request, data, len, index, total);
+    }
+    virtual bool isRequestHandlerTrivial() override final {return _onRequest ? false : true;}
+};
+
+#endif /* ASYNCWEBSERVERHANDLERIMPL_H_ */
diff --git a/lib/ESPAsyncWebServer/src/WebHandlers.cpp b/lib/ESPAsyncWebServer/src/WebHandlers.cpp
new file mode 100644
index 00000000..1f435e68
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/WebHandlers.cpp
@@ -0,0 +1,220 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "ESPAsyncWebServer.h"
+#include "WebHandlerImpl.h"
+
+AsyncStaticWebHandler::AsyncStaticWebHandler(const char* uri, FS& fs, const char* path, const char* cache_control)
+  : _fs(fs), _uri(uri), _path(path), _default_file("index.htm"), _cache_control(cache_control), _last_modified(""), _callback(nullptr)
+{
+  // Ensure leading '/'
+  if (_uri.length() == 0 || _uri[0] != '/') _uri = "/" + _uri;
+  if (_path.length() == 0 || _path[0] != '/') _path = "/" + _path;
+
+  // If path ends with '/' we assume a hint that this is a directory to improve performance.
+  // However - if it does not end with '/' we, can't assume a file, path can still be a directory.
+  _isDir = _path[_path.length()-1] == '/';
+
+  // Remove the trailing '/' so we can handle default file
+  // Notice that root will be "" not "/"
+  if (_uri[_uri.length()-1] == '/') _uri = _uri.substring(0, _uri.length()-1);
+  if (_path[_path.length()-1] == '/') _path = _path.substring(0, _path.length()-1);
+
+  // Reset stats
+  _gzipFirst = false;
+  _gzipStats = 0xF8;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setIsDir(bool isDir){
+  _isDir = isDir;
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setDefaultFile(const char* filename){
+  _default_file = String(filename);
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setCacheControl(const char* cache_control){
+  _cache_control = String(cache_control);
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(const char* last_modified){
+  _last_modified = String(last_modified);
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(struct tm* last_modified){
+  char result[30];
+  strftime (result,30,"%a, %d %b %Y %H:%M:%S %Z", last_modified);
+  return setLastModified((const char *)result);
+}
+
+#ifdef ESP8266
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(time_t last_modified){
+  return setLastModified((struct tm *)gmtime(&last_modified));
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(){
+  time_t last_modified;
+  if(time(&last_modified) == 0) //time is not yet set
+    return *this;
+  return setLastModified(last_modified);
+}
+#endif
+bool AsyncStaticWebHandler::canHandle(AsyncWebServerRequest *request){
+  if(request->method() != HTTP_GET 
+    || !request->url().startsWith(_uri) 
+    || !request->isExpectedRequestedConnType(RCT_DEFAULT, RCT_HTTP)
+  ){
+    return false;
+  }
+  if (_getFile(request)) {
+    // We interested in "If-Modified-Since" header to check if file was modified
+    if (_last_modified.length())
+      request->addInterestingHeader("If-Modified-Since");
+
+    if(_cache_control.length())
+      request->addInterestingHeader("If-None-Match");
+
+    DEBUGF("[AsyncStaticWebHandler::canHandle] TRUE\n");
+    return true;
+  }
+
+  return false;
+}
+
+bool AsyncStaticWebHandler::_getFile(AsyncWebServerRequest *request)
+{
+  // Remove the found uri
+  String path = request->url().substring(_uri.length());
+
+  // We can skip the file check and look for default if request is to the root of a directory or that request path ends with '/'
+  bool canSkipFileCheck = (_isDir && path.length() == 0) || (path.length() && path[path.length()-1] == '/');
+
+  path = _path + path;
+
+  // Do we have a file or .gz file
+  if (!canSkipFileCheck && _fileExists(request, path))
+    return true;
+
+  // Can't handle if not default file
+  if (_default_file.length() == 0)
+    return false;
+
+  // Try to add default file, ensure there is a trailing '/' ot the path.
+  if (path.length() == 0 || path[path.length()-1] != '/')
+    path += "/";
+  path += _default_file;
+
+  return _fileExists(request, path);
+}
+
+#ifdef ESP32
+#define FILE_IS_REAL(f) (f == true && !f.isDirectory())
+#else
+#define FILE_IS_REAL(f) (f == true)
+#endif
+
+bool AsyncStaticWebHandler::_fileExists(AsyncWebServerRequest *request, const String& path)
+{
+  bool fileFound = false;
+  bool gzipFound = false;
+
+  String gzip = path + ".gz";
+
+  if (_gzipFirst) {
+    request->_tempFile = _fs.open(gzip, "r");
+    gzipFound = FILE_IS_REAL(request->_tempFile);
+    if (!gzipFound){
+      request->_tempFile = _fs.open(path, "r");
+      fileFound = FILE_IS_REAL(request->_tempFile);
+    }
+  } else {
+    request->_tempFile = _fs.open(path, "r");
+    fileFound = FILE_IS_REAL(request->_tempFile);
+    if (!fileFound){
+      request->_tempFile = _fs.open(gzip, "r");
+      gzipFound = FILE_IS_REAL(request->_tempFile);
+    }
+  }
+
+  bool found = fileFound || gzipFound;
+
+  if (found) {
+    // Extract the file name from the path and keep it in _tempObject
+    size_t pathLen = path.length();
+    char * _tempPath = (char*)malloc(pathLen+1);
+    snprintf(_tempPath, pathLen+1, "%s", path.c_str());
+    request->_tempObject = (void*)_tempPath;
+
+    // Calculate gzip statistic
+    _gzipStats = (_gzipStats << 1) + (gzipFound ? 1 : 0);
+    if (_gzipStats == 0x00) _gzipFirst = false; // All files are not gzip
+    else if (_gzipStats == 0xFF) _gzipFirst = true; // All files are gzip
+    else _gzipFirst = _countBits(_gzipStats) > 4; // IF we have more gzip files - try gzip first
+  }
+
+  return found;
+}
+
+uint8_t AsyncStaticWebHandler::_countBits(const uint8_t value) const
+{
+  uint8_t w = value;
+  uint8_t n;
+  for (n=0; w!=0; n++) w&=w-1;
+  return n;
+}
+
+void AsyncStaticWebHandler::handleRequest(AsyncWebServerRequest *request)
+{
+  // Get the filename from request->_tempObject and free it
+  String filename = String((char*)request->_tempObject);
+  free(request->_tempObject);
+  request->_tempObject = NULL;
+  if((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+      return request->requestAuthentication();
+
+  if (request->_tempFile == true) {
+    String etag = String(request->_tempFile.size());
+    if (_last_modified.length() && _last_modified == request->header("If-Modified-Since")) {
+      request->_tempFile.close();
+      request->send(304); // Not modified
+    } else if (_cache_control.length() && request->hasHeader("If-None-Match") && request->header("If-None-Match").equals(etag)) {
+      request->_tempFile.close();
+      AsyncWebServerResponse * response = new AsyncBasicResponse(304); // Not modified
+      response->addHeader("Cache-Control", _cache_control);
+      response->addHeader("ETag", etag);
+      request->send(response);
+    } else {
+      AsyncWebServerResponse * response = new AsyncFileResponse(request->_tempFile, filename, String(), false, _callback);
+      if (_last_modified.length())
+        response->addHeader("Last-Modified", _last_modified);
+      if (_cache_control.length()){
+        response->addHeader("Cache-Control", _cache_control);
+        response->addHeader("ETag", etag);
+      }
+      request->send(response);
+    }
+  } else {
+    request->send(404);
+  }
+}
diff --git a/lib/ESPAsyncWebServer/src/WebRequest.cpp b/lib/ESPAsyncWebServer/src/WebRequest.cpp
new file mode 100644
index 00000000..bbce5ca4
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/WebRequest.cpp
@@ -0,0 +1,1008 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "ESPAsyncWebServer.h"
+#include "WebResponseImpl.h"
+#include "WebAuthentication.h"
+
+#ifndef ESP8266
+#define os_strlen strlen
+#endif
+
+static const String SharedEmptyString = String();
+
+#define __is_param_char(c) ((c) && ((c) != '{') && ((c) != '[') && ((c) != '&') && ((c) != '='))
+
+enum { PARSE_REQ_START, PARSE_REQ_HEADERS, PARSE_REQ_BODY, PARSE_REQ_END, PARSE_REQ_FAIL };
+
+AsyncWebServerRequest::AsyncWebServerRequest(AsyncWebServer* s, AsyncClient* c)
+  : _client(c)
+  , _server(s)
+  , _handler(NULL)
+  , _response(NULL)
+  , _temp()
+  , _parseState(0)
+  , _version(0)
+  , _method(HTTP_ANY)
+  , _url()
+  , _host()
+  , _contentType()
+  , _boundary()
+  , _authorization()
+  , _reqconntype(RCT_HTTP)
+  , _isDigest(false)
+  , _isMultipart(false)
+  , _isPlainPost(false)
+  , _expectingContinue(false)
+  , _contentLength(0)
+  , _parsedLength(0)
+  , _headers(LinkedList([](AsyncWebHeader *h){ delete h; }))
+  , _params(LinkedList([](AsyncWebParameter *p){ delete p; }))
+  , _pathParams(LinkedList([](String *p){ delete p; }))
+  , _multiParseState(0)
+  , _boundaryPosition(0)
+  , _itemStartIndex(0)
+  , _itemSize(0)
+  , _itemName()
+  , _itemFilename()
+  , _itemType()
+  , _itemValue()
+  , _itemBuffer(0)
+  , _itemBufferIndex(0)
+  , _itemIsFile(false)
+  , _tempObject(NULL)
+{
+  c->onError([](void *r, AsyncClient* c, int8_t error){ (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onError(error); }, this);
+  c->onAck([](void *r, AsyncClient* c, size_t len, uint32_t time){ (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onAck(len, time); }, this);
+  c->onDisconnect([](void *r, AsyncClient* c){ AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onDisconnect(); delete c; }, this);
+  c->onTimeout([](void *r, AsyncClient* c, uint32_t time){ (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onTimeout(time); }, this);
+  c->onData([](void *r, AsyncClient* c, void *buf, size_t len){ (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onData(buf, len); }, this);
+  c->onPoll([](void *r, AsyncClient* c){ (void)c; AsyncWebServerRequest *req = ( AsyncWebServerRequest*)r; req->_onPoll(); }, this);
+}
+
+AsyncWebServerRequest::~AsyncWebServerRequest(){
+  _headers.free();
+
+  _params.free();
+  _pathParams.free();
+
+  _interestingHeaders.free();
+
+  if(_response != NULL){
+    delete _response;
+  }
+
+  if(_tempObject != NULL){
+    free(_tempObject);
+  }
+
+  if(_tempFile){
+    _tempFile.close();
+  }
+}
+
+void AsyncWebServerRequest::_onData(void *buf, size_t len){
+  size_t i = 0;
+  while (true) {
+
+  if(_parseState < PARSE_REQ_BODY){
+    // Find new line in buf
+    char *str = (char*)buf;
+    for (i = 0; i < len; i++) {
+      if (str[i] == '\n') {
+        break;
+      }
+    }
+    if (i == len) { // No new line, just add the buffer in _temp
+      char ch = str[len-1];
+      str[len-1] = 0;
+      _temp.reserve(_temp.length()+len);
+      _temp.concat(str);
+      _temp.concat(ch);
+    } else { // Found new line - extract it and parse
+      str[i] = 0; // Terminate the string at the end of the line.
+      _temp.concat(str);
+      _temp.trim();
+      _parseLine();
+      if (++i < len) {
+        // Still have more buffer to process
+        buf = str+i;
+        len-= i;
+        continue;
+      }
+    }
+  } else if(_parseState == PARSE_REQ_BODY){
+    // A handler should be already attached at this point in _parseLine function.
+    // If handler does nothing (_onRequest is NULL), we don't need to really parse the body.
+    const bool needParse = _handler && !_handler->isRequestHandlerTrivial();
+    if(_isMultipart){
+      if(needParse){
+        size_t i;
+        for(i=0; i end) equal = end;
+    String name = params.substring(start, equal);
+    String value = equal + 1 < end ? params.substring(equal + 1, end) : String();
+    _addParam(new AsyncWebParameter(urlDecode(name), urlDecode(value)));
+    start = end + 1;
+  }
+}
+
+bool AsyncWebServerRequest::_parseReqHead(){
+  // Split the head into method, url and version
+  int index = _temp.indexOf(' ');
+  String m = _temp.substring(0, index);
+  index = _temp.indexOf(' ', index+1);
+  String u = _temp.substring(m.length()+1, index);
+  _temp = _temp.substring(index+1);
+
+  if(m == "GET"){
+    _method = HTTP_GET;
+  } else if(m == "POST"){
+    _method = HTTP_POST;
+  } else if(m == "DELETE"){
+    _method = HTTP_DELETE;
+  } else if(m == "PUT"){
+    _method = HTTP_PUT;
+  } else if(m == "PATCH"){
+    _method = HTTP_PATCH;
+  } else if(m == "HEAD"){
+    _method = HTTP_HEAD;
+  } else if(m == "OPTIONS"){
+    _method = HTTP_OPTIONS;
+  }
+
+  String g = String();
+  index = u.indexOf('?');
+  if(index > 0){
+    g = u.substring(index +1);
+    u = u.substring(0, index);
+  }
+  _url = urlDecode(u);
+  _addGetParams(g);
+
+  if(!_temp.startsWith("HTTP/1.0"))
+    _version = 1;
+
+  _temp = String();
+  return true;
+}
+
+bool strContains(String src, String find, bool mindcase = true) {
+  int pos=0, i=0;
+  const int slen = src.length();
+  const int flen = find.length();
+
+  if (slen < flen) return false;
+  while (pos <= (slen - flen)) {
+    for (i=0; i < flen; i++) {
+      if (mindcase) {
+        if (src[pos+i] != find[i]) i = flen + 1; // no match
+      } else if (tolower(src[pos+i]) != tolower(find[i])) i = flen + 1; // no match
+    }
+    if (i == flen) return true;
+    pos++;
+  }
+  return false;
+}
+
+bool AsyncWebServerRequest::_parseReqHeader(){
+  int index = _temp.indexOf(':');
+  if(index){
+    String name = _temp.substring(0, index);
+    String value = _temp.substring(index + 2);
+    if(name.equalsIgnoreCase("Host")){
+      _host = value;
+    } else if(name.equalsIgnoreCase("Content-Type")){
+	  _contentType = value.substring(0, value.indexOf(';'));
+      if (value.startsWith("multipart/")){
+        _boundary = value.substring(value.indexOf('=')+1);
+        _boundary.replace("\"","");
+        _isMultipart = true;
+      }
+    } else if(name.equalsIgnoreCase("Content-Length")){
+      _contentLength = atoi(value.c_str());
+    } else if(name.equalsIgnoreCase("Expect") && value == "100-continue"){
+      _expectingContinue = true;
+    } else if(name.equalsIgnoreCase("Authorization")){
+      if(value.length() > 5 && value.substring(0,5).equalsIgnoreCase("Basic")){
+        _authorization = value.substring(6);
+      } else if(value.length() > 6 && value.substring(0,6).equalsIgnoreCase("Digest")){
+        _isDigest = true;
+        _authorization = value.substring(7);
+      }
+    } else {
+      if(name.equalsIgnoreCase("Upgrade") && value.equalsIgnoreCase("websocket")){
+        // WebSocket request can be uniquely identified by header: [Upgrade: websocket]
+        _reqconntype = RCT_WS;
+      } else {
+        if(name.equalsIgnoreCase("Accept") && strContains(value, "text/event-stream", false)){
+          // WebEvent request can be uniquely identified by header:  [Accept: text/event-stream]
+          _reqconntype = RCT_EVENT;
+        }
+      }
+    }
+    _headers.add(new AsyncWebHeader(name, value));
+  }
+  _temp = String();
+  return true;
+}
+
+void AsyncWebServerRequest::_parsePlainPostChar(uint8_t data){
+  if(data && (char)data != '&')
+    _temp += (char)data;
+  if(!data || (char)data == '&' || _parsedLength == _contentLength){
+    String name = "body";
+    String value = _temp;
+    if(!_temp.startsWith("{") && !_temp.startsWith("[") && _temp.indexOf('=') > 0){
+      name = _temp.substring(0, _temp.indexOf('='));
+      value = _temp.substring(_temp.indexOf('=') + 1);
+    }
+    _addParam(new AsyncWebParameter(urlDecode(name), urlDecode(value), true));
+    _temp = String();
+  }
+}
+
+void AsyncWebServerRequest::_handleUploadByte(uint8_t data, bool last){
+  _itemBuffer[_itemBufferIndex++] = data;
+
+  if(last || _itemBufferIndex == 1460){
+    //check if authenticated before calling the upload
+    if(_handler)
+      _handler->handleUpload(this, _itemFilename, _itemSize - _itemBufferIndex, _itemBuffer, _itemBufferIndex, false);
+    _itemBufferIndex = 0;
+  }
+}
+
+enum {
+  EXPECT_BOUNDARY,
+  PARSE_HEADERS,
+  WAIT_FOR_RETURN1,
+  EXPECT_FEED1,
+  EXPECT_DASH1,
+  EXPECT_DASH2,
+  BOUNDARY_OR_DATA,
+  DASH3_OR_RETURN2,
+  EXPECT_FEED2,
+  PARSING_FINISHED,
+  PARSE_ERROR
+};
+
+void AsyncWebServerRequest::_parseMultipartPostByte(uint8_t data, bool last){
+#define itemWriteByte(b) do { _itemSize++; if(_itemIsFile) _handleUploadByte(b, last); else _itemValue+=(char)(b); } while(0)
+
+  if(!_parsedLength){
+    _multiParseState = EXPECT_BOUNDARY;
+    _temp = String();
+    _itemName = String();
+    _itemFilename = String();
+    _itemType = String();
+  }
+
+  if(_multiParseState == WAIT_FOR_RETURN1){
+    if(data != '\r'){
+      itemWriteByte(data);
+    } else {
+      _multiParseState = EXPECT_FEED1;
+    }
+  } else if(_multiParseState == EXPECT_BOUNDARY){
+    if(_parsedLength < 2 && data != '-'){
+      _multiParseState = PARSE_ERROR;
+      return;
+    } else if(_parsedLength - 2 < _boundary.length() && _boundary.c_str()[_parsedLength - 2] != data){
+      _multiParseState = PARSE_ERROR;
+      return;
+    } else if(_parsedLength - 2 == _boundary.length() && data != '\r'){
+      _multiParseState = PARSE_ERROR;
+      return;
+    } else if(_parsedLength - 3 == _boundary.length()){
+      if(data != '\n'){
+        _multiParseState = PARSE_ERROR;
+        return;
+      }
+      _multiParseState = PARSE_HEADERS;
+      _itemIsFile = false;
+    }
+  } else if(_multiParseState == PARSE_HEADERS){
+    if((char)data != '\r' && (char)data != '\n')
+       _temp += (char)data;
+    if((char)data == '\n'){
+      if(_temp.length()){
+        if(_temp.length() > 12 && _temp.substring(0, 12).equalsIgnoreCase("Content-Type")){
+          _itemType = _temp.substring(14);
+          _itemIsFile = true;
+        } else if(_temp.length() > 19 && _temp.substring(0, 19).equalsIgnoreCase("Content-Disposition")){
+          _temp = _temp.substring(_temp.indexOf(';') + 2);
+          while(_temp.indexOf(';') > 0){
+            String name = _temp.substring(0, _temp.indexOf('='));
+            String nameVal = _temp.substring(_temp.indexOf('=') + 2, _temp.indexOf(';') - 1);
+            if(name == "name"){
+              _itemName = nameVal;
+            } else if(name == "filename"){
+              _itemFilename = nameVal;
+              _itemIsFile = true;
+            }
+            _temp = _temp.substring(_temp.indexOf(';') + 2);
+          }
+          String name = _temp.substring(0, _temp.indexOf('='));
+          String nameVal = _temp.substring(_temp.indexOf('=') + 2, _temp.length() - 1);
+          if(name == "name"){
+            _itemName = nameVal;
+          } else if(name == "filename"){
+            _itemFilename = nameVal;
+            _itemIsFile = true;
+          }
+        }
+        _temp = String();
+      } else {
+        _multiParseState = WAIT_FOR_RETURN1;
+        //value starts from here
+        _itemSize = 0;
+        _itemStartIndex = _parsedLength;
+        _itemValue = String();
+        if(_itemIsFile){
+          if(_itemBuffer)
+            free(_itemBuffer);
+          _itemBuffer = (uint8_t*)malloc(1460);
+          if(_itemBuffer == NULL){
+            _multiParseState = PARSE_ERROR;
+            return;
+          }
+          _itemBufferIndex = 0;
+        }
+      }
+    }
+  } else if(_multiParseState == EXPECT_FEED1){
+    if(data != '\n'){
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r'); _parseMultipartPostByte(data, last);
+    } else {
+      _multiParseState = EXPECT_DASH1;
+    }
+  } else if(_multiParseState == EXPECT_DASH1){
+    if(data != '-'){
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r'); itemWriteByte('\n');  _parseMultipartPostByte(data, last);
+    } else {
+      _multiParseState = EXPECT_DASH2;
+    }
+  } else if(_multiParseState == EXPECT_DASH2){
+    if(data != '-'){
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r'); itemWriteByte('\n'); itemWriteByte('-');  _parseMultipartPostByte(data, last);
+    } else {
+      _multiParseState = BOUNDARY_OR_DATA;
+      _boundaryPosition = 0;
+    }
+  } else if(_multiParseState == BOUNDARY_OR_DATA){
+    if(_boundaryPosition < _boundary.length() && _boundary.c_str()[_boundaryPosition] != data){
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r'); itemWriteByte('\n'); itemWriteByte('-');  itemWriteByte('-');
+      uint8_t i;
+      for(i=0; i<_boundaryPosition; i++)
+        itemWriteByte(_boundary.c_str()[i]);
+      _parseMultipartPostByte(data, last);
+    } else if(_boundaryPosition == _boundary.length() - 1){
+      _multiParseState = DASH3_OR_RETURN2;
+      if(!_itemIsFile){
+        _addParam(new AsyncWebParameter(_itemName, _itemValue, true));
+      } else {
+        if(_itemSize){
+          //check if authenticated before calling the upload
+          if(_handler) _handler->handleUpload(this, _itemFilename, _itemSize - _itemBufferIndex, _itemBuffer, _itemBufferIndex, true);
+          _itemBufferIndex = 0;
+          _addParam(new AsyncWebParameter(_itemName, _itemFilename, true, true, _itemSize));
+        }
+        free(_itemBuffer);
+        _itemBuffer = NULL;
+      }
+
+    } else {
+      _boundaryPosition++;
+    }
+  } else if(_multiParseState == DASH3_OR_RETURN2){
+    if(data == '-' && (_contentLength - _parsedLength - 4) != 0){
+      //os_printf("ERROR: The parser got to the end of the POST but is expecting %u bytes more!\nDrop an issue so we can have more info on the matter!\n", _contentLength - _parsedLength - 4);
+      _contentLength = _parsedLength + 4;//lets close the request gracefully
+    }
+    if(data == '\r'){
+      _multiParseState = EXPECT_FEED2;
+    } else if(data == '-' && _contentLength == (_parsedLength + 4)){
+      _multiParseState = PARSING_FINISHED;
+    } else {
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r'); itemWriteByte('\n'); itemWriteByte('-');  itemWriteByte('-');
+      uint8_t i; for(i=0; i<_boundary.length(); i++) itemWriteByte(_boundary.c_str()[i]);
+      _parseMultipartPostByte(data, last);
+    }
+  } else if(_multiParseState == EXPECT_FEED2){
+    if(data == '\n'){
+      _multiParseState = PARSE_HEADERS;
+      _itemIsFile = false;
+    } else {
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r'); itemWriteByte('\n'); itemWriteByte('-');  itemWriteByte('-');
+      uint8_t i; for(i=0; i<_boundary.length(); i++) itemWriteByte(_boundary.c_str()[i]);
+      itemWriteByte('\r'); _parseMultipartPostByte(data, last);
+    }
+  }
+}
+
+void AsyncWebServerRequest::_parseLine(){
+  if(_parseState == PARSE_REQ_START){
+    if(!_temp.length()){
+      _parseState = PARSE_REQ_FAIL;
+      _client->close();
+    } else {
+      _parseReqHead();
+      _parseState = PARSE_REQ_HEADERS;
+    }
+    return;
+  }
+
+  if(_parseState == PARSE_REQ_HEADERS){
+    if(!_temp.length()){
+      //end of headers
+      _server->_rewriteRequest(this);
+      _server->_attachHandler(this);
+      _removeNotInterestingHeaders();
+      if(_expectingContinue){
+        const char * response = "HTTP/1.1 100 Continue\r\n\r\n";
+        _client->write(response, os_strlen(response));
+      }
+      //check handler for authentication
+      if(_contentLength){
+        _parseState = PARSE_REQ_BODY;
+      } else {
+        _parseState = PARSE_REQ_END;
+        if(_handler) _handler->handleRequest(this);
+        else send(501);
+      }
+    } else _parseReqHeader();
+  }
+}
+
+size_t AsyncWebServerRequest::headers() const{
+  return _headers.length();
+}
+
+bool AsyncWebServerRequest::hasHeader(const String& name) const {
+  for(const auto& h: _headers){
+    if(h->name().equalsIgnoreCase(name)){
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AsyncWebServerRequest::hasHeader(const __FlashStringHelper * data) const {
+  PGM_P p = reinterpret_cast(data);
+  size_t n = 0;
+  while (1) {
+    if (pgm_read_byte(p+n) == 0) break;
+      n += 1;
+  }
+  char * name = (char*) malloc(n+1);
+  name[n] = 0; 
+  if (name) {
+    for(size_t b=0; bname().equalsIgnoreCase(name)){
+      return h;
+    }
+  }
+  return nullptr;
+}
+
+AsyncWebHeader* AsyncWebServerRequest::getHeader(const __FlashStringHelper * data) const {
+  PGM_P p = reinterpret_cast(data);
+  size_t n = strlen_P(p); 
+  char * name = (char*) malloc(n+1);
+  if (name) {
+    strcpy_P(name, p); 
+    AsyncWebHeader* result = getHeader( String(name)); 
+    free(name); 
+    return result; 
+  } else {
+    return nullptr; 
+  }
+}
+
+AsyncWebHeader* AsyncWebServerRequest::getHeader(size_t num) const {
+  auto header = _headers.nth(num);
+  return header ? *header : nullptr;
+}
+
+size_t AsyncWebServerRequest::params() const {
+  return _params.length();
+}
+
+bool AsyncWebServerRequest::hasParam(const String& name, bool post, bool file) const {
+  for(const auto& p: _params){
+    if(p->name() == name && p->isPost() == post && p->isFile() == file){
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AsyncWebServerRequest::hasParam(const __FlashStringHelper * data, bool post, bool file) const {
+  PGM_P p = reinterpret_cast(data);
+  size_t n = strlen_P(p);
+
+  char * name = (char*) malloc(n+1);
+  name[n] = 0; 
+  if (name) {
+    strcpy_P(name,p);    
+    bool result = hasParam( name, post, file); 
+    free(name); 
+    return result; 
+  } else {
+    return false; 
+  }
+}
+
+AsyncWebParameter* AsyncWebServerRequest::getParam(const String& name, bool post, bool file) const {
+  for(const auto& p: _params){
+    if(p->name() == name && p->isPost() == post && p->isFile() == file){
+      return p;
+    }
+  }
+  return nullptr;
+}
+
+AsyncWebParameter* AsyncWebServerRequest::getParam(const __FlashStringHelper * data, bool post, bool file) const {
+  PGM_P p = reinterpret_cast(data);
+  size_t n = strlen_P(p);
+  char * name = (char*) malloc(n+1);
+  if (name) {
+    strcpy_P(name, p);   
+    AsyncWebParameter* result = getParam(name, post, file); 
+    free(name); 
+    return result; 
+  } else {
+    return nullptr; 
+  }
+}
+
+AsyncWebParameter* AsyncWebServerRequest::getParam(size_t num) const {
+  auto param = _params.nth(num);
+  return param ? *param : nullptr;
+}
+
+void AsyncWebServerRequest::addInterestingHeader(const String& name){
+  if(!_interestingHeaders.containsIgnoreCase(name))
+    _interestingHeaders.add(name);
+}
+
+void AsyncWebServerRequest::send(AsyncWebServerResponse *response){
+  _response = response;
+  if(_response == NULL){
+    _client->close(true);
+    _onDisconnect();
+    return;
+  }
+  if(!_response->_sourceValid()){
+    delete response;
+    _response = NULL;
+    send(500);
+  }
+  else {
+    _client->setRxTimeout(0);
+    _response->_respond(this);
+  }
+}
+
+AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(int code, const String& contentType, const String& content){
+  return new AsyncBasicResponse(code, contentType, content);
+}
+
+AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(FS &fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback){
+  if(fs.exists(path) || (!download && fs.exists(path+".gz")))
+    return new AsyncFileResponse(fs, path, contentType, download, callback);
+  return NULL;
+}
+
+AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(File content, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback){
+  if(content == true)
+    return new AsyncFileResponse(content, path, contentType, download, callback);
+  return NULL;
+}
+
+AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback){
+  return new AsyncStreamResponse(stream, contentType, len, callback);
+}
+
+AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback){
+  return new AsyncCallbackResponse(contentType, len, callback, templateCallback);
+}
+
+AsyncWebServerResponse * AsyncWebServerRequest::beginChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback){
+  if(_version)
+    return new AsyncChunkedResponse(contentType, callback, templateCallback);
+  return new AsyncCallbackResponse(contentType, 0, callback, templateCallback);
+}
+
+AsyncResponseStream * AsyncWebServerRequest::beginResponseStream(const String& contentType, size_t bufferSize){
+  return new AsyncResponseStream(contentType, bufferSize);
+}
+
+AsyncWebServerResponse * AsyncWebServerRequest::beginResponse_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback){
+  return new AsyncProgmemResponse(code, contentType, content, len, callback);
+}
+
+AsyncWebServerResponse * AsyncWebServerRequest::beginResponse_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback){
+  return beginResponse_P(code, contentType, (const uint8_t *)content, strlen_P(content), callback);
+}
+
+void AsyncWebServerRequest::send(int code, const String& contentType, const String& content){
+  send(beginResponse(code, contentType, content));
+}
+
+void AsyncWebServerRequest::send(FS &fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback){
+  if(fs.exists(path) || (!download && fs.exists(path+".gz"))){
+    send(beginResponse(fs, path, contentType, download, callback));
+  } else send(404);
+}
+
+void AsyncWebServerRequest::send(File content, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback){
+  if(content == true){
+    send(beginResponse(content, path, contentType, download, callback));
+  } else send(404);
+}
+
+void AsyncWebServerRequest::send(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback){
+  send(beginResponse(stream, contentType, len, callback));
+}
+
+void AsyncWebServerRequest::send(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback){
+  send(beginResponse(contentType, len, callback, templateCallback));
+}
+
+void AsyncWebServerRequest::sendChunked(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback){
+  send(beginChunkedResponse(contentType, callback, templateCallback));
+}
+
+void AsyncWebServerRequest::send_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback){
+  send(beginResponse_P(code, contentType, content, len, callback));
+}
+
+void AsyncWebServerRequest::send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback){
+  send(beginResponse_P(code, contentType, content, callback));
+}
+
+void AsyncWebServerRequest::redirect(const String& url){
+  AsyncWebServerResponse * response = beginResponse(302);
+  response->addHeader("Location",url);
+  send(response);
+}
+
+bool AsyncWebServerRequest::authenticate(const char * username, const char * password, const char * realm, bool passwordIsHash){
+  if(_authorization.length()){
+    if(_isDigest)
+      return checkDigestAuthentication(_authorization.c_str(), methodToString(), username, password, realm, passwordIsHash, NULL, NULL, NULL);
+    else if(!passwordIsHash)
+      return checkBasicAuthentication(_authorization.c_str(), username, password);
+    else
+      return _authorization.equals(password);
+  }
+  return false;
+}
+
+bool AsyncWebServerRequest::authenticate(const char * hash){
+  if(!_authorization.length() || hash == NULL)
+    return false;
+
+  if(_isDigest){
+    String hStr = String(hash);
+    int separator = hStr.indexOf(":");
+    if(separator <= 0)
+      return false;
+    String username = hStr.substring(0, separator);
+    hStr = hStr.substring(separator + 1);
+    separator = hStr.indexOf(":");
+    if(separator <= 0)
+      return false;
+    String realm = hStr.substring(0, separator);
+    hStr = hStr.substring(separator + 1);
+    return checkDigestAuthentication(_authorization.c_str(), methodToString(), username.c_str(), hStr.c_str(), realm.c_str(), true, NULL, NULL, NULL);
+  }
+
+  return (_authorization.equals(hash));
+}
+
+void AsyncWebServerRequest::requestAuthentication(const char * realm, bool isDigest){
+  AsyncWebServerResponse * r = beginResponse(401);
+  if(!isDigest && realm == NULL){
+    r->addHeader("WWW-Authenticate", "Basic realm=\"Login Required\"");
+  } else if(!isDigest){
+    String header = "Basic realm=\"";
+    header.concat(realm);
+    header.concat("\"");
+    r->addHeader("WWW-Authenticate", header);
+  } else {
+    String header = "Digest ";
+    header.concat(requestDigestAuthentication(realm));
+    r->addHeader("WWW-Authenticate", header);
+  }
+  send(r);
+}
+
+bool AsyncWebServerRequest::hasArg(const char* name) const {
+  for(const auto& arg: _params){
+    if(arg->name() == name){
+      return true;
+    }
+  }
+  return false;
+}
+
+bool AsyncWebServerRequest::hasArg(const __FlashStringHelper * data) const {
+  PGM_P p = reinterpret_cast(data);
+  size_t n = strlen_P(p); 
+  char * name = (char*) malloc(n+1);
+  if (name) {
+    strcpy_P(name, p);    
+    bool result = hasArg( name ); 
+    free(name); 
+    return result; 
+  } else {
+    return false; 
+  }
+}
+
+
+const String& AsyncWebServerRequest::arg(const String& name) const {
+  for(const auto& arg: _params){
+    if(arg->name() == name){
+      return arg->value();
+    }
+  }
+  return SharedEmptyString;
+}
+
+const String& AsyncWebServerRequest::arg(const __FlashStringHelper * data) const {
+  PGM_P p = reinterpret_cast(data);
+  size_t n = strlen_P(p);
+  char * name = (char*) malloc(n+1);
+  if (name) {
+    strcpy_P(name, p);
+    const String & result = arg( String(name) ); 
+    free(name); 
+    return result; 
+  } else {
+    return SharedEmptyString;
+  }
+
+}
+
+const String& AsyncWebServerRequest::arg(size_t i) const {
+  return getParam(i)->value();
+}
+
+const String& AsyncWebServerRequest::argName(size_t i) const {
+  return getParam(i)->name();
+}
+
+const String& AsyncWebServerRequest::pathArg(size_t i) const {
+  auto param = _pathParams.nth(i);
+  return param ? **param : SharedEmptyString;
+}
+
+const String& AsyncWebServerRequest::header(const char* name) const {
+  AsyncWebHeader* h = getHeader(String(name));
+  return h ? h->value() : SharedEmptyString;
+}
+
+const String& AsyncWebServerRequest::header(const __FlashStringHelper * data) const {
+  PGM_P p = reinterpret_cast(data);
+  size_t n = strlen_P(p); 
+  char * name = (char*) malloc(n+1);
+  if (name) {
+    strcpy_P(name, p);  
+    const String & result = header( (const char *)name ); 
+    free(name); 
+    return result; 
+  } else {
+    return SharedEmptyString; 
+  }
+};  
+
+
+const String& AsyncWebServerRequest::header(size_t i) const {
+  AsyncWebHeader* h = getHeader(i);
+  return h ?  h->value() : SharedEmptyString;
+}
+
+const String& AsyncWebServerRequest::headerName(size_t i) const {
+  AsyncWebHeader* h = getHeader(i);
+  return h ? h->name() : SharedEmptyString;
+}
+
+String AsyncWebServerRequest::urlDecode(const String& text) const {
+  char temp[] = "0x00";
+  unsigned int len = text.length();
+  unsigned int i = 0;
+  String decoded = String();
+  decoded.reserve(len); // Allocate the string internal buffer - never longer from source text
+  while (i < len){
+    char decodedChar;
+    char encodedChar = text.charAt(i++);
+    if ((encodedChar == '%') && (i + 1 < len)){
+      temp[2] = text.charAt(i++);
+      temp[3] = text.charAt(i++);
+      decodedChar = strtol(temp, NULL, 16);
+    } else if (encodedChar == '+') {
+      decodedChar = ' ';
+    } else {
+      decodedChar = encodedChar;  // normal ascii char
+    }
+    decoded.concat(decodedChar);
+  }
+  return decoded;
+}
+
+
+const char * AsyncWebServerRequest::methodToString() const {
+  if(_method == HTTP_ANY) return "ANY";
+  else if(_method & HTTP_GET) return "GET";
+  else if(_method & HTTP_POST) return "POST";
+  else if(_method & HTTP_DELETE) return "DELETE";
+  else if(_method & HTTP_PUT) return "PUT";
+  else if(_method & HTTP_PATCH) return "PATCH";
+  else if(_method & HTTP_HEAD) return "HEAD";
+  else if(_method & HTTP_OPTIONS) return "OPTIONS";
+  return "UNKNOWN";
+}
+
+const char *AsyncWebServerRequest::requestedConnTypeToString() const {
+  switch (_reqconntype) {
+    case RCT_NOT_USED: return "RCT_NOT_USED";
+    case RCT_DEFAULT:  return "RCT_DEFAULT";
+    case RCT_HTTP:     return "RCT_HTTP";
+    case RCT_WS:       return "RCT_WS";
+    case RCT_EVENT:    return "RCT_EVENT";
+    default:           return "ERROR";
+  }
+}
+
+bool AsyncWebServerRequest::isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2, RequestedConnectionType erct3) {
+    bool res = false;
+    if ((erct1 != RCT_NOT_USED) && (erct1 == _reqconntype)) res = true;
+    if ((erct2 != RCT_NOT_USED) && (erct2 == _reqconntype)) res = true;
+    if ((erct3 != RCT_NOT_USED) && (erct3 == _reqconntype)) res = true;
+    return res;
+}
diff --git a/lib/ESPAsyncWebServer/src/WebResponseImpl.h b/lib/ESPAsyncWebServer/src/WebResponseImpl.h
new file mode 100644
index 00000000..9a64e3a5
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/WebResponseImpl.h
@@ -0,0 +1,136 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef ASYNCWEBSERVERRESPONSEIMPL_H_
+#define ASYNCWEBSERVERRESPONSEIMPL_H_
+
+#ifdef Arduino_h
+// arduino is not compatible with std::vector
+#undef min
+#undef max
+#endif
+#include 
+// It is possible to restore these defines, but one can use _min and _max instead. Or std::min, std::max.
+
+class AsyncBasicResponse: public AsyncWebServerResponse {
+  private:
+    String _content;
+  public:
+    AsyncBasicResponse(int code, const String& contentType=String(), const String& content=String());
+    void _respond(AsyncWebServerRequest *request);
+    size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+class AsyncAbstractResponse: public AsyncWebServerResponse {
+  private:
+    String _head;
+    // Data is inserted into cache at begin(). 
+    // This is inefficient with vector, but if we use some other container, 
+    // we won't be able to access it as contiguous array of bytes when reading from it,
+    // so by gaining performance in one place, we'll lose it in another.
+    std::vector _cache;
+    size_t _readDataFromCacheOrContent(uint8_t* data, const size_t len);
+    size_t _fillBufferAndProcessTemplates(uint8_t* buf, size_t maxLen);
+  protected:
+    AwsTemplateProcessor _callback;
+  public:
+    AsyncAbstractResponse(AwsTemplateProcessor callback=nullptr);
+    void _respond(AsyncWebServerRequest *request);
+    size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
+    bool _sourceValid() const { return false; }
+    virtual size_t _fillBuffer(uint8_t *buf __attribute__((unused)), size_t maxLen __attribute__((unused))) { return 0; }
+};
+
+#ifndef TEMPLATE_PLACEHOLDER
+#define TEMPLATE_PLACEHOLDER '%'
+#endif
+
+#define TEMPLATE_PARAM_NAME_LENGTH 32
+class AsyncFileResponse: public AsyncAbstractResponse {
+  using File = fs::File;
+  using FS = fs::FS;
+  private:
+    File _content;
+    String _path;
+    void _setContentType(const String& path);
+  public:
+    AsyncFileResponse(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);
+    AsyncFileResponse(File content, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);
+    ~AsyncFileResponse();
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class AsyncStreamResponse: public AsyncAbstractResponse {
+  private:
+    Stream *_content;
+  public:
+    AsyncStreamResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback=nullptr);
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class AsyncCallbackResponse: public AsyncAbstractResponse {
+  private:
+    AwsResponseFiller _content;
+    size_t _filledLength;
+  public:
+    AsyncCallbackResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class AsyncChunkedResponse: public AsyncAbstractResponse {
+  private:
+    AwsResponseFiller _content;
+    size_t _filledLength;
+  public:
+    AsyncChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class AsyncProgmemResponse: public AsyncAbstractResponse {
+  private:
+    const uint8_t * _content;
+    size_t _readLength;
+  public:
+    AsyncProgmemResponse(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr);
+    bool _sourceValid() const { return true; }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class cbuf;
+
+class AsyncResponseStream: public AsyncAbstractResponse, public Print {
+  private:
+    cbuf *_content;
+  public:
+    AsyncResponseStream(const String& contentType, size_t bufferSize);
+    ~AsyncResponseStream();
+    bool _sourceValid() const { return (_state < RESPONSE_END); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+    size_t write(const uint8_t *data, size_t len);
+    size_t write(uint8_t data);
+    using Print::write;
+};
+
+#endif /* ASYNCWEBSERVERRESPONSEIMPL_H_ */
diff --git a/lib/ESPAsyncWebServer/src/WebResponses.cpp b/lib/ESPAsyncWebServer/src/WebResponses.cpp
new file mode 100644
index 00000000..a22e991a
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/WebResponses.cpp
@@ -0,0 +1,699 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "ESPAsyncWebServer.h"
+#include "WebResponseImpl.h"
+#include "cbuf.h"
+
+// Since ESP8266 does not link memchr by default, here's its implementation.
+void* memchr(void* ptr, int ch, size_t count)
+{
+  unsigned char* p = static_cast(ptr);
+  while(count--)
+    if(*p++ == static_cast(ch))
+      return --p;
+  return nullptr;
+}
+
+
+/*
+ * Abstract Response
+ * */
+const char* AsyncWebServerResponse::_responseCodeToString(int code) {
+  switch (code) {
+    case 100: return "Continue";
+    case 101: return "Switching Protocols";
+    case 200: return "OK";
+    case 201: return "Created";
+    case 202: return "Accepted";
+    case 203: return "Non-Authoritative Information";
+    case 204: return "No Content";
+    case 205: return "Reset Content";
+    case 206: return "Partial Content";
+    case 300: return "Multiple Choices";
+    case 301: return "Moved Permanently";
+    case 302: return "Found";
+    case 303: return "See Other";
+    case 304: return "Not Modified";
+    case 305: return "Use Proxy";
+    case 307: return "Temporary Redirect";
+    case 400: return "Bad Request";
+    case 401: return "Unauthorized";
+    case 402: return "Payment Required";
+    case 403: return "Forbidden";
+    case 404: return "Not Found";
+    case 405: return "Method Not Allowed";
+    case 406: return "Not Acceptable";
+    case 407: return "Proxy Authentication Required";
+    case 408: return "Request Time-out";
+    case 409: return "Conflict";
+    case 410: return "Gone";
+    case 411: return "Length Required";
+    case 412: return "Precondition Failed";
+    case 413: return "Request Entity Too Large";
+    case 414: return "Request-URI Too Large";
+    case 415: return "Unsupported Media Type";
+    case 416: return "Requested range not satisfiable";
+    case 417: return "Expectation Failed";
+    case 500: return "Internal Server Error";
+    case 501: return "Not Implemented";
+    case 502: return "Bad Gateway";
+    case 503: return "Service Unavailable";
+    case 504: return "Gateway Time-out";
+    case 505: return "HTTP Version not supported";
+    default:  return "";
+  }
+}
+
+AsyncWebServerResponse::AsyncWebServerResponse()
+  : _code(0)
+  , _headers(LinkedList([](AsyncWebHeader *h){ delete h; }))
+  , _contentType()
+  , _contentLength(0)
+  , _sendContentLength(true)
+  , _chunked(false)
+  , _headLength(0)
+  , _sentLength(0)
+  , _ackedLength(0)
+  , _writtenLength(0)
+  , _state(RESPONSE_SETUP)
+{
+  for(auto header: DefaultHeaders::Instance()) {
+    _headers.add(new AsyncWebHeader(header->name(), header->value()));
+  }
+}
+
+AsyncWebServerResponse::~AsyncWebServerResponse(){
+  _headers.free();
+}
+
+void AsyncWebServerResponse::setCode(int code){
+  if(_state == RESPONSE_SETUP)
+    _code = code;
+}
+
+void AsyncWebServerResponse::setContentLength(size_t len){
+  if(_state == RESPONSE_SETUP)
+    _contentLength = len;
+}
+
+void AsyncWebServerResponse::setContentType(const String& type){
+  if(_state == RESPONSE_SETUP)
+    _contentType = type;
+}
+
+void AsyncWebServerResponse::addHeader(const String& name, const String& value){
+  _headers.add(new AsyncWebHeader(name, value));
+}
+
+String AsyncWebServerResponse::_assembleHead(uint8_t version){
+  if(version){
+    addHeader("Accept-Ranges","none");
+    if(_chunked)
+      addHeader("Transfer-Encoding","chunked");
+  }
+  String out = String();
+  int bufSize = 300;
+  char buf[bufSize];
+
+  snprintf(buf, bufSize, "HTTP/1.%d %d %s\r\n", version, _code, _responseCodeToString(_code));
+  out.concat(buf);
+
+  if(_sendContentLength) {
+    snprintf(buf, bufSize, "Content-Length: %d\r\n", _contentLength);
+    out.concat(buf);
+  }
+  if(_contentType.length()) {
+    snprintf(buf, bufSize, "Content-Type: %s\r\n", _contentType.c_str());
+    out.concat(buf);
+  }
+
+  for(const auto& header: _headers){
+    snprintf(buf, bufSize, "%s: %s\r\n", header->name().c_str(), header->value().c_str());
+    out.concat(buf);
+  }
+  _headers.free();
+
+  out.concat("\r\n");
+  _headLength = out.length();
+  return out;
+}
+
+bool AsyncWebServerResponse::_started() const { return _state > RESPONSE_SETUP; }
+bool AsyncWebServerResponse::_finished() const { return _state > RESPONSE_WAIT_ACK; }
+bool AsyncWebServerResponse::_failed() const { return _state == RESPONSE_FAILED; }
+bool AsyncWebServerResponse::_sourceValid() const { return false; }
+void AsyncWebServerResponse::_respond(AsyncWebServerRequest *request){ _state = RESPONSE_END; request->client()->close(); }
+size_t AsyncWebServerResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){ (void)request; (void)len; (void)time; return 0; }
+
+/*
+ * String/Code Response
+ * */
+AsyncBasicResponse::AsyncBasicResponse(int code, const String& contentType, const String& content){
+  _code = code;
+  _content = content;
+  _contentType = contentType;
+  if(_content.length()){
+    _contentLength = _content.length();
+    if(!_contentType.length())
+      _contentType = "text/plain";
+  }
+  addHeader("Connection","close");
+}
+
+void AsyncBasicResponse::_respond(AsyncWebServerRequest *request){
+  _state = RESPONSE_HEADERS;
+  String out = _assembleHead(request->version());
+  size_t outLen = out.length();
+  size_t space = request->client()->space();
+  if(!_contentLength && space >= outLen){
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_WAIT_ACK;
+  } else if(_contentLength && space >= outLen + _contentLength){
+    out += _content;
+    outLen += _contentLength;
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_WAIT_ACK;
+  } else if(space && space < outLen){
+    String partial = out.substring(0, space);
+    _content = out.substring(space) + _content;
+    _contentLength += outLen - space;
+    _writtenLength += request->client()->write(partial.c_str(), partial.length());
+    _state = RESPONSE_CONTENT;
+  } else if(space > outLen && space < (outLen + _contentLength)){
+    size_t shift = space - outLen;
+    outLen += shift;
+    _sentLength += shift;
+    out += _content.substring(0, shift);
+    _content = _content.substring(shift);
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_CONTENT;
+  } else {
+    _content = out + _content;
+    _contentLength += outLen;
+    _state = RESPONSE_CONTENT;
+  }
+}
+
+size_t AsyncBasicResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){
+  (void)time;
+  _ackedLength += len;
+  if(_state == RESPONSE_CONTENT){
+    size_t available = _contentLength - _sentLength;
+    size_t space = request->client()->space();
+    //we can fit in this packet
+    if(space > available){
+      _writtenLength += request->client()->write(_content.c_str(), available);
+      _content = String();
+      _state = RESPONSE_WAIT_ACK;
+      return available;
+    }
+    //send some data, the rest on ack
+    String out = _content.substring(0, space);
+    _content = _content.substring(space);
+    _sentLength += space;
+    _writtenLength += request->client()->write(out.c_str(), space);
+    return space;
+  } else if(_state == RESPONSE_WAIT_ACK){
+    if(_ackedLength >= _writtenLength){
+      _state = RESPONSE_END;
+    }
+  }
+  return 0;
+}
+
+
+/*
+ * Abstract Response
+ * */
+
+AsyncAbstractResponse::AsyncAbstractResponse(AwsTemplateProcessor callback): _callback(callback)
+{
+  // In case of template processing, we're unable to determine real response size
+  if(callback) {
+    _contentLength = 0;
+    _sendContentLength = false;
+    _chunked = true;
+  }
+}
+
+void AsyncAbstractResponse::_respond(AsyncWebServerRequest *request){
+  addHeader("Connection","close");
+  _head = _assembleHead(request->version());
+  _state = RESPONSE_HEADERS;
+  _ack(request, 0, 0);
+}
+
+size_t AsyncAbstractResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){
+  (void)time;
+  if(!_sourceValid()){
+    _state = RESPONSE_FAILED;
+    request->client()->close();
+    return 0;
+  }
+  _ackedLength += len;
+  size_t space = request->client()->space();
+
+  size_t headLen = _head.length();
+  if(_state == RESPONSE_HEADERS){
+    if(space >= headLen){
+      _state = RESPONSE_CONTENT;
+      space -= headLen;
+    } else {
+      String out = _head.substring(0, space);
+      _head = _head.substring(space);
+      _writtenLength += request->client()->write(out.c_str(), out.length());
+      return out.length();
+    }
+  }
+
+  if(_state == RESPONSE_CONTENT){
+    size_t outLen;
+    if(_chunked){
+      if(space <= 8){
+        return 0;
+      }
+      outLen = space;
+    } else if(!_sendContentLength){
+      outLen = space;
+    } else {
+      outLen = ((_contentLength - _sentLength) > space)?space:(_contentLength - _sentLength);
+    }
+
+    uint8_t *buf = (uint8_t *)malloc(outLen+headLen);
+    if (!buf) {
+      // os_printf("_ack malloc %d failed\n", outLen+headLen);
+      return 0;
+    }
+
+    if(headLen){
+      memcpy(buf, _head.c_str(), _head.length());
+    }
+
+    size_t readLen = 0;
+
+    if(_chunked){
+      // HTTP 1.1 allows leading zeros in chunk length. Or spaces may be added.
+      // See RFC2616 sections 2, 3.6.1.
+      readLen = _fillBufferAndProcessTemplates(buf+headLen+6, outLen - 8);
+      if(readLen == RESPONSE_TRY_AGAIN){
+          free(buf);
+          return 0;
+      }
+      outLen = sprintf((char*)buf+headLen, "%x", readLen) + headLen;
+      while(outLen < headLen + 4) buf[outLen++] = ' ';
+      buf[outLen++] = '\r';
+      buf[outLen++] = '\n';
+      outLen += readLen;
+      buf[outLen++] = '\r';
+      buf[outLen++] = '\n';
+    } else {
+      readLen = _fillBufferAndProcessTemplates(buf+headLen, outLen);
+      if(readLen == RESPONSE_TRY_AGAIN){
+          free(buf);
+          return 0;
+      }
+      outLen = readLen + headLen;
+    }
+
+    if(headLen){
+        _head = String();
+    }
+
+    if(outLen){
+        _writtenLength += request->client()->write((const char*)buf, outLen);
+    }
+
+    if(_chunked){
+        _sentLength += readLen;
+    } else {
+        _sentLength += outLen - headLen;
+    }
+
+    free(buf);
+
+    if((_chunked && readLen == 0) || (!_sendContentLength && outLen == 0) || (!_chunked && _sentLength == _contentLength)){
+      _state = RESPONSE_WAIT_ACK;
+    }
+    return outLen;
+
+  } else if(_state == RESPONSE_WAIT_ACK){
+    if(!_sendContentLength || _ackedLength >= _writtenLength){
+      _state = RESPONSE_END;
+      if(!_chunked && !_sendContentLength)
+        request->client()->close(true);
+    }
+  }
+  return 0;
+}
+
+size_t AsyncAbstractResponse::_readDataFromCacheOrContent(uint8_t* data, const size_t len)
+{
+    // If we have something in cache, copy it to buffer
+    const size_t readFromCache = std::min(len, _cache.size());
+    if(readFromCache) {
+      memcpy(data, _cache.data(), readFromCache);
+      _cache.erase(_cache.begin(), _cache.begin() + readFromCache);
+    }
+    // If we need to read more...
+    const size_t needFromFile = len - readFromCache;
+    const size_t readFromContent = _fillBuffer(data + readFromCache, needFromFile);
+    return readFromCache + readFromContent;
+}
+
+size_t AsyncAbstractResponse::_fillBufferAndProcessTemplates(uint8_t* data, size_t len)
+{
+  if(!_callback)
+    return _fillBuffer(data, len);
+
+  const size_t originalLen = len;
+  len = _readDataFromCacheOrContent(data, len);
+  // Now we've read 'len' bytes, either from cache or from file
+  // Search for template placeholders
+  uint8_t* pTemplateStart = data;
+  while((pTemplateStart < &data[len]) && (pTemplateStart = (uint8_t*)memchr(pTemplateStart, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart + 1))) { // data[0] ... data[len - 1]
+    uint8_t* pTemplateEnd = (pTemplateStart < &data[len - 1]) ? (uint8_t*)memchr(pTemplateStart + 1, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart) : nullptr;
+    // temporary buffer to hold parameter name
+    uint8_t buf[TEMPLATE_PARAM_NAME_LENGTH + 1];
+    String paramName;
+    // If closing placeholder is found:
+    if(pTemplateEnd) {
+      // prepare argument to callback
+      const size_t paramNameLength = std::min(sizeof(buf) - 1, (unsigned int)(pTemplateEnd - pTemplateStart - 1));
+      if(paramNameLength) {
+        memcpy(buf, pTemplateStart + 1, paramNameLength);
+        buf[paramNameLength] = 0;
+        paramName = String(reinterpret_cast(buf));
+      } else { // double percent sign encountered, this is single percent sign escaped.
+        // remove the 2nd percent sign
+        memmove(pTemplateEnd, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1);
+        len += _readDataFromCacheOrContent(&data[len - 1], 1) - 1;
+        ++pTemplateStart;
+      }
+    } else if(&data[len - 1] - pTemplateStart + 1 < TEMPLATE_PARAM_NAME_LENGTH + 2) { // closing placeholder not found, check if it's in the remaining file data
+      memcpy(buf, pTemplateStart + 1, &data[len - 1] - pTemplateStart);
+      const size_t readFromCacheOrContent = _readDataFromCacheOrContent(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PARAM_NAME_LENGTH + 2 - (&data[len - 1] - pTemplateStart + 1));
+      if(readFromCacheOrContent) {
+        pTemplateEnd = (uint8_t*)memchr(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PLACEHOLDER, readFromCacheOrContent);
+        if(pTemplateEnd) {
+          // prepare argument to callback
+          *pTemplateEnd = 0;
+          paramName = String(reinterpret_cast(buf));
+          // Copy remaining read-ahead data into cache
+          _cache.insert(_cache.begin(), pTemplateEnd + 1, buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent);
+          pTemplateEnd = &data[len - 1];
+        }
+        else // closing placeholder not found in file data, store found percent symbol as is and advance to the next position
+        {
+          // but first, store read file data in cache
+          _cache.insert(_cache.begin(), buf + (&data[len - 1] - pTemplateStart), buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent);
+          ++pTemplateStart;
+        }
+      }
+      else // closing placeholder not found in content data, store found percent symbol as is and advance to the next position
+        ++pTemplateStart;
+    }
+    else // closing placeholder not found in content data, store found percent symbol as is and advance to the next position
+      ++pTemplateStart;
+    if(paramName.length()) {
+      // call callback and replace with result.
+      // Everything in range [pTemplateStart, pTemplateEnd] can be safely replaced with parameter value.
+      // Data after pTemplateEnd may need to be moved.
+      // The first byte of data after placeholder is located at pTemplateEnd + 1.
+      // It should be located at pTemplateStart + numBytesCopied (to begin right after inserted parameter value).
+      const String paramValue(_callback(paramName));
+      const char* pvstr = paramValue.c_str();
+      const unsigned int pvlen = paramValue.length();
+      const size_t numBytesCopied = std::min(pvlen, static_cast(&data[originalLen - 1] - pTemplateStart + 1));
+      // make room for param value
+      // 1. move extra data to cache if parameter value is longer than placeholder AND if there is no room to store
+      if((pTemplateEnd + 1 < pTemplateStart + numBytesCopied) && (originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1) < len)) {
+        _cache.insert(_cache.begin(), &data[originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1)], &data[len]);
+        //2. parameter value is longer than placeholder text, push the data after placeholder which not saved into cache further to the end
+        memmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[originalLen] - pTemplateStart - numBytesCopied);
+        len = originalLen; // fix issue with truncated data, not sure if it has any side effects
+      } else if(pTemplateEnd + 1 != pTemplateStart + numBytesCopied)
+        //2. Either parameter value is shorter than placeholder text OR there is enough free space in buffer to fit.
+        //   Move the entire data after the placeholder
+        memmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1);
+      // 3. replace placeholder with actual value
+      memcpy(pTemplateStart, pvstr, numBytesCopied);
+      // If result is longer than buffer, copy the remainder into cache (this could happen only if placeholder text itself did not fit entirely in buffer)
+      if(numBytesCopied < pvlen) {
+        _cache.insert(_cache.begin(), pvstr + numBytesCopied, pvstr + pvlen);
+      } else if(pTemplateStart + numBytesCopied < pTemplateEnd + 1) { // result is copied fully; if result is shorter than placeholder text...
+        // there is some free room, fill it from cache
+        const size_t roomFreed = pTemplateEnd + 1 - pTemplateStart - numBytesCopied;
+        const size_t totalFreeRoom = originalLen - len + roomFreed;
+        len += _readDataFromCacheOrContent(&data[len - roomFreed], totalFreeRoom) - roomFreed;
+      } else { // result is copied fully; it is longer than placeholder text
+        const size_t roomTaken = pTemplateStart + numBytesCopied - pTemplateEnd - 1;
+        len = std::min(len + roomTaken, originalLen);
+      }
+    }
+  } // while(pTemplateStart)
+  return len;
+}
+
+
+/*
+ * File Response
+ * */
+
+AsyncFileResponse::~AsyncFileResponse(){
+  if(_content)
+    _content.close();
+}
+
+void AsyncFileResponse::_setContentType(const String& path){
+  if (path.endsWith(".html")) _contentType = "text/html";
+  else if (path.endsWith(".htm")) _contentType = "text/html";
+  else if (path.endsWith(".css")) _contentType = "text/css";
+  else if (path.endsWith(".json")) _contentType = "application/json";
+  else if (path.endsWith(".js")) _contentType = "application/javascript";
+  else if (path.endsWith(".png")) _contentType = "image/png";
+  else if (path.endsWith(".gif")) _contentType = "image/gif";
+  else if (path.endsWith(".jpg")) _contentType = "image/jpeg";
+  else if (path.endsWith(".ico")) _contentType = "image/x-icon";
+  else if (path.endsWith(".svg")) _contentType = "image/svg+xml";
+  else if (path.endsWith(".eot")) _contentType = "font/eot";
+  else if (path.endsWith(".woff")) _contentType = "font/woff";
+  else if (path.endsWith(".woff2")) _contentType = "font/woff2";
+  else if (path.endsWith(".ttf")) _contentType = "font/ttf";
+  else if (path.endsWith(".xml")) _contentType = "text/xml";
+  else if (path.endsWith(".pdf")) _contentType = "application/pdf";
+  else if (path.endsWith(".zip")) _contentType = "application/zip";
+  else if(path.endsWith(".gz")) _contentType = "application/x-gzip";
+  else _contentType = "text/plain";
+}
+
+AsyncFileResponse::AsyncFileResponse(FS &fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback): AsyncAbstractResponse(callback){
+  _code = 200;
+  _path = path;
+
+  if(!download && !fs.exists(_path) && fs.exists(_path+".gz")){
+    _path = _path+".gz";
+    addHeader("Content-Encoding", "gzip");
+    _callback = nullptr; // Unable to process zipped templates
+    _sendContentLength = true;
+    _chunked = false;
+  }
+
+  _content = fs.open(_path, "r");
+  _contentLength = _content.size();
+
+  if(contentType == "")
+    _setContentType(path);
+  else
+    _contentType = contentType;
+
+  int filenameStart = path.lastIndexOf('/') + 1;
+  char buf[26+path.length()-filenameStart];
+  char* filename = (char*)path.c_str() + filenameStart;
+
+  if(download) {
+    // set filename and force download
+    snprintf(buf, sizeof (buf), "attachment; filename=\"%s\"", filename);
+  } else {
+    // set filename and force rendering
+    snprintf(buf, sizeof (buf), "inline; filename=\"%s\"", filename);
+  }
+  addHeader("Content-Disposition", buf);
+}
+
+AsyncFileResponse::AsyncFileResponse(File content, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback): AsyncAbstractResponse(callback){
+  _code = 200;
+  _path = path;
+
+  if(!download && String(content.name()).endsWith(".gz") && !path.endsWith(".gz")){
+    addHeader("Content-Encoding", "gzip");
+    _callback = nullptr; // Unable to process gzipped templates
+    _sendContentLength = true;
+    _chunked = false;
+  }
+
+  _content = content;
+  _contentLength = _content.size();
+
+  if(contentType == "")
+    _setContentType(path);
+  else
+    _contentType = contentType;
+
+  int filenameStart = path.lastIndexOf('/') + 1;
+  char buf[26+path.length()-filenameStart];
+  char* filename = (char*)path.c_str() + filenameStart;
+
+  if(download) {
+    snprintf(buf, sizeof (buf), "attachment; filename=\"%s\"", filename);
+  } else {
+    snprintf(buf, sizeof (buf), "inline; filename=\"%s\"", filename);
+  }
+  addHeader("Content-Disposition", buf);
+}
+
+size_t AsyncFileResponse::_fillBuffer(uint8_t *data, size_t len){
+  return _content.read(data, len);
+}
+
+/*
+ * Stream Response
+ * */
+
+AsyncStreamResponse::AsyncStreamResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback): AsyncAbstractResponse(callback) {
+  _code = 200;
+  _content = &stream;
+  _contentLength = len;
+  _contentType = contentType;
+}
+
+size_t AsyncStreamResponse::_fillBuffer(uint8_t *data, size_t len){
+  size_t available = _content->available();
+  size_t outLen = (available > len)?len:available;
+  size_t i;
+  for(i=0;iread();
+  return outLen;
+}
+
+/*
+ * Callback Response
+ * */
+
+AsyncCallbackResponse::AsyncCallbackResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback): AsyncAbstractResponse(templateCallback) {
+  _code = 200;
+  _content = callback;
+  _contentLength = len;
+  if(!len)
+    _sendContentLength = false;
+  _contentType = contentType;
+  _filledLength = 0;
+}
+
+size_t AsyncCallbackResponse::_fillBuffer(uint8_t *data, size_t len){
+  size_t ret = _content(data, len, _filledLength);
+  if(ret != RESPONSE_TRY_AGAIN){
+      _filledLength += ret;
+  }
+  return ret;
+}
+
+/*
+ * Chunked Response
+ * */
+
+AsyncChunkedResponse::AsyncChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor processorCallback): AsyncAbstractResponse(processorCallback) {
+  _code = 200;
+  _content = callback;
+  _contentLength = 0;
+  _contentType = contentType;
+  _sendContentLength = false;
+  _chunked = true;
+  _filledLength = 0;
+}
+
+size_t AsyncChunkedResponse::_fillBuffer(uint8_t *data, size_t len){
+  size_t ret = _content(data, len, _filledLength);
+  if(ret != RESPONSE_TRY_AGAIN){
+      _filledLength += ret;
+  }
+  return ret;
+}
+
+/*
+ * Progmem Response
+ * */
+
+AsyncProgmemResponse::AsyncProgmemResponse(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback): AsyncAbstractResponse(callback) {
+  _code = code;
+  _content = content;
+  _contentType = contentType;
+  _contentLength = len;
+  _readLength = 0;
+}
+
+size_t AsyncProgmemResponse::_fillBuffer(uint8_t *data, size_t len){
+  size_t left = _contentLength - _readLength;
+  if (left > len) {
+    memcpy_P(data, _content + _readLength, len);
+    _readLength += len;
+    return len;
+  }
+  memcpy_P(data, _content + _readLength, left);
+  _readLength += left;
+  return left;
+}
+
+
+/*
+ * Response Stream (You can print/write/printf to it, up to the contentLen bytes)
+ * */
+
+AsyncResponseStream::AsyncResponseStream(const String& contentType, size_t bufferSize){
+  _code = 200;
+  _contentLength = 0;
+  _contentType = contentType;
+  _content = new cbuf(bufferSize);
+}
+
+AsyncResponseStream::~AsyncResponseStream(){
+  delete _content;
+}
+
+size_t AsyncResponseStream::_fillBuffer(uint8_t *buf, size_t maxLen){
+  return _content->read((char*)buf, maxLen);
+}
+
+size_t AsyncResponseStream::write(const uint8_t *data, size_t len){
+  if(_started())
+    return 0;
+
+  if(len > _content->room()){
+    size_t needed = len - _content->room();
+    _content->resizeAdd(needed);
+  }
+  size_t written = _content->write((const char*)data, len);
+  _contentLength += written;
+  return written;
+}
+
+size_t AsyncResponseStream::write(uint8_t data){
+  return write(&data, 1);
+}
diff --git a/lib/ESPAsyncWebServer/src/WebServer.cpp b/lib/ESPAsyncWebServer/src/WebServer.cpp
new file mode 100644
index 00000000..95c2dd69
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/WebServer.cpp
@@ -0,0 +1,193 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include "ESPAsyncWebServer.h"
+#include "WebHandlerImpl.h"
+
+bool ON_STA_FILTER(AsyncWebServerRequest *request) {
+  return WiFi.localIP() == request->client()->localIP();
+}
+
+bool ON_AP_FILTER(AsyncWebServerRequest *request) {
+  return WiFi.localIP() != request->client()->localIP();
+}
+
+
+AsyncWebServer::AsyncWebServer(uint16_t port)
+  : _server(port)
+  , _rewrites(LinkedList([](AsyncWebRewrite* r){ delete r; }))
+  , _handlers(LinkedList([](AsyncWebHandler* h){ delete h; }))
+{
+  _catchAllHandler = new AsyncCallbackWebHandler();
+  if(_catchAllHandler == NULL)
+    return;
+  _server.onClient([](void *s, AsyncClient* c){
+    if(c == NULL)
+      return;
+    c->setRxTimeout(3);
+    AsyncWebServerRequest *r = new AsyncWebServerRequest((AsyncWebServer*)s, c);
+    if(r == NULL){
+      c->close(true);
+      c->free();
+      delete c;
+    }
+  }, this);
+}
+
+AsyncWebServer::~AsyncWebServer(){
+  reset();  
+  end();
+  if(_catchAllHandler) delete _catchAllHandler;
+}
+
+AsyncWebRewrite& AsyncWebServer::addRewrite(AsyncWebRewrite* rewrite){
+  _rewrites.add(rewrite);
+  return *rewrite;
+}
+
+bool AsyncWebServer::removeRewrite(AsyncWebRewrite *rewrite){
+  return _rewrites.remove(rewrite);
+}
+
+AsyncWebRewrite& AsyncWebServer::rewrite(const char* from, const char* to){
+  return addRewrite(new AsyncWebRewrite(from, to));
+}
+
+AsyncWebHandler& AsyncWebServer::addHandler(AsyncWebHandler* handler){
+  _handlers.add(handler);
+  return *handler;
+}
+
+bool AsyncWebServer::removeHandler(AsyncWebHandler *handler){
+  return _handlers.remove(handler);
+}
+
+void AsyncWebServer::begin(){
+  _server.setNoDelay(true);
+  _server.begin();
+}
+
+void AsyncWebServer::end(){
+  _server.end();
+}
+
+#if ASYNC_TCP_SSL_ENABLED
+void AsyncWebServer::onSslFileRequest(AcSSlFileHandler cb, void* arg){
+  _server.onSslFileRequest(cb, arg);
+}
+
+void AsyncWebServer::beginSecure(const char *cert, const char *key, const char *password){
+  _server.beginSecure(cert, key, password);
+}
+#endif
+
+void AsyncWebServer::_handleDisconnect(AsyncWebServerRequest *request){
+  delete request;
+}
+
+void AsyncWebServer::_rewriteRequest(AsyncWebServerRequest *request){
+  for(const auto& r: _rewrites){
+    if (r->match(request)){
+      request->_url = r->toUrl();
+      request->_addGetParams(r->params());
+    }
+  }
+}
+
+void AsyncWebServer::_attachHandler(AsyncWebServerRequest *request){
+  for(const auto& h: _handlers){
+    if (h->filter(request) && h->canHandle(request)){
+      request->setHandler(h);
+      return;
+    }
+  }
+  
+  request->addInterestingHeader("ANY");
+  request->setHandler(_catchAllHandler);
+}
+
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody){
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  handler->onUpload(onUpload);
+  handler->onBody(onBody);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload){
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  handler->onUpload(onUpload);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest){
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, ArRequestHandlerFunction onRequest){
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->onRequest(onRequest);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncStaticWebHandler& AsyncWebServer::serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control){
+  AsyncStaticWebHandler* handler = new AsyncStaticWebHandler(uri, fs, path, cache_control);
+  addHandler(handler);
+  return *handler;
+}
+
+void AsyncWebServer::onNotFound(ArRequestHandlerFunction fn){
+  _catchAllHandler->onRequest(fn);
+}
+
+void AsyncWebServer::onFileUpload(ArUploadHandlerFunction fn){
+  _catchAllHandler->onUpload(fn);
+}
+
+void AsyncWebServer::onRequestBody(ArBodyHandlerFunction fn){
+  _catchAllHandler->onBody(fn);
+}
+
+void AsyncWebServer::reset(){
+  _rewrites.free();
+  _handlers.free();
+  
+  if (_catchAllHandler != NULL){
+    _catchAllHandler->onRequest(NULL);
+    _catchAllHandler->onUpload(NULL);
+    _catchAllHandler->onBody(NULL);
+  }
+}
+
diff --git a/lib/ESPAsyncWebServer/src/edit.htm b/lib/ESPAsyncWebServer/src/edit.htm
new file mode 100644
index 00000000..43d49845
--- /dev/null
+++ b/lib/ESPAsyncWebServer/src/edit.htm
@@ -0,0 +1,627 @@
+
+
+
+
+ESP Editor
+
+
+
+
+
+
+  

+  

+  

+  

+  
+  
+
+
diff --git a/lib/GyverFilters/examples/GFilterRA/GFilterRA.ino b/lib/GyverFilters/examples/GFilterRA/GFilterRA.ino
new file mode 100644
index 00000000..c6db1517
--- /dev/null
+++ b/lib/GyverFilters/examples/GFilterRA/GFilterRA.ino
@@ -0,0 +1,16 @@
+#include "GyverFilters.h"
+GFilterRA analog0;    // фильтр назовём analog0
+
+void setup() {
+  Serial.begin(9600);
+
+  // установка коэффициента фильтрации (0.0... 1.0). Чем меньше, тем плавнее фильтр
+  analog0.setCoef(0.01);
+
+  // установка шага фильтрации (мс). Чем меньше, тем резче фильтр
+  analog0.setStep(10);
+}
+
+void loop() {
+  Serial.println(analog0.filteredTime(analogRead(0)));
+}
diff --git a/lib/GyverFilters/examples/GLinear_arrays/GLinear_arrays.ino b/lib/GyverFilters/examples/GLinear_arrays/GLinear_arrays.ino
new file mode 100644
index 00000000..6c407ec4
--- /dev/null
+++ b/lib/GyverFilters/examples/GLinear_arrays/GLinear_arrays.ino
@@ -0,0 +1,32 @@
+/*
+  Пример линейной аппроксимации методом наименьших квадратов
+  Два массива: по оси Х и по оси У
+  Линейная аппроксимация повозоляет получить уравнение прямой,
+  равноудалённой от точек на плоскости ХУ. Удобно для расчёта
+  роста изменяющейся шумящей величины. Уравнение вида у = A*x + B
+  В папке с данным примером есть скриншот из excel,
+  иллюстрирующий работу аппроксимации с такими же исходными
+*/
+
+// два массива с данными (одинаковой размероности и размера)
+int x_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+int y_array[] = {1, 5, 2, 8, 3, 9, 10, 5, 15, 12};
+
+#include 
+GLinear test;    // указываем тип данных в <>
+
+void setup() {
+  Serial.begin(9600);
+
+  // передаём массивы и размер одного из них
+  test.compute((int*)x_array, (int*)y_array, sizeof(x_array));
+
+  // Уравнение вида у = A*x + B
+  Serial.println(test.getA());  // получить коэффициент А
+  Serial.println(test.getB());  // получить коэффициент В
+  Serial.println(test.getDelta());  // получить изменение (аппроксимированное)
+}
+
+void loop() {
+
+}
\ No newline at end of file
diff --git a/lib/GyverFilters/examples/GLinear_arrays/excel.jpg b/lib/GyverFilters/examples/GLinear_arrays/excel.jpg
new file mode 100644
index 00000000..9cd71117
Binary files /dev/null and b/lib/GyverFilters/examples/GLinear_arrays/excel.jpg differ
diff --git a/lib/GyverFilters/examples/GLinear_running/GLinear_running.ino b/lib/GyverFilters/examples/GLinear_running/GLinear_running.ino
new file mode 100644
index 00000000..575c50dc
--- /dev/null
+++ b/lib/GyverFilters/examples/GLinear_running/GLinear_running.ino
@@ -0,0 +1,34 @@
+/*
+  Пример линейной аппроксимации методом наименьших квадратов
+  Два массива: по оси Х и по оси У
+  Наполнение массивов осуществляется динамически: сдвигом и записью в крайнюю ячейку,
+  то есть аппроксимация по последним ARRAY_SIZE изменениям!!
+*/
+#define ARRAY_SIZE 10   // размер пространства для аппроксимации
+
+// два массива с данными (одинаковой размероности и размера)
+int x_array[ARRAY_SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};  // ось x от 1 до 10, допустим СЕКУНД
+int y_array[ARRAY_SIZE];    // значения по оси У будем брать с датчика
+
+#include 
+GLinear test;    // указываем тип данных в <>
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  for (byte i = 0; i < ARRAY_SIZE - 1; i++) {    // счётчик от 0 до ARRAY_SIZE
+    y_array[i] = y_array[i + 1];    // сдвинуть массив давлений КРОМЕ ПОСЛЕДНЕЙ ЯЧЕЙКИ на шаг назад
+  }
+  // последний элемент массива теперь - новое значение (просто с аналог. датчика)
+  y_array[ARRAY_SIZE - 1] = analogRead(0);
+
+  // передаём массивы и размер одного из них
+  test.compute((int*)x_array, (int*)y_array, sizeof(x_array));
+
+  // по нашим исходным данным это будет производная, т.е. "изменение единиц в секунду"
+  Serial.println(test.getDelta());  // получить изменение (аппроксимированное)
+
+  delay(1000);  // секундная задержка
+}
diff --git a/lib/GyverFilters/examples/alphabeta_example/alphabeta_example.ino b/lib/GyverFilters/examples/alphabeta_example/alphabeta_example.ino
new file mode 100644
index 00000000..8f43b77a
--- /dev/null
+++ b/lib/GyverFilters/examples/alphabeta_example/alphabeta_example.ino
@@ -0,0 +1,24 @@
+/*
+   Пример альфа-бета фильтра
+*/
+
+#include "GyverFilters.h"
+
+// параметры: период дискретизации (измерений), process variation, noise variation
+GABfilter testFilter(0.08, 40, 1);
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  delay(80);
+  int value = analogRead(0);
+  value += random(2) * random(-1, 2) * random(10, 70);
+  Serial.print("$");
+  Serial.print(value);
+  Serial.print(" ");
+  value = testFilter.filtered((int)value);
+  Serial.print(value);
+  Serial.println(";");
+}
diff --git a/lib/GyverFilters/examples/filters_comparsion/filters_comparsion.ino b/lib/GyverFilters/examples/filters_comparsion/filters_comparsion.ino
new file mode 100644
index 00000000..b981993a
--- /dev/null
+++ b/lib/GyverFilters/examples/filters_comparsion/filters_comparsion.ino
@@ -0,0 +1,30 @@
+/*
+   Сравнение калмана и бегущего среднего
+*/
+#include "GyverFilters.h"
+
+// параметры: разброс измерения, разброс оценки, скорость изменения значений
+// разброс измерения: шум измерений
+// разброс оценки: подстраивается сам, можно поставить таким же как разброс измерения
+// скорость изменения значений: 0.001-1, варьировать самому
+
+GKalman kalman(90, 90, 0.5);
+GFilterRA average(0.5, 80);
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {  
+  int value = analogRead(0);
+  value += random(2) * random(-1, 2) * random(50, 100);
+  Serial.print("$");
+  Serial.print(value);
+  Serial.print(" ");  
+  
+  Serial.print((int)kalman.filtered(value));
+  Serial.print(" ");
+  Serial.print((int)average.filtered(value));
+  Serial.println(";");
+  delay(80);
+}
diff --git a/lib/GyverFilters/examples/kalman_example/kalman_example.ino b/lib/GyverFilters/examples/kalman_example/kalman_example.ino
new file mode 100644
index 00000000..802307af
--- /dev/null
+++ b/lib/GyverFilters/examples/kalman_example/kalman_example.ino
@@ -0,0 +1,31 @@
+/*
+   Пример простого одномерного фильтра
+*/
+
+#include "GyverFilters.h"
+
+// параметры: разброс измерения, разброс оценки, скорость изменения значений
+// разброс измерения: шум измерений
+// разброс оценки: подстраивается сам, можно поставить таким же как разброс измерения
+// скорость изменения значений: 0.001-1, варьировать самому
+
+GKalman testFilter(40, 40, 0.5);
+
+// также может быть объявлен как (разброс измерения, скорость изменения значений)
+// GKalman testFilter(40, 0.5);
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  delay(80);
+  int value = analogRead(0);
+  value += random(2) * random(-1, 2) * random(10, 70);
+  Serial.print("$");
+  Serial.print(value);
+  Serial.print(" ");
+  value = testFilter.filtered((int)value);
+  Serial.print(value);
+  Serial.println(";");
+}
diff --git a/lib/GyverFilters/examples/median3_example/median3_example.ino b/lib/GyverFilters/examples/median3_example/median3_example.ino
new file mode 100644
index 00000000..c99176bc
--- /dev/null
+++ b/lib/GyverFilters/examples/median3_example/median3_example.ino
@@ -0,0 +1,21 @@
+/*
+	Пример использования быстрого медианного фильтра 3 порядка
+*/
+
+#include "GyverFilters.h"
+GMedian3 testFilter; 		// указываем тип данных в <>
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {    
+  int value = analogRead(0);
+  // добавляем шум "выбросы"
+  value += random(2) * random(2) * random(-1, 2) * random(50, 250);
+  Serial.print(value);
+  Serial.print(',');  
+  value = testFilter.filtered(value);
+  Serial.println(value);
+  delay(80);
+}
diff --git a/lib/GyverFilters/examples/median_example/median_example.ino b/lib/GyverFilters/examples/median_example/median_example.ino
new file mode 100644
index 00000000..c3fb0067
--- /dev/null
+++ b/lib/GyverFilters/examples/median_example/median_example.ino
@@ -0,0 +1,23 @@
+/*
+	Пример использования медианного фильтра.
+*/
+
+#include "GyverFilters.h"
+
+// указываем размер окна и тип данных в <>
+GMedian<10, int> testFilter;    
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  delay(80);
+  int value = analogRead(0);
+  // добавляем шум "выбросы"
+  value += random(2) * random(2) * random(-1, 2) * random(50, 250);
+  Serial.print(value);
+  Serial.print(',');  
+  value = testFilter.filtered(value);
+  Serial.println(value);
+}
\ No newline at end of file
diff --git a/lib/GyverFilters/keywords.txt b/lib/GyverFilters/keywords.txt
new file mode 100644
index 00000000..57f38dbc
--- /dev/null
+++ b/lib/GyverFilters/keywords.txt
@@ -0,0 +1,28 @@
+#######################################
+# Syntax Coloring Map For GyverFilters
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+GyverFilters	KEYWORD1
+GFilterRA	KEYWORD1
+GMedian3	KEYWORD1
+GMedian	KEYWORD1
+GABfilter	KEYWORD1
+GKalman	KEYWORD1
+GLinear	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+setCoef	KEYWORD2
+setStep	KEYWORD2
+filteredTime	KEYWORD2
+filtered	KEYWORD2
+setParameters	KEYWORD2
+getA	KEYWORD2
+getB	KEYWORD2
+getDelta	KEYWORD2
\ No newline at end of file
diff --git a/lib/GyverFilters/library.properties b/lib/GyverFilters/library.properties
new file mode 100644
index 00000000..2c0c881a
--- /dev/null
+++ b/lib/GyverFilters/library.properties
@@ -0,0 +1,9 @@
+name=GyverFilters
+version=2.1
+author=AlexGyver 
+maintainer=AlexGyver 
+sentence=Library with few filters for data.
+paragraph=Includes median, running average, AB, simplified Kalman and linear approximation filtering algorithms.
+category=Data Processing
+url=https://github.com/AlexGyver/GyverLibs
+architectures=*
\ No newline at end of file
diff --git a/lib/GyverFilters/src/GyverFilters.h b/lib/GyverFilters/src/GyverFilters.h
new file mode 100644
index 00000000..cb35777c
--- /dev/null
+++ b/lib/GyverFilters/src/GyverFilters.h
@@ -0,0 +1,28 @@
+#pragma once
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+/*
+	GyverFilters - библиотека с некоторыми удобными фильтрами.
+	Документация: https://alexgyver.ru/gyverfilters/
+	- GFilterRA - компактная альтернатива фильтра экспоненциальное бегущее среднее (Running Average)			
+	- GMedian3 - быстрый медианный фильтр 3-го порядка (отсекает выбросы)
+	- GMedian - медианный фильтр N-го порядка. Порядок настраивается в GyverFilters.h - MEDIAN_FILTER_SIZE
+	- GABfilter - альфа-бета фильтр (разновидность Калмана для одномерного случая)
+	- GKalman - упрощённый Калман для одномерного случая (на мой взгляд лучший из фильтров)
+	- GLinear - линейная аппроксимация методом наименьших квадратов для двух массивов
+	
+	Версии
+	- 1.6 от 12.11.2019
+	- 1.7: исправлен GLinear
+	- 1.8: небольшие улучшения
+	- 2.0:
+		- Улучшен и исправлен median и median3
+		- Улучшен linear
+		- Смотрите примеры! Использование этих фильтров чуть изменилось
+	- 2.1: Исправлен расчёт дельты в линейном фильтре
+*/
\ No newline at end of file
diff --git a/lib/GyverFilters/src/filters/alfaBeta.h b/lib/GyverFilters/src/filters/alfaBeta.h
new file mode 100644
index 00000000..51b09726
--- /dev/null
+++ b/lib/GyverFilters/src/filters/alfaBeta.h
@@ -0,0 +1,37 @@
+#pragma once
+#include 
+
+// альфа-бета фильтр
+class GABfilter {
+public:
+	// период дискретизации (измерений), process variation, noise variation
+	GABfilter(float delta, float sigma_process, float sigma_noise) {setParameters(delta, sigma_process, sigma_noise);}
+	
+	// период дискретизации (измерений), process variation, noise variation
+	void setParameters(float delta, float sigma_process, float sigma_noise) {
+		dt = delta;
+		float lambda = (float)sigma_process * dt * dt / sigma_noise;
+		float r = (4 + lambda - (float)sqrt(8 * lambda + lambda * lambda)) / 4;
+		a = (float)1 - r * r;
+		b = (float)2 * (2 - a) - 4 * (float)sqrt(1 - a);
+	}
+	
+	// возвращает фильтрованное значение
+	float filtered(float value) {				
+		xm = value;
+		xk = xk_1 + ((float) vk_1 * dt );
+		vk = vk_1;
+		rk = xm - xk;
+		xk += (float)a * rk;
+		vk += (float)( b * rk ) / dt;
+		xk_1 = xk;
+		vk_1 = vk;
+		return xk_1;
+	}
+	
+private:
+	float dt;
+	float xk_1, vk_1, a, b;
+	float xk, vk, rk;
+	float xm;
+};
\ No newline at end of file
diff --git a/lib/GyverFilters/src/filters/kalman.h b/lib/GyverFilters/src/filters/kalman.h
new file mode 100644
index 00000000..10458090
--- /dev/null
+++ b/lib/GyverFilters/src/filters/kalman.h
@@ -0,0 +1,38 @@
+#pragma once
+#include 
+
+// упрощённый Калман для одномерного случая
+class GKalman {
+public:
+	// разброс измерения, разброс оценки, скорость изменения значений
+	GKalman(float mea_e, float est_e, float q) { setParameters(mea_e, est_e, q); }
+	
+	// разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки)
+	GKalman(float mea_e, float q) {GKalman::setParameters(mea_e, mea_e, q);}
+	
+	// разброс измерения, разброс оценки, скорость изменения значений
+	void setParameters(float mea_e, float est_e, float q) {
+		_err_measure = mea_e;
+		_err_estimate = est_e;
+		_q = q;
+	}
+	
+	// разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки)
+	void setParameters(float mea_e, float q) {setParameters(mea_e, mea_e, q);}
+	
+	// возвращает фильтрованное значение
+	float filtered(float value) {		
+		float _kalman_gain, _current_estimate;
+		_kalman_gain = _err_estimate / (_err_estimate + _err_measure);
+		_current_estimate = _last_estimate + _kalman_gain * (value - _last_estimate);
+		_err_estimate =  (1.0 - _kalman_gain)*_err_estimate + fabs(_last_estimate-_current_estimate)*_q;
+		_last_estimate=_current_estimate;
+		return _current_estimate;
+	}
+
+private:
+	float _err_measure = 0.0;
+	float _err_estimate = 0.0;
+	float _q = 0.0;
+	float _last_estimate = 0.0;
+};
\ No newline at end of file
diff --git a/lib/GyverFilters/src/filters/linear.h b/lib/GyverFilters/src/filters/linear.h
new file mode 100644
index 00000000..a3f320a2
--- /dev/null
+++ b/lib/GyverFilters/src/filters/linear.h
@@ -0,0 +1,49 @@
+#pragma once
+#include 
+
+// линейная аппроксимация методом наименьших квадратов
+template < typename TYPE >
+class GLinear {
+public:
+	GLinear(){};
+	void compute(TYPE *x_array, TYPE *y_array, int arrSize) {		// аппроксимировать
+		int32_t sumX = 0, sumY = 0, sumX2 = 0, sumXY = 0;	
+		arrSize /= sizeof(int);
+		for (int i = 0; i < arrSize; i++) {		// для всех элементов массива
+			sumX += x_array[i];
+			sumY += (long)y_array[i];
+			sumX2 += x_array[i] * x_array[i];
+			sumXY += (long)y_array[i] * x_array[i];
+		}
+		a = (long)arrSize * sumXY;             // расчёт коэффициента наклона приямой
+		a = a - (long)sumX * sumY;
+		a = (float)a / (arrSize * sumX2 - sumX * sumX);
+		b = (float)(sumY - (float)a * sumX) / arrSize;
+		delta = a * (x_array[arrSize-1] - x_array[0]);			// расчёт изменения
+	}
+	float getA() {return a;}			// получить коэффициент А
+	float getB() {return b;}			// получить коэффициент В
+	float getDelta() {return delta;}	// получить аппроксимированное изменение
+	
+private:	
+	float a, b, delta;
+};
+
+/*
+Сам алгоритм выглядит так:
+void loop() {
+  sumX = 0;
+  sumY = 0;
+  sumX2 = 0;
+  sumXY = 0;
+  for (int i = 0; i < steps; i++) {
+    sumX += X[i];
+    sumY += Y[i];
+    sumX2 += X[i] * X[i];
+    sumXY += X[i] * Y[i];
+  }
+  a = (steps * sumXY - sumX * sumY) / (steps * sumX2 - sumX * sumX);
+  b = (sumY - a * sumX) / steps;
+  int delta = steps * a;
+}
+*/
\ No newline at end of file
diff --git a/lib/GyverFilters/src/filters/median.h b/lib/GyverFilters/src/filters/median.h
new file mode 100644
index 00000000..f7580806
--- /dev/null
+++ b/lib/GyverFilters/src/filters/median.h
@@ -0,0 +1,35 @@
+#pragma once
+
+// медианный фильтр N-го порядка
+template < int SIZE, typename TYPE >
+class GMedian {
+public:
+	TYPE filtered(TYPE newVal) {
+		buffer[_count] = newVal;
+		if ((_count < _numRead - 1) && (buffer[_count] > buffer[_count + 1])) {
+			for (int i = _count; i < _numRead - 1; i++) {
+				if (buffer[i] > buffer[i + 1]) {
+					float buff = buffer[i];
+					buffer[i] = buffer[i + 1];
+					buffer[i + 1] = buff;
+				}
+			}
+		} else {
+			if ((_count > 0) and (buffer[_count - 1] > buffer[_count])) {
+				for (int i = _count; i > 0; i--) {
+					if (buffer[i] < buffer[i - 1]) {
+						float buff = buffer[i];
+						buffer[i] = buffer[i - 1];
+						buffer[i - 1] = buff;
+					}
+				}
+			}
+		}
+		if (++_count >= _numRead) _count = 0;
+		return buffer[(int)_numRead / 2];
+	}
+private:
+	TYPE buffer[SIZE];
+	byte _count = 0;
+	byte _numRead = SIZE;
+};
\ No newline at end of file
diff --git a/lib/GyverFilters/src/filters/median3.h b/lib/GyverFilters/src/filters/median3.h
new file mode 100644
index 00000000..8b99cc1e
--- /dev/null
+++ b/lib/GyverFilters/src/filters/median3.h
@@ -0,0 +1,30 @@
+#pragma once
+
+// быстрый медианный фильтр 3-го порядка
+template < typename TYPE >
+class GMedian3 {
+public:
+	TYPE filtered(TYPE value) {	// возвращает фильтрованное значение
+		buffer[_counter] = value;
+		if (++_counter > 2) _counter = 0;
+		
+		TYPE middle;	
+		
+		if ((buffer[0] <= buffer[1]) && (buffer[0] <= buffer[2])) {
+			middle = (buffer[1] <= buffer[2]) ? buffer[1] : buffer[2];
+		}
+		else {
+			if ((buffer[1] <= buffer[0]) && (buffer[1] <= buffer[2])) {
+				middle = (buffer[0] <= buffer[2]) ? buffer[0] : buffer[2];
+			}
+			else {
+				middle = (buffer[0] <= buffer[1]) ? buffer[0] : buffer[1];
+			}
+		}
+		return middle;
+	}
+	
+private:
+	TYPE buffer[3];
+	uint8_t _counter = 0;
+};
\ No newline at end of file
diff --git a/lib/GyverFilters/src/filters/runningAverage.cpp b/lib/GyverFilters/src/filters/runningAverage.cpp
new file mode 100644
index 00000000..9a1b2b03
--- /dev/null
+++ b/lib/GyverFilters/src/filters/runningAverage.cpp
@@ -0,0 +1,43 @@
+#include 
+
+GFilterRA::GFilterRA() {}
+
+GFilterRA::GFilterRA(float coef, uint16_t interval) {
+	_coef = coef;
+	_filterInterval = interval;
+}
+
+GFilterRA::GFilterRA(float coef) {
+	_coef = coef;
+}
+
+void GFilterRA::setCoef(float coef) {
+	_coef = coef;
+}
+void GFilterRA::setStep(uint16_t interval) {
+	_filterInterval = interval;
+}
+
+float GFilterRA::filteredTime(int16_t value) {
+	if (millis() - _filterTimer >= _filterInterval) {
+		_filterTimer = millis();
+		return GFilterRA::filtered(value);
+	}
+}
+
+float GFilterRA::filteredTime(float value) {
+	if (millis() - _filterTimer >= _filterInterval) {
+		_filterTimer = millis();
+		return GFilterRA::filtered(value);
+	}
+}
+
+float GFilterRA::filtered(int16_t value) {
+	_lastValue += (float)(value - _lastValue) * _coef;
+	return _lastValue;
+}
+
+float GFilterRA::filtered(float value) {
+	_lastValue += (float)(value - _lastValue) * _coef;
+	return _lastValue;
+}
\ No newline at end of file
diff --git a/lib/GyverFilters/src/filters/runningAverage.h b/lib/GyverFilters/src/filters/runningAverage.h
new file mode 100644
index 00000000..7910a0fe
--- /dev/null
+++ b/lib/GyverFilters/src/filters/runningAverage.h
@@ -0,0 +1,24 @@
+#pragma once
+#include 
+
+// экспоненциальное бегущее среднее
+class GFilterRA
+{
+public:
+	GFilterRA();								// инициализация фильтра
+	GFilterRA(float coef);						// расширенная инициализация фильтра (коэффициент)
+	GFilterRA(float coef, uint16_t interval);	// расширенная инициализация фильтра (коэффициент, шаг фильтрации)
+	void setCoef(float coef);	    			// настройка коэффициента фильтрации (0.00 - 1.00). Чем меньше, тем плавнее
+	void setStep(uint16_t interval);			// установка шага фильтрации (мс). Чем меньше, тем резче фильтр
+	
+	float filteredTime(int16_t value);			// возвращает фильтрованное значение с опорой на встроенный таймер	
+	float filtered(int16_t value);				// возвращает фильтрованное значение
+	
+	float filteredTime(float value);			// возвращает фильтрованное значение с опорой на встроенный таймер	
+	float filtered(float value);				// возвращает фильтрованное значение
+	
+private:
+	float _coef = 0.0, _lastValue = 0.0;
+	uint32_t _filterTimer = 0;
+	uint16_t _filterInterval = 0;
+};
\ No newline at end of file
diff --git a/lib/README b/lib/README
new file mode 100644
index 00000000..6debab1e
--- /dev/null
+++ b/lib/README
@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in a an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include 
+#include 
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html
diff --git a/lib/TickerScheduler/README.md b/lib/TickerScheduler/README.md
new file mode 100644
index 00000000..33f0182e
--- /dev/null
+++ b/lib/TickerScheduler/README.md
@@ -0,0 +1,81 @@
+# TickerScheduler
+Simple scheduler for ESP8266 Arduino based on Ticker
+
+### Initialization
+
+`TickerScheduler(uint size);`
+
+| Param | Description | 
+| --- | --- |
+|  size  |  Amount of task Tickers to initialize  |
+
+**Example**: 
+
+`TickerScheduler ts(5)`
+
+
+### Add task
+
+`boolean add(uint i, uint32_t period, tscallback_t f, boolean shouldFireNow = false); `
+
+| Param | Description | 
+| --- | --- |
+|  i  |  Task ID  |
+| period  | Task execution period in ms  |
+| f | Task callback |
+| shouldFireNow|  `true` if you want to execute task right after first scheduler update or wait next scheduled start |
+
+**Returns**:
+
+`true` - task added sucessfully
+
+`false` - task was not added 
+
+**Example**:
+
+`ts.add(0, 3000, sendData)`
+
+### Execute scheduler in `loop()`
+
+`ts.update()`
+
+### Remove task
+
+`boolean remove(uint i)`
+
+**Returns**:
+
+`true` - task removed sucessfully
+
+`false` - task was not removed
+
+| Param | Description | 
+| --- | --- |
+|  i  |  Task ID  |
+
+### Enable/Disable task
+
+`boolean enable(uint i)`
+
+`boolean disable(uint i)`
+
+**Returns**:
+
+`true` - task enabled/disabled sucessfully
+
+`false` - task was not enabled/disabled
+
+| Param | Description | 
+| --- | --- |
+|  i  |  Task ID  |
+
+### Enable / disable all tasks
+
+`void enableAll()`
+
+`void disableAll()`
+
+### TODO
+
+* Task callback parameters support
+* ...
diff --git a/lib/TickerScheduler/TickerScheduler.cpp b/lib/TickerScheduler/TickerScheduler.cpp
new file mode 100644
index 00000000..af47ffa1
--- /dev/null
+++ b/lib/TickerScheduler/TickerScheduler.cpp
@@ -0,0 +1,116 @@
+#include "TickerScheduler.h"
+
+TickerScheduler::TickerScheduler(uint8_t size)
+{
+    this->items = new TickerSchedulerItem[size];
+    this->size = size;
+}
+
+TickerScheduler::~TickerScheduler()
+{
+    for (uint8_t i = 0; i < this->size; i++)
+    {
+        this->remove(i);
+        yield();
+    }
+
+    delete[] this->items;
+    this->items = NULL;
+    this->size = 0;
+}
+
+void TickerScheduler::handleTickerFlag(bool * flag)
+{
+	if (!*flag)
+		*flag = true;
+}
+
+void TickerScheduler::handleTicker(tscallback_t f, void * arg, bool * flag)
+{
+    if (*flag)
+    {
+        yield();
+        *flag = false;
+        yield();
+        f(arg);
+        yield();
+    }
+}
+
+bool TickerScheduler::add(uint8_t i, uint32_t period, tscallback_t f, void* arg, boolean shouldFireNow)
+{
+    if (i >= this->size || this->items[i].is_used)
+        return false;
+
+    this->items[i].cb = f;
+    this->items[i].cb_arg = arg;
+    this->items[i].flag = shouldFireNow;
+    this->items[i].period = period;
+    this->items[i].is_used = true;
+
+    enable(i);
+
+    return true;
+}
+
+bool TickerScheduler::remove(uint8_t i)
+{
+    if (i >= this->size || !this->items[i].is_used)
+        return false;
+
+    this->items[i].is_used = false;
+    this->items[i].t.detach();
+    this->items[i].flag = false;
+    this->items[i].cb = NULL;
+
+    return true;
+}
+
+bool TickerScheduler::disable(uint8_t i)
+{
+    if (i >= this->size || !this->items[i].is_used)
+        return false;
+
+    this->items[i].t.detach();
+
+    return true;
+}
+
+bool TickerScheduler::enable(uint8_t i)
+{
+    if (i >= this->size || !this->items[i].is_used)
+        return false;
+
+	bool * flag = &this->items[i].flag;
+	this->items[i].t.attach_ms(this->items[i].period, TickerScheduler::handleTickerFlag, flag);
+
+    return true;
+}
+
+void TickerScheduler::disableAll()
+{
+    for (uint8_t i = 0; i < this->size; i++)
+        disable(i);
+}
+
+void TickerScheduler::enableAll()
+{
+    for (uint8_t i = 0; i < this->size; i++)
+        enable(i);
+}
+
+void TickerScheduler::update()
+{
+    for (uint8_t i = 0; i < this->size; i++)
+    {
+		if (this->items[i].is_used)
+		{
+			#ifdef ARDUINO_ARCH_AVR
+			this->items[i].t.Tick();
+			#endif
+
+			handleTicker(this->items[i].cb, this->items[i].cb_arg, &this->items[i].flag);
+		}
+        yield();
+    }
+}
diff --git a/lib/TickerScheduler/TickerScheduler.h b/lib/TickerScheduler/TickerScheduler.h
new file mode 100644
index 00000000..98ae1f05
--- /dev/null
+++ b/lib/TickerScheduler/TickerScheduler.h
@@ -0,0 +1,91 @@
+#ifndef TICKERSCHEDULER_H
+#define TICKERSCHEDULER_H
+
+#if defined(ARDUINO) && ARDUINO >= 100
+    #include "Arduino.h"
+#endif
+#include 
+
+
+#ifdef ARDUINO_ARCH_AVR
+class Ticker
+{
+	typedef void(*ticker_callback_t)(bool*);
+
+private:
+	bool is_attached = false;
+	uint32_t period = 0;
+	uint32_t last_tick = 0;
+	ticker_callback_t callback;
+	bool *callback_argument;
+public:
+	void Tick()
+	{
+		if (is_attached && millis() - last_tick >= period)
+		{
+			callback(callback_argument);
+			last_tick = millis();
+		}
+	}
+
+	void detach()
+	{
+		this->is_attached = true;
+	}
+
+	template void attach_ms(uint32_t milliseconds, void(*callback)(TArg), TArg arg)
+	{
+		this->period = milliseconds;
+		this->callback = callback;
+		this->callback_argument = arg;
+		this->is_attached = true;
+	}
+};
+#endif
+
+//#ifdef ARDUINO_ARCH_ESP8266
+#include 
+#include 
+//#endif
+
+void tickerFlagHandle(volatile bool * flag);
+
+#ifdef _GLIBCXX_FUNCTIONAL
+typedef std::function tscallback_t;
+#else
+typedef void(*tscallback_t)(void*);
+#endif
+
+struct TickerSchedulerItem
+{
+    Ticker t;
+    bool flag = false;
+    tscallback_t cb;
+	void * cb_arg;
+    uint32_t period;
+    volatile bool is_used = false;
+};
+
+class TickerScheduler
+{
+private:
+	uint8_t size;
+    TickerSchedulerItem *items = NULL;
+
+    void handleTicker(tscallback_t, void *, bool * flag);
+	static void handleTickerFlag(bool * flag);
+
+public:
+    TickerScheduler(uint8_t size);
+    ~TickerScheduler();
+    
+    bool add(uint8_t i, uint32_t period, tscallback_t, void *, boolean shouldFireNow = false);
+    bool remove(uint8_t i);
+    bool enable(uint8_t i);
+    bool disable(uint8_t i);
+    void enableAll();
+    void disableAll();
+    void update();
+};
+
+#endif
diff --git a/lib/TickerScheduler/example/blink/blink/blink.ino b/lib/TickerScheduler/example/blink/blink/blink.ino
new file mode 100644
index 00000000..49afc470
--- /dev/null
+++ b/lib/TickerScheduler/example/blink/blink/blink.ino
@@ -0,0 +1,29 @@
+#include 
+
+#define LED1 4
+#define LED2 5
+
+TickerScheduler ts(2);
+
+void blink1() {
+  digitalWrite(LED1, !digitalRead(LED1));
+}
+
+void blink2() {
+  digitalWrite(LED2, !digitalRead(LED2));
+}
+
+void setup() {
+  pinMode(LED1, OUTPUT);
+  digitalWrite(LED1, LOW);
+
+  pinMode(LED2, OUTPUT);
+  digitalWrite(LED2, LOW);
+  
+  ts.add(0, 1000, [&](void *) { blink1(); }, nullptr, true);
+  ts.add(1, 3000, [&](void *) { blink2(); }, nullptr, true);
+}
+
+void loop() {
+  ts.update();
+}
diff --git a/partitions_custom.csv b/partitions_custom.csv
new file mode 100644
index 00000000..86202b53
--- /dev/null
+++ b/partitions_custom.csv
@@ -0,0 +1,6 @@
+# Name,   Type, SubType,  Offset,   Size,  Flags
+ota_0,     app, ota_0,   0x10000,  0x1A0000
+ota_1,     app, ota_1,          ,  0x1A0000
+otadata,  data, ota,    0x350000,  0x2000
+nvs,      data, nvs,            ,  0x6000 
+data,     data, spiffs,         ,  0xA8000
\ No newline at end of file
diff --git a/platformio.ini b/platformio.ini
new file mode 100644
index 00000000..7af0d773
--- /dev/null
+++ b/platformio.ini
@@ -0,0 +1,94 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+;To choose board please use one of definition:
+;esp8266_1mb , esp8266_4mb , esp32_4mb
+[platformio]
+default_envs = esp8266_4mb
+
+
+[common_env_data]
+lib_deps_external = 
+	bblanchon/ArduinoJson @5.*
+	thomasfredericks/Bounce2
+	knolleary/PubSubClient
+	beegee-tokyo/DHT sensor library for ESPx
+	adafruit/Adafruit BMP280 Library
+	adafruit/Adafruit BME280 Library
+	milesburton/DallasTemperature
+lib_deps_internal = 
+	ESP Async WebServer
+	GyverFilters
+	OneWire
+
+
+
+[env:esp8266_4mb]
+build_flags = -Desp8266_4mb="esp8266_4mb"
+framework = arduino
+board = nodemcuv2
+board_build.ldscript = eagle.flash.4m1m.ld
+platform = https://github.com/platformio/platform-espressif8266.git
+lib_deps = 
+	${common_env_data.lib_deps_external}
+	${common_env_data.lib_deps_internal}
+	ESPAsyncTCP
+	ESPAsyncUDP
+	EspSoftwareSerial
+	CTBot
+monitor_filters = esp8266_exception_decoder
+upload_speed = 921600
+monitor_speed = 115200
+board_build.filesystem = littlefs
+
+
+
+[env:esp8266_1mb]
+build_flags = -Desp8266_1mb="esp8266_1mb"
+framework = arduino
+board = nodemcuv2
+board_build.ldscript = eagle.flash.1m256.ld
+platform = https://github.com/platformio/platform-espressif8266.git
+lib_deps = 
+	${common_env_data.lib_deps_external}
+	${common_env_data.lib_deps_internal}
+	ESPAsyncTCP
+	ESPAsyncUDP
+	EspSoftwareSerial
+	CTBot
+monitor_filters = esp8266_exception_decoder
+upload_speed = 921600
+monitor_speed = 115200
+
+
+
+[env:esp32_4mb]
+build_flags = -Desp32_4mb="esp32_4mb"
+framework = arduino
+board = esp32dev
+platform = https://github.com/platformio/platform-espressif32.git
+lib_deps = 
+	${common_env_data.lib_deps_external}
+	${common_env_data.lib_deps_internal}
+	AsyncTCP
+	madhephaestus/ESP32Servo
+	luc-github/ESP32SSDP
+	CTBot
+	EspSoftwareSerial
+monitor_filters = esp32_exception_decoder
+upload_speed = 921600
+monitor_speed = 115200
+
+
+
+
+
+
+
diff --git a/src/BufferExecute.cpp b/src/BufferExecute.cpp
new file mode 100644
index 00000000..2a28b95f
--- /dev/null
+++ b/src/BufferExecute.cpp
@@ -0,0 +1,166 @@
+#include "BufferExecute.h"
+#include "Global.h"
+#include "SoftUART.h"
+//
+#include "items/vSensorDallas.h"
+#include "items/vSensorUltrasonic.h"
+#include "items/vButtonOut.h"
+#include "items/vPwmOut.h"
+#include "items/vInOutput.h"
+#include "items/vLogging.h"
+#include "items/vImpulsOut.h"
+#include "items/vCountDown.h"
+#include "items/vSensorAnalog.h"
+#include "items/vSensorDht.h"
+#include "items/vSensorBme280.h"
+#include "items/vSensorBmp280.h"
+
+void loopCmdAdd(const String& cmdStr) {
+    if (cmdStr.endsWith(",")) {
+        orderBuf += cmdStr;
+#ifdef uartEnable    
+        if (jsonReadBool(configSetupJson, "uart")) {
+            if (jsonReadBool(configSetupJson, "uartEvents")) {
+                if (myUART) {
+                    myUART->print(cmdStr);
+                    SerialPrint("I", "<=UART", cmdStr);
+                }
+            }
+        }
+#endif
+    }
+}
+
+void fileCmdExecute(const String& filename) {
+    String cmdStr = readFile(filename, 4096);
+    csvCmdExecute(cmdStr);
+}
+
+void csvCmdExecute(String& cmdStr) {
+    cmdStr.replace(";", " ");
+    cmdStr += "\r\n";
+    cmdStr.replace("\r\n", "\n");
+    cmdStr.replace("\r", "\n");
+    int count = 0;
+    while (cmdStr.length()) {
+        String buf = selectToMarker(cmdStr, "\n");
+
+        buf = deleteBeforeDelimiter(buf, " ");  //отсечка чекбокса
+
+        count++;
+        if (count > 1) {
+            SerialPrint("I", "Items", buf);
+            String order = selectToMarker(buf, " "); //отсечка самой команды
+
+            if (order == F("button-out")) {
+                sCmd.addCommand(order.c_str(), buttonOut);
+            }
+#ifdef PwmOutEnable
+            else if (order == F("pwm-out")) {
+                sCmd.addCommand(order.c_str(), pwmOut);
+            }
+#endif
+            else if (order == F("button-in")) {
+                sCmd.addCommand(order.c_str(), buttonIn);
+            }
+            else if (order == F("inoutput")) {
+                sCmd.addCommand(order.c_str(), inOutput);
+            }
+            else if (order == F("analog-adc")) {
+                sCmd.addCommand(order.c_str(), analogAdc);
+            }
+            else if (order == F("ultrasonic-cm")) {
+                sCmd.addCommand(order.c_str(), ultrasonic);
+            }
+            else if (order == F("dallas-temp")) {
+                sCmd.addCommand(order.c_str(), dallas);
+            }
+#ifdef SensorDhtEnabled
+            else if (order == F("dht")) {
+                sCmd.addCommand(order.c_str(), dhtSensor);
+            }
+#endif
+#ifdef SensorBme280Enabled
+            else if (order == F("bme280")) {
+                sCmd.addCommand(order.c_str(), bme280Sensor);
+            }
+#endif
+#ifdef SensorBmp280Enabled
+            else if (order == F("bmp280")) {
+                sCmd.addCommand(order.c_str(), bmp280Sensor);
+            }
+#endif
+            else if (order == F("uptime")) {
+                sCmd.addCommand(order.c_str(), sysUptime);
+            }
+            else if (order == F("logging")) {
+                sCmd.addCommand(order.c_str(), logging);
+            }
+            else if (order == F("impuls-out")) {
+                sCmd.addCommand(order.c_str(), impuls);
+            }
+            else if (order == F("count-down")) {
+                sCmd.addCommand(order.c_str(), countDown);
+            }
+
+            sCmd.readStr(buf);
+        }
+        cmdStr = deleteBeforeDelimiter(cmdStr, "\n");
+    }
+}
+
+void spaceCmdExecute(String& cmdStr) {
+    cmdStr += "\r\n";
+    cmdStr.replace("\r\n", "\n");
+    cmdStr.replace("\r", "\n");
+    while (cmdStr.length()) {
+        String buf = selectToMarker(cmdStr, "\n");
+        sCmd.readStr(buf);
+        cmdStr = deleteBeforeDelimiter(cmdStr, "\n");
+    }
+}
+
+void loopCmdExecute() {
+    if (orderBuf.length()) {
+        String tmp = selectToMarker(orderBuf, ",");  //выделяем первую команду rel 5 1,
+        SerialPrint("I", "CMD", "do: " + tmp);
+        sCmd.readStr(tmp);                                //выполняем
+        orderBuf = deleteBeforeDelimiter(orderBuf, ",");  //осекаем
+    }
+}
+
+void addKey(String& key, String& keyNumberTable, int number) {
+    keyNumberTable += key + " " + String(number) + ",";
+}
+
+int getKeyNum(String& key, String& keyNumberTable) {
+    String keyNumberTableBuf = keyNumberTable;
+
+    int number = -1;
+    while (keyNumberTableBuf.length()) {
+        String tmp = selectToMarker(keyNumberTableBuf, ",");
+        String keyIncomming = selectToMarker(tmp, " ");
+        if (keyIncomming == key) {
+            number = selectToMarkerLast(tmp, " ").toInt();
+        }
+        keyNumberTableBuf = deleteBeforeDelimiter(keyNumberTableBuf, ",");
+    }
+    return number;
+}
+
+String getValue(String& key) {
+    String live = jsonReadStr(configLiveJson, key);
+    String store = jsonReadStr(configStoreJson, key);
+    if (live != nullptr) {
+        return live;
+    }
+    else if (store != nullptr) {
+        return store;
+    }
+    else if (store == nullptr && live == nullptr) {
+        return "no value";
+    }
+    else {
+        return "data error";
+    }
+}
diff --git a/src/Bus.cpp b/src/Bus.cpp
new file mode 100644
index 00000000..eeff8108
--- /dev/null
+++ b/src/Bus.cpp
@@ -0,0 +1,41 @@
+#include "Bus.h"
+#include "Class/NotAsync.h"
+#include "Global.h"
+
+void busInit() {
+    myNotAsyncActions->add(
+        do_BUSSCAN, [&](void*) {
+            String tmp = i2c_scan();
+            if (tmp == "error") {
+                tmp = i2c_scan();
+                Serial.println(tmp);
+                jsonWriteStr(configLiveJson, "i2c", tmp);
+            }
+            else {
+                Serial.println(tmp);
+                jsonWriteStr(configLiveJson, "i2c", tmp);
+            }
+        },
+        nullptr);
+    SerialPrint("I", F("Bus"), F("Bus Init"));
+}
+
+String i2c_scan() {
+    String out;
+    byte count = 0;
+    Wire.begin();
+    for (byte i = 8; i < 120; i++) {
+        Wire.beginTransmission(i);
+        if (Wire.endTransmission() == 0) {
+            count++;
+            out += String(count) + ". 0x" + String(i, HEX) + "; ";
+            delay(1);
+        }
+    }
+    if (count == 0) {
+        return "error";
+    }
+    else {
+        return out;
+    }
+}
\ No newline at end of file
diff --git a/src/Class/CallBackTest.cpp b/src/Class/CallBackTest.cpp
new file mode 100644
index 00000000..55252e5e
--- /dev/null
+++ b/src/Class/CallBackTest.cpp
@@ -0,0 +1,49 @@
+#include "Class/CallBackTest.h"
+
+CallBackTest::CallBackTest(){};
+
+void CallBackTest::loop() {
+    count++;
+    if (count > 5000) {
+        // Проверяем что переменная содержит указатель - не пустая не null
+        // и непосредственно вызываем то, на что это указывает
+        // просто пишем имя - без () - это указатель на фунецию.
+        // () - вызываем функцию - с пустым набором параметров
+
+        if (_cb != NULL) {
+            _cb();
+        }
+        //или ровно тоже самое
+        //if (_cb) _cb();
+
+        if (_pcb) {
+            if (_pcb("SomeTextValue")) {
+                Serial.println("Got true!");
+            } else {
+                Serial.println("Got false!");
+            }
+        }
+
+        count = 0;
+    }
+}
+
+//передаем внутрь класса функцию любую void функцию без агрументов
+void CallBackTest::setCallback(AsyncActionCb cb) {
+    _cb = cb;
+}
+
+//передаем внутрь класса функцию любую void функцию с аргументами
+void CallBackTest::setCallback(AsyncParamActionCb pcb) {
+    _pcb = pcb;
+}
+//CallBackTest* CB;
+
+//CB->setCallback([]() {
+//    Serial.println("123");
+//});
+//
+//CB->setCallback([](const String str) {
+//    Serial.println(str);
+//    return true;
+//});
\ No newline at end of file
diff --git a/src/Class/LineParsing.cpp b/src/Class/LineParsing.cpp
new file mode 100644
index 00000000..9e9e7ac0
--- /dev/null
+++ b/src/Class/LineParsing.cpp
@@ -0,0 +1,2 @@
+#include "Class/LineParsing.h"
+LineParsing myLineParsing;
\ No newline at end of file
diff --git a/src/Class/NotAsync.cpp b/src/Class/NotAsync.cpp
new file mode 100644
index 00000000..75c2ce24
--- /dev/null
+++ b/src/Class/NotAsync.cpp
@@ -0,0 +1,30 @@
+#include "Class/NotAsync.h"
+
+NotAsync::NotAsync(uint8_t size) {
+    this->items = new NotAsyncItem[size];
+    this->size = size;
+}
+
+NotAsync::~NotAsync() {}
+
+void NotAsync::add(uint8_t i, NotAsyncCb f, void* arg) {
+    this->items[i].cb = f;
+    this->items[i].cb_arg = arg;
+    this->items[i].is_used = true;
+}
+
+void NotAsync::loop() {
+    if (this->items[task].is_used) {
+        handle(this->items[task].cb, this->items[task].cb_arg);
+        task = 0;
+    }
+}
+
+void NotAsync::make(uint8_t task) {
+    this->task = task;
+}
+
+void NotAsync::handle(NotAsyncCb f, void* arg) {
+    f(arg);
+}
+NotAsync* myNotAsyncActions;
\ No newline at end of file
diff --git a/src/Class/ScenarioClass3.cpp b/src/Class/ScenarioClass3.cpp
new file mode 100644
index 00000000..09350105
--- /dev/null
+++ b/src/Class/ScenarioClass3.cpp
@@ -0,0 +1,33 @@
+#include "Class/ScenarioClass3.h"
+
+#include "MqttClient.h"
+#include "RemoteOrdersUdp.h"
+Scenario* myScenario;
+
+void eventGen2(String eventName, String eventValue) {
+    if (!jsonReadBool(configSetupJson, "scen")) {
+        return;
+    }
+    String event = eventName + " " + eventValue + ",";
+    eventBuf += event;
+
+    if (jsonReadBool(configSetupJson, "MqttOut")) {
+        if (eventName != "timenow") {
+            publishEvent(eventName, eventValue);
+        }
+    }
+}
+
+void streamEventUDP(String event) {
+#ifdef UDP_ENABLED
+
+    if (!jsonReadBool(configSetupJson, "snaUdp")) {
+        return;
+    }
+
+    if (event.indexOf("timenow") == -1) {
+        event = "iotm;event:" + event;
+        asyncUdp.broadcastTo(event.c_str(), 4210);
+    }
+#endif
+}
\ No newline at end of file
diff --git a/src/Clock.cpp b/src/Clock.cpp
new file mode 100644
index 00000000..0cb26942
--- /dev/null
+++ b/src/Clock.cpp
@@ -0,0 +1,16 @@
+#include "Clock.h"
+
+#include "Global.h"
+
+Clock* timeNow;
+void clockInit() {
+    timeNow = new Clock;
+    timeNow->setNtpPool(jsonReadStr(configSetupJson, "ntp"));
+    timeNow->setTimezone(jsonReadStr(configSetupJson, "timezone").toInt());
+    ts.add(
+        TIME_SYNC, 30000, [&](void*) {
+            timeNow->hasSync();
+        },
+        nullptr, true);
+    SerialPrint("I", F("NTP"), F("Clock Init"));
+}
diff --git a/src/FSEditor.cpp b/src/FSEditor.cpp
new file mode 100644
index 00000000..98be53cd
--- /dev/null
+++ b/src/FSEditor.cpp
@@ -0,0 +1,334 @@
+#include "FSEditor.h"
+
+#include "FileSystem.h"
+
+#define FS_MAXLENGTH_FILEPATH 32
+
+const char *excludeListFile = "/.exclude.files";
+typedef struct ExcludeListS {
+    char *item;
+    ExcludeListS *next;
+} ExcludeList;
+
+static ExcludeList *excludes = NULL;
+
+static bool matchWild(const char *pattern, const char *testee) {
+    const char *nxPat = NULL, *nxTst = NULL;
+
+    while (*testee) {
+        if ((*pattern == '?') || (*pattern == *testee)) {
+            pattern++;
+            testee++;
+            continue;
+        }
+        if (*pattern == '*') {
+            nxPat = pattern++;
+            nxTst = testee;
+            continue;
+        }
+        if (nxPat) {
+            pattern = nxPat + 1;
+            testee = ++nxTst;
+            continue;
+        }
+        return false;
+    }
+    while (*pattern == '*') {
+        pattern++;
+    }
+    return (*pattern == 0);
+}
+
+static bool addExclude(const char *item) {
+    size_t len = strlen(item);
+    if (!len) {
+        return false;
+    }
+    ExcludeList *e = (ExcludeList *)malloc(sizeof(ExcludeList));
+    if (!e) {
+        return false;
+    }
+    e->item = (char *)malloc(len + 1);
+    if (!e->item) {
+        free(e);
+        return false;
+    }
+    memcpy(e->item, item, len + 1);
+    e->next = excludes;
+    excludes = e;
+    return true;
+}
+
+static void loadExcludeList(fs::FS &_fs, const char *filename) {
+    static char linebuf[FS_MAXLENGTH_FILEPATH];
+    fs::File excludeFile = _fs.open(filename, "r");
+    if (!excludeFile) {
+        return;
+    }
+    if (excludeFile.isDirectory()) {
+        excludeFile.close();
+        return;
+    }
+    if (excludeFile.size() > 0) {
+        uint8_t idx;
+        bool isOverflowed = false;
+        while (excludeFile.available()) {
+            linebuf[0] = '\0';
+            idx = 0;
+            int lastChar;
+            do {
+                lastChar = excludeFile.read();
+                if (lastChar != '\r') {
+                    linebuf[idx++] = (char)lastChar;
+                }
+            } while ((lastChar >= 0) && (lastChar != '\n') && (idx < FS_MAXLENGTH_FILEPATH));
+
+            if (isOverflowed) {
+                isOverflowed = (lastChar != '\n');
+                continue;
+            }
+            isOverflowed = (idx >= FS_MAXLENGTH_FILEPATH);
+            linebuf[idx - 1] = '\0';
+            if (!addExclude(linebuf)) {
+                excludeFile.close();
+                return;
+            }
+        }
+    }
+    excludeFile.close();
+}
+
+static bool isExcluded(fs::FS &_fs, const char *filename) {
+    if (excludes == NULL) {
+        loadExcludeList(_fs, excludeListFile);
+    }
+    if (strcmp(excludeListFile, filename) == 0) return true;
+    ExcludeList *e = excludes;
+    while (e) {
+        if (matchWild(e->item, filename)) {
+            return true;
+        }
+        e = e->next;
+    }
+    return false;
+}
+
+// WEB HANDLER IMPLEMENTATION
+
+#ifdef ESP32
+FSEditor::FSEditor(const fs::FS &fs, const String &username, const String &password)
+#else
+FSEditor::FSEditor(const String &username, const String &password, const fs::FS &fs)
+#endif
+    : _fs(fs), _username(username), _password(password), _authenticated(false), _startTime(0) {
+}
+
+bool FSEditor::canHandle(AsyncWebServerRequest *request) {
+    if (request->url().equalsIgnoreCase("/edit")) {
+        if (request->method() == HTTP_GET) {
+            if (request->hasParam("list"))
+                return true;
+            if (request->hasParam("edit")) {
+                request->_tempFile = _fs.open(request->arg("edit"), "r");
+                if (!request->_tempFile) {
+                    return false;
+                }
+                if (request->_tempFile.isDirectory()) {
+                    request->_tempFile.close();
+                    return false;
+                }
+            }
+            if (request->hasParam("download")) {
+                request->_tempFile = _fs.open(request->arg("download"), "r");
+                if (!request->_tempFile) {
+                    return false;
+                }
+                if (request->_tempFile.isDirectory()) {
+                    request->_tempFile.close();
+                    return false;
+                }
+            }
+            request->addInterestingHeader("If-Modified-Since");
+            return true;
+        } else if (request->method() == HTTP_POST)
+            return true;
+        else if (request->method() == HTTP_DELETE)
+            return true;
+        else if (request->method() == HTTP_PUT)
+            return true;
+    }
+    return false;
+}
+
+#ifdef ESP8266
+void FSEditor::getDirList(const String &path, String &output) {
+    auto dir = _fs.openDir(path.c_str());
+    while (dir.next()) {
+        String fname = dir.fileName();
+        if (!path.endsWith("/") && !fname.startsWith("/")) {
+            fname = "/" + fname;
+        }
+        fname = path + fname;
+        if (isExcluded(_fs, fname.c_str())) {
+            continue;
+        }
+        if (dir.isDirectory()) {
+            getDirList(fname, output);
+            continue;
+        }
+        if (output != "[") output += ',';
+        char buf[128];
+        sprintf(buf, "{\"type\":\"file\",\"name\":\"%s\",\"size\":%d}", fname.c_str(), dir.fileSize());
+        output += buf;
+    }
+}
+#else
+void FSEditor::getDirList(const String &path, String &output) {
+    auto dir = _fs.open(path, FILE_READ);
+    dir.rewindDirectory();
+    while (dir.openNextFile()) {
+        String fname = dir.name();
+        if (!path.endsWith("/") && !fname.startsWith("/")) {
+            fname = "/" + fname;
+        }
+        fname = path + fname;
+        if (isExcluded(_fs, fname.c_str())) {
+            continue;
+        }
+        if (dir.isDirectory()) {
+            getDirList(fname, output);
+            continue;
+        }
+        if (output != "[") output += ',';
+        char buf[128];
+        sprintf(buf, "{\"type\":\"file\",\"name\":\"%s\",\"size\":%d}", fname.c_str(), dir.size());
+        output += buf;
+    }
+}
+#endif
+
+void FSEditor::handleRequest(AsyncWebServerRequest *request) {
+    if (_username.length() && _password.length() && !request->authenticate(_username.c_str(), _password.c_str()))
+        return request->requestAuthentication();
+
+    if (request->method() == HTTP_GET) {
+        if (request->hasParam("list")) {
+            if (request->hasParam("list")) {
+                String path = request->getParam("list")->value();
+                String output = "[";
+                getDirList(path, output);
+                output += "]";
+                request->send(200, "application/json", output);
+                output = String();
+            }
+        } else if (request->hasParam("edit") || request->hasParam("download")) {
+#ifdef ESP8266
+            request->send(request->_tempFile, request->_tempFile.fullName(), String(), request->hasParam("download"));
+#else
+            request->send(request->_tempFile, request->_tempFile.name(), String(), request->hasParam("download"));
+#endif
+        } else {
+            const char *buildTime = __DATE__ " " __TIME__ " GMT";
+            if (request->header("If-Modified-Since").equals(buildTime)) {
+                request->send(304);
+            } else {
+                AsyncWebServerResponse *response = request->beginResponse(FileFS, "/edit.htm", "text/html");
+                // response->addHeader("Content-Encoding", "gzip");
+                response->addHeader("Last-Modified", buildTime);
+                request->send(response);
+            }
+        }
+    } else if (request->method() == HTTP_DELETE) {
+        if (request->hasParam("path", true)) {
+            if (!(_fs.remove(request->getParam("path", true)->value()))) {
+#ifdef ESP32
+                _fs.rmdir(request->getParam("path", true)->value());  // try rmdir for littlefs
+#endif
+            }
+
+            request->send(200, "", "DELETE: " + request->getParam("path", true)->value());
+        } else
+            request->send(404);
+    } else if (request->method() == HTTP_POST) {
+        if (request->hasParam("data", true, true) && _fs.exists(request->getParam("data", true, true)->value()))
+            request->send(200, "", "UPLOADED: " + request->getParam("data", true, true)->value());
+
+        else if (request->hasParam("rawname", true) && request->hasParam("raw0", true)) {
+            String rawnam = request->getParam("rawname", true)->value();
+
+            if (_fs.exists(rawnam)) _fs.remove(rawnam);  // delete it to allow a mode
+
+            int k = 0;
+            uint16_t i = 0;
+            fs::File f = _fs.open(rawnam, "a");
+
+            while (request->hasParam("raw" + String(k), true)) {  //raw0 .. raw1
+                if (f) {
+                    i += f.print(request->getParam("raw" + String(k), true)->value());
+                }
+                k++;
+            }
+            f.close();
+            request->send(200, "", "IPADWRITE: " + rawnam + ":" + String(i));
+
+        } else {
+            request->send(500);
+        }
+
+    } else if (request->method() == HTTP_PUT) {
+        if (request->hasParam("path", true)) {
+            String filename = request->getParam("path", true)->value();
+            if (_fs.exists(filename)) {
+                request->send(200);
+            } else {
+/*******************************************************/
+#ifdef ESP32
+                if (strchr(filename.c_str(), '/')) {
+                    // For file creation, silently make subdirs as needed.  If any fail,
+                    // it will be caught by the real file open later on
+                    char *pathStr = strdup(filename.c_str());
+                    if (pathStr) {
+                        // Make dirs up to the final fnamepart
+                        char *ptr = strchr(pathStr, '/');
+                        while (ptr) {
+                            *ptr = 0;
+                            _fs.mkdir(pathStr);
+                            *ptr = '/';
+                            ptr = strchr(ptr + 1, '/');
+                        }
+                    }
+                    free(pathStr);
+                }
+#endif
+                /*******************************************************/
+                fs::File f = _fs.open(filename, "w");
+                if (f) {
+                    f.write((uint8_t)0x00);
+                    f.close();
+                    request->send(200, "", "CREATE: " + filename);
+                } else {
+                    request->send(500);
+                }
+            }
+        } else
+            request->send(400);
+    }
+}
+
+void FSEditor::handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final) {
+    if (!index) {
+        if (!_username.length() || request->authenticate(_username.c_str(), _password.c_str())) {
+            _authenticated = true;
+            request->_tempFile = _fs.open(filename, "w");
+            _startTime = millis();
+        }
+    }
+    if (_authenticated && request->_tempFile) {
+        if (len) {
+            request->_tempFile.write(data, len);
+        }
+        if (final) {
+            request->_tempFile.close();
+        }
+    }
+}
diff --git a/src/FileSystem.cpp b/src/FileSystem.cpp
new file mode 100644
index 00000000..4db0d187
--- /dev/null
+++ b/src/FileSystem.cpp
@@ -0,0 +1,39 @@
+#include "FileSystem.h"
+
+#include "Global.h"
+#ifdef ESP8266
+bool getInfo(FSInfo& info) {
+    return FileFS.info(info);
+}
+
+// Информация о ФС
+void getFSInfo() {
+    FSInfo buf;
+    if (getInfo(buf)) {
+        //SerialPrint("I", F("FS"), F("Get FS info completed"));
+
+        size_t totalBytes = buf.totalBytes;      // всего
+        size_t usedBytes = buf.usedBytes;        // использовано
+        size_t maxOpenFiles = buf.maxOpenFiles;  // лимит на открые файлы
+        size_t blockSize = buf.blockSize;
+        size_t pageSize = buf.pageSize;
+        size_t maxPathLength = buf.maxPathLength;  // лимит на пути и имена файлов
+
+        size_t freeBytes = totalBytes - usedBytes;
+        float freePer = ((float)freeBytes / totalBytes) * 100;
+
+        jsonWriteStr(configSetupJson, F("freeBytes"), String(freePer) + "% (" + prettyBytes(freeBytes) + ")");
+
+        //SerialPrint("I", F("FS"), "totalBytes=" + String(totalBytes));
+        //SerialPrint("I", F("FS"), "usedBytes=" + String(usedBytes));
+        //SerialPrint("I", F("FS"), "maxOpenFiles=" + String(maxOpenFiles));
+        //SerialPrint("I", F("FS"), "blockSize=" + String(blockSize));
+        //SerialPrint("I", F("FS"), "pageSize=" + String(pageSize));
+        //SerialPrint("I", F("FS"), "maxPathLength=" + String(maxPathLength));
+        //SerialPrint("I", F("FS"), "freeBytes=" + String(freeBytes));
+        //SerialPrint("I", F("FS"), "freePer=" + String(freePer));
+    } else {
+        SerialPrint("E", F("FS"), F("FS info error"));
+    }
+}
+#endif
diff --git a/src/Global.cpp b/src/Global.cpp
new file mode 100644
index 00000000..6274d264
--- /dev/null
+++ b/src/Global.cpp
@@ -0,0 +1,79 @@
+#include "Global.h"
+
+#ifdef WS_enable
+AsyncWebSocket ws;
+//AsyncEventSource events;
+#endif
+
+TickerScheduler ts(SYGNAL + 1);
+WiFiClient espClient;
+PubSubClient mqtt(espClient);
+StringCommand sCmd;
+AsyncWebServer server(80);
+OneWire* oneWire;
+DallasTemperature sensors;
+
+/*
+* Global vars
+*/
+
+boolean just_load = true;
+boolean telegramInitBeen = false;
+
+// Json
+String configSetupJson = "{}";
+String configLiveJson = "{}";
+String configStoreJson = "{}";
+String configOptionJson = "{}";
+String telegramMsgJson = "{}";
+
+// Mqtt
+String chipId = "";
+String prex = "";
+String all_widgets = "";
+String scenario = "";
+
+//orders and events
+String orderBuf = "";
+String eventBuf = "";
+String itemsFile = "";
+String itemsLine = "";
+
+//key lists and numbers
+//=========================================
+String impuls_KeyList = "";
+int impuls_EnterCounter = -1;
+//=========================================
+String buttonOut_KeyList = "";
+int buttonOut_EnterCounter = -1;
+//=========================================
+String inOutput_KeyList = "";
+int inOutput_EnterCounter = -1;
+//=========================================
+String pwmOut_KeyList = "";
+int pwmOut_EnterCounter = -1;
+//=========================================
+String countDown_KeyList = "";
+int countDown_EnterCounter = -1;
+//=========================================
+String logging_KeyList = "";
+int logging_EnterCounter = -1;
+//=========================================
+int dht_EnterCounter = -1;
+//=========================================
+
+
+String itemName;
+String presetName;
+
+// Upgrade
+String serverIP;
+
+// Scenario
+int scenario_line_status[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+int lastVersion;
+
+boolean busScanFlag = false;
+boolean fsCheckFlag = false;
+boolean delElementFlag = false;
+
diff --git a/src/Init.cpp b/src/Init.cpp
new file mode 100644
index 00000000..074211c2
--- /dev/null
+++ b/src/Init.cpp
@@ -0,0 +1,134 @@
+#include "Init.h"
+
+#include "BufferExecute.h"
+#include "Class/LineParsing.h"
+#include "Cmd.h"
+#include "Global.h"
+#include "items/vButtonOut.h"
+#include "items/vCountDown.h"
+#include "items/vImpulsOut.h"
+#include "items/vInOutput.h"
+#include "items/vLogging.h"
+#include "items/vPwmOut.h"
+#include "items/vSensorDallas.h"
+#include "items/vSensorUltrasonic.h"
+
+void loadConfig() {
+    configSetupJson = readFile("config.json", 4096);
+    configSetupJson.replace("\r\n", "");
+
+    configStoreJson = readFile("store.json", 4096);
+    configStoreJson.replace("\r\n", "");
+
+    jsonWriteStr(configSetupJson, "warning1", "");
+    jsonWriteStr(configSetupJson, "warning2", "");
+    jsonWriteStr(configSetupJson, "warning3", "");
+
+    jsonWriteStr(configSetupJson, "chipID", chipId);
+    jsonWriteInt(configSetupJson, "firmware_version", FIRMWARE_VERSION);
+
+    prex = jsonReadStr(configSetupJson, "mqttPrefix") + "/" + chipId;
+
+    //Serial.println(configSetupJson);
+
+    serverIP = jsonReadStr(configSetupJson, "serverip");
+
+    SerialPrint("I", F("Conf"), F("Config Json Init"));
+}
+
+void espInit() {
+    deviceInit();
+    loadScenario();
+    SerialPrint("I", F("esp"), F("esp Init"));
+}
+
+void deviceInit() {
+    //======clear dallas params======
+    if (mySensorDallas2 != nullptr) {
+        mySensorDallas2->clear();
+    }
+    //======clear ultrasonic params======
+    if (mySensorUltrasonic != nullptr) {
+        mySensorUltrasonic->clear();
+    }
+    //======clear logging params======
+    if (myLogging != nullptr) {
+        myLogging->clear();
+    }
+    logging_KeyList = "";
+    logging_EnterCounter = -1;
+    //======clear impuls params=======
+    if (myImpulsOut != nullptr) {
+        myImpulsOut->clear();
+    }
+    impuls_KeyList = "";
+    impuls_EnterCounter = -1;
+    //======clear buttonOut params=======
+    if (myButtonOut != nullptr) {
+        myButtonOut->clear();
+    }
+    buttonOut_KeyList = "";
+    buttonOut_EnterCounter = -1;
+    //======clear input params=======
+    if (myInOutput != nullptr) {
+        myInOutput->clear();
+    }
+    inOutput_KeyList = "";
+    inOutput_EnterCounter = -1;
+    //======clear pwm params=======
+#ifdef PwmOutEnable
+    if (myPwmOut != nullptr) {
+        myPwmOut->clear();
+    }
+    pwmOut_KeyList = "";
+    pwmOut_EnterCounter = -1;
+#endif
+    //===================================
+    if (myCountDown != nullptr) {
+        myCountDown->clear();
+    }
+    countDown_KeyList = "";
+    countDown_EnterCounter = -1;
+    //===================================
+    dht_EnterCounter = -1;
+    //=========================================
+
+#ifdef LAYOUT_IN_RAM
+    all_widgets = "";
+#else
+    removeFile(String("layout.txt"));
+#endif
+
+    myLineParsing.clearErrors();
+
+    fileCmdExecute(String(DEVICE_CONFIG_FILE));
+
+    int errors = myLineParsing.getPinErrors();
+
+    if (errors > 0) {
+        jsonWriteStr(configSetupJson, F("warning3"), F("
Обнаружен неверный номер пина
"));
+    } else {
+        jsonWriteStr(configSetupJson, F("warning3"), "");
+    }
+    //outcoming_date();
+}
+//-------------------------------сценарии-----------------------------------------------------
+
+void loadScenario() {
+    if (jsonReadStr(configSetupJson, "scen") == "1") {
+        scenario = readFile(String(DEVICE_SCENARIO_FILE), 2048);
+    }
+}
+
+void uptime_init() {
+    ts.add(
+        UPTIME, 5000, [&](void*) {
+            handle_uptime();
+        },
+        nullptr, true);
+    SerialPrint("I", F("Uptime"), F("Uptime Init"));
+}
+
+void handle_uptime() {
+    jsonWriteStr(configSetupJson, "uptime", timeNow->getUptime());
+}
diff --git a/src/ItemsList.cpp b/src/ItemsList.cpp
new file mode 100644
index 00000000..10415c85
--- /dev/null
+++ b/src/ItemsList.cpp
@@ -0,0 +1,186 @@
+#include "ItemsList.h"
+
+#include "Class/NotAsync.h"
+#include "FileSystem.h"
+#include "Init.h"
+#include "Utils/StringUtils.h"
+
+static const char* firstLine PROGMEM = "Удалить;Тип элемента;Id;Виджет;Имя вкладки;Имя виджета;Позиция виджета";
+
+void itemsListInit() {
+    myNotAsyncActions->add(
+        do_deviceInit, [&](void*) {
+            deviceInit();
+        },
+        nullptr);
+
+    myNotAsyncActions->add(
+        do_delChoosingItems, [&](void*) {
+            delChoosingItems();
+        },
+        nullptr);
+
+    SerialPrint("I", F("Items"), F("Items Init"));
+}
+
+void addItem2(int num) {
+    File configFile = FileFS.open("/items/items.txt", "r");
+    if (!configFile) {
+        return;
+    }
+    configFile.seek(0, SeekSet);
+    String seachingLine;
+    int i = 0;
+    while (configFile.position() != configFile.size()) {
+        i++;
+        String item = configFile.readStringUntil('*');
+        if (i == num) {
+            if (i == 1) {
+                seachingLine = "\n" + item;
+            } else {
+                seachingLine = item;
+            }
+            break;
+        }
+    }
+    configFile.close();
+
+    randomSeed(micros());
+    unsigned int rnd = random(0, 1000);
+    seachingLine.replace("id", String(rnd));
+    seachingLine.replace("order", String(getNewElementNumber("order.txt")));
+    if (seachingLine.indexOf("gpio") != -1) {
+        seachingLine.replace("gpio", "pin[" + String(getFreePinAll()) + "]");
+    }
+    
+    addFile(DEVICE_CONFIG_FILE, seachingLine);
+    Serial.println(seachingLine);
+}
+
+void addPreset2(int num) {
+    File configFile = FileFS.open("/presets/presets.c.txt", "r");
+    if (!configFile) {
+        return;
+    }
+    configFile.seek(0, SeekSet);
+    String config;
+    int i1 = 0;
+    while (configFile.position() != configFile.size()) {
+        i1++;
+        String item = configFile.readStringUntil('*');
+        if (i1 == num) {
+            if (i1 == 1) {
+                config = "\n" + item;
+            } else {
+                config = item;
+            }
+            break;
+        }
+    }
+    configFile.close();
+    addFile(DEVICE_CONFIG_FILE, config);
+    //===========================================================================
+    File scenFile = FileFS.open("/presets/presets.s.txt", "r");
+    if (!scenFile) {
+        return;
+    }
+    scenFile.seek(0, SeekSet);
+    String scen;
+    int i2 = 0;
+    while (scenFile.position() != scenFile.size()) {
+        i2++;
+        String item = scenFile.readStringUntil('*');
+        if (i2 == num) {
+            if (i1 == 1) {
+                scen = "\n" + item;
+            } else {
+                scen = item;
+            }
+            break;
+        }
+    }
+    scenFile.close();
+    if (readFile(String(DEVICE_SCENARIO_FILE), 2048) == "//") {
+        removeFile(DEVICE_SCENARIO_FILE);
+        scen = deleteBeforeDelimiter(scen, "\n");
+        addFile(DEVICE_SCENARIO_FILE, scen);
+    } else {
+        addFile(DEVICE_SCENARIO_FILE, scen);
+    }
+}
+
+void delAllItems() {
+    removeFile(DEVICE_CONFIG_FILE);
+    addFile(DEVICE_CONFIG_FILE, String(firstLine));
+    removeFile(DEVICE_SCENARIO_FILE);
+    addFile(DEVICE_SCENARIO_FILE, "//");
+    removeFile("id.txt");
+    removeFile("order.txt");
+    removeFile("pins.txt");
+}
+
+uint8_t getNewElementNumber(String file) {
+    uint8_t number = readFile(file, 100).toInt();
+    number++;
+    removeFile(file);
+    addFile(file, String(number));
+    return number;
+}
+
+uint8_t getFreePinAll() {
+#ifdef ESP8266
+    uint8_t pins[] = {0, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5};
+#endif
+#ifdef ESP32
+    uint8_t pins[] = {0, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5};
+#endif
+    uint8_t array_sz = sizeof(pins) / sizeof(pins[0]);
+    uint8_t i = getNewElementNumber("pins.txt");
+    if (i < array_sz) {
+        return pins[i];
+    } else {
+        return 0;
+    }
+}
+
+bool isPinExist(unsigned int num) {
+    bool ret = false;
+    unsigned int pins[] = {0, 1, 2, 3, 4, 5, 9, 10, 12, 13, 14, 15, 16};
+    uint8_t array_sz = sizeof(pins) / sizeof(pins[0]);
+    for (uint8_t i = 0; i < array_sz; i++) {
+        if (pins[i] == num) ret = true;
+    }
+    return ret;
+}
+
+uint8_t getFreePinAnalog() {
+#ifdef ESP8266
+    return 0;
+#endif
+}
+
+void delChoosingItems() {
+    File configFile = FileFS.open("/" + String(DEVICE_CONFIG_FILE), "r");
+    if (!configFile) {
+        return;
+    }
+    configFile.seek(0, SeekSet);
+    String finalConf;
+    bool firstLine = true;
+    while (configFile.position() != configFile.size()) {
+        String item = configFile.readStringUntil('\n');
+        if (firstLine) {
+            finalConf += item;
+        } else {
+            int checkbox = selectToMarker(item, ";").toInt();
+            if (checkbox == 0) {
+                finalConf += "\n" + item;
+            }
+        }
+        firstLine = false;
+    }
+    removeFile(String(DEVICE_CONFIG_FILE));
+    addFile(String(DEVICE_CONFIG_FILE), finalConf);
+    Serial.println(finalConf);
+    configFile.close();
+}
\ No newline at end of file
diff --git a/src/MqttClient.cpp b/src/MqttClient.cpp
new file mode 100644
index 00000000..f5147292
--- /dev/null
+++ b/src/MqttClient.cpp
@@ -0,0 +1,378 @@
+#include "MqttClient.h"
+
+#include "BufferExecute.h"
+#include "Class/NotAsync.h"
+#include "Global.h"
+#include "Init.h"
+#include "items/vLogging.h"
+
+enum MqttBroker { MQTT_PRIMARY,
+                  MQTT_RESERVE };
+
+MqttBroker activeBroker = MQTT_PRIMARY;
+
+String mqttPrefix;
+String mqttRootDevice;
+String mqttPass;
+String mqttServer;
+String mqttUser;
+uint16_t mqttPort{0};
+uint16_t reconnectionCounter{0};
+uint16_t fallbackCounter{0};
+
+const String getParamName(const char* param, MqttBroker broker) {
+    return String("mqtt") + param + (broker == MQTT_RESERVE ? "2" : "");
+}
+
+bool checkBrokerParams(MqttBroker broker) {
+    return !jsonReadStr(configSetupJson, getParamName("Server", broker)).isEmpty();
+}
+
+void mqttInit() {
+    myNotAsyncActions->add(
+        do_MQTTPARAMSCHANGED, [&](void*) {
+            mqttReconnect();
+        },
+        nullptr);
+
+    mqtt.setCallback(mqttCallback);
+
+    ts.add(
+        WIFI_MQTT_CONNECTION_CHECK, MQTT_RECONNECT_INTERVAL,
+        [&](void*) {
+            if (WiFi.status() == WL_CONNECTED) {
+                SerialPrint("I", "WIFI", "OK");
+                if (mqtt.connected()) {
+                    if (activeBroker == MQTT_RESERVE) {
+                        // при 20 cекундных интервалах проверки, каждые 100 сек
+                        if (fallbackCounter++ > 5) {
+                            if (checkBrokerParams(MQTT_PRIMARY)) {
+                                activeBroker = MQTT_PRIMARY;
+                                fallbackCounter = 0;
+                                mqttReconnect();
+                            }
+                        }
+                    } else {
+                        SerialPrint("I", "MQTT", "OK");
+                        setLedStatus(LED_OFF);
+                    }
+                } else {
+                    SerialPrint("E", "MQTT", "lost connection");
+                    if (reconnectionCounter++ > 5) {
+                        if (activeBroker == MQTT_PRIMARY) {
+                            if (checkBrokerParams(MQTT_RESERVE)) {
+                                activeBroker = MQTT_RESERVE;
+                            }
+                        } else {
+                            activeBroker = MQTT_PRIMARY;
+                        }
+                        reconnectionCounter = 0;
+                    }
+                    mqttConnect();
+                }
+            } else {
+                SerialPrint("E", "WIFI", "Lost WiFi connection");
+                ts.remove(WIFI_MQTT_CONNECTION_CHECK);
+                startAPMode();
+            }
+        },
+        nullptr, true);
+
+    myNotAsyncActions->add(
+        do_sendScenMQTT, [&](void*) {
+            String scen = readFile(String(DEVICE_SCENARIO_FILE), 2048);
+            publishInfo("scen", scen);
+        },
+        nullptr);
+}
+
+void mqttDisconnect() {
+    SerialPrint("I", "MQTT", "disconnect");
+    mqtt.disconnect();
+}
+
+void mqttReconnect() {
+    mqttDisconnect();
+    mqttConnect();
+}
+
+void mqttLoop() {
+    if (!isNetworkActive() || !mqtt.connected()) {
+        return;
+    }
+    mqtt.loop();
+}
+
+void mqttSubscribe() {
+    SerialPrint("I", "MQTT", "subscribe");
+    mqtt.subscribe(mqttPrefix.c_str());
+    mqtt.subscribe((mqttRootDevice + "/+/control").c_str());
+    mqtt.subscribe((mqttRootDevice + "/update").c_str());
+
+    if (jsonReadBool(configSetupJson, "MqttIn")) {
+        mqtt.subscribe((mqttPrefix + "/+/+/event").c_str());
+        mqtt.subscribe((mqttPrefix + "/+/+/order").c_str());
+        mqtt.subscribe((mqttPrefix + "/+/+/info").c_str());
+    }
+}
+
+bool readBrokerParams(MqttBroker broker) {
+    if (!checkBrokerParams(broker)) {
+        return false;
+    }
+    mqttServer = jsonReadStr(configSetupJson, getParamName("Server", broker));
+    mqttPort = jsonReadInt(configSetupJson, getParamName("Port", broker));
+    mqttUser = jsonReadStr(configSetupJson, getParamName("User", broker));
+    mqttPass = jsonReadStr(configSetupJson, getParamName("Pass", broker));
+
+    return true;
+}
+
+boolean mqttConnect() {
+    SerialPrint("I", "MQTT", String("use ") + (activeBroker == MQTT_PRIMARY ? "primary" : "reserve"));
+    if (!checkBrokerParams(activeBroker)) {
+        SerialPrint("E", "MQTT", "empty broker address");
+        return false;
+    }
+    readBrokerParams(activeBroker);
+    SerialPrint("I", "MQTT", "start connection");
+    mqttPrefix = jsonReadStr(configSetupJson, "mqttPrefix");
+    mqttRootDevice = mqttPrefix + "/" + chipId;
+    SerialPrint("I", "MQTT", "broker " + mqttServer + ":" + String(mqttPort, DEC));
+    SerialPrint("I", "MQTT", "topic " + mqttRootDevice);
+    setLedStatus(LED_FAST);
+    mqtt.setServer(mqttServer.c_str(), mqttPort);
+    bool res = false;
+    if (!mqtt.connected()) {
+        if (mqtt.connect(chipId.c_str(), mqttUser.c_str(), mqttPass.c_str())) {
+            SerialPrint("I", "MQTT", "connected");
+            setLedStatus(LED_OFF);
+            mqttSubscribe();
+            res = true;
+        } else {
+            SerialPrint("E", "MQTT", "could't connect, retry in " + String(MQTT_RECONNECT_INTERVAL / 1000) + "s");
+            setLedStatus(LED_FAST);
+        }
+    }
+    return res;
+}
+
+void mqttCallback(char* topic, uint8_t* payload, size_t length) {
+    String topicStr = String(topic);
+    //SerialPrint("I", "=>MQTT", topicStr);
+    String payloadStr;
+    payloadStr.reserve(length + 1);
+    for (size_t i = 0; i < length; i++) {
+        payloadStr += (char)payload[i];
+    }
+
+    //SerialPrint("I", "=>MQTT", payloadStr);
+
+    if (payloadStr.startsWith("HELLO")) {
+        SerialPrint("I", "MQTT", "Full update");
+        publishWidgets();
+        publishState();
+
+        choose_log_date_and_send();
+    }
+
+    else if (topicStr.indexOf("control") != -1) {
+        String key = selectFromMarkerToMarker(topicStr, "/", 3);
+
+        String order;
+        order += key;
+        order += " ";
+        order += payloadStr;
+        order += ",";
+
+        loopCmdAdd(order);
+
+        SerialPrint("I", "=>MQTT", "Msg from iotmanager app: " + key + " " + payloadStr);
+    }
+
+    else if (topicStr.indexOf("event") != -1) {
+        if (!jsonReadBool(configSetupJson, "MqttIn")) {
+            return;
+        }
+        if (topicStr.indexOf(chipId) == -1) {
+            String devId = selectFromMarkerToMarker(topicStr, "/", 2);
+            String key = selectFromMarkerToMarker(topicStr, "/", 3);
+            SerialPrint("I", "=>MQTT", "Received event from other device: '" + devId + "' " + key + " " + payloadStr);
+            String event = key + " " + payloadStr + ",";
+            eventBuf += event;
+        }
+    }
+
+    else if (topicStr.indexOf("order") != -1) {
+        if (!jsonReadBool(configSetupJson, "MqttIn")) {
+            return;
+        }
+        String devId = selectFromMarkerToMarker(topicStr, "/", 2);
+        String key = selectFromMarkerToMarker(topicStr, "/", 3);
+        SerialPrint("I", "=>MQTT", "Received direct order " + key + " " + payloadStr);
+        String order = key + " " + payloadStr + ",";
+        orderBuf += order;
+    }
+
+    else if (topicStr.indexOf("info") != -1) {
+        if (topicStr.indexOf("scen") != -1) {
+            writeFile(String(DEVICE_SCENARIO_FILE), payloadStr);
+            loadScenario();
+            SerialPrint("I", "=>MQTT", "Scenario received");
+        }
+    }
+}
+
+boolean publish(const String& topic, const String& data) {
+    if (mqtt.beginPublish(topic.c_str(), data.length(), false)) {
+        mqtt.print(data);
+        return mqtt.endPublish();
+    }
+    return false;
+}
+
+boolean publishData(const String& topic, const String& data) {
+    String path = mqttRootDevice + "/" + topic;
+    if (!publish(path, data)) {
+        SerialPrint("[E]", "MQTT", "on publish data");
+        return false;
+    }
+    return true;
+}
+
+boolean publishChart(const String& topic, const String& data) {
+    String path = mqttRootDevice + "/" + topic + "/status";
+    if (!publish(path, data)) {
+        SerialPrint("[E]", "MQTT", "on publish chart");
+        return false;
+    }
+    return true;
+}
+
+boolean publishControl(String id, String topic, String state) {
+    String path = mqttPrefix + "/" + id + "/" + topic + "/control";
+    return mqtt.publish(path.c_str(), state.c_str(), false);
+}
+
+boolean publishChart_test(const String& topic, const String& data) {
+    String path = mqttRootDevice + "/" + topic + "/status";
+    return mqtt.publish(path.c_str(), data.c_str(), false);
+}
+
+boolean publishStatus(const String& topic, const String& data) {
+    String path = mqttRootDevice + "/" + topic + "/status";
+    String json = "{}";
+    jsonWriteStr(json, "status", data);
+    return mqtt.publish(path.c_str(), json.c_str(), false);
+}
+
+boolean publishEvent(const String& topic, const String& data) {
+    String path = mqttRootDevice + "/" + topic + "/event";
+    return mqtt.publish(path.c_str(), data.c_str(), true);
+}
+
+boolean publishInfo(const String& topic, const String& data) {
+    String path = mqttRootDevice + "/" + topic + "/info";
+    return mqtt.publish(path.c_str(), data.c_str(), false);
+}
+
+#ifdef LAYOUT_IN_RAM
+void publishWidgets() {
+    if (all_widgets != "") {
+        int counter = 0;
+        String line;
+        int psn_1 = 0;
+        int psn_2;
+        do {
+            psn_2 = all_widgets.indexOf("\r\n", psn_1);  //\r\n
+            line = all_widgets.substring(psn_1, psn_2);
+            line.replace("\n", "");
+            line.replace("\r\n", "");
+            //jsonWriteStr(line, "id", String(counter));
+            //jsonWriteStr(line, "pageId", String(counter));
+            counter++;
+            sendMQTT("config", line);
+            Serial.println("[V] " + line);
+            psn_1 = psn_2 + 1;
+        } while (psn_2 + 2 < all_widgets.length());
+        getMemoryLoad("I after send all widgets");
+    }
+}
+#endif
+
+#ifndef LAYOUT_IN_RAM
+void publishWidgets() {
+    auto file = seekFile("layout.txt");
+    if (!file) {
+        SerialPrint("[E]", "MQTT", "no file layout.txt");
+        return;
+    }
+    while (file.available()) {
+        String payload = file.readStringUntil('\n');
+        SerialPrint("I", "MQTT", "widgets: " + payload);
+        publishData("config", payload);
+    }
+    file.close();
+}
+#endif
+
+void publishState() {
+    // берет строку json и ключи превращает в топики а значения колючей в них посылает
+    String str = configLiveJson + "," + configStoreJson;
+    str.replace("{", "");
+    str.replace("}", "");
+    str += ",";
+
+    while (str.length()) {
+        String tmp = selectToMarker(str, ",");
+
+        String topic = selectToMarker(tmp, "\":");
+        topic.replace("\"", "");
+
+        String state = selectToMarkerLast(tmp, "\":");
+        state.replace("\"", "");
+
+        if (topic != "timenow") {
+            publishStatus(topic, state);
+        }
+        str = deleteBeforeDelimiter(str, ",");
+    }
+}
+
+const String getStateStr() {
+    switch (mqtt.state()) {
+        case -4:
+            return F("no respond");
+            break;
+        case -3:
+            return F("connection was broken");
+            break;
+        case -2:
+            return F("connection failed");
+            break;
+        case -1:
+            return F("client disconnected");
+            break;
+        case 0:
+            return F("client connected");
+            break;
+        case 1:
+            return F("doesn't support the requested version");
+            break;
+        case 2:
+            return F("rejected the client identifier");
+            break;
+        case 3:
+            return F("unable to accept the connection");
+            break;
+        case 4:
+            return F("wrong username/password");
+            break;
+        case 5:
+            return F("not authorized to connect");
+            break;
+        default:
+            return F("unspecified");
+            break;
+    }
+}
diff --git a/src/RemoteOrdersUdp.cpp b/src/RemoteOrdersUdp.cpp
new file mode 100644
index 00000000..70ff516c
--- /dev/null
+++ b/src/RemoteOrdersUdp.cpp
@@ -0,0 +1,110 @@
+#include "RemoteOrdersUdp.h"
+#include 
+#include "Global.h"
+#include "Class/NotAsync.h"
+#include "Init.h"
+
+#ifdef UDP_ENABLED
+AsyncUDP asyncUdp;
+
+void asyncUdpInit() {
+
+    if (!jsonReadBool(configSetupJson, "snaUdp")) {
+        return;
+    }
+
+    if (asyncUdp.listenMulticast(IPAddress(239, 255, 255, 255), 4210)) {
+        asyncUdp.onPacket([](AsyncUDPPacket packet) {
+
+            //Serial.print("UDP Packet Type: ");
+            //Serial.println(packet.isBroadcast() ? "Broadcast" : packet.isMulticast() ? "Multicast" : "Unicast");
+            //
+            //Serial.print("From: ");
+            //Serial.print(packet.remoteIP());
+            //Serial.print(":");
+            //Serial.println(packet.remotePort());
+            //
+            //Serial.print("To: ");
+            //Serial.print(packet.localIP());
+            //Serial.print(":");
+            //Serial.println(packet.localPort());
+            //Serial.print(", Length: ");
+            //Serial.print(packet.length());
+            //
+            //Serial.print(", Data: ");
+            //Serial.write(packet.data(), packet.length());
+
+            String data = uint8tToString(packet.data(), packet.length());
+            Serial.print("[i] [udp] Packet received: '");
+            Serial.print(data);
+
+            if (udpPacketValidation(data)) {
+                Serial.println("', packet valid");
+                udpPacketParse(data);
+            }
+
+
+            //else {
+            //    //Serial.println("', Packet invalid");
+            //}
+            //reply to the client
+            //String ip = WiFi.localIP().toString();
+            //asyncUdp.broadcastTo(ip.c_str(), packet.remotePort());
+            //packet.printf(ip.c_str(), packet.length());
+
+            });
+    }
+
+    myNotAsyncActions->add(
+        do_sendScenUDP, [&](void*) {
+
+            String scen = "iotm;scen:";
+            scen += readFile(String(DEVICE_SCENARIO_FILE), 2048);
+
+            asyncUdp.broadcastTo(scen.c_str(), 4210);
+
+        },
+        nullptr);
+
+    //ts.add(
+    //UDP, 10000, [&](void*) {
+    //Serial.println("sended");
+    //asyncUdp.broadcastTo("iotm;Anyone here?", 4210); 
+    //asyncUdp.broadcast("test");
+    //asyncUdp.print("Hello Server!");
+    //},
+    //nullptr, true);
+
+     SerialPrint("I", F("UDP"), "Udp Init");
+
+}
+
+bool udpPacketValidation(String& data) {
+    if (data.indexOf("iotm;") != -1) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+void udpPacketParse(String& data) {
+    if (data.indexOf("scen:") != -1) {
+        data = deleteBeforeDelimiter(data, ":");
+        writeFile(String(DEVICE_SCENARIO_FILE), data);
+        loadScenario();
+    }
+    else if (data.indexOf("event:") != -1) {
+        data = deleteBeforeDelimiter(data, ":");
+        eventBuf += data;
+    }
+}
+
+String uint8tToString(uint8_t* data, size_t len) {
+    String ret;
+    while (len--) {
+        ret += (char)*data++;
+    }
+    return ret;
+}
+#endif
\ No newline at end of file
diff --git a/src/SSDP.cpp b/src/SSDP.cpp
new file mode 100644
index 00000000..fb431bbd
--- /dev/null
+++ b/src/SSDP.cpp
@@ -0,0 +1,63 @@
+#include "SSDP.h"
+
+#include "Global.h"
+
+#ifdef SSDP_ENABLED
+#ifdef ESP8266
+#include 
+#endif
+#ifdef ESP32
+#include 
+#endif
+
+String xmlNode(String tags, String data);
+
+String decToHex(uint32_t decValue, byte desiredStringLength);
+
+void SsdpInit() {
+    server.on("/description.xml", HTTP_GET, [](AsyncWebServerRequest* request) {
+        String ssdpSend = F("");
+        String ssdpHeder = xmlNode(F("major"), "1");
+        ssdpHeder += xmlNode(F("minor"), "0");
+        ssdpHeder = xmlNode(F("specVersion"), ssdpHeder);
+        ssdpHeder += xmlNode(F("URLBase"), "http://" + WiFi.localIP().toString());
+        String ssdpDescription = xmlNode(F("deviceType"), F("upnp:rootdevice"));
+        ssdpDescription += xmlNode(F("friendlyName"), jsonReadStr(configSetupJson, F("name")));
+        ssdpDescription += xmlNode(F("presentationURL"), "/");
+        ssdpDescription += xmlNode(F("serialNumber"), getChipId());
+#ifdef ESP8266
+        ssdpDescription += xmlNode(F("modelName"), F("ESP8266"));
+#endif
+#ifdef ESP32
+        ssdpDescription += xmlNode(F("modelName"), F("ESP32"));
+#endif
+        ssdpDescription += xmlNode(F("modelNumber"), getChipId());
+        ssdpDescription += xmlNode(F("modelURL"), F("https://github.com/IoTManagerProject/IoTManager/wiki"));
+        ssdpDescription += xmlNode(F("manufacturer"), F("Borisenko Dmitry"));
+        ssdpDescription += xmlNode(F("manufacturerURL"), F("https://github.com/IoTManagerProject/IoTManager"));
+        ssdpDescription += xmlNode(F("UDN"), "uuid:38323636-4558-4dda-9188-cda0e6" + decToHex(ESP_getChipId(), 6));
+        ssdpDescription = xmlNode("device", ssdpDescription);
+        ssdpHeder += ssdpDescription;
+        ssdpSend += ssdpHeder;
+        ssdpSend += "";
+        Serial.println("->!!!SSDP Get request received");
+        request->send(200, "text/xml", ssdpSend);
+    });
+    //Если версия  2.0.0 закаментируйте следующую строчку
+    SSDP.setDeviceType(F("upnp:rootdevice"));
+    SSDP.setSchemaURL(F("description.xml"));
+    SSDP.begin();
+    SerialPrint("I", F("SSDP"), F("Ssdp Init"));
+}
+
+String xmlNode(String tags, String data) {
+    String temp = "<" + tags + ">" + data + "";
+    return temp;
+}
+
+String decToHex(uint32_t decValue, byte desiredStringLength) {
+    String hexString = String(decValue, HEX);
+    while (hexString.length() < desiredStringLength) hexString = "0" + hexString;
+    return hexString;
+}
+#endif
\ No newline at end of file
diff --git a/src/Servo/Servs.cpp b/src/Servo/Servs.cpp
new file mode 100644
index 00000000..96ebba91
--- /dev/null
+++ b/src/Servo/Servs.cpp
@@ -0,0 +1,40 @@
+#include "Servo/Servos.h"
+
+Servos myServo;
+
+Servos::Servos(){};
+
+Servo *Servos::create(uint8_t num, uint8_t pin) {
+    // Ищем среди ранее созданных
+    for (size_t i = 0; i < _items.size(); i++) {
+        auto item = _items.at(i);
+        if (item.num == num) {
+            if (item.pin != pin) {
+                item.obj->attach(pin);
+                item.pin = pin;
+            };
+            return item.obj;
+        }
+    }
+    // Добавляем новый
+    Servo_t newItem{num, pin};
+    newItem.obj = new Servo();
+    newItem.obj->attach(pin);
+    _items.push_back(newItem);
+    return newItem.obj;
+}
+
+Servo *Servos::get(uint8_t num) {
+    // Ищем среди ранее созданных
+    for (size_t i = 0; i < _items.size(); i++) {
+        auto item = _items.at(i);
+        if (item.num == num) {
+            return item.obj;
+        }
+    }
+    return nullptr;
+}
+
+size_t Servos::count() {
+    return _items.size();
+}
diff --git a/src/SoftUART.cpp b/src/SoftUART.cpp
new file mode 100644
index 00000000..c40a3f08
--- /dev/null
+++ b/src/SoftUART.cpp
@@ -0,0 +1,57 @@
+#include "Consts.h"
+#ifdef uartEnable
+#include "SoftUART.h"
+#include "Global.h"
+#include "BufferExecute.h"
+
+#ifdef ESP8266
+SoftwareSerial* myUART = nullptr;
+#else
+HardwareSerial* myUART = nullptr;
+#endif
+
+void uartInit() {
+    if (!jsonReadBool(configSetupJson, "uart")) {
+        return;
+    }
+    if (!myUART) {
+#ifdef ESP8266
+        myUART = new SoftwareSerial(jsonReadInt(configSetupJson, "uartTX"), jsonReadInt(configSetupJson, "uartRX"));
+        myUART->begin(jsonReadInt(configSetupJson, "uartS"));
+#else
+        myUART = new HardwareSerial(2);
+        myUART->begin(4, 5);
+#endif
+    }
+    SerialPrint("I", F("UART"), F("UART Init"));
+}
+
+void uartHandle() {
+    if (myUART) {
+        if (!jsonReadBool(configSetupJson, "uart")) {
+            return;
+        }
+        static String incStr;
+        if (myUART->available()) {
+            char inc;
+            inc = myUART->read();
+            incStr += inc;
+            if (inc == '\n') {
+                parse(incStr);
+                incStr = "";               
+            }
+        }
+    }
+}
+
+void parse(String& incStr) {
+    incStr.replace("\r\n", "");
+    incStr.replace("\r", "");
+    incStr.replace("\n", "");
+    if (incStr.indexOf("set") != -1) {
+        incStr = deleteBeforeDelimiter(incStr, " ");
+        loopCmdAdd(incStr);
+        SerialPrint("I", "=>UART", incStr);
+    }
+}
+#endif
\ No newline at end of file
diff --git a/src/Telegram.cpp b/src/Telegram.cpp
new file mode 100644
index 00000000..3e069988
--- /dev/null
+++ b/src/Telegram.cpp
@@ -0,0 +1,121 @@
+#include "Consts.h"
+#ifdef telegramEnable
+#include "BufferExecute.h"
+#include "Telegram.h"
+CTBot* myBot{nullptr};
+
+void telegramInit() {
+    if (isTelegramEnabled()) {
+        telegramInitBeen = true;
+        sCmd.addCommand("telegram", sendTelegramMsg);
+        String token = jsonReadStr(configSetupJson, "telegramApi");
+        if (!myBot) {
+            myBot = new CTBot();
+        }
+        myBot->setTelegramToken(token);
+        myBot->enableUTF8Encoding(true);
+        if (myBot->testConnection()) {
+            SerialPrint("I", "Telegram", "Connected");
+        } else {
+            SerialPrint("E", "Telegram", "Not connected");
+        }
+        SerialPrint("I", F("Telegram"), F("Telegram Init"));
+    }
+}
+
+void handleTelegram() {
+    if (telegramInitBeen) {
+        if (isTelegramEnabled()) {
+            if (isTelegramInputOn()) {
+                TBMessage msg;
+                static unsigned long prevMillis;
+                unsigned long currentMillis = millis();
+                unsigned long difference = currentMillis - prevMillis;
+                if (difference >= 10000) {
+                    prevMillis = millis();
+                    if (myBot->getNewMessage(msg)) {
+                        SerialPrint("->", "Telegram", "chat ID: " + String(msg.sender.id) + ", msg: " + String(msg.text));
+                        if (jsonReadBool(configSetupJson, "autos")) {
+                            jsonWriteInt(configSetupJson, "chatId", msg.sender.id);
+                            saveConfig();
+                        }
+                        telegramMsgParse(String(msg.text));
+                    }
+                }
+            }
+        }
+    }
+}
+
+void telegramMsgParse(String msg) {
+    if (msg.indexOf("set") != -1) {
+        msg = deleteBeforeDelimiter(msg, "_");
+        msg.replace("_", " ");
+        loopCmdAdd(String(msg) + ",");
+        myBot->sendMessage(jsonReadInt(configSetupJson, "chatId"), "order done");
+        SerialPrint("<-", "Telegram", "chat ID: " + String(jsonReadInt(configSetupJson, "chatId")) + ", msg: " + String(msg));
+    } else if (msg.indexOf("get") != -1) {
+        msg = deleteBeforeDelimiter(msg, "_");
+        myBot->sendMessage(jsonReadInt(configSetupJson, "chatId"), getValue(msg));  //jsonReadStr(configLiveJson , msg));
+        SerialPrint("<-", "Telegram", "chat ID: " + String(jsonReadInt(configSetupJson, "chatId")) + ", msg: " + String(msg));
+    } else if (msg.indexOf("all") != -1) {
+        String list = returnListOfParams();
+        myBot->sendMessage(jsonReadInt(configSetupJson, "chatId"), list);
+        SerialPrint("<-", "Telegram", "chat ID: " + String(jsonReadInt(configSetupJson, "chatId")) + "\n" + list);
+    } else {
+        myBot->sendMessage(jsonReadInt(configSetupJson, "chatId"), "ID: " + chipId + ", Name: " + jsonReadStr(configSetupJson, F("name")));
+        myBot->sendMessage(jsonReadInt(configSetupJson, "chatId"), F("Wrong order, use /all to get all values, /get_id to get value, or /set_id_value to set value"));
+    }
+}
+
+void sendTelegramMsg() {
+    String sabject = sCmd.next();
+    String msg = sCmd.next();
+    if (sabject == "often") {
+        msg.replace("#", " ");
+        myBot->sendMessage(jsonReadInt(configSetupJson, "chatId"), msg);
+        SerialPrint("<-", "Telegram", "chat ID: " + String(jsonReadInt(configSetupJson, "chatId")) + ", msg: " + msg);
+    } else {
+        String prevMsg = jsonReadStr(telegramMsgJson, sabject);
+        if (prevMsg != msg) {
+            jsonWriteStr(telegramMsgJson, sabject, msg);
+            msg.replace("#", " ");
+            sabject.replace("#", " ");
+            myBot->sendMessage(jsonReadInt(configSetupJson, "chatId"), sabject + " " + msg);
+            SerialPrint("<-", "Telegram", "chat ID: " + String(jsonReadInt(configSetupJson, "chatId")) + ", msg: " + sabject + " " + msg);
+        }
+    }
+}
+
+bool isTelegramEnabled() {
+    return jsonReadBool(configSetupJson, "telegonof");
+}
+
+bool isTelegramInputOn() {
+    return jsonReadBool(configSetupJson, "teleginput");
+}
+
+String returnListOfParams() {
+    String cmdStr = readFile(DEVICE_CONFIG_FILE, 4096);
+    cmdStr += "\r\n";
+    cmdStr.replace("\r\n", "\n");
+    cmdStr.replace("\r", "\n");
+    int count = 0;
+    String out;
+    while (cmdStr.length()) {
+        String buf = selectToMarker(cmdStr, "\n");
+        count++;
+        if (count > 1) {
+            String id = selectFromMarkerToMarker(buf, ";", 2);
+            String value = getValue(id);  //jsonReadStr(configLiveJson , id);
+            String page = selectFromMarkerToMarker(buf, ";", 4);
+            page.replace("#", " ");
+            String name = selectFromMarkerToMarker(buf, ";", 5);
+            name.replace("#", " ");
+            out += page + " " + " " + name + " " + value + "\n";
+        }
+        cmdStr = deleteBeforeDelimiter(cmdStr, "\n");
+    }
+    return out;
+}
+#endif
\ No newline at end of file
diff --git a/src/Tests.cpp b/src/Tests.cpp
new file mode 100644
index 00000000..7ba1141c
--- /dev/null
+++ b/src/Tests.cpp
@@ -0,0 +1,18 @@
+#include "Tests.h"
+
+#include "Global.h"
+#include "ItemsList.h"
+#include "Macro.h"
+#include "Utils/StringUtils.h"
+
+void testsPerform() {
+    Serial.println("====some tests section====");
+
+    //Serial.println(isDigitDotCommaStr("-12552.5555"));
+
+    //String str = "Geeks for Geeks ";
+
+    //Serial.println(itemsCount2(str, " "));
+
+    Serial.println("==========end============");
+}
\ No newline at end of file
diff --git a/src/UpgradeFirm.cpp b/src/UpgradeFirm.cpp
new file mode 100644
index 00000000..b3f57051
--- /dev/null
+++ b/src/UpgradeFirm.cpp
@@ -0,0 +1,136 @@
+#include "Upgrade.h"
+
+#include "FileSystem.h"
+
+#include "Class/NotAsync.h"
+#ifdef ESP8266
+#include "ESP8266.h"
+#else
+#include 
+#endif
+
+#include "Global.h"
+
+void upgradeInit() {
+    myNotAsyncActions->add(
+        do_UPGRADE, [&](void*) {
+            upgrade_firmware(3);
+        },
+        nullptr);
+
+    myNotAsyncActions->add(
+        do_GETLASTVERSION, [&](void*) {
+            getLastVersion();
+        },
+        nullptr);
+
+    if (isNetworkActive()) {
+        getLastVersion();
+        if (lastVersion > 0) {
+            SerialPrint("I", "Update", "available version: " + String(lastVersion));
+            if (lastVersion > FIRMWARE_VERSION) {
+                jsonWriteStr(configSetupJson, "warning2", F("
Вышла новая версия прошивки, нажмите обновить прошивку
"));
+            }
+        }
+    };
+    SerialPrint("I", F("Update"), F("Updater Init"));
+}
+
+void getLastVersion() {
+    if ((WiFi.status() == WL_CONNECTED)) {
+#ifdef ESP8266
+        String tmp = getURL(serverIP + F("/projects/iotmanager/esp8266/esp8266ver/esp8266ver.txt"));
+#else
+        String tmp = getURL(serverIP + F("/projects/iotmanager/esp32/esp32ver/esp32ver.txt"));
+#endif
+        if (tmp == "error") {
+            lastVersion = -1;
+        }
+        else {
+            lastVersion = tmp.toInt();
+        }
+    }
+    else {
+        lastVersion = -2;
+    }
+    jsonWriteInt(configSetupJson, "last_version", lastVersion);
+}
+
+void upgrade_firmware(int type) {
+    String scenario_ForUpdate;
+    String devconfig_ForUpdate;
+    String configSetup_ForUpdate;
+
+    scenario_ForUpdate = readFile(String(DEVICE_SCENARIO_FILE), 4096);
+    devconfig_ForUpdate = readFile(String(DEVICE_CONFIG_FILE), 4096);
+    configSetup_ForUpdate = configSetupJson;
+
+    if (type == 1) {  //only build
+        if (upgradeBuild()) restartEsp();
+    }
+
+    else if (type == 2) {  //only spiffs
+        if (upgradeFS()) {
+            writeFile(String(DEVICE_SCENARIO_FILE), scenario_ForUpdate);
+            writeFile(String(DEVICE_CONFIG_FILE), devconfig_ForUpdate);
+            writeFile("config.json", configSetup_ForUpdate);
+            restartEsp();
+        }
+    }
+
+    else if (type == 3) {  //spiffs and build
+        if (upgradeFS()) {
+            writeFile(String(DEVICE_SCENARIO_FILE), scenario_ForUpdate);
+            writeFile(String(DEVICE_CONFIG_FILE), devconfig_ForUpdate);
+            writeFile("config.json", configSetup_ForUpdate);
+            saveConfig();
+            if (upgradeBuild()) {
+                restartEsp();
+            }
+        }
+    }
+}
+
+bool upgradeFS() {
+    WiFiClient wifiClient;
+    bool ret = false;
+    Serial.printf("Start upgrade %s, please wait...", FS_NAME);
+#ifdef ESP8266
+    ESPhttpUpdate.rebootOnUpdate(false);
+    t_httpUpdate_return retFS = ESPhttpUpdate.updateSpiffs(wifiClient, serverIP + F("/projects/iotmanager/esp8266/") + FS_NAME + "/"+ FS_NAME+ ".bin");
+#else
+    httpUpdate.rebootOnUpdate(false);
+    HTTPUpdateResult retFS = httpUpdate.updateSpiffs(wifiClient, serverIP + F("/projects/iotmanager/esp32/littlefs/spiffs.bin"));
+#endif
+    if (retFS == HTTP_UPDATE_OK) {  //если FS обновилась успешно
+        SerialPrint("I", "Update", "FS upgrade done!");
+        ret = true;
+    }
+    return ret;
+}
+
+bool upgradeBuild() {
+    WiFiClient wifiClient;
+    bool ret = false;
+    Serial.println("Start upgrade BUILD, please wait...");
+
+#ifdef ESP8266
+    ESPhttpUpdate.rebootOnUpdate(false);
+    t_httpUpdate_return retBuild = ESPhttpUpdate.update(wifiClient, serverIP + F("/projects/iotmanager/esp8266/firmware/firmware.bin"));
+#else
+    httpUpdate.rebootOnUpdate(false);
+    HTTPUpdateResult retBuild = httpUpdate.update(wifiClient, serverIP + F("/projects/iotmanager/esp32/firmware/firmware.bin"));
+#endif
+
+    if (retBuild == HTTP_UPDATE_OK) {  //если BUILD обновился успешно
+        SerialPrint("I", "Update", "BUILD upgrade done!");
+        ret = true;
+    }
+    return ret;
+}
+
+void restartEsp() {
+    Serial.println("Restart ESP....");
+    delay(1000);
+    ESP.restart();
+}
\ No newline at end of file
diff --git a/src/Utils/FileUtils.cpp b/src/Utils/FileUtils.cpp
new file mode 100644
index 00000000..aa8cbaed
--- /dev/null
+++ b/src/Utils/FileUtils.cpp
@@ -0,0 +1,183 @@
+#include "Utils/FileUtils.h"
+
+#include "FileSystem.h"
+#include "Utils/StringUtils.h"
+#include "Utils\SerialPrint.h"
+
+const String filepath(const String& filename) {
+    return filename.startsWith("/") ? filename : "/" + filename;
+}
+
+bool fileSystemInit() {
+    if (!FileFS.begin()) {
+        SerialPrint("E", F("FS"), F("FS Init ERROR, may be FS was not flashed"));
+        return false;
+    }
+    SerialPrint("I", F("FS"), F("FS Init completed"));
+    return true;
+}
+
+void removeFile(const String& filename) {
+    String path = filepath(filename);
+    if (FileFS.exists(path)) {
+        if (!FileFS.remove(path)) {
+            SerialPrint("I", "Files", "remove " + path);
+        }
+    } else {
+        SerialPrint("E", "Files", "not exist" + path);
+    }
+}
+
+File seekFile(const String& filename, size_t position) {
+    String path = filepath(filename);
+    auto file = FileFS.open(path, "r");
+    if (!file) {
+        SerialPrint("[E]", "Files", "open " + path);
+    }
+    // поставим курсор в начало файла
+    file.seek(position, SeekSet);
+    return file;
+}
+
+const String readFileString(const String& filename, const String& to_find) {
+    String path = filepath(filename);
+    String res = "failed";
+    auto file = FileFS.open(path, "r");
+    if (!file) {
+        return "failed";
+    }
+    if (file.find(to_find.c_str())) {
+        res = file.readStringUntil('\n');
+    }
+    file.close();
+    return res;
+}
+
+const String addFileLn(const String& filename, const String& str) {
+    String path = filepath(filename);
+    auto file = FileFS.open(path, "a");
+    if (!file) {
+        return "failed";
+    }
+    file.println(str);
+    file.close();
+    return "sucсess";
+}
+
+const String addFile(const String& filename, const String& str) {
+    String path = filepath(filename);
+    auto file = FileFS.open(path, "a");
+    if (!file) {
+        return "failed";
+    }
+    file.print(str);
+    file.close();
+    return "sucсess";
+}
+
+bool copyFile(const String& src, const String& dst, bool overwrite) {
+    String srcPath = filepath(src);
+    String dstPath = filepath(dst);
+    SerialPrint("I", "Files", "copy " + srcPath + " to " + dstPath);
+    if (!FileFS.exists(srcPath)) {
+        SerialPrint("[E]", "Files", "not exist: " + srcPath);
+        return false;
+    }
+    if (FileFS.exists(dstPath)) {
+        if (!overwrite) {
+            SerialPrint("[E]", "Files", "already exist: " + dstPath);
+            return false;
+        }
+        FileFS.remove(dstPath);
+    }
+    auto srcFile = FileFS.open(srcPath, "r");
+    auto dstFile = FileFS.open(dstPath, "w");
+
+    uint8_t buf[512];
+    while (srcFile.available()) {
+        size_t len = srcFile.read(buf, 512);
+        dstFile.write(buf, len);
+    }
+    srcFile.close();
+    dstFile.close();
+    return true;
+}
+
+const String writeFile(const String& filename, const String& str) {
+    String path = filepath(filename);
+    auto file = FileFS.open(path, "w");
+    if (!file) {
+        return "failed";
+    }
+    file.print(str);
+    file.close();
+    return "sucсess";
+}
+
+const String readFile(const String& filename, size_t max_size) {
+    String path = filepath(filename);
+    auto file = FileFS.open(path, "r");
+    if (!file) {
+        return "failed";
+    }
+    size_t size = file.size();
+    if (size > max_size) {
+        file.close();
+        return "large";
+    }
+    String temp = file.readString();
+    file.close();
+    return temp;
+}
+
+size_t countLines(const String filename) {
+    size_t cnt = -1;
+    String path = filepath(filename);
+    auto file = FileFS.open(path, "r");
+    if (!file) {
+        return cnt;
+    }
+    file.seek(0, SeekSet);
+    size_t size = file.size();
+    size_t psn;
+    do {
+        cnt++;
+        file.readStringUntil('\n');
+        psn = file.position();
+    } while (psn < size);
+    file.close();
+    return cnt;
+}
+
+size_t getFileSize(const String filename) {
+    size_t size = -1;
+    String filepath(filename);
+    auto file = FileFS.open(filepath, "r");
+    if (!file) {
+        return size;
+    }
+    size = file.size();
+    file.close();
+    return size;
+}
+
+const String getFSSizeInfo() {
+    String res;
+#ifdef ESP8266
+    FSInfo info;
+    if (FileFS.info(info)) {
+        res = prettyBytes(info.usedBytes) + " of " + prettyBytes(info.totalBytes);
+    } else {
+        res = "error";
+    }
+#else
+    res = prettyBytes(FileFS.usedBytes()) + " of " + prettyBytes(FileFS.totalBytes());
+#endif
+    return res;
+}
+
+const String getConfigFile(uint8_t preset, ConfigType_t type) {
+    char buf[64];
+    sprintf(buf, "/conf/%s%03d.txt", (type == CT_CONFIG) ? "c" : "s", preset);
+    return String(buf);
+}
\ No newline at end of file
diff --git a/src/Utils/JsonUtils.cpp b/src/Utils/JsonUtils.cpp
new file mode 100644
index 00000000..ca70c082
--- /dev/null
+++ b/src/Utils/JsonUtils.cpp
@@ -0,0 +1,60 @@
+#include "Utils/JsonUtils.h"
+#include "Utils/FileUtils.h"
+#include "Global.h"
+
+String jsonReadStr(String& json, String name) {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& root = jsonBuffer.parseObject(json);
+    return root[name].as();
+}
+
+boolean jsonReadBool(String& json, String name) {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& root = jsonBuffer.parseObject(json);
+    return root[name].as();
+}
+
+int jsonReadInt(String& json, String name) {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& root = jsonBuffer.parseObject(json);
+    return root[name];
+}
+
+String jsonWriteStr(String& json, String name, String value) {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& root = jsonBuffer.parseObject(json);
+    root[name] = value;
+    json = "";
+    root.printTo(json);
+    return json;
+}
+
+String jsonWriteBool(String& json, String name, boolean value) {
+    return jsonWriteStr(json, name, value ? "1" : "0");
+}
+
+String jsonWriteInt(String& json, String name, int value) {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& root = jsonBuffer.parseObject(json);
+    root[name] = value;
+    json = "";
+    root.printTo(json);
+    return json;
+}
+
+String jsonWriteFloat(String& json, String name, float value) {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& root = jsonBuffer.parseObject(json);
+    root[name] = value;
+    json = "";
+    root.printTo(json);
+    return json;
+}
+
+void saveConfig() {
+    writeFile(String("config.json"), configSetupJson);
+}
+
+void saveStore() {
+    writeFile(String("store.json"), configStoreJson);
+}
\ No newline at end of file
diff --git a/src/Utils/SerialPrint.cpp b/src/Utils/SerialPrint.cpp
new file mode 100644
index 00000000..77f6047c
--- /dev/null
+++ b/src/Utils/SerialPrint.cpp
@@ -0,0 +1,9 @@
+#include "Utils\SerialPrint.h"
+
+#include "Global.h"
+
+void SerialPrint(String errorLevel, String module, String msg) {
+    //if (module == "Stat") {
+        Serial.println(prettyMillis(millis()) + " [" + errorLevel + "] [" + module + "] " + msg);
+    //}
+}
\ No newline at end of file
diff --git a/src/Utils/StringUtils.cpp b/src/Utils/StringUtils.cpp
new file mode 100644
index 00000000..11e110bd
--- /dev/null
+++ b/src/Utils/StringUtils.cpp
@@ -0,0 +1,136 @@
+#include "Utils/StringUtils.h"
+
+#include "Consts.h"
+
+String selectToMarkerLast(String str, String found) {
+    int p = str.lastIndexOf(found);
+    return str.substring(p + found.length());
+}
+
+String selectToMarker(String str, String found) {
+    int p = str.indexOf(found);
+    return str.substring(0, p);
+}
+
+String extractInner(String str) {
+    int p1 = str.indexOf("[");
+    int p2 = str.indexOf("]");
+    return str.substring(p1 + 1, p2);
+}
+
+String deleteAfterDelimiter(String str, String found) {
+    int p = str.indexOf(found);
+    return str.substring(0, p);
+}
+
+String deleteBeforeDelimiter(String str, String found) {
+    int p = str.indexOf(found) + found.length();
+    return str.substring(p);
+}
+
+String deleteBeforeDelimiterTo(String str, String found) {
+    int p = str.indexOf(found);
+    return str.substring(p);
+}
+
+String deleteToMarkerLast(String str, String found) {
+    int p = str.lastIndexOf(found);
+    return str.substring(0, p);
+}
+
+String selectToMarkerPlus(String str, String found, int plus) {
+    int p = str.indexOf(found);
+    return str.substring(0, p + plus);
+}
+
+String selectFromMarkerToMarker(String str, String tofind, int number) {
+    if (str.indexOf(tofind) == -1) {
+        return "not found";
+    }
+    str += tofind;  // добавим для корректного поиска
+    uint8_t i = 0;  // Индекс перебора
+    do {
+        if (i == number) {
+            // если индекс совпал с позицией
+            return selectToMarker(str, tofind);
+        }
+        // отбросим проверенный блок до разделителя
+        str = deleteBeforeDelimiter(str, tofind);
+        i++;
+    } while (str.length() != 0);
+
+    return "not found";
+}
+
+uint8_t hexStringToUint8(String hex) {
+    uint8_t tmp = strtol(hex.c_str(), NULL, 0);
+    if (tmp >= 0x00 && tmp <= 0xFF) {
+        return tmp;
+    }
+}
+
+uint16_t hexStringToUint16(String hex) {
+    uint16_t tmp = strtol(hex.c_str(), NULL, 0);
+    if (tmp >= 0x0000 && tmp <= 0xFFFF) {
+        return tmp;
+    }
+}
+
+size_t itemsCount2(String str, const String& separator) {
+    // если строки поиск нет сразу выход
+    if (str.indexOf(separator) == -1) {
+        return 0;
+    }
+    // добавим для корректного поиска
+    str += separator;
+    size_t cnt = 0;
+    while (str.length()) {
+        // отбросим проверенный блок до разделителя
+        str = deleteBeforeDelimiter(str, separator);
+        cnt++;
+    }
+    return cnt;
+}
+
+size_t itemsCount(String& str, const char* delim) {
+    size_t cnt = 0;
+    char* cstr = new char[str.length() + 1];
+    strcpy(cstr, str.c_str());
+    char* token;
+    while ((token = strtok_r(cstr, delim, &cstr))) {
+        cnt++;
+        //printf("%s\n", token);
+    }
+    delete[] cstr;
+    return cnt;
+}
+
+boolean isDigitStr(const String& str) {
+    for (size_t i = 0; i < str.length(); i++) {
+        if (!isDigit(str.charAt(i))) {
+            return false;
+        }
+    }
+    return str.length();
+}
+
+boolean isDigitDotCommaStr(const String& str) {
+    for (size_t i = 0; i < str.length(); i++) {
+        char latter = str.charAt(i);
+        if (!isDigit(latter) && latter != '.' && latter != '-') {
+            return false;
+        }
+    }
+    return true;
+}
+
+String prettyBytes(size_t size) {
+    if (size < 1024)
+        return String(size) + "b";
+    else if (size < (1024 * 1024))
+        return String(size / 1024.0) + "kB";
+    else if (size < (1024 * 1024 * 1024))
+        return String(size / 1024.0 / 1024.0) + "MB";
+    else
+        return String(size / 1024.0 / 1024.0 / 1024.0) + "GB";
+}
diff --git a/src/Utils/SysUtils.cpp b/src/Utils/SysUtils.cpp
new file mode 100644
index 00000000..a9f507a1
--- /dev/null
+++ b/src/Utils/SysUtils.cpp
@@ -0,0 +1,250 @@
+#include "Utils/SysUtils.h"
+
+#include "Global.h"
+
+
+const String getUniqueId(const char* name) {
+    return String(name) + getMacAddress();
+}
+
+uint32_t ESP_getChipId(void) {
+#ifdef ESP32
+    uint32_t id = 0;
+    for (uint32_t i = 0; i < 17; i = i + 8) {
+        id |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i;
+    }
+    return id;
+#else
+    return ESP.getChipId();
+#endif
+}
+
+uint32_t ESP_getFlashChipId(void) {
+#ifdef ESP32
+    // Нет аналогичной (без доп.кода) функций в 32
+    // надо использовать другой id - варианты есть
+    return ESP_getChipId();
+#else
+    return ESP.getFlashChipId();
+#endif
+}
+
+const String getChipId() {
+    return String(ESP_getChipId()) + "-" + String(ESP_getFlashChipId());
+}
+
+void setChipId() {
+    chipId = getChipId();
+    SerialPrint("I", "System", "id: " + chipId);
+}
+
+#ifdef ESP8266
+static uint32_t total_memory = 52864;
+#else
+static uint32_t total_memory = ESP.getHeapSize();
+#endif
+
+const String printMemoryStatus() {
+    uint32_t free = ESP.getFreeHeap();
+    uint32_t used = total_memory - free;
+    uint32_t memory_load = (used * 100) / total_memory;
+    char buf[64];
+    sprintf(buf, "used: %d%% free: %s", memory_load, getHeapStats().c_str());
+    return String(buf);
+}
+
+#ifdef ESP8266
+const String getHeapStats() {
+    uint32_t free;
+    uint16_t max;
+    uint8_t frag;
+    ESP.getHeapStats(&free, &max, &frag);
+    String buf;
+    buf += prettyBytes(free);
+    buf += " frag: ";
+    buf += frag;
+    buf += '%';
+    return buf;
+}
+#else
+const String getHeapStats() {
+    String buf;
+    buf = prettyBytes(ESP.getFreeHeap());
+    return buf;
+}
+#endif
+
+const String getMacAddress() {
+    uint8_t mac[6];
+    char buf[13] = {0};
+#if defined(ESP8266)
+    WiFi.macAddress(mac);
+    sprintf(buf, MACSTR, MAC2STR(mac));
+#else
+    esp_read_mac(mac, ESP_MAC_WIFI_STA);
+    sprintf(buf, MACSTR, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+#endif
+    return String(buf);
+}
+
+#ifdef ESP8266
+void setLedStatus(LedStatus_t status) {
+    if (jsonReadBool(configSetupJson, "blink") == 1) {
+        pinMode(LED_PIN, OUTPUT);
+        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;
+        }
+    }
+}
+#else
+void setLedStatus(LedStatus_t status) {
+    if (jsonReadBool(configSetupJson, "blink") == 1) {
+        pinMode(LED_PIN, OUTPUT);
+        switch (status) {
+            case LED_OFF:
+                digitalWrite(LED_PIN, HIGH);
+                break;
+            case LED_ON:
+                digitalWrite(LED_PIN, LOW);
+                break;
+            case LED_SLOW:
+                break;
+            case LED_FAST:
+                break;
+            default:
+                break;
+        }
+    }
+}
+#endif
+//===================================================================
+/*
+  void web_print (String text) {
+  if (WiFi.status() == WL_CONNECTED) {
+    jsonWriteStr(json, "test1",  jsonReadStr(json, "test2"));
+    jsonWriteStr(json, "test2",  jsonReadStr(json, "test3"));
+    jsonWriteStr(json, "test3",  jsonReadStr(json, "test4"));
+    jsonWriteStr(json, "test4",  jsonReadStr(json, "test5"));
+    jsonWriteStr(json, "test5",  jsonReadStr(json, "test6"));
+
+    jsonWriteStr(json, "test6", GetTime() + " " + text);
+
+    ws.textAll(json);
+  }
+  }
+*/
+//===================================================================
+/*
+  "socket": [
+      "ws://{{ip}}/ws"
+        ],
+*/
+//===================================================================
+/*
+  {
+      "type": "h4",
+      "title": "('{{build2}}'=='{{firmware_version}}'?'NEW':'OLD')"
+    },
+*/
+//===================================================================
+/*
+    {
+      "type": "button",
+      "title": "Конфигурация устройства",
+      "socket": "test2",
+      "class": "btn btn-block btn-primary"
+    },
+  {
+      "type": "hr"
+    },
+               {
+      "type": "h6",
+      "title": "{{test1}}"
+    },
+                {
+      "type": "h6",
+      "title": "{{test2}}"
+    },
+               {
+      "type": "h6",
+      "title": "{{test3}}"
+    },
+                {
+      "type": "h6",
+      "title": "{{test4}}"
+    },
+                {
+      "type": "h6",
+      "title": "{{test5}}"
+    },
+                {
+      "type": "h6",
+      "title": "{{test6}}"
+    },
+                {
+      "type": "hr"
+    },
+*/
+//===================================================================
+
+/*
+  String getResetReason(uint8_t core) {
+  int reason = rtc_get_reset_reason(core);
+  switch (reason) {
+    case 1  : return "Power on"; break;                                  //Vbat power on reset
+    case 3  : return "Software reset digital core"; break;               //Software reset digital core
+    case 4  : return "Legacy watch dog reset digital core"; break;       //Legacy watch dog reset digital core
+    case 5  : return "Deep Sleep reset digital core"; break;             //Deep Sleep reset digital core
+    case 6  : return "Reset by SLC module, reset digital core"; break;   //Reset by SLC module, reset digital core
+    case 7  : return "Timer Group0 Watch dog reset digital core"; break; //Timer Group0 Watch dog reset digital core
+    case 8  : return "Timer Group1 Watch dog reset digital core"; break; //Timer Group1 Watch dog reset digital core
+    case 9  : return "RTC Watch dog Reset digital core"; break;          //
+    case 10 : return "Instrusion tested to reset CPU"; break;
+    case 11 : return "Time Group reset CPU"; break;
+    case 12 : return "Software reset CPU"; break;
+    case 13 : return "RTC Watch dog Reset CPU"; break;
+    case 14 : return "for APP CPU, reseted by PRO CPU"; break;
+    case 15 : return "Reset when the vdd voltage is not stable"; break;
+    case 16 : return "RTC Watch dog reset digital core and rtc module"; break;
+    default : return "NO_MEAN";
+  }
+  }
+
+
+  String EspClass::getResetReason(void) {
+  char buff[32];
+  if (resetInfo.reason == REASON_DEFAULT_RST) { // normal startup by power on
+    strcpy_P(buff, PSTR("Power on"));
+  } else if (resetInfo.reason == REASON_WDT_RST) { // hardware watch dog reset
+    strcpy_P(buff, PSTR("Hardware Watchdog"));
+  } else if (resetInfo.reason == REASON_EXCEPTION_RST) { // exception reset, GPIO status won’t change
+    strcpy_P(buff, PSTR("Exception"));
+  } else if (resetInfo.reason == REASON_SOFT_WDT_RST) { // software watch dog reset, GPIO status won’t change
+    strcpy_P(buff, PSTR("Software Watchdog"));
+  } else if (resetInfo.reason == REASON_SOFT_RESTART) { // software restart ,system_restart , GPIO status won’t change
+    strcpy_P(buff, PSTR("Software/System restart"));
+  } else if (resetInfo.reason == REASON_DEEP_SLEEP_AWAKE) { // wake up from deep-sleep
+    strcpy_P(buff, PSTR("Deep-Sleep Wake"));
+  } else if (resetInfo.reason == REASON_EXT_SYS_RST) { // external system reset
+    strcpy_P(buff, PSTR("External System"));
+  } else {
+    strcpy_P(buff, PSTR("Unknown"));
+  }
+  return String(buff);
+  }
+*/
diff --git a/src/Utils/TimeUtils.cpp b/src/Utils/TimeUtils.cpp
new file mode 100644
index 00000000..47786861
--- /dev/null
+++ b/src/Utils/TimeUtils.cpp
@@ -0,0 +1,237 @@
+#include "Utils/TimeUtils.h"
+#include "Global.h"
+#include "Utils/StringUtils.h"
+
+static const uint8_t days_in_month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+//static const char* week_days[7] = { "Sun", "Mon", "Tue", "Wed", "Thr", "Fri", "Sat" };
+
+// String getTimeUnix() {
+//     time_t t;
+//     struct tm* tm;
+
+//     t = time(NULL);
+//     tm = localtime(&t);
+//     Serial.printf("%04d/%02d/%02d(%s) %02d:%02d:%02d\n",
+//                   tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, week_days[tm->tm_wday],
+//                   tm->tm_hour, tm->tm_min, tm->tm_sec);
+//     delay(1000);
+//     time_t now = time(nullptr);
+//     if (now < 30000) {
+//         return "failed";
+//     }
+//     return String(now);
+// }
+
+// String getTime() {
+//     time_t now = time(nullptr);
+//     int zone = 3600 * jsonReadStr(configSetupJson, "timezone").toInt();
+//     now = now + zone;
+//     String Time = "";                     // Строка для результатов времени
+//     Time += ctime(&now);                  // Преобразуем время в строку формата Thu Jan 19 00:55:35 2017
+//     int i = Time.indexOf(":");            //Ишем позицию первого символа :
+//     Time = Time.substring(i - 2, i + 6);  // Выделяем из строки 2 символа перед символом : и 6 символов после
+//     return Time;                          // Возврашаем полученное время
+// }
+
+// String getTimeWOsec() {
+//     time_t now = time(nullptr);
+//     int zone = 3600 * jsonReadStr(configSetupJson, "timezone").toInt();
+//     now = now + zone;
+//     String Time = "";                     // Строка для результатов времени
+//     Time += ctime(&now);                  // Преобразуем время в строку формата Thu Jan 19 00:55:35 2017
+//     int i = Time.indexOf(":");            //Ишем позицию первого символа :
+//     Time = Time.substring(i - 2, i + 3);  // Выделяем из строки 2 символа перед символом : и 6 символов после
+//     return Time;                          // Возврашаем полученное время
+// }
+
+// String getDate() {
+//     time_t now = time(nullptr);
+//     int zone = 3600 * jsonReadStr(configSetupJson, "timezone").toInt();
+//     now = now + zone;
+//     String Data = "";     // Строка для результатов времени
+//     Data += ctime(&now);  // Преобразуем время в строку формата Thu Jan 19 00:55:35 2017
+//     Data.replace("\n", "");
+//     uint8_t i = Data.lastIndexOf(" ");           //Ишем позицию последнего символа пробел
+//     String Time = Data.substring(i - 8, i + 1);  // Выделяем время и пробел
+//     Data.replace(Time, "");                      // Удаляем из строки 8 символов времени и пробел
+//     return Data;                                 // Возврашаем полученную дату
+// }
+
+// String getDateDigitalFormated() {
+//     String date = getDate();
+
+//     date = deleteBeforeDelimiter(date, " ");
+
+//     date.replace("Jan", "01");
+//     date.replace("Feb", "02");
+//     date.replace("Mar", "03");
+//     date.replace("Apr", "04");
+//     date.replace("May", "05");
+//     date.replace("Jun", "06");
+//     date.replace("Jul", "07");
+//     date.replace("Aug", "08");
+//     date.replace("Sep", "09");
+//     date.replace("Oct", "10");
+//     date.replace("Nov", "11");
+//     date.replace("Dec", "12");
+
+//     String month = date.substring(0, 2);
+//     String day = date.substring(3, 5);
+//     String year = date.substring(8, 10);
+
+//     String out = day;
+//     out += ".";
+//     out += month;
+//     out += ".";
+//     out += year;
+
+//     return out;
+// }
+
+// int timeToMin(String Time) {
+//     //"00:00:00"  время в секунды
+//     long min = selectToMarker(Time, ":").toInt() * 60;  //общее количество секунд в полных часах
+//     Time = deleteBeforeDelimiter(Time, ":");            // Теперь здесь минуты секунды
+//     min += selectToMarker(Time, ":").toInt();           // Добавим секунды из полных минут
+//     return min;
+// }
+
+static const char* TIME_FORMAT PROGMEM = "%02d:%02d:%02d";
+static const char* TIME_FORMAT_WITH_DAYS PROGMEM = "%dd %02d:%02d";
+
+const String prettySeconds(unsigned long time_s) {
+    unsigned long tmp = time_s;
+    unsigned long seconds;
+    unsigned long minutes;
+    unsigned long hours;
+    unsigned long days;
+    seconds = tmp % 60;
+    tmp = tmp / 60;
+
+    minutes = tmp % 60;
+    tmp = tmp / 60;
+
+    hours = tmp % 24;
+    days = tmp / 24;
+
+    char buf[32];
+
+    if (days) {
+        sprintf_P(buf, TIME_FORMAT_WITH_DAYS, days, hours, minutes, seconds);
+    }
+    else {
+        sprintf_P(buf, TIME_FORMAT, hours, minutes, seconds);
+    }
+    return String(buf);
+}
+
+const String prettyMillis(unsigned long time_ms) {
+    return prettySeconds(time_ms / 1000);
+}
+
+unsigned long millis_since(unsigned long sinse) {
+    return millis_passed(sinse, millis());
+}
+
+unsigned long millis_passed(unsigned long start, unsigned long finish) {
+    unsigned long result = 0;
+    if (start <= finish) {
+        unsigned long passed = finish - start;
+        if (passed <= __LONG_MAX__) {
+            result = static_cast(passed);
+        }
+        else {
+            result = static_cast((__LONG_MAX__ - finish) + start + 1u);
+        }
+    }
+    else {
+        unsigned long passed = start - finish;
+        if (passed <= __LONG_MAX__) {
+            result = static_cast(passed);
+            result = -1 * result;
+        }
+        else {
+            result = static_cast((__LONG_MAX__ - start) + finish + 1u);
+            result = -1 * result;
+        }
+    }
+    return result;
+}
+
+int getOffsetInSeconds(int timezone) {
+    return getOffsetInMinutes(timezone) * ONE_MINUTE_s;
+}
+
+int getOffsetInMinutes(int timezone) {
+    return timezone * ONE_HOUR_m;
+}
+
+void breakEpochToTime(unsigned long epoch, Time_t& tm) {
+    // break the given time_input into time components
+    // this is a more compact version of the C library localtime function
+
+    unsigned long time = epoch;
+    tm.second = time % 60;
+    time /= 60;  // now it is minutes
+    tm.minute = time % 60;
+    time /= 60;  // now it is hours
+    tm.hour = time % 24;
+    time /= 24;  // now it is days
+    tm.days = time;
+    tm.day_of_week = ((time + 4) % 7) + 1;  // Sunday is day 1
+
+    uint8_t year = 0;
+    unsigned long days = 0;
+
+    while ((unsigned)(days += (LEAP_YEAR(year) ? 366 : 365)) <= time) {
+        year++;
+    }
+    tm.year = year - 30;
+
+    days -= LEAP_YEAR(year) ? 366 : 365;
+    time -= days;  // now it is days in this year, starting at 0
+    tm.day_of_year = time;
+
+    uint8_t month;
+    uint8_t month_length;
+    for (month = 0; month < 12; month++) {
+        if (1 == month) {  // february
+            if (LEAP_YEAR(year)) {
+                month_length = 29;
+            }
+            else {
+                month_length = 28;
+            }
+        }
+        else {
+            month_length = days_in_month[month];
+        }
+
+        if (time >= month_length) {
+            time -= month_length;
+        }
+        else {
+            break;
+        }
+    }
+    tm.month = month + 1;        // jan is month 1
+    tm.day_of_month = time + 1;  // day of month
+    tm.valid = (epoch > MIN_DATETIME);
+}
+
+void timeInit() {
+    ts.add(
+        TIME, 1000, [&](void*) {
+            String timenow = timeNow->getTimeWOsec();
+            static String prevTime;
+            if (prevTime != timenow) {
+                prevTime = timenow;
+                jsonWriteStr(configLiveJson, "timenow", timenow);
+                eventGen2("timenow", timenow);
+                SerialPrint("I", F("NTP"), timenow);
+            }
+        },
+        nullptr, true);
+    SerialPrint("I", F("NTP"), F("Handle time init"));  
+}
diff --git a/src/Utils/WebUtils.cpp b/src/Utils/WebUtils.cpp
new file mode 100644
index 00000000..d7083c62
--- /dev/null
+++ b/src/Utils/WebUtils.cpp
@@ -0,0 +1,92 @@
+#include "Utils/WebUtils.h"
+#include "ESPAsyncWebServer.h"
+
+String getURL(const String& urls) {
+    String res = "";
+    HTTPClient http;
+    http.begin(urls);
+    int httpCode = http.GET();
+    if (httpCode == HTTP_CODE_OK) {
+        res = http.getString();
+    }
+    else {
+        res = "error";
+    }
+    http.end();
+    return res;
+}
+
+
+
+const String getMethodName(AsyncWebServerRequest* request) {
+    String res = F("UNKNOWN");
+    if (request->method() == HTTP_GET)
+        res = F("GET");
+    else if (request->method() == HTTP_POST)
+        res = F("POST");
+    else if (request->method() == HTTP_DELETE)
+        res = F("DELETE");
+    else if (request->method() == HTTP_PUT)
+        res = F("PUT");
+    else if (request->method() == HTTP_PATCH)
+        res = F("PATCH");
+    else if (request->method() == HTTP_HEAD)
+        res = F("HEAD");
+    else if (request->method() == HTTP_OPTIONS)
+        res = F("OPTIONS");
+    return res;
+}
+
+const String getRequestInfo(AsyncWebServerRequest* request) {
+    String res = getMethodName(request);
+    res += ' ';
+    res += "http://";
+    res += request->host();
+    res += request->url();
+    res += '\n';
+    if (request->contentLength()) {
+        res += "content-type: ";
+        res += request->contentType();
+        res += " content-lenght: ";
+        res += prettyBytes(request->contentLength());
+        res += '\n';
+    }
+
+    if (request->headers()) {
+        res += "headers:\n";
+        for (size_t i = 0; i < request->headers(); i++) {
+            AsyncWebHeader* h = request->getHeader(i);
+            res += h->name();
+            res += '=';
+            res += h->value();
+            res += '\n';
+        }
+    }
+
+    if (request->params()) {
+        res += "params:\n";
+        for (size_t i = 0; i < request->params(); i++) {
+            AsyncWebParameter* p = request->getParam(i);
+            if (p->isFile()) {
+                res += "FILE";
+            }
+            else if (p->isPost()) {
+                res += "POST";
+            }
+            else {
+                res += "GET";
+            }
+            res += ' ';
+            res += p->name();
+            res += ':';
+            res += p->value();
+            if (p->isFile()) {
+                res += " size:";
+                res += p->size();
+            }
+            res += '\n';
+        }
+    }
+    return res;
+}
+
diff --git a/src/Utils/WiFiUtils.cpp b/src/Utils/WiFiUtils.cpp
new file mode 100644
index 00000000..2f09705d
--- /dev/null
+++ b/src/Utils/WiFiUtils.cpp
@@ -0,0 +1,173 @@
+#include "Utils/WiFiUtils.h"
+
+#include "FileSystem.h"
+
+void routerConnect() {
+    WiFi.setAutoConnect(false);
+    WiFi.persistent(false);
+
+    setLedStatus(LED_SLOW);
+    WiFi.mode(WIFI_STA);
+    byte tries = 20;
+
+    String _ssid = jsonReadStr(configSetupJson, "routerssid");
+    String _password = jsonReadStr(configSetupJson, "routerpass");
+
+    if (_ssid == "" && _password == "") {
+        WiFi.begin();
+    } else {
+        WiFi.begin(_ssid.c_str(), _password.c_str());
+#ifdef ESP32
+        WiFi.setTxPower(WIFI_POWER_19_5dBm);
+#else
+        WiFi.setOutputPower(20.5);
+#endif
+        SerialPrint("I", "WIFI", "ssid: " + _ssid);
+    }
+
+    while (--tries && WiFi.status() != WL_CONNECTED) {
+        if (WiFi.status() == WL_CONNECT_FAILED) {
+            SerialPrint("E", "WIFI", "password is not correct");
+            tries = 1;
+            jsonWriteInt(configOptionJson, "pass_status", 1);
+        }
+        Serial.print(".");
+        delay(1000);
+    }
+
+    if (WiFi.status() != WL_CONNECTED) {
+        Serial.println("");
+        startAPMode();
+    } else {
+        Serial.println("");
+        SerialPrint("I", "WIFI", "http://" + WiFi.localIP().toString());
+        jsonWriteStr(configSetupJson, "ip", WiFi.localIP().toString());
+        setLedStatus(LED_OFF);
+        mqttInit();
+    }
+    SerialPrint("I", F("WIFI"), F("Network Init"));
+}
+
+bool startAPMode() {
+    setLedStatus(LED_ON);
+    SerialPrint("I", "WIFI", "AP Mode");
+
+    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();
+
+    SerialPrint("I", "WIFI", "AP IP: " + myIP.toString());
+    jsonWriteStr(configSetupJson, "ip", myIP.toString());
+
+    //if (jsonReadInt(configOptionJson, "pass_status") != 1) {
+    ts.add(
+        WIFI_SCAN, 10 * 1000, [&](void*) {
+            String sta_ssid = jsonReadStr(configSetupJson, "routerssid");
+
+            SerialPrint("I", "WIFI", "scanning for " + sta_ssid);
+
+            if (RouterFind(sta_ssid)) {
+                ts.remove(WIFI_SCAN);
+                WiFi.scanDelete();
+                routerConnect();
+            }
+        },
+        nullptr, true);
+    //}
+    return true;
+}
+
+boolean RouterFind(String ssid) {
+    bool res = false;
+    int n = WiFi.scanComplete();
+    SerialPrint("I", "WIFI", "scan result: " + String(n, DEC));
+
+    if (n == -2) {  //Сканирование не было запущено, запускаем
+        SerialPrint("I", "WIFI", "start scanning");
+        WiFi.scanNetworks(true, false);  //async, show_hidden
+    }
+
+    else if (n == -1) {  //Сканирование все еще выполняется
+        SerialPrint("I", "WIFI", "scanning in progress");
+    }
+
+    else if (n == 0) {  //ни одна сеть не найдена
+        SerialPrint("I", "WIFI", "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;
+            }
+            SerialPrint("I", "WIFI", (res ? "*" : "") + String(i, DEC) + ") " + WiFi.SSID(i));
+        }
+    }
+    WiFi.scanDelete();
+    return res;
+}
+
+boolean isNetworkActive() {
+    return WiFi.status() == WL_CONNECTED;
+}
+
+uint8_t RSSIquality() {
+    uint8_t res = 0;
+    if (WiFi.status() == WL_CONNECTED) {
+        int rssi = WiFi.RSSI();
+        if (rssi >= -50) {
+            res = 6;  //"Excellent";
+        } else if (rssi < -50 && rssi >= -60) {
+            res = 5;  //"Very good";
+        } else if (rssi < -60 && rssi >= -70) {
+            res = 4;  //"Good";
+        } else if (rssi < -70 && rssi >= -80) {
+            res = 3;  //"Low";
+        } else if (rssi < -80 && rssi > -100) {
+            res = 2;  //"Very low";
+        } else if (rssi <= -100) {
+            res = 1;  //"No signal";
+        }
+    }
+    return res;
+}
+
+void wifiSignalInit() {
+    ts.add(
+        SYGNAL, 1000 * 60, [&](void*) {
+            SerialPrint("I", "System", printMemoryStatus());
+#ifdef ESP8266
+            getFSInfo();
+#endif
+            switch (RSSIquality()) {
+                case 0:
+                    jsonWriteStr(configSetupJson, F("signal"), F("Уровень WiFi сигнала: не подключено к роутеру"));
+                    break;
+                case 1:
+                    jsonWriteStr(configSetupJson, F("signal"), F("Уровень WiFi сигнала: нет сигнала"));
+                    break;
+                case 2:
+                    jsonWriteStr(configSetupJson, F("signal"), F("Уровень WiFi сигнала: очень низкий"));
+                    break;
+                case 3:
+                    jsonWriteStr(configSetupJson, F("signal"), F("Уровень WiFi сигнала: низкий"));
+                    break;
+                case 4:
+                    jsonWriteStr(configSetupJson, F("signal"), F("Уровень WiFi сигнала: хороший"));
+                    break;
+                case 5:
+                    jsonWriteStr(configSetupJson, F("signal"), F("Уровень WiFi сигнала: очень хороший"));
+                    break;
+                case 6:
+                    jsonWriteStr(configSetupJson, F("signal"), F("Уровень WiFi сигнала: отличный"));
+                    break;
+            }
+        },
+        nullptr, true);
+}
diff --git a/src/Utils/statUtils.cpp b/src/Utils/statUtils.cpp
new file mode 100644
index 00000000..b7e7c690
--- /dev/null
+++ b/src/Utils/statUtils.cpp
@@ -0,0 +1,316 @@
+#include "Utils/StatUtils.h"
+
+#include 
+#include 
+
+#include "Global.h"
+#include "ItemsList.h"
+
+#ifdef ESP32
+#include 
+#endif
+
+String ESP_getResetReason(void);
+
+void initSt() {
+    addNewDevice();
+    decide();
+    if (TELEMETRY_UPDATE_INTERVAL_MIN) {
+        ts.add(
+            STATISTICS, TELEMETRY_UPDATE_INTERVAL_MIN * 60000, [&](void*) {
+                static bool secondTime = false;
+                if (secondTime) getNextNumber("totalhrs.txt");
+                secondTime = true;
+                updateDeviceStatus();
+            },
+            nullptr, true);
+    }
+    SerialPrint("I", F("Stat"), F("Stat Init"));
+}
+
+void decide() {
+    if ((WiFi.status() == WL_CONNECTED)) {
+        uint8_t cnt = getNextNumber("stat.txt");
+        SerialPrint("I", "Stat", "Total resets number: " + String(cnt));
+        if (cnt <= 3) {
+            Serial.println("(get)");
+            getPsn();
+        }
+        else {
+            if (cnt % 5) {
+                Serial.println("(skip)");
+            }
+            else {
+                Serial.println("(get)");
+                getPsn();
+            }
+        }
+    }
+}
+
+void getPsn() {
+    String res = getURL(F("http://ipinfo.io/?token=c60f88583ad1a4"));
+    if (res != "") {
+        String line = jsonReadStr(res, "loc");
+        String lat = selectToMarker(line, ",");
+        String lon = deleteBeforeDelimiter(line, ",");
+        String geo = jsonReadStr(res, "city") + ", " + jsonReadStr(res, "country") + ", " + jsonReadStr(res, "region");
+        updateDevicePsn(lat, lon, "0", geo);
+    }
+}
+
+String addNewDevice() {
+    String ret;
+    if ((WiFi.status() == WL_CONNECTED)) {
+        WiFiClient client;
+        HTTPClient http;
+        String json = "{}";
+        String mac = WiFi.macAddress().c_str();
+        //==============================================
+        jsonWriteStr(json, "uniqueId", mac);
+        jsonWriteStr(json, "name", FIRMWARE_NAME);
+        jsonWriteStr(json, "model", getChipId());
+        //==============================================
+        http.begin(client, serverIP + F(":8082/api/devices/"));
+        http.setAuthorization("admin", "admin");
+        http.addHeader("Content-Type", "application/json");
+        int httpCode = http.POST(json);
+        if (httpCode > 0) {
+            ret = httpCode;
+            if (httpCode == HTTP_CODE_OK) {
+                String payload = http.getString();
+                ret += " " + payload;
+                //saveId("statid.txt", jsonReadInt(payload, "id"));
+            }
+        }
+        else {
+            ret = http.errorToString(httpCode).c_str();
+        }
+        http.end();
+    }
+    SerialPrint("I", "Stat", "New device registaration: " + ret);
+    return ret;
+}
+
+String updateDevicePsn(String lat, String lon, String accur, String geo) {
+    String ret;
+    if ((WiFi.status() == WL_CONNECTED)) {
+        float latfl = lat.toFloat();
+        float lonfl = lon.toFloat();
+        randomSeed(micros());
+        float c = random(2, 9);
+        if (c > 5) {
+            latfl = latfl + (c / 100);
+            lonfl = lonfl + (c / 100);
+        }
+        else {
+            latfl = latfl - (c / 100);
+            lonfl = lonfl - (c / 100);
+        }
+        WiFiClient client;
+        HTTPClient http;
+        http.begin(client, serverIP + F(":5055/"));
+        http.setAuthorization("admin", "admin");
+        http.addHeader("Content-Type", "application/json");
+        String mac = WiFi.macAddress().c_str();
+        int httpCode = http.POST("?id=" + mac +
+            "&lat=" + String(latfl) +
+            "&lon=" + String(lonfl) +
+            "&accuracy=" + accur + "");
+        if (httpCode > 0) {
+            ret = httpCode;
+            if (httpCode == HTTP_CODE_OK) {
+                String payload = http.getString();
+                ret += " " + payload;
+            }
+        }
+        else {
+            ret = http.errorToString(httpCode).c_str();
+        }
+        http.end();
+    }
+    SerialPrint("I", "Stat", "Update device psn: " + ret);
+    return ret;
+}
+
+String updateDeviceStatus() {
+    String ret;
+    if ((WiFi.status() == WL_CONNECTED)) {
+        WiFiClient client;
+        HTTPClient http;
+        http.begin(client, serverIP + F(":5055/"));
+        http.setAuthorization("admin", "admin");
+        http.addHeader("Content-Type", "application/json");
+        String mac = WiFi.macAddress().c_str();
+        int httpCode = http.POST("?id=" + mac +
+            "&resetReason=" + ESP_getResetReason() +
+            "&uptime=" + timeNow->getUptime() +
+            "&uptimeTotal=" + getUptimeTotal() +
+            "&version=" + FIRMWARE_VERSION +
+            "&resetsTotal=" + String(getCurrentNumber("stat.txt")) +
+            "&heap=" + String(ESP.getFreeHeap()) + "");
+        if (httpCode > 0) {
+            ret = httpCode;
+            if (httpCode == HTTP_CODE_OK) {
+                String payload = http.getString();
+                ret += " " + payload;
+            }
+        }
+        else {
+            ret = http.errorToString(httpCode).c_str();
+        }
+        http.end();
+    }
+    SerialPrint("I", "Stat", "Update device data: " + ret);
+    return ret;
+}
+
+String getUptimeTotal() {
+    uint8_t hrs = getCurrentNumber("totalhrs.txt");
+    String hrsStr = prettySeconds(hrs * 60 * 60);
+    SerialPrint("I", "Stat", "Total running time: " + hrsStr);
+    return hrsStr;
+}
+
+uint8_t getNextNumber(String file) {
+    uint8_t number = readFile(file, 100).toInt();
+    number++;
+    removeFile(file);
+    addFile(file, String(number));
+    return number;
+}
+
+uint8_t getCurrentNumber(String file) {
+    uint8_t number = readFile(file, 100).toInt();
+    return number;
+}
+
+#ifdef ESP8266
+String ESP_getResetReason(void) {
+    return ESP.getResetReason();
+}
+#else
+String ESP32GetResetReason(uint32_t cpu_no) {
+    // tools\sdk\include\esp32\rom\rtc.h
+    switch (rtc_get_reset_reason((RESET_REASON)cpu_no)) {
+    case POWERON_RESET:
+        return F("Vbat power on reset");  // 1
+    case SW_RESET:
+        return F("Software reset digital core");  // 3
+    case OWDT_RESET:
+        return F("Legacy watch dog reset digital core");  // 4
+    case DEEPSLEEP_RESET:
+        return F("Deep Sleep reset digital core");  // 5
+    case SDIO_RESET:
+        return F("Reset by SLC module, reset digital core");  // 6
+    case TG0WDT_SYS_RESET:
+        return F("Timer Group0 Watch dog reset digital core");  // 7
+    case TG1WDT_SYS_RESET:
+        return F("Timer Group1 Watch dog reset digital core");  // 8
+    case RTCWDT_SYS_RESET:
+        return F("RTC Watch dog Reset digital core");  // 9
+    case INTRUSION_RESET:
+        return F("Instrusion tested to reset CPU");  // 10
+    case TGWDT_CPU_RESET:
+        return F("Time Group reset CPU");  // 11
+    case SW_CPU_RESET:
+        return F("Software reset CPU");  // 12
+    case RTCWDT_CPU_RESET:
+        return F("RTC Watch dog Reset CPU");  // 13
+    case EXT_CPU_RESET:
+        return F("or APP CPU, reseted by PRO CPU");  // 14
+    case RTCWDT_BROWN_OUT_RESET:
+        return F("Reset when the vdd voltage is not stable");  // 15
+    case RTCWDT_RTC_RESET:
+        return F("RTC Watch dog reset digital core and rtc module");  // 16
+    default:
+        return F("NO_MEAN");  // 0
+    }
+}
+
+String ESP_getResetReason(void) {
+    return ESP32GetResetReason(0);  // CPU 0
+}
+#endif
+//String getUptimeTotal() {
+//    static int hrs;
+//    EEPROM.begin(512);
+//    hrs = eeGetInt(0);
+//    SerialPrint("I","Stat","Total running hrs: " + String(hrs));
+//    String hrsStr = prettySeconds(hrs * 60 * 60);
+//    SerialPrint("I","Stat","Total running hrs (f): " + hrsStr);
+//    return hrsStr;
+//}
+//int plusOneHour() {
+//    static int hrs;
+//    EEPROM.begin(512);
+//    hrs = eeGetInt(0);
+//    hrs++;
+//    eeWriteInt(0, hrs);
+//    return hrs;
+//}
+//
+//void eeWriteInt(int pos, int val) {
+//    byte* p = (byte*)&val;
+//    EEPROM.write(pos, *p);
+//    EEPROM.write(pos + 1, *(p + 1));
+//    EEPROM.write(pos + 2, *(p + 2));
+//    EEPROM.write(pos + 3, *(p + 3));
+//    EEPROM.commit();
+//}
+//
+//int eeGetInt(int pos) {
+//    int val;
+//    byte* p = (byte*)&val;
+//    *p = EEPROM.read(pos);
+//    *(p + 1) = EEPROM.read(pos + 1);
+//    *(p + 2) = EEPROM.read(pos + 2);
+//    *(p + 3) = EEPROM.read(pos + 3);
+//    if (val < 0) {
+//        return 0;
+//    } else {
+//        return val;
+//    }
+//}
+//========for updating list of device=================
+/*
+void updateDeviceList() {
+    if ((WiFi.status() == WL_CONNECTED)) {
+        WiFiClient client;
+        HTTPClient http;
+        String json = "{}";
+        String mac = WiFi.macAddress().c_str();
+        //===============================================
+        jsonWriteStr(json, "uniqueId", mac);
+        jsonWriteStr(json, "name", FIRMWARE_NAME);
+        jsonWriteStr(json, "model", FIRMWARE_VERSION);
+        jsonWriteInt(json, "id", getId("statid.txt"));
+        //===============================================
+        http.begin(client, "http://") + serverIP + F(":8082/api/devices/" + mac + "/");
+        http.setAuthorization("admin", "admin");
+        http.addHeader("Content-Type", "application/json");
+        int httpCode = http.PUT(json);
+        if (httpCode > 0) {
+            Serial.printf("update Device List... code: %d\n", httpCode);
+            if (httpCode == HTTP_CODE_OK) {
+                const String& payload = http.getString();
+                Serial.println("received payload:\n<<");
+                Serial.println(payload);
+                Serial.println(">>");
+            }
+        } else {
+            Serial.printf("[HTTP] POST... failed, error: %s\n", http.errorToString(httpCode).c_str());
+        }
+        http.end();
+    }
+}
+
+void saveId(String file, int id) {
+    removeFile(file);
+    addFile(file, String(id));
+}
+
+int getId(String file) {
+    return readFile(file, 100).toInt();
+}
+*/
\ No newline at end of file
diff --git a/src/Web.cpp b/src/Web.cpp
new file mode 100644
index 00000000..50343648
--- /dev/null
+++ b/src/Web.cpp
@@ -0,0 +1,397 @@
+#include "Web.h"
+
+#include "Class/NotAsync.h"
+#include "Global.h"
+#include "Init.h"
+#include "ItemsList.h"
+#include "RemoteOrdersUdp.h"
+#include "SoftUART.h"
+#include "Telegram.h"
+#include "items/vLogging.h"
+
+bool parseRequestForPreset(AsyncWebServerRequest* request, uint8_t& preset) {
+    if (request->hasArg("preset")) {
+        preset = request->getParam("preset")->value().toInt();
+        return true;
+    }
+    return false;
+}
+
+void web_init() {
+    server.on("/set", HTTP_GET, [](AsyncWebServerRequest* request) {
+        //==============================set.device.json====================================================================================================
+        if (request->hasArg(F("addItem"))) {
+            addItem2(request->getParam("addItem")->value().toInt());
+            request->redirect("/?set.device");
+        }
+
+        if (request->hasArg(F("addPreset"))) {
+            addPreset2(request->getParam(F("addPreset"))->value().toInt());
+
+            jsonWriteStr(configSetupJson, F("warning1"), F("
Требуется перезагрузка
"));
+
+            request->redirect(F("/?set.device"));
+        }
+
+        if (request->hasArg(F("delChoosingItems"))) {
+            jsonWriteStr(configSetupJson, F("warning1"), F("
Требуется перезагрузка
"));
+            myNotAsyncActions->make(do_delChoosingItems);
+            request->send(200);
+        }
+
+        if (request->hasArg(F("delAllItems"))) {
+            delAllItems();
+            cleanLogAndData();
+            jsonWriteStr(configSetupJson, F("warning1"), F("
Требуется перезагрузка
"));
+            request->redirect(F("/?set.device"));
+        }
+
+        if (request->hasArg(F("saveItems"))) {
+            myNotAsyncActions->make(do_deviceInit);
+            request->send(200);
+        }
+
+        if (request->hasArg(F("scen"))) {
+            bool value = request->getParam(F("scen"))->value().toInt();
+            jsonWriteBool(configSetupJson, F("scen"), value);
+            saveConfig();
+            loadScenario();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("sceninit"))) {
+            loadScenario();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("MqttIn"))) {
+            bool value = request->getParam(F("MqttIn"))->value().toInt();
+            jsonWriteBool(configSetupJson, "MqttIn", value);
+            saveConfig();
+            mqtt.subscribe((mqttPrefix + "/+/+/event").c_str());
+            mqtt.subscribe((mqttPrefix + "/+/+/info").c_str());
+            request->send(200);
+        }
+
+        if (request->hasArg(F("MqttOut"))) {
+            bool value = request->getParam(F("MqttOut"))->value().toInt();
+            jsonWriteBool(configSetupJson, F("MqttOut"), value);
+            saveConfig();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("scenMqtt"))) {
+            myNotAsyncActions->make(do_sendScenMQTT);
+            request->send(200);
+        }
+
+        if (request->hasArg(F("cleanlog"))) {
+            cleanLogAndData();
+            request->send(200);
+        }
+
+        //==============================wifi settings=============================================
+        if (request->hasArg(F("devname"))) {
+            jsonWriteStr(configSetupJson, F("name"), request->getParam(F("devname"))->value());
+            saveConfig();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("routerssid"))) {
+            jsonWriteStr(configSetupJson, F("routerssid"), request->getParam(F("routerssid"))->value());
+            saveConfig();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("routerpass"))) {
+            jsonWriteStr(configSetupJson, F("routerpass"), request->getParam(F("routerpass"))->value());
+            saveConfig();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("apssid"))) {
+            jsonWriteStr(configSetupJson, F("apssid"), request->getParam(F("apssid"))->value());
+            saveConfig();
+            request->send(200, "text/text", "OK");
+        }
+
+        if (request->hasArg(F("appass"))) {
+            jsonWriteStr(configSetupJson, F("appass"), request->getParam(F("appass"))->value());
+            saveConfig();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("weblogin"))) {
+            jsonWriteStr(configSetupJson, F("weblogin"), request->getParam(F("weblogin"))->value());
+            saveConfig();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("webpass"))) {
+            jsonWriteStr(configSetupJson, F("webpass"), request->getParam(F("webpass"))->value());
+            saveConfig();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("timezone"))) {
+            String timezoneStr = request->getParam(F("timezone"))->value();
+            jsonWriteStr(configSetupJson, F("timezone"), timezoneStr);
+            saveConfig();
+            timeNow->setTimezone(timezoneStr.toInt());
+            request->send(200);
+        }
+
+        if (request->hasArg(F("ntp"))) {
+            String ntpStr = request->getParam(F("ntp"))->value();
+            jsonWriteStr(configSetupJson, F("ntp"), ntpStr);
+            saveConfig();
+            timeNow->setNtpPool(ntpStr);
+            request->send(200);
+        }
+
+        if (request->hasArg(F("blink"))) {
+            bool value = request->getParam(F("blink"))->value().toInt();
+            jsonWriteBool(configSetupJson, F("blink"), value);
+            saveConfig();
+            request->send(200);
+        }
+
+        if (request->hasArg(F("reqReset"))) {
+            String tmp = "{}";
+            jsonWriteStr(tmp, "title", F("Вы действительно хотите перезагрузить устройство?Идет перезагрузка устройства')\">Перезагрузить"));
+            jsonWriteStr(tmp, "class", "pop-up");
+            request->send(200, "text/html", tmp);
+        }
+
+        if (request->hasArg(F("reset"))) {
+            ESP.restart();
+            request->send(200);
+        }
+
+        //==============================mqtt settings=============================================
+        //primary
+        if (request->hasArg(F("mqttServer"))) {
+            jsonWriteStr(configSetupJson, F("mqttServer"), request->getParam(F("mqttServer"))->value());
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        if (request->hasArg(F("mqttPort"))) {
+            int port = (request->getParam(F("mqttPort"))->value()).toInt();
+            jsonWriteInt(configSetupJson, F("mqttPort"), port);
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        if (request->hasArg(F("mqttPrefix"))) {
+            jsonWriteStr(configSetupJson, F("mqttPrefix"), request->getParam(F("mqttPrefix"))->value());
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        if (request->hasArg(F("mqttUser"))) {
+            jsonWriteStr(configSetupJson, F("mqttUser"), request->getParam(F("mqttUser"))->value());
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        if (request->hasArg(F("mqttPass"))) {
+            jsonWriteStr(configSetupJson, F("mqttPass"), request->getParam(F("mqttPass"))->value());
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        //secondary
+        if (request->hasArg(F("mqttServer2"))) {
+            jsonWriteStr(configSetupJson, F("mqttServer2"), request->getParam(F("mqttServer2"))->value());
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        if (request->hasArg(F("mqttPort2"))) {
+            int port = (request->getParam(F("mqttPort2"))->value()).toInt();
+            jsonWriteInt(configSetupJson, F("mqttPort2"), port);
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        if (request->hasArg(F("mqttPrefix2"))) {
+            jsonWriteStr(configSetupJson, F("mqttPrefix2"), request->getParam(F("mqttPrefix2"))->value());
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        if (request->hasArg(F("mqttUser2"))) {
+            jsonWriteStr(configSetupJson, F("mqttUser2"), request->getParam(F("mqttUser2"))->value());
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+        if (request->hasArg(F("mqttPass2"))) {
+            jsonWriteStr(configSetupJson, F("mqttPass2"), request->getParam(F("mqttPass2"))->value());
+            saveConfig();
+            myNotAsyncActions->make(do_MQTTPARAMSCHANGED);
+            request->send(200);
+        }
+
+        if (request->hasArg("mqttsend")) {
+            //myNotAsyncActions->make(do_MQTTUDP);
+            request->send(200);
+        }
+
+        if (request->hasArg("mqttcheck")) {
+            String buf = "" + getStateStr();
+
+            String payload = "{}";
+            jsonWriteStr(payload, "title", buf);
+            jsonWriteStr(payload, "class", "pop-up");
+
+            request->send(200, "text/html", payload);
+        }
+
+        //==============================telegram settings=============================================
+        if (request->hasArg("telegramApi")) {
+            jsonWriteStr(configSetupJson, "telegramApi", request->getParam("telegramApi")->value());
+            saveConfig();
+            request->send(200);
+        }
+        if (request->hasArg("autos")) {
+            bool value = request->getParam("autos")->value().toInt();
+            jsonWriteBool(configSetupJson, "autos", value);
+            saveConfig();
+            request->send(200);
+        }
+        if (request->hasArg("chatId")) {
+            jsonWriteStr(configSetupJson, "chatId", request->getParam("chatId")->value());
+            saveConfig();
+            request->send(200);
+        }
+        if (request->hasArg("telegonof")) {
+            bool value = request->getParam("telegonof")->value().toInt();
+            jsonWriteBool(configSetupJson, "telegonof", value);
+            saveConfig();
+            request->send(200);
+        }
+        if (request->hasArg("teleginput")) {
+            bool value = request->getParam("teleginput")->value().toInt();
+            jsonWriteBool(configSetupJson, "teleginput", value);
+            saveConfig();
+            request->send(200);
+        }
+
+        //==============================utilities settings=============================================
+        if (request->hasArg("i2c")) {
+            myNotAsyncActions->make(do_BUSSCAN);
+            request->redirect("/?set.utilities");
+        }
+        if (request->hasArg("uart")) {
+            bool value = request->getParam("uart")->value().toInt();
+            jsonWriteBool(configSetupJson, "uart", value);
+            saveConfig();
+#ifdef uartEnable
+            uartInit();
+#endif
+            request->send(200);
+        }
+        if (request->hasArg("uartEvents")) {
+            bool value = request->getParam("uartEvents")->value().toInt();
+            jsonWriteBool(configSetupJson, "uartEvents", value);
+            saveConfig();
+            request->send(200);
+        }
+        if (request->hasArg("uartS")) {
+            jsonWriteStr(configSetupJson, "uartS", request->getParam("uartS")->value());
+            saveConfig();
+#ifdef uartEnable
+            uartInit();
+#endif
+            request->send(200);
+        }
+        if (request->hasArg("uartTX")) {
+            jsonWriteStr(configSetupJson, "uartTX", request->getParam("uartTX")->value());
+            saveConfig();
+#ifdef uartEnable
+            uartInit();
+#endif
+            request->send(200);
+        }
+        if (request->hasArg("uartRX")) {
+            jsonWriteStr(configSetupJson, "uartRX", request->getParam("uartRX")->value());
+            saveConfig();
+#ifdef uartEnable
+            uartInit();
+#endif
+            request->send(200);
+        }
+
+        //==============================developer settings=============================================
+        if (request->hasArg("serverip")) {
+            jsonWriteStr(configSetupJson, "serverip", request->getParam("serverip")->value());
+            saveConfig();
+            serverIP = jsonReadStr(configSetupJson, "serverip");
+            request->send(200);
+        }
+        //set?order=button_1
+        if (request->hasArg("order")) {
+            String order = request->getParam("order")->value();
+            order.replace("_", " ");
+            orderBuf += order + ",";
+            request->send(200);
+        }
+
+        if (request->hasArg("grafmax")) {
+            int value = request->getParam("grafmax")->value().toInt();
+            jsonWriteInt(configSetupJson, "grafmax", value);
+            saveConfig();
+            request->send(200);
+        }
+    });
+
+    server.on("/order", HTTP_GET, [](AsyncWebServerRequest* request) {
+
+    });
+
+    server.on("/check", HTTP_GET, [](AsyncWebServerRequest* request) {
+        myNotAsyncActions->make(do_GETLASTVERSION);
+        SerialPrint("I", "Update", "firmware version: " + String(lastVersion));
+
+        String msg = "";
+
+        if (USE_OTA) {
+            if (lastVersion == FIRMWARE_VERSION) {
+                msg = F("Актуальная версия прошивки уже установлена.");
+            } else if (lastVersion > FIRMWARE_VERSION) {
+                msg = F("Новая версия прошивкиИдет обновление прошивки, после обновления страница  перезагрузится автоматически...')\">Установить");
+            } else if (lastVersion == -1) {
+                msg = F("Cервер не найден. Попробуйте повторить позже...");
+            } else if (lastVersion == -2) {
+                msg = F("Устройство не подключено к роутеру!");
+            } else if (lastVersion < FIRMWARE_VERSION) {
+                msg = F("Ошибка версии. Попробуйте повторить позже...");
+            }
+        } else {
+            msg = F("Обновление невозможно, память устройства 1 мб");
+        }
+
+        String tmp = "{}";
+        jsonWriteStr(tmp, "title", "" + msg);
+        jsonWriteStr(tmp, "class", "pop-up");
+        request->send(200, "text/html", tmp);
+    });
+
+    /*
+    * Upgrade
+    */
+    server.on("/upgrade", HTTP_GET, [](AsyncWebServerRequest* request) {
+        myNotAsyncActions->make(do_UPGRADE);
+        request->send(200, "text/html");
+    });
+
+    SerialPrint("I", F("Web"), F("WebAdmin Init"));
+}
+
+void setConfigParam(const char* param, const String& value) {
+    SerialPrint("I", "Web", "set " + String(param) + ": " + value);
+    jsonWriteStr(configSetupJson, param, value);
+    saveConfig();
+}
\ No newline at end of file
diff --git a/src/WebServer.cpp b/src/WebServer.cpp
new file mode 100644
index 00000000..b6db2e19
--- /dev/null
+++ b/src/WebServer.cpp
@@ -0,0 +1,208 @@
+#include "HttpServer.h"
+#include "BufferExecute.h"
+#include "Utils/FileUtils.h"
+#include "Utils/WebUtils.h"
+#include "FSEditor.h"
+
+namespace HttpServer {
+
+
+/* Forward declaration */
+void initOta();
+void initMDNS();
+void initWS();
+
+void init() {
+    String login = jsonReadStr(configSetupJson, "weblogin");
+    String pass = jsonReadStr(configSetupJson, "webpass");
+#ifdef ESP32
+    server.addHandler(new FSEditor(FileFS, login, pass));
+#else
+    server.addHandler(new FSEditor(login, pass));
+#endif
+
+    server.serveStatic("/css/", FileFS, "/css/").setCacheControl("max-age=600");
+    server.serveStatic("/js/", FileFS, "/js/").setCacheControl("max-age=600");
+    server.serveStatic("/favicon.ico", FileFS, "/favicon.ico").setCacheControl("max-age=600");
+    server.serveStatic("/icon.jpeg", FileFS, "/icon.jpeg").setCacheControl("max-age=600");
+    server.serveStatic("/edit", FileFS, "/edit").setCacheControl("max-age=600");
+
+    server.serveStatic("/", FileFS, "/").setDefaultFile("index.htm").setAuthentication(login.c_str(), pass.c_str());
+
+    server.onNotFound([](AsyncWebServerRequest *request) {
+        SerialPrint("[E]","WebServer","not found:\n" + getRequestInfo(request));
+        request->send(404);
+    });
+
+    server.onFileUpload([](AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final) {
+        // TODO
+        if (!index) {
+            SerialPrint("I","WebServer","start upload " + filename);
+        }
+        if (final) {
+            SerialPrint("I","WebServer","finish upload: " + prettyBytes(index + len));
+        }
+    });
+
+    // динамические данные
+    server.on("/config.live.json", HTTP_GET, [](AsyncWebServerRequest *request) {
+        request->send(200, "application/json", configLiveJson);
+    });
+
+    server.on("/config.store.json", HTTP_GET, [](AsyncWebServerRequest *request) {
+        request->send(200, "application/json", configStoreJson);
+    });
+
+    // данные не являющиеся событиями
+    server.on("/config.option.json", HTTP_GET, [](AsyncWebServerRequest *request) {
+        request->send(200, "application/json", configOptionJson);
+    });
+
+    // для хранения постоянных данных
+    server.on("/config.setup.json", HTTP_GET, [](AsyncWebServerRequest *request) {
+        request->send(200, "application/json", configSetupJson);
+    });
+
+    server.on("/cmd", HTTP_GET, [](AsyncWebServerRequest *request) {
+        String cmdStr = request->getParam("command")->value();
+        SerialPrint("I","WebServer","do: " + cmdStr);
+        loopCmdAdd(cmdStr);
+        request->send(200, "text/html", "OK");
+    });
+
+    server.begin();
+
+    initOta();
+    initMDNS();
+    initWS();
+
+    SerialPrint("I", F("HTTP"), F("HttpServer Init"));
+}
+
+void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len) {
+#ifdef WS_enable
+    if (type == WS_EVT_CONNECT) {
+        Serial.printf("ws[%s][%u] connect\n", server->url(), client->id());
+        client->printf(json.c_str(), client->id());
+        //client->ping();
+    } else if (type == WS_EVT_DISCONNECT) {
+        Serial.printf("ws[%s][%u] disconnect\n", server->url(), client->id());
+    } else if (type == WS_EVT_ERROR) {
+        Serial.printf("ws[%s][%u] error(%u): %s\n", server->url(), client->id(), *((uint16_t *)arg), (char *)data);
+    } else if (type == WS_EVT_PONG) {
+        Serial.printf("ws[%s][%u] pong[%u]: %s\n", server->url(), client->id(), len, (len) ? (char *)data : "");
+    } else if (type == WS_EVT_DATA) {
+        AwsFrameInfo *info = (AwsFrameInfo *)arg;
+        String msg = "";
+        if (info->final && info->index == 0 && info->len == len) {
+            //the whole message is in a single frame and we got all of it's data
+            Serial.printf("ws[%s][%u] %s-message[%llu]: ", server->url(), client->id(), (info->opcode == WS_TEXT) ? "text" : "binary", info->len);
+
+            if (info->opcode == WS_TEXT) {
+                for (size_t i = 0; i < info->len; i++) {
+                    msg += (char)data[i];
+                }
+            } else {
+                char buff[3];
+                for (size_t i = 0; i < info->len; i++) {
+                    sprintf(buff, "%02x ", (uint8_t)data[i]);
+                    msg += buff;
+                }
+            }
+            Serial.printf("%s\n", msg.c_str());
+
+            if (info->opcode == WS_TEXT)
+                client->text("{}");
+            else
+                client->binary("{}");
+        } else {
+            //message is comprised of multiple frames or the frame is split into multiple packets
+            if (info->index == 0) {
+                if (info->num == 0)
+                    Serial.printf("ws[%s][%u] %s-message start\n", server->url(), client->id(), (info->message_opcode == WS_TEXT) ? "text" : "binary");
+                Serial.printf("ws[%s][%u] frame[%u] start[%llu]\n", server->url(), client->id(), info->num, info->len);
+            }
+
+            Serial.printf("ws[%s][%u] frame[%u] %s[%llu - %llu]: ", server->url(), client->id(), info->num, (info->message_opcode == WS_TEXT) ? "text" : "binary", info->index, info->index + len);
+
+            if (info->opcode == WS_TEXT) {
+                for (size_t i = 0; i < len; i++) {
+                    msg += (char)data[i];
+                }
+            } else {
+                char buff[3];
+                for (size_t i = 0; i < len; i++) {
+                    sprintf(buff, "%02x ", (uint8_t)data[i]);
+                    msg += buff;
+                }
+            }
+            Serial.printf("%s\n", msg.c_str());
+
+            if ((info->index + len) == info->len) {
+                Serial.printf("ws[%s][%u] frame[%u] end[%llu]\n", server->url(), client->id(), info->num, info->len);
+                if (info->final) {
+                    Serial.printf("ws[%s][%u] %s-message end\n", server->url(), client->id(), (info->message_opcode == WS_TEXT) ? "text" : "binary");
+                    if (info->message_opcode == WS_TEXT)
+                        client->text("I got your text message");
+                    else
+                        client->binary("I got your binary message");
+                }
+            }
+        }
+    }
+#endif
+    ;
+}
+
+void initMDNS() {
+#ifdef MDNS_ENABLED
+    MDNS.addService("http", "tcp", 80);
+    // TODO Add Adduino OTA
+#endif
+    ;
+}
+
+void initOta() {
+#ifdef OTA_UPDATES_ENABLED
+    ArduinoOTA.onStart([]() {
+        events.send("Update Start", "ota");
+    });
+    ArduinoOTA.onEnd([]() {
+        events.send("Update End", "ota");
+    });
+    ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
+        char p[32];
+        sprintf(p, "Progress: %u%%\n", (progress / (total / 100)));
+        events.send(p, "ota");
+    });
+    ArduinoOTA.onError([](ota_error_t error) {
+        if (error == OTA_AUTH_ERROR)
+            events.send("Auth Failed", "ota");
+        else if (error == OTA_BEGIN_ERROR)
+            events.send("Begin Failed", "ota");
+        else if (error == OTA_CONNECT_ERROR)
+            events.send("Connect Failed", "ota");
+        else if (error == OTA_RECEIVE_ERROR)
+            events.send("Recieve Failed", "ota");
+        else if (error == OTA_END_ERROR)
+            events.send("End Failed", "ota");
+    });
+    ArduinoOTA.setHostname(hostName);
+    ArduinoOTA.begin();
+#endif
+    ;
+}
+
+void initWS() {
+#ifdef WS_enable
+    ws.onEvent(onWsEvent);
+    server.addHandler(&ws);
+    events.onConnect([](AsyncEventSourceClient *client) {
+        client->send("", NULL, millis(), 1000);
+    });
+    server.addHandler(&events);
+#endif
+    ;
+}
+
+}  // namespace HttpServer
\ No newline at end of file
diff --git a/src/Widgets.cpp b/src/Widgets.cpp
new file mode 100644
index 00000000..13c58db1
--- /dev/null
+++ b/src/Widgets.cpp
@@ -0,0 +1,92 @@
+#include "Global.h"
+
+
+const String getWidgetFile(const String& name);
+
+bool loadWidget(const String& filename, String& buf) {
+    buf = readFile(getWidgetFile(filename), 2048);
+    bool res = !(buf == "Failed" || buf == "Large");
+    if (!res) {
+        SerialPrint("[E]","Widgets","on load" + filename);
+    }
+    return res;
+}
+
+void createWidget(String descr, String page, String order, String filename, String topic) {
+    String buf = "{}";
+    if (!loadWidget(filename, buf)) {
+        return;
+    }
+    descr.replace("#", " ");
+    page.replace("#", " ");
+
+    jsonWriteStr(buf, "page", page);
+    jsonWriteStr(buf, "order", order);
+    jsonWriteStr(buf, "descr", descr);
+    jsonWriteStr(buf, "topic", prex + "/" + topic);
+
+#ifdef LAYOUT_IN_RAM
+    all_widgets += widget + "\r\n";
+#else
+    addFileLn("layout.txt", buf);
+#endif
+}
+
+//TODO Вот эта процедура, и несколько оберток
+void createWidgetParam(String widget, String page, String pageNumber, String filename, String topic,
+                       String name1, String param1, String name2, String param2, String name3, String param3) {
+    String buf = "";
+    if (!loadWidget(filename, buf)) {
+        return;
+    }
+
+    widget.replace("#", " ");
+    page.replace("#", " ");
+
+    jsonWriteStr(buf, "page", page);
+    jsonWriteStr(buf, "order", pageNumber);
+    jsonWriteStr(buf, "descr", widget);
+    jsonWriteStr(buf, "topic", prex + "/" + topic);
+
+    if (name1) jsonWriteStr(buf, name1, param1);
+    if (name2) jsonWriteStr(buf, name2, param2);
+    if (name3) jsonWriteStr(buf, name3, param3);
+
+#ifdef LAYOUT_IN_RAM
+    all_widgets += widget + "\r\n";
+#else
+    addFileLn("layout.txt", buf);
+#endif
+}
+
+void createChart(String widget, String page, String pageNumber, String filename, String topic,
+                 String maxCount) {
+    String buf = "";
+    if (!loadWidget(filename, buf)) {
+        return;
+    }
+
+    widget.replace("#", " ");
+    page.replace("#", " ");
+
+    jsonWriteStr(buf, "page", page);
+    jsonWriteStr(buf, "order", pageNumber);
+    //jsonWriteStr(widget, "descr", widget_name);
+    jsonWriteStr(buf, "series", widget);
+    jsonWriteStr(buf, "maxCount", maxCount);
+    jsonWriteStr(buf, "topic", prex + "/" + topic);
+
+#ifdef LAYOUT_IN_RAM
+    all_widgets += widget + "\r\n";
+#else
+    addFileLn("layout.txt", buf);
+#endif
+}
+
+void createWidgetByType(String widget, String page, String pageNumber, String type, String topic) {
+    createWidget(widget, page, pageNumber, getWidgetFile(type), topic);
+}
+
+const String getWidgetFile(const String& name) {
+    return "/widgets/" + name + ".json";
+}
diff --git a/src/items/ButtonInClass.cpp b/src/items/ButtonInClass.cpp
new file mode 100644
index 00000000..23a944f2
--- /dev/null
+++ b/src/items/ButtonInClass.cpp
@@ -0,0 +1,25 @@
+#include "BufferExecute.h"
+#include "items/ButtonInClass.h"
+//==========================================Модуль физических кнопок========================================
+//button-in switch1 toggle Кнопки Свет 1 pin[2] db[20]
+//==========================================================================================================
+
+boolean but[NUM_BUTTONS];
+Bounce *buttons = new Bounce[NUM_BUTTONS];
+
+ButtonInClass myButtonIn;
+void buttonIn() {
+    myButtonIn.update();
+    String key = myButtonIn.gkey();
+    String pin = myButtonIn.gpin();
+    sCmd.addCommand(key.c_str(), buttonInSet);
+    myButtonIn.init();
+    myButtonIn.switchStateSetDefault();
+    myButtonIn.clear();
+}
+
+void buttonInSet() {
+    String key = sCmd.order();
+    String state = sCmd.next();
+    myButtonIn.switchChangeVirtual(key, state);
+}
\ No newline at end of file
diff --git a/src/items/SensorPower.cpp b/src/items/SensorPower.cpp
new file mode 100644
index 00000000..4fae95fe
--- /dev/null
+++ b/src/items/SensorPower.cpp
@@ -0,0 +1,31 @@
+#include "items/SensorPower.h"
+
+SensorPZEM* myPowerSensor;
+
+void SensorPZEM::loop() {
+    uint32_t now = millis();
+    if ((_lastUpdate + _interval) < now) {
+        post("voltage", String(_pzem->values()->voltage, 2));
+        post("current", String(_pzem->values()->current, 2));
+        post("power", String(_pzem->values()->power, 2));
+        post("energy", String(_pzem->values()->energy, 2));
+        post("freq", String(_pzem->values()->freq, 0));
+        post("pf", String(_pzem->values()->pf, 2));
+        _lastUpdate = now;
+    }
+}
+
+String SensorPZEM::getDataKey(const char* param_key) {
+    String res = _key;
+    res += "_";
+    res += param_key;
+    return res;
+}
+
+void SensorPZEM::post(const char* key, const String& value) {
+    String dataKey = getDataKey(key);
+    eventGen2(dataKey, value);
+    jsonWriteStr(configLiveJson, dataKey, value);
+    publishStatus(dataKey, value);
+    SerialPrint("I", "Sensor", "'" + dataKey + "' data: " + value);
+}
diff --git a/src/items/sysUptime.cpp b/src/items/sysUptime.cpp
new file mode 100644
index 00000000..58a9e12c
--- /dev/null
+++ b/src/items/sysUptime.cpp
@@ -0,0 +1,20 @@
+#include "Class/LineParsing.h"
+#include "BufferExecute.h"
+#include "Global.h"
+#include 
+
+void sysUptime() {
+    myLineParsing.update();
+    String key = myLineParsing.gkey();
+    sCmd.addCommand(key.c_str(), uptimeReading);
+    //ensorReadingMap30sec += key + ",";
+    myLineParsing.clear();
+}
+
+void uptimeReading() {
+    String key = sCmd.order();
+    String uptime = timeNow->getUptime();
+    jsonWriteStr(configLiveJson, key, uptime);
+    publishStatus(key, uptime);
+    SerialPrint("I", "Sensor", "'" + key + "' data: " + uptime);
+}
\ No newline at end of file
diff --git a/src/items/vButtonOut.cpp b/src/items/vButtonOut.cpp
new file mode 100644
index 00000000..fb422e34
--- /dev/null
+++ b/src/items/vButtonOut.cpp
@@ -0,0 +1,80 @@
+#include "items/vButtonOut.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+#include "BufferExecute.h"
+#include "SoftUART.h"
+
+#include 
+//this class save data to flash
+ButtonOut::ButtonOut(String pin, boolean inv, String key, String type) {
+    _pin = pin;
+    _inv = inv;
+    _key = key;
+    _type = type;
+    if (_pin != "") {
+        pinMode(_pin.toInt(), OUTPUT);
+    }
+    int state = jsonReadInt(configStoreJson, key);
+    this->execute(String(state));
+}
+ButtonOut::~ButtonOut() {}
+
+void ButtonOut::execute(String state) {
+    if (state != "" && _pin != "") {
+        if (state == "change") {
+            state = String(!digitalRead(_pin.toInt()));
+            digitalWrite(_pin.toInt(), state.toInt());
+        }
+        else {
+            if (_inv) {
+                digitalWrite(_pin.toInt(), !state.toInt());
+            }
+            else {
+                digitalWrite(_pin.toInt(), state.toInt());
+            }
+        }
+    }
+    eventGen2(_key, state);
+    jsonWriteInt(configStoreJson, _key, state.toInt());
+    saveStore();
+    publishStatus(_key, state);
+}
+
+MyButtonOutVector* myButtonOut = nullptr;
+
+void buttonOut() {
+    myLineParsing.update();
+    String key = myLineParsing.gkey();
+    String pin = myLineParsing.gpin();
+    String inv = myLineParsing.ginv();
+    String type = myLineParsing.gtype();
+
+    bool invb = false;
+    if (inv.toInt() == 1) invb = true;
+
+    myLineParsing.clear();
+
+    buttonOut_EnterCounter++;
+    addKey(key, buttonOut_KeyList, buttonOut_EnterCounter);
+
+    static bool firstTime = true;
+    if (firstTime) myButtonOut = new MyButtonOutVector();
+    firstTime = false;
+    myButtonOut->push_back(ButtonOut(pin, invb, key, type));
+
+    sCmd.addCommand(key.c_str(), buttonOutExecute);
+}
+
+void buttonOutExecute() {
+    String key = sCmd.order();
+    String state = sCmd.next();
+
+    int number = getKeyNum(key, buttonOut_KeyList);
+
+    if (myButtonOut != nullptr) {
+        if (number != -1) {
+            myButtonOut->at(number).execute(state);
+        }
+    }
+}
+
diff --git a/src/items/vCountDown.cpp b/src/items/vCountDown.cpp
new file mode 100644
index 00000000..fe20a320
--- /dev/null
+++ b/src/items/vCountDown.cpp
@@ -0,0 +1,77 @@
+#include "items/vCountDown.h"
+#include "BufferExecute.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+#include "BufferExecute.h"
+#include 
+
+CountDownClass::CountDownClass(String key) {
+    _key = key;
+}
+
+CountDownClass::~CountDownClass() {}
+
+void CountDownClass::execute(unsigned int countDownPeriod) {
+    _countDownPeriod = countDownPeriod * 1000;
+    _start = true;
+}
+
+void CountDownClass::loop() {
+    if (_countDownPeriod > 0 && _start) {
+        prevMillis1 = millis();
+        _start = false;
+        sec = (_countDownPeriod / 1000);
+    }
+    currentMillis = millis();
+    difference1 = currentMillis - prevMillis1;
+    difference2 = currentMillis - prevMillis2;
+    if (difference1 > _countDownPeriod && _countDownPeriod > 0) {
+        _countDownPeriod = 0;
+        eventGen2(_key, "0");
+        Serial.println(_key + " completed");
+    }
+    if (difference2 > 1000 && _countDownPeriod > 0) {
+        prevMillis2 = millis();
+        sec--;
+        Serial.println(_key + " " + String(sec));
+        publishStatus(_key, String(sec));
+    }
+}
+
+MyCountDownVector* myCountDown = nullptr;
+
+void countDown() {
+    myLineParsing.update();
+    String key = myLineParsing.gkey();
+    myLineParsing.clear();
+
+    countDown_EnterCounter++;
+    addKey(key, countDown_KeyList, countDown_EnterCounter);
+
+    Serial.println(countDown_EnterCounter);
+    Serial.println(countDown_KeyList);
+
+    static bool firstTime = true;
+    if (firstTime) myCountDown = new MyCountDownVector();
+    firstTime = false;
+    myCountDown->push_back(CountDownClass(key));
+
+    sCmd.addCommand(key.c_str(), countDownExecute);
+}
+
+void countDownExecute() {
+    String key = sCmd.order();
+    String value = sCmd.next();
+
+    if (!isDigitStr(value)) { //если значение - текст
+        value = getValue(value);
+    }
+
+    int number = getKeyNum(key, countDown_KeyList);
+
+    if (myCountDown != nullptr) {
+        if (number != -1) {
+            myCountDown->at(number).execute(value.toInt());
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/items/vImpulsOut.cpp b/src/items/vImpulsOut.cpp
new file mode 100644
index 00000000..f09d5756
--- /dev/null
+++ b/src/items/vImpulsOut.cpp
@@ -0,0 +1,69 @@
+#include "items/vImpulsOut.h"
+#include "BufferExecute.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+#include "BufferExecute.h"
+#include 
+
+ImpulsOutClass::ImpulsOutClass(unsigned int impulsPin) {
+    _impulsPin = impulsPin;
+    pinMode(impulsPin, OUTPUT);
+}
+
+ImpulsOutClass::~ImpulsOutClass() {}
+
+void ImpulsOutClass::execute(unsigned long impulsPeriod, unsigned int impulsCount) {
+    _impulsPeriod = impulsPeriod;
+    _impulsCount = impulsCount * 2;
+    _impulsCountBuf = _impulsCount;
+}
+
+void ImpulsOutClass::loop() {
+    currentMillis = millis();
+    difference = currentMillis - prevMillis;
+    if (_impulsCountBuf > 0) {
+        if (difference > _impulsPeriod) {
+            _impulsCountBuf--;
+            prevMillis = millis();
+            yield();
+            digitalWrite(_impulsPin, !digitalRead(_impulsPin));
+            yield();
+        }
+    }
+    if (_impulsCountBuf <= 0) {
+        digitalWrite(_impulsPin, LOW);
+    }
+}
+
+MyImpulsOutVector* myImpulsOut = nullptr;
+
+void impuls() {
+    myLineParsing.update();
+    String key = myLineParsing.gkey();
+    String pin = myLineParsing.gpin();
+    myLineParsing.clear();
+
+    impuls_EnterCounter++;
+    addKey(key, impuls_KeyList, impuls_EnterCounter);
+
+    static bool firstTime = true;
+    if (firstTime) myImpulsOut = new MyImpulsOutVector();
+    firstTime = false;
+    myImpulsOut->push_back(ImpulsOutClass(pin.toInt()));
+
+    sCmd.addCommand(key.c_str(), impulsExecute);
+}
+
+void impulsExecute() {
+    String key = sCmd.order();
+    String impulsPeriod = sCmd.next();
+    String impulsCount = sCmd.next();
+
+    int number = getKeyNum(key, impuls_KeyList);
+
+    if (myImpulsOut != nullptr) {
+        if (number != -1) {
+            myImpulsOut->at(number).execute(impulsPeriod.toInt(), impulsCount.toInt());
+        }
+    }
+}
diff --git a/src/items/vInOutput.cpp b/src/items/vInOutput.cpp
new file mode 100644
index 00000000..6581c1fb
--- /dev/null
+++ b/src/items/vInOutput.cpp
@@ -0,0 +1,79 @@
+#include "items/vInOutput.h"
+#include 
+#include "Class/LineParsing.h"
+#include "Global.h"
+#include "BufferExecute.h"
+#include "Clock.h"
+
+//this class save date to flash
+InOutput::InOutput(String key, String widget) {
+    _key = key;
+    String value = jsonReadStr(configStoreJson, key);
+
+    if (value == "") {
+        if (widget.indexOf("Digit") != -1) {
+            value = "25";
+        }
+        if (widget.indexOf("Time") != -1) {
+            value = "12:00";
+        }
+    }
+
+    this->execute(value);
+}
+InOutput::~InOutput() {}
+
+void InOutput::execute(String value) {
+    eventGen2(_key, value);
+    jsonWriteStr(configStoreJson, _key, value);
+    saveStore();
+    publishStatus(_key, value);
+}
+
+MyInOutputVector* myInOutput = nullptr;
+
+void inOutput() {
+    myLineParsing.update();
+    String widget = myLineParsing.gfile();
+    String key = myLineParsing.gkey();
+    myLineParsing.clear();
+
+    inOutput_EnterCounter++;
+    addKey(key, inOutput_KeyList, inOutput_EnterCounter);
+
+    static bool firstTime = true;
+    if (firstTime) myInOutput = new MyInOutputVector();
+    firstTime = false;
+    myInOutput->push_back(InOutput(key, widget));
+
+    sCmd.addCommand(key.c_str(), inOutputExecute);
+}
+
+void inOutputExecute() {
+    String key = sCmd.order();
+    String value = sCmd.next();
+    //String type = sCmd.next();
+
+
+    if (!isDigitStr(value)) { //если значение - текст
+        if (value.indexOf(":") == -1) { //если этот текст не время
+            String valueJson = getValue(value);
+            if (valueJson != "no value") {  //если это ключ переменной
+                value = valueJson;
+            }
+            else { //если это просто текст
+                value.replace("#", " ");
+                value.replace("%date%", timeNow->getDateTimeDotFormated());
+            }
+        }
+    }
+
+    int number = getKeyNum(key, inOutput_KeyList);
+
+    if (myInOutput != nullptr) {
+        if (number != -1) {
+            myInOutput->at(number).execute(value);
+        }
+    }
+}
+
diff --git a/src/items/vLogging.cpp b/src/items/vLogging.cpp
new file mode 100644
index 00000000..9edf1710
--- /dev/null
+++ b/src/items/vLogging.cpp
@@ -0,0 +1,190 @@
+#include "items/vLogging.h"
+
+#include 
+
+#include "BufferExecute.h"
+#include "Class/LineParsing.h"
+#include "FileSystem.h"
+#include "Global.h"
+
+LoggingClass::LoggingClass(unsigned long period, unsigned int maxPoints, String loggingValueKey, String key) {
+    _period = period * 1000;
+    _maxPoints = maxPoints;
+    _loggingValueKey = loggingValueKey;
+    _key = key;
+}
+
+LoggingClass::~LoggingClass() {}
+
+void LoggingClass::loop() {
+    if (_period > 0) {
+        currentMillis = millis();
+        difference = currentMillis - prevMillis;
+        if (difference >= _period) {
+            prevMillis = millis();
+            execute("");
+        }
+    }
+}
+
+void LoggingClass::execute(String keyOrValue) {
+    String loggingValue = "";
+
+    if (keyOrValue == "") {  //прилетело из лупа
+        if (getValue(_loggingValueKey) != "no value") {
+            loggingValue = getValue(_loggingValueKey);
+        } else {
+            SerialPrint("E", "Logging", "This value not found on this device");
+        }
+    } else {                                   //прилетело из события
+        if (isDigitDotCommaStr(keyOrValue)) {  //если это число или дробное число
+            loggingValue = keyOrValue;
+        } else {  //если это ключ
+            if (getValue(_loggingValueKey) != "no value") {
+                loggingValue = getValue(keyOrValue);
+            } else {
+                SerialPrint("E", "Logging", "This value not found on this device");
+            }
+        }
+    }
+
+    String filename = "logs/" + _key + ".txt";
+
+    size_t cnt = countLines(filename);
+    size_t sz = getFileSize(filename);
+
+    SerialPrint("I", "Logging", "http://" + WiFi.localIP().toString() + "/" + filename + " lines " + String(cnt, DEC) + ", size " + String(sz));
+
+    if ((cnt > _maxPoints + 1)) {
+        removeFile(filename);
+        SerialPrint("E", "Logging", "file been remooved: " + filename + " " + String(cnt) + ">" + String(_maxPoints));
+        cnt = 0;
+    }
+
+    if (loggingValue != "") {
+        if (cnt >= _maxPoints) {                         //удаляем старую строку и добавляем новую
+            String logData = readFile(filename, 20480);  //10240
+            SerialPrint("I", "Logging", "Free heap " + String(ESP.getFreeHeap()));
+            if (logData == "large") {
+                SerialPrint("E", "Logging", "File is very large");
+            }
+
+            logData = deleteBeforeDelimiter(logData, "\r\n");
+
+            if (timeNow->hasTimeSynced()) {
+                logData += timeNow->getTimeUnix() + " " + loggingValue + "\r\n";
+
+                writeFile(filename, logData);
+            }
+        } else {  //просто добавляем новую строку
+            if (timeNow->hasTimeSynced()) {
+                addFileLn(filename, timeNow->getTimeUnix() + " " + loggingValue);
+            }
+        }
+    }
+
+    String buf = "{}";
+    jsonWriteInt(buf, "x", timeNow->getTimeUnix().toInt());
+    jsonWriteFloat(buf, "y1", loggingValue.toFloat());
+    buf = "{\"status\":[" + buf + "]}";
+    publishChart(_key, buf);
+}
+
+MyLoggingVector* myLogging = nullptr;
+
+void logging() {
+    myLineParsing.update();
+    String loggingValueKey = myLineParsing.gval();
+    String key = myLineParsing.gkey();
+    String interv = myLineParsing.gint();
+    String maxcnt = myLineParsing.gcnt();
+    myLineParsing.clear();
+
+    logging_KeyList += key + ",";
+
+    logging_EnterCounter++;
+    addKey(key, logging_KeyList, logging_EnterCounter);
+
+    static bool firstTime = true;
+    if (firstTime) myLogging = new MyLoggingVector();
+    firstTime = false;
+    myLogging->push_back(LoggingClass(interv.toInt(), maxcnt.toInt(), loggingValueKey, key));
+
+    sCmd.addCommand(key.c_str(), loggingExecute);
+}
+
+void loggingExecute() {
+    String key = sCmd.order();
+    String value = sCmd.next();
+    int number = getKeyNum(key, logging_KeyList);
+    if (myLogging != nullptr) {
+        if (number != -1) {
+            myLogging->at(number).execute(value);
+        }
+    }
+}
+
+void choose_log_date_and_send() {
+    String all_line = logging_KeyList;
+    while (all_line.length() != 0) {
+        String tmp = selectToMarker(all_line, ",");
+        sendLogData("logs/" + tmp + ".txt", tmp);
+        all_line = deleteBeforeDelimiter(all_line, ",");
+    }
+}
+
+void sendLogData(String file, String topic) {
+    File configFile = FileFS.open(file, "r");
+    if (!configFile) {
+        return;
+    }
+    configFile.seek(0, SeekSet);
+    int i = 0;
+    String buf = "{}";
+    String json_array;
+    String unix_time;
+    String value;
+    unsigned int psn;
+    unsigned int sz = configFile.size();
+    do {
+        i++;
+        psn = configFile.position();
+        String line = configFile.readStringUntil('\n');
+        unix_time = selectToMarker(line, " ");
+        jsonWriteInt(buf, "x", unix_time.toInt());
+        value = deleteBeforeDelimiter(line, " ");
+        jsonWriteFloat(buf, "y1", value.toFloat());
+        if (unix_time != "" || value != "") {
+            json_array += buf + ",";
+        }
+        int grafmax = jsonReadInt(configSetupJson, "grafmax");
+        if (grafmax != 0) {
+            if (i >= grafmax) {
+                json_array = "{\"status\":[" + json_array + "]}";
+                json_array.replace("},]}", "}]}");
+                publishChart(topic, json_array);
+                json_array = "";
+                i = 0;
+            }
+        }
+    } while (psn < sz);
+
+    configFile.close();
+
+    json_array = "{\"status\":[" + json_array + "]}";
+    json_array.replace("},]}", "}]}");
+    publishChart(topic, json_array);
+}
+
+void cleanLogAndData() {
+#ifdef ESP8266
+    auto dir = FileFS.openDir("logs");
+    while (dir.next()) {
+        String fname = dir.fileName();
+        SerialPrint("I", "System", fname);
+        removeFile("logs/" + fname);
+    }
+#endif
+    removeFile("store.json");
+    configStoreJson = "";
+}
diff --git a/src/items/vPwmOut.cpp b/src/items/vPwmOut.cpp
new file mode 100644
index 00000000..06c39916
--- /dev/null
+++ b/src/items/vPwmOut.cpp
@@ -0,0 +1,60 @@
+
+#include "Consts.h"
+#ifdef PwmOutEnable
+#include "items/vPwmOut.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+#include "BufferExecute.h"
+#include 
+
+
+//this class save data to flash
+PwmOut::PwmOut(unsigned int pin, String key) {
+    _pin = pin;
+    _key = key;
+    pinMode(_pin, OUTPUT);
+    int state = jsonReadInt(configStoreJson, key);
+    this->execute(String(state));
+}
+PwmOut::~PwmOut() {}
+
+void PwmOut::execute(String state) {
+    analogWrite(_pin, state.toInt());
+    eventGen2(_key, state);
+    jsonWriteInt(configStoreJson, _key, state.toInt());
+    saveStore();
+    publishStatus(_key, state);
+}
+
+MyPwmOutVector* myPwmOut = nullptr;
+
+void pwmOut() {
+    myLineParsing.update();
+    String key = myLineParsing.gkey();
+    String pin = myLineParsing.gpin();
+    myLineParsing.clear();
+
+    pwmOut_EnterCounter++;
+    addKey(key, pwmOut_KeyList, pwmOut_EnterCounter);
+
+    static bool firstTime = true;
+    if (firstTime) myPwmOut = new MyPwmOutVector();
+    firstTime = false;
+    myPwmOut->push_back(PwmOut(pin.toInt(), key));
+
+    sCmd.addCommand(key.c_str(), pwmOutExecute);
+}
+
+void pwmOutExecute() {
+    String key = sCmd.order();
+    String state = sCmd.next();
+
+    int number = getKeyNum(key, pwmOut_KeyList);
+
+    if (myPwmOut != nullptr) {
+        if (number != -1) {
+            myPwmOut->at(number).execute(state);
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/src/items/vSensorAnalog.cpp b/src/items/vSensorAnalog.cpp
new file mode 100644
index 00000000..ea1ec282
--- /dev/null
+++ b/src/items/vSensorAnalog.cpp
@@ -0,0 +1,70 @@
+#include "items/vSensorAnalog.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+#include "BufferExecute.h"
+#include 
+
+SensorAnalog::SensorAnalog(String key, unsigned long interval, unsigned int adcPin, int map1, int map2, int map3, int map4, float c) {
+    _interval = interval * 1000;
+    _key = key;
+    _adcPin = _adcPin;
+
+    _map1 = map1;
+    _map2 = map2;
+    _map3 = map3;
+    _map4 = map4;
+
+    _c = c;
+}
+
+SensorAnalog::~SensorAnalog() {}
+
+void SensorAnalog::loop() {
+    currentMillis = millis();
+    difference = currentMillis - prevMillis;
+    if (difference >= _interval) {
+        prevMillis = millis();
+        readAnalog();
+    }
+}
+
+void SensorAnalog::readAnalog() {
+    int value;
+#ifdef ESP32
+    value = analogRead(_adcPin);
+#endif
+#ifdef ESP8266
+    value = analogRead(A0);
+#endif
+
+    value = map(value, _map1, _map2, _map3, _map4);
+    float valueFloat = value * _c;
+
+    eventGen2(_key, String(valueFloat));
+    jsonWriteStr(configLiveJson, _key, String(valueFloat));
+    publishStatus(_key, String(valueFloat));
+    SerialPrint("I", "Sensor", "'" + _key + "' data: " + String(valueFloat));
+}
+
+MySensorAnalogVector* mySensorAnalog = nullptr;
+
+void analogAdc() {
+    myLineParsing.update();
+    String interval = myLineParsing.gint();
+    String pin = myLineParsing.gpin();
+    String key = myLineParsing.gkey();
+    String map = myLineParsing.gmap();
+    String c = myLineParsing.gc();
+    myLineParsing.clear();
+
+    int map1 = selectFromMarkerToMarker(map, ",", 0).toInt();
+    int map2 = selectFromMarkerToMarker(map, ",", 1).toInt();
+    int map3 = selectFromMarkerToMarker(map, ",", 2).toInt();
+    int map4 = selectFromMarkerToMarker(map, ",", 3).toInt();
+
+    static bool firstTime = true;
+    if (firstTime) mySensorAnalog = new MySensorAnalogVector();
+    firstTime = false;
+    mySensorAnalog->push_back(SensorAnalog(key, interval.toInt(), pin.toInt(), map1, map2, map3, map4, c.toFloat()));
+}
+
diff --git a/src/items/vSensorBme280.cpp b/src/items/vSensorBme280.cpp
new file mode 100644
index 00000000..6ec0b64b
--- /dev/null
+++ b/src/items/vSensorBme280.cpp
@@ -0,0 +1,100 @@
+#include "items/vSensorBme280.h"
+
+#include 
+
+#include "BufferExecute.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+
+Adafruit_BME280* bme = nullptr;
+
+SensorBme280::SensorBme280(const paramsBme& paramsTmp, const paramsBme& paramsHum, const paramsBme& paramsPrs) {
+    _paramsTmp = paramsBme(paramsTmp);
+    _paramsHum = paramsBme(paramsHum);
+    _paramsPrs = paramsBme(paramsPrs);
+
+    if (!bme) {
+        bme = new Adafruit_BME280;
+    }
+
+    bme->getTemperatureSensor();
+    bme->getPressureSensor();
+    bme->getHumiditySensor();
+    bme->begin(hexStringToUint8(_paramsPrs.addr));
+}
+
+SensorBme280::~SensorBme280() {}
+
+void SensorBme280::loop() {
+    difference = millis() - prevMillis;
+    if (difference >= _paramsPrs.interval) {
+        prevMillis = millis();
+        read();
+    }
+}
+
+void SensorBme280::read() {
+    float tmp = bme->readTemperature();
+    float hum = bme->readHumidity();
+    float prs = bme->readPressure();
+    prs = prs / 1.333224 / 100;
+
+    tmp = tmp * _paramsTmp.c;
+    hum = hum * _paramsHum.c;
+    prs = prs * _paramsPrs.c;
+
+    eventGen2(_paramsTmp.key, String(tmp));
+    jsonWriteStr(configLiveJson, _paramsTmp.key, String(tmp));
+    publishStatus(_paramsTmp.key, String(tmp));
+    SerialPrint("I", "Sensor", "'" + _paramsTmp.key + "' data: " + String(tmp));
+
+    eventGen2(_paramsHum.key, String(hum));
+    jsonWriteStr(configLiveJson, _paramsHum.key, String(hum));
+    publishStatus(_paramsHum.key, String(hum));
+    SerialPrint("I", "Sensor", "'" + _paramsHum.key + "' data: " + String(hum));
+
+    eventGen2(_paramsPrs.key, String(prs));
+    jsonWriteStr(configLiveJson, _paramsPrs.key, String(prs));
+    publishStatus(_paramsPrs.key, String(prs));
+    SerialPrint("I", "Sensor", "'" + _paramsPrs.key + "' data: " + String(prs));
+}
+
+MySensorBme280Vector* mySensorBme280 = nullptr;
+
+void bme280Sensor() {
+    myLineParsing.update();
+    String key = myLineParsing.gkey();
+    String addr = myLineParsing.gaddr();
+    String interval = myLineParsing.gint();
+    String c = myLineParsing.gc();
+    myLineParsing.clear();
+
+    static int enterCnt = -1;
+    enterCnt++;
+
+    static paramsBme paramsTmp;
+    static paramsBme paramsHum;
+    static paramsBme paramsPrs;
+
+    if (enterCnt == 0) {
+        paramsTmp.key = key;
+        paramsTmp.c = c.toFloat();
+    }
+
+    if (enterCnt == 1) {
+        paramsHum.key = key;
+        paramsHum.c = c.toFloat();
+    }
+
+    if (enterCnt == 2) {
+        paramsPrs.key = key;
+        paramsPrs.addr = addr;
+        paramsPrs.interval = interval.toInt() * 1000;
+        paramsPrs.c = c.toFloat();
+
+        static bool firstTime = true;
+        if (firstTime) mySensorBme280 = new MySensorBme280Vector();
+        firstTime = false;
+        mySensorBme280->push_back(SensorBme280(paramsTmp, paramsHum, paramsPrs));
+    }
+}
diff --git a/src/items/vSensorBmp280.cpp b/src/items/vSensorBmp280.cpp
new file mode 100644
index 00000000..df238317
--- /dev/null
+++ b/src/items/vSensorBmp280.cpp
@@ -0,0 +1,86 @@
+#include "items/vSensorBmp280.h"
+
+#include 
+
+#include "BufferExecute.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+
+Adafruit_BMP280* bmp = nullptr;
+
+SensorBmp280::SensorBmp280(const paramsBmp& paramsTmp, const paramsBmp& paramsPrs) {
+    _paramsTmp = paramsBmp(paramsTmp);
+    _paramsPrs = paramsBmp(paramsPrs);
+
+    if (!bmp) {
+        bmp = new Adafruit_BMP280;
+    }
+
+    bmp->getTemperatureSensor();
+    bmp->getPressureSensor();
+    bmp->begin(hexStringToUint8(_paramsPrs.addr));
+}
+
+SensorBmp280::~SensorBmp280() {}
+
+void SensorBmp280::loop() {
+    difference = millis() - prevMillis;
+    if (difference >= _paramsPrs.interval) {
+        prevMillis = millis();
+        read();
+    }
+}
+
+void SensorBmp280::read() {
+    float tmp = bmp->readTemperature();
+    float prs = bmp->readPressure();
+    prs = prs / 1.333224 / 100;
+
+    tmp = tmp * _paramsTmp.c;
+    prs = prs * _paramsPrs.c;
+
+    eventGen2(_paramsTmp.key, String(tmp));
+    jsonWriteStr(configLiveJson, _paramsTmp.key, String(tmp));
+    publishStatus(_paramsTmp.key, String(tmp));
+    SerialPrint("I", "Sensor", "'" + _paramsTmp.key + "' data: " + String(tmp));
+
+    eventGen2(_paramsPrs.key, String(prs));
+    jsonWriteStr(configLiveJson, _paramsPrs.key, String(prs));
+    publishStatus(_paramsPrs.key, String(prs));
+    SerialPrint("I", "Sensor", "'" + _paramsPrs.key + "' data: " + String(prs));
+}
+
+MySensorBmp280Vector* mySensorBmp280 = nullptr;
+
+void bmp280Sensor() {
+    myLineParsing.update();
+    String key = myLineParsing.gkey();
+    String addr = myLineParsing.gaddr();
+    String interval = myLineParsing.gint();
+    String c = myLineParsing.gc();
+    myLineParsing.clear();
+
+    static int enterCnt = -1;
+    enterCnt++;
+
+    static paramsBmp paramsTmp;
+    static paramsBmp paramsHum;
+    static paramsBmp paramsPrs;
+
+    if (enterCnt == 0) {
+        paramsTmp.key = key;
+        paramsTmp.c = c.toFloat();
+    }
+
+    if (enterCnt == 1) {
+        paramsPrs.key = key;
+        paramsPrs.addr = addr;
+        paramsPrs.interval = interval.toInt() * 1000;
+        paramsPrs.c = c.toFloat();
+
+        static bool firstTime = true;
+        if (firstTime) mySensorBmp280 = new MySensorBmp280Vector();
+        firstTime = false;
+        mySensorBmp280->push_back(SensorBmp280(paramsTmp, paramsPrs));
+    }
+}
diff --git a/src/items/vSensorDallas.cpp b/src/items/vSensorDallas.cpp
new file mode 100644
index 00000000..d52b8b57
--- /dev/null
+++ b/src/items/vSensorDallas.cpp
@@ -0,0 +1,54 @@
+#include "items/vSensorDallas.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+#include "BufferExecute.h"
+#include 
+
+SensorDallas::SensorDallas(unsigned long interval, unsigned int pin, unsigned int index, String key) {
+    _interval = interval * 1000;
+    _key = key;
+    _pin = pin;
+    _index = index;
+
+    oneWire = new OneWire((uint8_t)_pin);
+    sensors.setOneWire(oneWire);
+    sensors.begin();
+    sensors.setResolution(12);
+}
+
+SensorDallas::~SensorDallas() {}
+
+void SensorDallas::loop() {
+    currentMillis = millis();
+    difference = currentMillis - prevMillis;
+    if (difference >= _interval) {
+        prevMillis = millis();
+        readDallas();
+    }
+}
+
+void SensorDallas::readDallas() {
+    sensors.requestTemperaturesByIndex(_index);
+    float value = sensors.getTempCByIndex(_index);
+    eventGen2(_key, String(value));
+    jsonWriteStr(configLiveJson, _key, String(value));
+    publishStatus(_key, String(value));
+    SerialPrint("I", "Sensor", "'" + _key + "' data: " + String(value));
+}
+
+MySensorDallasVector* mySensorDallas2 = nullptr;
+
+void dallas() {
+    myLineParsing.update();
+    String interval = myLineParsing.gint();
+    String pin = myLineParsing.gpin();
+    String index = myLineParsing.gindex();
+    String key = myLineParsing.gkey();
+    myLineParsing.clear();
+
+    static bool firstTime = true;
+    if (firstTime) mySensorDallas2 = new MySensorDallasVector();
+    firstTime = false;
+    mySensorDallas2->push_back(SensorDallas(interval.toInt(), pin.toInt(), index.toInt(), key));
+}
+
diff --git a/src/items/vSensorDht.cpp b/src/items/vSensorDht.cpp
new file mode 100644
index 00000000..5c79d74c
--- /dev/null
+++ b/src/items/vSensorDht.cpp
@@ -0,0 +1,94 @@
+#include "items/vSensorDht.h"
+
+#include 
+
+#include "BufferExecute.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+
+SensorDht::SensorDht(const paramsDht& paramsTmp, const paramsDht& paramsHum) {
+    _paramsTmp = paramsDht(paramsTmp);
+    _paramsHum = paramsDht(paramsHum);
+
+    dht = new DHTesp();
+
+    if (_paramsHum.type == "dht11") {
+        dht->setup(_paramsHum.pin, DHTesp::DHT11);
+    } else if (_paramsHum.type == "dht22") {
+        dht->setup(_paramsHum.pin, DHTesp::DHT22);
+    }
+
+    _paramsHum.interval = _paramsHum.interval + dht->getMinimumSamplingPeriod();
+}
+
+SensorDht::~SensorDht() {}
+
+void SensorDht::loop() {
+    difference = millis() - prevMillis;
+    if (difference >= _paramsHum.interval) {
+        prevMillis = millis();
+        readTmpHum();
+    }
+}
+
+void SensorDht::readTmpHum() {
+    float tmp = dht->getTemperature();
+    float hum = dht->getHumidity();
+
+    if (String(tmp) != "nan" && String(hum) != "nan") {
+        tmp = tmp * _paramsTmp.c;
+        hum = hum * _paramsHum.c;
+
+        eventGen2(_paramsTmp.key, String(tmp));
+        jsonWriteStr(configLiveJson, _paramsTmp.key, String(tmp));
+        publishStatus(_paramsTmp.key, String(tmp));
+        SerialPrint("I", "Sensor", "'" + _paramsTmp.key + "' data: " + String(tmp));
+
+        eventGen2(_paramsHum.key, String(hum));
+        jsonWriteStr(configLiveJson, _paramsHum.key, String(hum));
+        publishStatus(_paramsHum.key, String(hum));
+        SerialPrint("I", "Sensor", "'" + _paramsHum.key + "' data: " + String(hum));
+
+    } else {
+        SerialPrint("E", "Sensor DHT", "Error");
+    }
+}
+
+MySensorDhtVector* mySensorDht = nullptr;
+
+void dhtSensor() {
+    myLineParsing.update();
+    String type = myLineParsing.gtype();
+    String interval = myLineParsing.gint();
+    String pin = myLineParsing.gpin();
+    String key = myLineParsing.gkey();
+    String c = myLineParsing.gc();
+    myLineParsing.clear();
+
+    static int enterCnt = -1;
+    enterCnt++;
+
+    static paramsDht paramsTmp;
+    static paramsDht paramsHum;
+
+    if (enterCnt == 0) {
+        paramsTmp.key = key;
+        paramsTmp.interval = interval.toInt() * 1000;
+        paramsTmp.c = c.toFloat();
+    }
+
+    if (enterCnt == 1) {
+        paramsHum.type = type;
+        paramsHum.key = key;
+        paramsHum.interval = interval.toInt() * 1000;
+        paramsHum.pin = pin.toInt();
+        paramsHum.c = c.toFloat();
+
+        static bool firstTime = true;
+        if (firstTime) mySensorDht = new MySensorDhtVector();
+        firstTime = false;
+        mySensorDht->push_back(SensorDht(paramsTmp, paramsHum));
+
+        enterCnt = -1;
+    }
+}
diff --git a/src/items/vSensorUltrasonic.cpp b/src/items/vSensorUltrasonic.cpp
new file mode 100644
index 00000000..273424cf
--- /dev/null
+++ b/src/items/vSensorUltrasonic.cpp
@@ -0,0 +1,89 @@
+#include "items/vSensorUltrasonic.h"
+#include "Class/LineParsing.h"
+#include "Global.h"
+#include "BufferExecute.h"
+#include 
+
+GMedian<5, int> testFilter;
+
+SensorUltrasonic::SensorUltrasonic(String key, unsigned long interval, unsigned int trig, unsigned int echo, int map1, int map2, int map3, int map4, float c) {
+    _interval = interval * 1000;
+    _key = key;
+    _trig = trig;
+    _echo = echo;
+
+    _map1 = map1;
+    _map2 = map2;
+    _map3 = map3;
+    _map4 = map4;
+
+    _c = c;
+
+    pinMode(_trig, OUTPUT);
+    pinMode(_echo, INPUT);
+}
+
+SensorUltrasonic::~SensorUltrasonic() {}
+
+void SensorUltrasonic::loop() {
+    currentMillis = millis();
+    difference = currentMillis - prevMillis;
+    if (difference >= _interval) {
+        prevMillis = millis();
+        readUltrasonic();
+    }
+}
+
+void SensorUltrasonic::readUltrasonic() {
+
+    static unsigned int counter;
+    counter++;
+
+    int value;
+
+    digitalWrite(_trig, LOW);
+    delayMicroseconds(2);
+    digitalWrite(_trig, HIGH);
+    delayMicroseconds(10);
+    digitalWrite(_trig, LOW);
+    long duration_ = pulseIn(_echo, HIGH, 30000);  // 3000 µs = 50cm // 30000 µs = 5 m
+    value = duration_ / 29 / 2;
+
+    value = testFilter.filtered(value);
+
+    value = map(value, _map1, _map2, _map3, _map4);
+    float valueFloat = value * _c;
+
+    if (counter > 10) {
+        eventGen2(_key, String(valueFloat));
+        jsonWriteStr(configLiveJson, _key, String(valueFloat));
+        publishStatus(_key, String(valueFloat));
+        SerialPrint("I", "Sensor", "'" + _key + "' data: " + String(valueFloat));    
+    }
+}
+
+MySensorUltrasonicVector* mySensorUltrasonic = nullptr;
+
+void ultrasonic() {
+    myLineParsing.update();
+    String interval = myLineParsing.gint();
+    String pin = myLineParsing.gpin();
+    String key = myLineParsing.gkey();
+    String map = myLineParsing.gmap();
+    String c = myLineParsing.gc();
+    myLineParsing.clear();
+
+    unsigned int trig = selectFromMarkerToMarker(pin, ",", 0).toInt();
+    unsigned int echo = selectFromMarkerToMarker(pin, ",", 1).toInt();
+
+    int map1 = selectFromMarkerToMarker(map, ",", 0).toInt();
+    int map2 = selectFromMarkerToMarker(map, ",", 1).toInt();
+    int map3 = selectFromMarkerToMarker(map, ",", 2).toInt();
+    int map4 = selectFromMarkerToMarker(map, ",", 3).toInt();
+
+    static bool firstTime = true;
+    if (firstTime) mySensorUltrasonic = new MySensorUltrasonicVector();
+    firstTime = false;
+    mySensorUltrasonic->push_back(SensorUltrasonic(key, interval.toInt(), trig, echo, map1, map2, map3, map4, c.toFloat()));
+}
+
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 00000000..bd065a05
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,156 @@
+
+#include 
+
+#include "BufferExecute.h"
+#include "Bus.h"
+#include "Class/CallBackTest.h"
+#include "Class/NotAsync.h"
+#include "Class/ScenarioClass3.h"
+#include "Cmd.h"
+#include "FileSystem.h"
+#include "Global.h"
+#include "Init.h"
+#include "ItemsList.h"
+#include "RemoteOrdersUdp.h"
+#include "SoftUART.h"
+#include "Telegram.h"
+#include "Tests.h"
+#include "Utils/StatUtils.h"
+#include "Utils/Timings.h"
+#include "Utils/WebUtils.h"
+#include "items/ButtonInClass.h"
+#include "items/vCountDown.h"
+#include "items/vImpulsOut.h"
+#include "items/vLogging.h"
+#include "items/vSensorAnalog.h"
+#include "items/vSensorBme280.h"
+#include "items/vSensorBmp280.h"
+#include "items/vSensorDallas.h"
+#include "items/vSensorDht.h"
+#include "items/vSensorUltrasonic.h"
+
+void not_async_actions();
+
+Timings metric;
+boolean initialized = false;
+
+void setup() {
+    Serial.begin(115200);
+    Serial.flush();
+    Serial.println();
+    Serial.println(F("--------------started----------------"));
+
+    myNotAsyncActions = new NotAsync(do_LAST);
+    myScenario = new Scenario();
+
+    //=========================================initialisation==============================================================
+    setChipId();
+    fileSystemInit();
+    loadConfig();
+#ifdef uartEnable
+    uartInit();
+#endif
+    clockInit();
+    timeInit();
+    itemsListInit();
+    espInit();
+    routerConnect();
+#ifdef telegramEnable
+    telegramInit();
+#endif
+    uptime_init();
+    upgradeInit();
+    HttpServer::init();
+    web_init();
+    initSt();
+    busInit();
+    wifiSignalInit();
+#ifdef UDP_ENABLED
+    asyncUdpInit();
+#endif
+#ifdef SSDP_ENABLED
+    SsdpInit();
+#endif
+#ifdef ESP8266
+    getFSInfo();
+#endif
+
+    testsPerform();
+
+    just_load = false;
+    initialized = true;
+}
+
+void loop() {
+    if (!initialized) {
+        return;
+    }
+#ifdef OTA_UPDATES_ENABLED
+    ArduinoOTA.handle();
+#endif
+#ifdef WS_enable
+    ws.cleanupClients();
+#endif
+    timeNow->loop();
+    mqttLoop();
+    myButtonIn.loop();
+    myScenario->loop();
+    loopCmdExecute();
+
+    myNotAsyncActions->loop();
+    ts.update();
+
+#ifdef telegramEnable
+    handleTelegram();
+#endif
+
+#ifdef uartEnable
+    uartHandle();
+#endif
+
+    if (myLogging != nullptr) {
+        for (unsigned int i = 0; i < myLogging->size(); i++) {
+            myLogging->at(i).loop();
+        }
+    }
+    if (myImpulsOut != nullptr) {
+        for (unsigned int i = 0; i < myImpulsOut->size(); i++) {
+            myImpulsOut->at(i).loop();
+        }
+    }
+    if (mySensorDallas2 != nullptr) {
+        for (unsigned int i = 0; i < mySensorDallas2->size(); i++) {
+            mySensorDallas2->at(i).loop();
+        }
+    }
+    if (mySensorUltrasonic != nullptr) {
+        for (unsigned int i = 0; i < mySensorUltrasonic->size(); i++) {
+            mySensorUltrasonic->at(i).loop();
+        }
+    }
+    if (myCountDown != nullptr) {
+        for (unsigned int i = 0; i < myCountDown->size(); i++) {
+            myCountDown->at(i).loop();
+        }
+    }
+    if (mySensorAnalog != nullptr) {
+        for (unsigned int i = 0; i < mySensorAnalog->size(); i++) {
+            mySensorAnalog->at(i).loop();
+        }
+    }
+    if (mySensorDht != nullptr) {
+        for (unsigned int i = 0; i < mySensorDht->size(); i++) {
+            mySensorDht->at(i).loop();
+        }
+    }
+    if (mySensorBme280 != nullptr) {
+        for (unsigned int i = 0; i < mySensorBme280->size(); i++) {
+            mySensorBme280->at(i).loop();
+        }
+    }
+    if (mySensorBmp280 != nullptr) {
+        for (unsigned int i = 0; i < mySensorBmp280->size(); i++) {
+            mySensorBmp280->at(i).loop();
+        }
+    }
+}
\ No newline at end of file
diff --git a/tools/littlefsbuilder.py b/tools/littlefsbuilder.py
new file mode 100644
index 00000000..df1fb52d
--- /dev/null
+++ b/tools/littlefsbuilder.py
@@ -0,0 +1,2 @@
+Import("env")
+env.Replace( MKSPIFFSTOOL=env.get("PROJECT_DIR") + '/tools/mklittlefs.exe' )
diff --git a/tools/mklittlefs.exe b/tools/mklittlefs.exe
new file mode 100644
index 00000000..7de93ff2
Binary files /dev/null and b/tools/mklittlefs.exe differ