iotmanager/IoTManager
1
0
Fork 0
mirror of https://github.com/IoTManagerProject/IoTManager.git synced 2026-03-26 22:22:16 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'ver4dev' of https://github.com/IoTManagerProject/IoTManager into ver4dev

Browse Source
This commit is contained in:
IoT Manager
2023-11-11 23:19:31 +01:00
parent 40122a2b21 06bf5aa39f
commit f068d8c10b
12 changed files with 425 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
compilerProfile.json
View File

@@ -144,6 +144,10 @@
"path": "src/modules/virtual/LogingDaily",
"active": true
},
{
"path": "src/modules/virtual/Math",
"active": false
},
{
"path": "src/modules/virtual/owmWeather",
"active": true

4
data_svelte/flashProfile.json
View File

@@ -22,6 +22,10 @@
"path": "src/modules/virtual/LogingDaily",
"active": true
},
{
"path": "src/modules/virtual/Math",
"active": false
},
{
"path": "src/modules/virtual/owmWeather",
"active": true

7
data_svelte/items.json
View File

@@ -723,10 +723,11 @@
"widget": "rangeServo",
"page": "servo",
"descr": "угол",
"int": 1,
"pin": 12,
"apin": -1,
"amap": "0, 4096, 0, 180",
"minPulseWidth": 544,
"maxPulseWidth": 2400,
"neutralPulseWidth": 1500,
"trackingID": "",
"num": 47
},
{

4
myProfile.json
View File

@@ -144,6 +144,10 @@
"path": "src/modules/virtual/LogingDaily",
"active": true
},
{
"path": "src/modules/virtual/Math",
"active": false
},
{
"path": "src/modules/virtual/owmWeather",
"active": true

50
src/modules/exec/IoTServo/IoTServo.cpp
View File

@@ -9,37 +9,41 @@ extern IoTGpio IoTgpio;
class IoTServo : public IoTItem {
private:
Servo servObj;
int _apin, _oldValue;
int _locmap1, _locmap2, _locmap3, _locmap4;
// int _apin, _oldValue;
int _oldValue;
// int _locmap1, _locmap2, _locmap3, _locmap4;
public:
IoTServo(String parameters): IoTItem(parameters) {
int pin;
int pin, minPulseWidth, maxPulseWidth, neutralPulseWidth;
jsonRead(parameters, "pin", pin);
servObj.attach(pin);
jsonRead(parameters, "minPulseWidth", minPulseWidth);
jsonRead(parameters, "maxPulseWidth", maxPulseWidth);
jsonRead(parameters, "neutralPulseWidth", neutralPulseWidth);
servObj.attach(pin, minPulseWidth, maxPulseWidth, neutralPulseWidth);
jsonRead(parameters, "apin", _apin);
if (_apin >= 0) IoTgpio.pinMode(_apin, INPUT);
// jsonRead(parameters, "apin", _apin);
// if (_apin >= 0) IoTgpio.pinMode(_apin, INPUT);
String map;
jsonRead(parameters, F("amap"), map, false);
if (map != "") {
_locmap1 = selectFromMarkerToMarker(map, ",", 0).toInt();
_locmap2 = selectFromMarkerToMarker(map, ",", 1).toInt();
_locmap3 = selectFromMarkerToMarker(map, ",", 2).toInt();
_locmap4 = selectFromMarkerToMarker(map, ",", 3).toInt();
}
// String map;
// jsonRead(parameters, F("amap"), map, false);
// if (map != "") {
// _locmap1 = selectFromMarkerToMarker(map, ",", 0).toInt();
// _locmap2 = selectFromMarkerToMarker(map, ",", 1).toInt();
// _locmap3 = selectFromMarkerToMarker(map, ",", 2).toInt();
// _locmap4 = selectFromMarkerToMarker(map, ",", 3).toInt();
// }
}
void doByInterval() {
if (_apin >= 0) {
value.valD = map(IoTgpio.analogRead(_apin), _locmap1, _locmap2, _locmap3, _locmap4);
if (abs(_oldValue - value.valD) > 5) {
_oldValue = value.valD;
servObj.write(_oldValue);
}
}
}
// void doByInterval() {
// if (_apin >= 0) {
// value.valD = map(IoTgpio.analogRead(_apin), _locmap1, _locmap2, _locmap3, _locmap4);
// if (abs(_oldValue - value.valD) > 5) {
// _oldValue = value.valD;
// servObj.write(_oldValue);
// }
// }
// }
IoTValue execute(String command, std::vector<IoTValue> &param) {
if (command == "rotate") {

14
src/modules/exec/IoTServo/modinfo.json
View File

@@ -10,10 +10,11 @@
"widget": "rangeServo",
"page": "servo",
"descr": "угол",
"int": 1,
"pin": 12,
"apin": -1,
"amap": "0, 4096, 0, 180"
"minPulseWidth": 544,
"maxPulseWidth": 2400,
"neutralPulseWidth": 1500,
"trackingID": ""
}
],
"about": {
@@ -30,10 +31,11 @@
"title": "Сервопривод",
"moduleDesc": "Предназначен для управления сервоприводом по уровню аналогово сигнала.",
"propInfo": {
"int": "Пауза в секундах между опросами аналогового входа. Если 0, то читаем постоянно",
"pin": "Пин, к которому подключен сервопривод",
"apin": "Номер GPIO аналогового пина. Если -1, то функция отключена.",
"amap": "Настройки преобразования значений аналога в нужный диапазон сервы, имеет смысл, если аналог включен."
"minPulseWidth": "Минимальная длина импульса",
"maxPulseWidth": "Максимальная длина импульса",
"neutralPulseWidth": "Нейтральная длина импульса",
"trackingID": "Идентификатор отслеживания значения другого элемента конфигурации, например, чтение аналога"
},
"retInfo": "Содержит текущее значение поворота",
"funcInfo": [

302
src/modules/sensors/Ble/Ble.cpp
View File

@@ -1,27 +1,139 @@
#include "Global.h"
#include "classes/IoTItem.h"
#include <Arduino.h>
#ifdef ESP32
#include <NimBLEDevice.h>
#include <decoder.h>
#include <vector>
// Создаем переменную для хранения данных с датчиков bluetooth
StaticJsonDocument<JSON_BUFFER_SIZE * 4> BLEbuffer;
JsonObject extBLEdata = BLEbuffer.to<JsonObject>();
// StaticJsonDocument<JSON_BUFFER_SIZE * 4> BLEbuffer;
// DynamicJsonDocument extBLEdata(JSON_BUFFER_SIZE * 4);
// JsonObject extBLEdata = BLEbuffer.to<JsonObject>();
class BleSens;
std::vector<BleSens *> BleSensArray;
BLEScan *pBLEScan;
TheengsDecoder decoder;
StaticJsonDocument<512> doc;
class BleSens : public IoTItem
{
private:
// описание параметров передаваемых из настроек датчика из веба
String _MAC;
String _sensor;
int timeRecv;
public:
String whoIAm(/*String &mac, String &sens*/)
{
// mac = _MAC;
// sens = _sensor;
return _MAC;
}
void setBLEdata(JsonObject extBLEdata)
{
if (_sensor == "last")
{
timeRecv = extBLEdata[_sensor].as<int>();
char *s;
s = TimeToString(millis() / 1000 - timeRecv / 1000);
value.isDecimal = 0;
if (timeRecv > 0)
{
value.valS = s;
}
else
{
value.valS = "";
}
regEvent(value.valS, _id);
}
else
{
String valStr = extBLEdata[_sensor].as<String>();
if (valStr != "null")
{
if (value.isDecimal == isDigitDotCommaStr(valStr))
{
value.isDecimal = 1;
value.valD = valStr.toFloat();
regEvent(value.valD, _id);
}
else
{
value.isDecimal = 0;
value.valS = valStr;
regEvent(value.valS, _id);
}
}
else
{
value.isDecimal = 0;
value.valS = "";
regEvent(value.valS, _id);
}
}
}
char *TimeToString(unsigned long t)
{
static char str[12];
long h = t / 3600;
t = t % 3600;
int m = t / 60;
int s = t % 60;
sprintf(str, "%02ld:%02d:%02d", h, m, s);
return str;
}
void doByInterval()
{
if (_sensor == "last")
{
char *s;
s = TimeToString(millis() / 1000 - timeRecv / 1000);
value.isDecimal = 0;
if (timeRecv > 0)
{
value.valS = s;
}
else
{
value.valS = "";
}
regEvent(value.valS, _id);
}
}
BleSens(String parameters) : IoTItem(parameters)
{
_MAC = jsonReadStr(parameters, "MAC");
_sensor = jsonReadStr(parameters, "sensor");
BleSensArray.push_back(this);
}
~BleSens(){};
};
//=======================================================================================================
/** Callback to process the results of the last scan or restart it */
void scanEndedCB(NimBLEScanResults results)
{
int count = results.getCount();
SerialPrint("i", F("BLE"), "Scan done! "); // +"Devices found: " + String(count));
// pBLEScan->clearResults();
}
class BleScan : public IoTItem, BLEAdvertisedDeviceCallbacks
{
private:
//описание параметров передаваемых из настроек датчика из веба
// описание параметров передаваемых из настроек датчика из веба
int _scanDuration;
String _filter;
bool _debug;
StaticJsonDocument<512> doc;
BLEScan *pBLEScan;
TheengsDecoder decoder;
public:
//=======================================================================================================
std::string convertServiceData(std::string deviceServiceData)
{
int serviceDataLength = (int)deviceServiceData.length();
@@ -67,169 +179,77 @@ public:
if (decoder.decodeBLEJson(BLEdata))
{
BLEdata.remove("manufacturerdata");
BLEdata.remove("servicedata");
BLEdata.remove("type");
BLEdata.remove("cidc");
BLEdata.remove("acts");
BLEdata.remove("cont");
BLEdata.remove("track");
String mac_address = BLEdata["id"].as<const char *>();
mac_address.replace(":", "");
if (_filter != "")
// дописываем время прихода пакета данных
BLEdata["last"] = millis();
if (_debug)
{
if (BLEdata[_filter])
if ((_filter != "" && BLEdata[_filter]) || _filter == "")
{
for (JsonPair kv : BLEdata)
{
extBLEdata[mac_address][kv.key()] = BLEdata[kv.key()];
}
// дописываем время прихода пакета данных
extBLEdata[mac_address]["last"] = millis();
// for (JsonPair kv : BLEdata)
// {
// String val = BLEdata.as<String>();
String output;
serializeJson(BLEdata, output);
SerialPrint("i", F("BLE"), _id + " " + output);
//}
}
}
else
BLEdata.remove("servicedatauuid");
SerialPrint("i", F("BLE"), "found: " + mac_address);
// Перебираем все зарегистрированные сенсоры BleSens
for (std::vector<BleSens *>::iterator it = BleSensArray.begin();
it != BleSensArray.end(); ++it)
{
for (JsonPair kv : BLEdata)
{
extBLEdata[mac_address][kv.key()] = BLEdata[kv.key()];
}
// дописываем время прихода пакета данных
extBLEdata[mac_address]["last"] = millis();
// Если это данные для нужного сенсора (по его МАКУ)
if ((*it)->whoIAm() == mac_address)
// то передаем ему json, дальше он сам разберется
(*it)->setBLEdata(BLEdata);
}
};
}
}
BleScan(String parameters) : IoTItem(parameters)
{
_scanDuration = jsonReadInt(parameters, "scanDuration");
_filter = jsonReadStr(parameters, "filter");
jsonRead(parameters, "debug", _debug);
if (pBLEScan->isScanning() == false)
{
SerialPrint("i", F("BLE"), "Start Scanning...");
BLEDevice::init("");
pBLEScan = BLEDevice::getScan(); // create new scan
pBLEScan->setAdvertisedDeviceCallbacks(this);
pBLEScan->setActiveScan(false); // active scan uses more power, but get results faster
pBLEScan->setInterval(100);
pBLEScan->setWindow(99); // less or equal setInterval value
}
BLEDevice::init("");
pBLEScan = BLEDevice::getScan(); // create new scan
pBLEScan->setAdvertisedDeviceCallbacks(this);
pBLEScan->setActiveScan(false); // active scan uses more power, but get results faster
pBLEScan->setInterval(100);
pBLEScan->setWindow(99); // less or equal setInterval value
pBLEScan->setMaxResults(0); // do not store the scan results, use callback only.
}
//=======================================================================================================
// doByInterval()
void doByInterval()
{
if (_scanDuration > 0)
if (pBLEScan->isScanning() == false)
{
BLEScanResults foundDevices = pBLEScan->start(_scanDuration, true);
int count = foundDevices.getCount();
SerialPrint("i", F("BLE"), "Devices found: " + String(count));
SerialPrint("i", F("BLE"), "Scan done!");
pBLEScan->clearResults();
}
for (JsonPair kv : extBLEdata)
{
String val = extBLEdata[kv.key()].as<String>();
SerialPrint("i", F("BLE"), _id + " " + kv.key().c_str() + " " + val);
if (_scanDuration > 0)
{
SerialPrint("i", F("BLE"), "Start Scanning...");
pBLEScan->start(_scanDuration, scanEndedCB, false);
}
}
}
//=======================================================================================================
~BleScan(){};
};
class BleSens : public IoTItem
{
private:
//описание параметров передаваемых из настроек датчика из веба
String _MAC;
String _sensor;
public:
//=======================================================================================================
char *TimeToString(unsigned long t)
{
static char str[12];
long h = t / 3600;
t = t % 3600;
int m = t / 60;
int s = t % 60;
sprintf(str, "%02ld:%02d:%02d", h, m, s);
return str;
}
BleSens(String parameters) : IoTItem(parameters)
{
_MAC = jsonReadStr(parameters, "MAC");
_sensor = jsonReadStr(parameters, "sensor");
}
//=======================================================================================================
// doByInterval()
void doByInterval()
{
if (_sensor == "last")
{
int valInt = extBLEdata[_MAC][_sensor].as<int>();
char *s;
s = TimeToString(millis() / 1000 - valInt / 1000);
value.isDecimal = 0;
if (valInt > 0)
{
value.valS = s;
}
else
{
value.valS = "";
}
regEvent(value.valS, _id);
}
else
{
String valStr = extBLEdata[_MAC][_sensor].as<String>();
if (valStr != "null")
{
if (value.isDecimal = isDigitDotCommaStr(valStr))
{
value.isDecimal = 1;
value.valD = valStr.toFloat();
regEvent(value.valD, _id);
}
else
{
value.isDecimal = 0;
value.valS = valStr;
regEvent(value.valS, _id);
}
}
else
{
value.isDecimal = 0;
value.valS = "";
regEvent(value.valS, _id);
}
}
}
//=======================================================================================================
~BleSens(){};
};
#endif
// Заглушка для ESP8266
#ifdef ESP8266
class Ble : public IoTItem
{
private:
public:
Ble(String parameters) : IoTItem(parameters) {}
};
#endif
//=======================================================================================================
void *getAPI_Ble(String subtype, String param)
{

39
src/modules/sensors/Ble/modinfo.json
View File

@@ -3,7 +3,6 @@
"configItem": [
{
"name": "bluetooth сканер",
"num": 1,
"type": "Reading",
"subtype": "BleScan",
"id": "BleScan",
@@ -12,11 +11,11 @@
"descr": "",
"int": 135,
"scanDuration": 10,
"filter": "servicedatauuid"
"filter": "servicedatauuid",
"debug":1
},
{
"name": "bluetooth датчик",
"num": 1,
"type": "Reading",
"subtype": "BleSens",
"id": "BleSens",
@@ -24,20 +23,20 @@
"page": "Сенсоры",
"descr": "",
"needSave": 0,
"int": 30,
"global": 0,
"round": 1,
"int": 60,
"MAC": "",
"sensor": ""
}
],
"about": {
"authorName": "AVAKS",
"authorContact": "https://t.me/@avaks_dev",
"authorGit": "https://github.com/avaksru",
"authorName": "AVAKS, v3 - Mit4bmw",
"authorContact": "https://t.me/@avaks, https://t.me/Mit4bmw",
"authorGit": "https://github.com/avaksru, https://github.com/Mit4el",
"specialThanks": "@Serghei63",
"moduleName": "Ble",
"moduleVersion": "1.0",
"moduleVersion": "3.0",
"usedRam": {
"esp32_4mb": 1261449,
"esp8266_4mb": 0
@@ -50,9 +49,9 @@
"moduleDesc": "Позволяет получить данные с Bluetooth часов и термометров Mijia, Xiaomi, Cleargrass, ...",
"propInfo": {
"round": "Округление после запятой.",
"int": "Интервал сканирования BLE окружения (BleScan) / Интервал отправки собранной телеметрии в MQTT (BleSens)",
"int": "Интервал сканирования BLE окружения (BleScan) / В BleSens темп обновления времнени поступления данных, сами даные обновляются по мене сканирования/поступления",
"scanDuration": "Длительность сканирования ",
"filter": "Позволяет установить фильтр по параметру передаваемому датчиком. Данные будут считываться только с датчиков у которых есть передаваемый параметр указанный в фильтре",
"filter": "Позволяет установить фильтр по параметру передаваемому датчиком. Влияет только на вывод лога при debug=1, что бы было легче найти датчики, если много устройств в эфире",
"MAC": "MAC адрес беспроводного датчика",
"sensor": "Тип сенсора: температура / влажность / время / ... "
}
@@ -61,15 +60,27 @@
"usedLibs": {
"esp32_4mb": [
"https://github.com/h2zero/NimBLE-Arduino.git",
"https://github.com/avaksru/decoder.git"
"https://github.com/Mit4el/decoder.git"
],
"esp32_16mb": [
"https://github.com/h2zero/NimBLE-Arduino.git",
"https://github.com/Mit4el/decoder.git"
],
"esp32_4mb3f": [
"https://github.com/h2zero/NimBLE-Arduino.git",
"https://github.com/avaksru/decoder.git"
],
"https://github.com/Mit4el/decoder.git"
],
"esp32cam_4mb": [
"https://github.com/h2zero/NimBLE-Arduino.git",
"https://github.com/avaksru/decoder.git"
"https://github.com/Mit4el/decoder.git"
],
"esp32s3_16mb": [
"https://github.com/h2zero/NimBLE-Arduino.git",
"https://github.com/Mit4el/decoder.git"
],
"esp32c3m_4mb": [
"https://github.com/h2zero/NimBLE-Arduino.git",
"https://github.com/Mit4el/decoder.git"
]
}
}

36
src/modules/sensors/RTC/RTC.cpp
View File

@@ -63,6 +63,42 @@ class RTC : public IoTItem {
valTmp.valS = _watch->gettime(param[0].valS + " ");
return valTmp;
}
} else if (command == "setUnixTime") {
if (param.size() == 1) {
long ut = strtoul(param[0].valS.c_str(), nullptr, 10);
_watch->settimeUnix(ut);
return {};
}
} else if (command == "setTime") {
if (param.size() == 6) {
_watch->settime(param[0].valD, param[1].valD, param[2].valD, param[3].valD, param[4].valD, param[5].valD); //сек, мин, час, день, мес, год
return {};
}
} else if (command == "getTimeFloat") {
if (param.size() == 1) {
IoTValue valTmp;
_watch->gettime();
valTmp.isDecimal = true;
String type = param[0].valS;
if (type == "H") {
valTmp.valD = static_cast<float>(_watch->Hours);
} else if (type == "i") {
valTmp.valD = static_cast<float>(_watch->minutes);
} else if (type == "s") {
valTmp.valD = static_cast<float>(_watch->seconds);
} else if (type == "w") {
valTmp.valD = static_cast<float>(_watch->weekday);
} else if (type == "d") {
valTmp.valD = static_cast<float>(_watch->day);
} else if (type == "m") {
valTmp.valD = static_cast<float>(_watch->month);
} else if (type == "Y") {
valTmp.valD = static_cast<float>(_watch->year);
} else {
return {}; // Если переданный тип не поддерживается
}
return valTmp;
}
}
return {};

21
src/modules/sensors/RTC/modinfo.json
View File

@@ -54,6 +54,27 @@
"params": [
"Формат как у функции date() в PHP"
]
},
{
"name": "setTime",
"descr": "Установить время через сценарии в формате сек, мин, час, день, мес, год.",
"params": [
"сек", "мин", "час", "день", "мес", "год"
]
},
{
"name": "setUnixTime",
"descr": "Установить время через сценарий в формате юникстайм",
"params": [
"rtc.setUnixTime('46489234') - параметр в виде строки"
]
},
{
"name": "getTimeFloat",
"descr": "Получить числовое значение времени по указанному формату",
"params": [
"s - Вернуть секунды, i - Вернуть минуты, H - Вернуть часы в 24-часовом формате, d - Вернуть день месяца, w - Вернуть день недели, m - Вернуть месяц, Y - Вернуть год(4 знака)"
]
}
]
},

