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

wifi multipoint v2 array

Browse Source
This commit is contained in:
Mit4el
2023-09-24 20:58:51 +03:00
parent 48ccdd7e86
commit 307786f087
8 changed files with 617 additions and 527 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
data_svelte/myProfile.json
View File

@@ -3,8 +3,8 @@
"name": "IoTmanagerVer4", "name": "IoTmanagerVer4",
"apssid": "IoTmanager", "apssid": "IoTmanager",
"appass": "", "appass": "",
"routerssid": "iot", "routerssid": ["iot","wifi"],
"routerpass": "hostel3333", "routerpass": ["hostel3333","pswd"],
"timezone": 2, "timezone": 2,
"ntp": "pool.ntp.org", "ntp": "pool.ntp.org",
"weblogin": "admin", "weblogin": "admin",
@@ -32,6 +32,11 @@
"firmware": "0x00000", "firmware": "0x00000",
"littlefs": "0x300000" "littlefs": "0x300000"
}, },
{
"name": "esp8266_16mb",
"firmware": "0x00000",
"littlefs": "0x200000"
},
{ {
"name": "esp32_4mb", "name": "esp32_4mb",
"boot_app0": "0xe000", "boot_app0": "0xe000",
@@ -40,6 +45,14 @@
"partitions": "0x8000", "partitions": "0x8000",
"littlefs": "0x290000" "littlefs": "0x290000"
}, },
{
"name": "esp32_16mb",
"boot_app0": "0xe000",
"bootloader_qio_80m": "0x1000",
"firmware": "0x10000",
"partitions": "0x8000",
"littlefs": "0x910000"
},
{ {
"name": "esp8266_1mb", "name": "esp8266_1mb",
"firmware": "0x00000000", "firmware": "0x00000000",

10
data_svelte/settings.json
View File

@@ -2,8 +2,14 @@
"name": "IoTmanagerVer4", "name": "IoTmanagerVer4",
"apssid": "IoTmanager", "apssid": "IoTmanager",
"appass": "", "appass": "",
"routerssid": "iot", "routerssid": [
"routerpass": "hostel3333", "iot",
"wifi"
],
"routerpass": [
"hostel3333",
"pswd"
],
"timezone": 2, "timezone": 2,
"ntp": "pool.ntp.org", "ntp": "pool.ntp.org",
"weblogin": "admin", "weblogin": "admin",

1
include/utils/JsonUtils.h
View File

@@ -15,6 +15,7 @@ extern bool jsonRead(const String& json, String key, float& value, bool e = true
extern bool jsonRead(const String& json, String key, String& value, bool e = true); extern bool jsonRead(const String& json, String key, String& value, bool e = true);
extern bool jsonRead(const String& json, String key, bool& value, bool e = true); extern bool jsonRead(const String& json, String key, bool& value, bool e = true);
extern bool jsonRead(const String& json, String key, int& value, bool e = true); extern bool jsonRead(const String& json, String key, int& value, bool e = true);
extern bool jsonReadArray(const String& json, String key, JsonArray& jArray, bool e = true);
extern String jsonReadStr(const String& json, String name, bool e = true); extern String jsonReadStr(const String& json, String name, bool e = true);
extern int jsonReadInt(const String& json, String name, bool e = true); extern int jsonReadInt(const String& json, String name, bool e = true);

2
include/utils/WiFiUtils.h
View File

@@ -7,6 +7,6 @@
inline boolean isNetworkActive() {return WiFi.status() == WL_CONNECTED;}; inline boolean isNetworkActive() {return WiFi.status() == WL_CONNECTED;};
void routerConnect(); void routerConnect();
bool startAPMode(); bool startAPMode();
boolean RouterFind(String ssid); boolean RouterFind(JsonArray jArray);
uint8_t RSSIquality(); uint8_t RSSIquality();
extern void wifiSignalInit(); extern void wifiSignalInit();

4
myProfile.json
View File

@@ -3,8 +3,8 @@
"name": "IoTmanagerVer4", "name": "IoTmanagerVer4",
"apssid": "IoTmanager", "apssid": "IoTmanager",
"appass": "", "appass": "",
"routerssid": "iot", "routerssid": ["iot","wifi"],
"routerpass": "hostel3333", "routerpass": ["hostel3333","pswd"],
"timezone": 2, "timezone": 2,
"ntp": "pool.ntp.org", "ntp": "pool.ntp.org",
"weblogin": "admin", "weblogin": "admin",

769
src/WsServer.cpp
View File

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

20
src/utils/JsonUtils.cpp
View File

@@ -98,6 +98,26 @@ bool jsonRead(const String& json, String key, int& value, bool e) {
return true; return true;
} }
bool jsonReadArray(const String& json, String key, JsonArray& jArray, bool e) {
DynamicJsonDocument doc(JSON_BUFFER_SIZE);
DeserializationError error = deserializeJson(doc, json);
if (error) {
if (e) {
SerialPrint("E", F("jsonReadArray"), error.f_str());
jsonErrorDetected();
}
return false;
} else if (!doc.containsKey(key)) {
if (e) {
SerialPrint("E", F("jsonReadArray"), key + " missing in " + json);
jsonErrorDetected();
}
return false;
}
jArray = doc[key];
return true;
}
// new============================================================================== // new==============================================================================
bool jsonWriteStr_(String& json, const String& key, const String& value, bool e) { bool jsonWriteStr_(String& json, const String& key, const String& value, bool e) {
bool ret = true; bool ret = true;

321
src/utils/WiFiUtils.cpp
View File

@@ -3,195 +3,208 @@
#define TRIESONE 25 // количество попыток подключения к одной сети из несколких #define TRIESONE 25 // количество попыток подключения к одной сети из несколких
#define TRIES 40 // количество попыток подключения сети если она одна #define TRIES 40 // количество попыток подключения сети если она одна
void routerConnect() { void routerConnect()
WiFi.setAutoConnect(false); {
WiFi.persistent(false); WiFi.setAutoConnect(false);
WiFi.persistent(false);
WiFi.mode(WIFI_STA); WiFi.mode(WIFI_STA);
byte triesOne = TRIESONE; byte triesOne = TRIESONE;
String _ssid = jsonReadStr(settingsFlashJson, "routerssid"); JsonArray _ssidList;
String _password = jsonReadStr(settingsFlashJson, "routerpass"); JsonArray _passwordList;
std::vector<String> _ssidList; jsonReadArray(settingsFlashJson, "routerssid", _ssidList);
std::vector<String> _passwordList; jsonReadArray(settingsFlashJson, "routerpass", _passwordList);
for (size_t i = 0; i < 3; i++) if (_ssidList.size() > 1)
{ triesOne = TRIES;
String _stmp = selectFromMarkerToMarker(_ssid, ",", i);
String _ptmp = selectFromMarkerToMarker(_password, ",", i);
if (_stmp == "not found" && _ssidList.size() == 0)
{
triesOne = TRIES;
_ssidList.push_back(_ssid);
_passwordList.push_back(_password);
break;
}
if (_stmp != "not found")
{
_ssidList.push_back(_stmp);
_passwordList.push_back(_ptmp);
}
}
if (_ssid == "" && _password == "") { if (_passwordList.size() == 0 && _ssidList[0] == "" && _passwordList[0] == "")
WiFi.begin(); {
} else { WiFi.begin();
WiFi.begin(_ssidList[0].c_str(), _passwordList[0].c_str()); }
else
{
WiFi.begin(_ssidList[0].as<const char*>(), _passwordList[0].as<const char*>());
#ifdef ESP32 #ifdef ESP32
WiFi.setTxPower(WIFI_POWER_19_5dBm); WiFi.setTxPower(WIFI_POWER_19_5dBm);
#else #else
WiFi.setOutputPower(20.5); WiFi.setOutputPower(20.5);
#endif #endif
String _ssid;
if (_ssidList.size() > 1) String _password;
{ for (int8_t i = 0; i < _ssidList.size(); i++)
SerialPrint("i", "WIFI", "ssid list: " + _ssid); {
SerialPrint("i", "WIFI", "pass list: " + _password); _ssid = _ssid + _ssidList[i].as<String>() + "; ";
}
} }
for (size_t i = 0; i < _ssidList.size(); i++) { for (int8_t i = 0; i < _passwordList.size(); i++)
triesOne = TRIESONE; {
if (WiFi.status() == WL_CONNECTED) _password = _password + _passwordList[i].as<String>() + "; ";
break; }
WiFi.begin(_ssidList[i].c_str(), _passwordList[i].c_str()); SerialPrint("i", "WIFI", "ssid list: " + _ssid);
SerialPrint("i", "WIFI", "ssid connect: " + _ssidList[i]); SerialPrint("i", "WIFI", "pass list: " + _password);
SerialPrint("i", "WIFI", "pass connect: " + _passwordList[i]); }
while (--triesOne && WiFi.status() != WL_CONNECTED) { for (size_t i = 0; i < _ssidList.size(); i++)
{
triesOne = TRIESONE;
if (WiFi.status() == WL_CONNECTED)
break;
WiFi.begin(_ssidList[i].as<const char*>(), _passwordList[i].as<const char*>());
SerialPrint("i", "WIFI", "ssid connect: " + _ssidList[i].as<String>());
SerialPrint("i", "WIFI", "pass connect: " + _passwordList[i].as<String>());
while (--triesOne && WiFi.status() != WL_CONNECTED)
{
// SerialPrint("i", "WIFI", ": " + String((int)WiFi.status())); // SerialPrint("i", "WIFI", ": " + String((int)WiFi.status()));
#ifdef ESP8266 #ifdef ESP8266
if (WiFi.status() == WL_CONNECT_FAILED || WiFi.status() == WL_WRONG_PASSWORD) if (WiFi.status() == WL_CONNECT_FAILED || WiFi.status() == WL_WRONG_PASSWORD)
#else #else
if (WiFi.status() == WL_CONNECT_FAILED) if (WiFi.status() == WL_CONNECT_FAILED)
#endif #endif
{ {
SerialPrint("E", "WIFI", "password is not correct"); SerialPrint("E", "WIFI", "password is not correct");
triesOne = 1; triesOne = 1;
jsonWriteInt(errorsHeapJson, "passer", 1); jsonWriteInt(errorsHeapJson, "passer", 1);
break; break;
} }
Serial.print("."); Serial.print(".");
delay(1000); delay(1000);
}
Serial.println("");
} }
Serial.println("");
}
if (WiFi.status() != WL_CONNECTED) { if (WiFi.status() != WL_CONNECTED)
Serial.println(""); {
startAPMode(); Serial.println("");
} else { startAPMode();
Serial.println(""); }
SerialPrint("i", "WIFI", "http://" + WiFi.localIP().toString()); else
jsonWriteStr(settingsFlashJson, "ip", WiFi.localIP().toString()); {
Serial.println("");
SerialPrint("i", "WIFI", "http://" + WiFi.localIP().toString());
jsonWriteStr(settingsFlashJson, "ip", WiFi.localIP().toString());
mqttInit(); mqttInit();
} }
SerialPrint("i", F("WIFI"), F("Network Init")); SerialPrint("i", F("WIFI"), F("Network Init"));
} }
bool startAPMode() { bool startAPMode()
SerialPrint("i", "WIFI", "AP Mode"); {
SerialPrint("i", "WIFI", "AP Mode");
WiFi.disconnect(); WiFi.disconnect();
WiFi.mode(WIFI_AP); WiFi.mode(WIFI_AP);
String _ssidAP = jsonReadStr(settingsFlashJson, "apssid"); String _ssidAP = jsonReadStr(settingsFlashJson, "apssid");
String _passwordAP = jsonReadStr(settingsFlashJson, "appass"); String _passwordAP = jsonReadStr(settingsFlashJson, "appass");
WiFi.softAP(_ssidAP.c_str(), _passwordAP.c_str()); WiFi.softAP(_ssidAP.c_str(), _passwordAP.c_str());
IPAddress myIP = WiFi.softAPIP(); IPAddress myIP = WiFi.softAPIP();
SerialPrint("i", "WIFI", "AP IP: " + myIP.toString()); SerialPrint("i", "WIFI", "AP IP: " + myIP.toString());
jsonWriteStr(settingsFlashJson, "ip", myIP.toString()); jsonWriteStr(settingsFlashJson, "ip", myIP.toString());
if (jsonReadInt(errorsHeapJson, "passer") != 1) { if (jsonReadInt(errorsHeapJson, "passer") != 1)
ts.add( {
WIFI_SCAN, 30 * 1000, [&](void*) { ts.add(
String sta_ssid = jsonReadStr(settingsFlashJson, "routerssid"); WIFI_SCAN, 30 * 1000,
[&](void *)
SerialPrint("i", "WIFI", "scanning for " + sta_ssid); {
JsonArray jArray;
if (RouterFind(sta_ssid)) { jsonReadArray(settingsFlashJson, "routerssid", jArray);
ts.remove(WIFI_SCAN); for (int8_t i = 0; i < jArray.size(); i++)
WiFi.scanDelete(); {
routerConnect(); SerialPrint("i", "WIFI", "scanning for " + jArray[i].as<String>());
} }
}, if (RouterFind(jArray))
nullptr, true); {
} ts.remove(WIFI_SCAN);
return true; WiFi.scanDelete();
routerConnect();
}
},
nullptr, true);
}
return true;
} }
boolean RouterFind(String ssid) { boolean RouterFind(JsonArray jArray)
bool res = false; {
int n = WiFi.scanComplete(); bool res = false;
SerialPrint("i", "WIFI", "scan result: " + String(n, DEC)); int n = WiFi.scanComplete();
SerialPrint("i", "WIFI", "scan result: " + String(n, DEC));
if (n == -2) { //Сканирование не было запущено, запускаем if (n == -2)
SerialPrint("i", "WIFI", "start scanning"); { // Сканирование не было запущено, запускаем
WiFi.scanNetworks(true, false); // async, show_hidden SerialPrint("i", "WIFI", "start scanning");
} WiFi.scanNetworks(true, false); // async, show_hidden
}
else if (n == -1) { //Сканирование все еще выполняется else if (n == -1)
SerialPrint("i", "WIFI", "scanning in progress"); { // Сканирование все еще выполняется
} SerialPrint("i", "WIFI", "scanning in progress");
}
else if (n == 0) { //ни одна сеть не найдена else if (n == 0)
SerialPrint("i", "WIFI", "no networks found"); { // ни одна сеть не найдена
WiFi.scanNetworks(true, false); SerialPrint("i", "WIFI", "no networks found");
} WiFi.scanNetworks(true, false);
else if (n > 0) }
else if (n > 0)
{
for (int8_t i = 0; i < n; i++)
{ {
std::vector<String> _ssidList; for (int8_t k = 0; k < jArray.size(); k++)
for (size_t i = 0; i < 3; i++) {
if (WiFi.SSID(i) == String(jArray[k]))
{ {
String _stmp = selectFromMarkerToMarker(ssid, ",", i); res = true;
if (_stmp == "not found" && _ssidList.size() == 0)
{
_ssidList.push_back(ssid);
break;
}
if (_stmp != "not found")
_ssidList.push_back(_stmp);
} }
}
// SerialPrint("i", "WIFI", (res ? "*" : "") + String(i, DEC) + ") " + WiFi.SSID(i));
jsonWriteStr_(ssidListHeapJson, String(i), WiFi.SSID(i));
for (int8_t i = 0; i < n; i++) // String(WiFi.RSSI(i)
{
if (WiFi.SSID(i) == _ssidList[0] || WiFi.SSID(i) == _ssidList[1] ||
WiFi.SSID(i) == _ssidList[2])
{
res = true;
}
// SerialPrint("i", "WIFI", (res ? "*" : "") + String(i, DEC) + ") " + WiFi.SSID(i));
jsonWriteStr_(ssidListHeapJson, String(i), WiFi.SSID(i));
// String(WiFi.RSSI(i)
}
} }
SerialPrint("i", "WIFI", ssidListHeapJson); }
WiFi.scanDelete(); SerialPrint("i", "WIFI", ssidListHeapJson);
return res; WiFi.scanDelete();
return res;
} }
// boolean isNetworkActive() { // boolean isNetworkActive() {
// return WiFi.status() == WL_CONNECTED; // return WiFi.status() == WL_CONNECTED;
// } // }
uint8_t RSSIquality() { uint8_t RSSIquality()
uint8_t res = 0; {
if (WiFi.status() == WL_CONNECTED) { uint8_t res = 0;
int rssi = WiFi.RSSI(); if (WiFi.status() == WL_CONNECTED)
if (rssi >= -50) { {
res = 6; //"Excellent"; int rssi = WiFi.RSSI();
} else if (rssi < -50 && rssi >= -60) { if (rssi >= -50)
res = 5; //"Very good"; {
} else if (rssi < -60 && rssi >= -70) { res = 6; //"Excellent";
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; 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;
} }