69
src/modules/virtual/Math/Math.cpp Normal file
View File

@@ -0,0 +1,69 @@
#include "Global.h"
#include "classes/IoTItem.h"
#include <ctime>
class IoTMath : public IoTItem {
private:
time_t convertTime(float day, float month, float year, float hour, float minute) {
// Преобразование из float в int
int d = static_cast<int>(day);
int m = static_cast<int>(month);
int y = static_cast<int>(year);
int h = static_cast<int>(hour);
int min = static_cast<int>(minute);
if (d < 1 || d > 31 || m < 1 || m > 12 || y < 1900 || h < 0 || h > 23 || min < 0 || min > 59) {
SerialPrint("E", F("IoTMath"), F("Invalid date or time parameters!"));
return -1;
}
// Структура для хранения даты и времени
struct tm t;
t.tm_year = y - 1900;
t.tm_mon = m - 1;
t.tm_mday = d;
t.tm_hour = h;
t.tm_min = min;
t.tm_sec = 0;
t.tm_isdst = -1; // Пусть система сама определяет DST
return mktime(&t);
}
public:
IoTMath(String parameters) : IoTItem(parameters) {}
IoTValue execute(String command, std::vector<IoTValue> &param) {
if(command == "map" && param.size() == 5) {
IoTValue valTmp;
valTmp.isDecimal = true;
valTmp.valD = map(param[0].valD, param[1].valD, param[2].valD, param[3].valD, param[4].valD);
//SerialPrint("i", F("IoTMath"), F("Mapping value done."));
return valTmp;
} else if(command == "convertTime" && param.size() == 5) {
time_t unixTime = convertTime(param[0].valD, param[1].valD, param[2].valD, param[3].valD, param[4].valD);
if (unixTime == -1) {
SerialPrint("E", F("IoTMath"), F("Failed to convert time."));
return {};
}
IoTValue valTmp;
valTmp.isDecimal = true;
valTmp.valD = unixTime;
//SerialPrint("i", F("IoTMath"), F("Time conversion done."));
return valTmp;
}
SerialPrint("E", F("IoTMath"), F("Unknown command or wrong parameters."));
return {};
}
};
void *getAPI_IoTMath(String subtype, String param) {
if (subtype == F("IoTMath")) {
return new IoTMath(param);
}
return nullptr;
}

62
src/modules/virtual/Math/modinfo.json Normal file
View File

@@ -0,0 +1,62 @@
{
"menuSection": "virtual_elments",
"configItem": [
{
"global": 0,
"name": "Math library",
"type": "Reading",
"subtype": "IoTMath",
"id": "math",
"widget": "anydataValue",
"page": "Математика",
"descr": ""
}
],
"about": {
"authorName": "Berenbaum Maxim",
"authorContact": "https://t.me/Bermax_sys",
"authorGit": "https://github.com/xpohuk8",
"exampleURL": "https://iotmanager.org/wiki",
"specialThanks": "Ilya Belyakov",
"moduleName": "IoTMath",
"moduleVersion": "1.0",
"usedRam": {
"esp32_4mb": 15,
"esp8266_4mb": 15
},
"title": "Модуль Math",
"moduleDesc": "Модуль для расчета значений с использованием математических функций. Подходит для коррекции показаний датчиков.",
"propInfo": {
},
"funcInfo": [
{
"name": "map",
"descr": "Аналог функции map",
"params": [
"Значение1", "Значение2", "Значение3", "Значение4"
]
},
{
"name": "convertTime",
"descr": "Перевести время из формата d-m-Y H:i:s например, 13-08-2023 16:24:00 в юникс-время ",
"params": [
"tm.convertTime(13, 08, 2023, 16, 24); - передаем пять целых чисел. секунды подставятся в ноль"
]
}
]
},
"defActive": true,
"usedLibs": {
"esp32_4mb": [],
"esp32_4mb3f": [],
"esp32cam_4mb": [],
"esp32s2_4mb": [],
"esp8266_4mb": [],
"esp8266_1mb": [],
"esp8266_1mb_ota": [],
"esp8285_1mb": [],
"esp8285_1mb_ota": [],
"esp8266_2mb": [],
"esp8266_2mb_ota": []
}
}