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 pull request #22 from IoTManagerProject/ver4dev

Browse Source 
Ver4dev
This commit is contained in:
Mit4el
2023-10-11 23:34:59 +03:00
committed by GitHub
parent 0afb996af0 7a0710e946
commit 59d7821040
24 changed files with 748 additions and 569 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
src/UpgradeFirm.cpp
View File

@@ -4,6 +4,8 @@ updateFirm update;
void upgrade_firmware(int type, String path) {
putUserDataToRam();
// сбросим файл статуса последнего обновления
writeFile("ota.json", "{}");
// only build
if (type == 1) {
@@ -36,10 +38,10 @@ bool upgradeFS(String path) {
bool ret = false;
WiFiClient wifiClient;
SerialPrint("!!!", F("Update"), "Start upgrade FS... " + path);
handleUpdateStatus(true, UPDATE_FS_IN_PROGRESS);
if (path == "") {
SerialPrint("E", F("Update"), F("FS Path error"));
handleUpdateStatus(true, PATH_ERROR);
saveUpdeteStatus("fs", PATH_ERROR);
return ret;
}
#ifdef ESP8266
@@ -55,10 +57,10 @@ bool upgradeFS(String path) {
// если FS обновилась успешно
if (retFS == HTTP_UPDATE_OK) {
SerialPrint("!!!", F("Update"), F("FS upgrade done!"));
handleUpdateStatus(true, UPDATE_FS_COMPLETED);
saveUpdeteStatus("fs", UPDATE_COMPLETED);
ret = true;
} else {
handleUpdateStatus(true, UPDATE_FS_FAILED);
saveUpdeteStatus("fs", UPDATE_FAILED);
if (retFS == HTTP_UPDATE_FAILED) {
SerialPrint("E", F("Update"), "HTTP_UPDATE_FAILED");
} else if (retFS == HTTP_UPDATE_NO_UPDATES) {
@@ -72,10 +74,10 @@ bool upgradeBuild(String path) {
bool ret = false;
WiFiClient wifiClient;
SerialPrint("!!!", F("Update"), "Start upgrade BUILD... " + path);
handleUpdateStatus(true, UPDATE_BUILD_IN_PROGRESS);
if (path == "") {
SerialPrint("E", F("Update"), F("Build Path error"));
handleUpdateStatus(true, PATH_ERROR);
saveUpdeteStatus("build", PATH_ERROR);
return ret;
}
#if defined(esp8266_4mb) || defined(esp8266_16mb) || defined(esp8266_1mb) || defined(esp8266_1mb_ota) || defined(esp8266_2mb) || defined(esp8266_2mb_ota)
@@ -90,10 +92,10 @@ bool upgradeBuild(String path) {
// если BUILD обновился успешно
if (retBuild == HTTP_UPDATE_OK) {
SerialPrint("!!!", F("Update"), F("BUILD upgrade done!"));
handleUpdateStatus(true, UPDATE_BUILD_COMPLETED);
saveUpdeteStatus("build", UPDATE_COMPLETED);
ret = true;
} else {
handleUpdateStatus(true, UPDATE_BUILD_FAILED);
saveUpdeteStatus("build", UPDATE_FAILED);
if (retBuild == HTTP_UPDATE_FAILED) {
SerialPrint("E", F("Update"), "HTTP_UPDATE_FAILED");
} else if (retBuild == HTTP_UPDATE_NO_UPDATES) {
@@ -132,7 +134,7 @@ void putUserDataToRam() {
update.settingsFlashJson = readFile("settings.json", 4096);
update.layoutJson = readFile("layout.json", 4096);
update.scenarioTxt = readFile("scenario.txt", 4096);
update.chartsData = createDataBaseSting();
// update.chartsData = createDataBaseSting();
}
void saveUserDataToFlash() {
@@ -140,10 +142,13 @@ void saveUserDataToFlash() {
writeFile("/settings.json", update.settingsFlashJson);
writeFile("/layout.json", update.layoutJson);
writeFile("/scenario.txt", update.scenarioTxt);
writeDataBaseSting(update.chartsData);
// writeDataBaseSting(update.chartsData);
}
void handleUpdateStatus(bool send, int state) {
jsonWriteInt_(errorsHeapJson, F("upd"), state);
if (send) sendStringToWs("errors", errorsHeapJson, -1);
void saveUpdeteStatus(String key, int val) {
const String path = "ota.json";
String json = readFile(path, 1024);
if (json == "failed") json = "{}";
jsonWriteInt_(json, key, val);
writeFile(path, json);
}

594
src/WsServer.cpp
View File

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

4
src/modules/API.cpp
View File

@@ -3,7 +3,6 @@
void* getAPI_Cron(String subtype, String params);
void* getAPI_Loging(String subtype, String params);
void* getAPI_LogingDaily(String subtype, String params);
void* getAPI_owmWeather(String subtype, String params);
void* getAPI_Timer(String subtype, String params);
void* getAPI_Variable(String subtype, String params);
void* getAPI_VariableColor(String subtype, String params);
@@ -36,6 +35,7 @@ void* getAPI_Pcf8574(String subtype, String params);
void* getAPI_Pwm8266(String subtype, String params);
void* getAPI_TelegramLT(String subtype, String params);
void* getAPI_Lcd2004(String subtype, String params);
void* getAPI_Oled64(String subtype, String params);
void* getAPI_TM16XX(String subtype, String params);
void* getAPI(String subtype, String params) {
@@ -43,7 +43,6 @@ void* tmpAPI;
if ((tmpAPI = getAPI_Cron(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Loging(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_LogingDaily(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_owmWeather(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Timer(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Variable(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_VariableColor(subtype, params)) != nullptr) return tmpAPI;
@@ -76,6 +75,7 @@ if ((tmpAPI = getAPI_Pcf8574(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Pwm8266(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_TelegramLT(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Lcd2004(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Oled64(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_TM16XX(subtype, params)) != nullptr) return tmpAPI;
return nullptr;
}

29
src/modules/display/Lcd2004/Lcd2004.cpp
View File

@@ -2,7 +2,7 @@
#include "classes/IoTItem.h"
#include <RobotClass_LiquidCrystal_I2C.h>
RobotClass_LiquidCrystal_I2C *LCDI2C;
RobotClass_LiquidCrystal_I2C* LCDI2C;
class Lcd2004 : public IoTItem {
private:
@@ -12,7 +12,7 @@ class Lcd2004 : public IoTItem {
int _prevStrSize;
String _addr;
bool _isShow = true; // экран показывает
bool _isShow = true; // экран показывает
public:
Lcd2004(String parameters) : IoTItem(parameters) {
@@ -26,9 +26,9 @@ class Lcd2004 : public IoTItem {
}
jsonRead(parameters, "size", size);
int w = selectFromMarkerToMarker(size, ",", 0).toInt(); //количество столбцов
int h = selectFromMarkerToMarker(size, ",", 1).toInt(); //количество строк
if (LCDI2C == nullptr) { //инициализации экрана еще не было
int w = selectFromMarkerToMarker(size, ",", 0).toInt(); // количество столбцов
int h = selectFromMarkerToMarker(size, ",", 1).toInt(); // количество строк
if (LCDI2C == nullptr) { // инициализации экрана еще не было
LCDI2C = new RobotClass_LiquidCrystal_I2C(hexStringToUint8(_addr), w, h, CP_UTF8);
if (LCDI2C != nullptr) {
LCDI2C->init();
@@ -46,7 +46,7 @@ class Lcd2004 : public IoTItem {
jsonRead(parameters, "postfix", _postfix);
}
void drawItem(IoTItem* item) {
void drawItem(IoTItem* item) {
String tmpStr = _prefix;
tmpStr += item->getValue();
tmpStr += _postfix;
@@ -66,15 +66,18 @@ class Lcd2004 : public IoTItem {
}
void onRegEvent(IoTItem* eventItem) {
if (LCDI2C == nullptr) { scanI2C(); return;}
if (!eventItem || _id2show == "") return;
if (LCDI2C == nullptr) {
scanI2C();
return;
}
if (!eventItem || _id2show == "") return;
if (_id2show == eventItem->getID()) {
setValue(eventItem->value, false);
}
}
IoTValue execute(String command, std::vector<IoTValue> &param) {
IoTValue execute(String command, std::vector<IoTValue>& param) {
if (command == "noBacklight")
LCDI2C->noBacklight();
else if (command == "backlight")
@@ -89,7 +92,7 @@ class Lcd2004 : public IoTItem {
if (_isShow) {
LCDI2C->noDisplay();
_isShow = false;
} else {
} else {
LCDI2C->display();
_isShow = true;
}
@@ -119,7 +122,7 @@ class Lcd2004 : public IoTItem {
return {};
}
//печать пустой строки нужной длинны для затирания предыдущего значения на экране
// печать пустой строки нужной длинны для затирания предыдущего значения на экране
void printBlankStr(int strSize) {
String tmpStr = "";
for (int i = 0; i < strSize; i++) tmpStr += " ";
@@ -127,13 +130,13 @@ class Lcd2004 : public IoTItem {
LCDI2C->print(tmpStr);
}
~Lcd2004(){
~Lcd2004() {
if (LCDI2C) delete LCDI2C;
LCDI2C = nullptr;
};
};
void *getAPI_Lcd2004(String subtype, String param) {
void* getAPI_Lcd2004(String subtype, String param) {
if (subtype == F("Lcd2004")) {
return new Lcd2004(param);
} else {

134
src/modules/display/Oled64/Oled64.cpp Normal file
View File

@@ -0,0 +1,134 @@
#include "Global.h"
#include "classes/IoTItem.h"
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 0
Adafruit_SSD1306 display(OLED_RESET);
class Oled64 : public IoTItem {
private:
unsigned int _x;
unsigned int _y;
String _id2show, _prefix = "", _postfix = "";
String _size = "1";
String _addr;
int _prevStrSize;
bool _isShow = true;
public:
Oled64(String parameters) : IoTItem(parameters) {
String size, xy;
_prevStrSize = 0;
jsonRead(parameters, "addr", _addr);
if (_addr == "") {
scanI2C();
return;
}
display.begin(SSD1306_SWITCHCAPVCC, hexStringToUint8(_addr));
display.display();
display.clearDisplay();
jsonRead(parameters, "coord", xy);
_x = selectFromMarkerToMarker(xy, ",", 0).toInt();
_y = selectFromMarkerToMarker(xy, ",", 1).toInt();
jsonRead(parameters, "id2show", _id2show);
jsonRead(parameters, "prefix", _prefix);
jsonRead(parameters, "postfix", _postfix);
jsonRead(parameters, "size", _size);
}
void drawItem(IoTItem *item) {
String tmpStr = _prefix;
tmpStr += item->getValue();
tmpStr += _postfix;
display.setRotation(0);
display.setCursor(_x, _y);
display.setTextColor(WHITE, BLACK);
display.setTextSize(_size.toInt());
printBlankStr(_prevStrSize);
display.setCursor(_x, _y);
display.print(tmpStr);
_prevStrSize = tmpStr.length();
display.display();
_prevStrSize = tmpStr.length();
}
void setValue(const IoTValue &Value, bool genEvent = true) {
value = Value;
drawItem(this);
IoTItem::setValue(Value, genEvent);
}
void onRegEvent(IoTItem *eventItem) {
if (!eventItem || _id2show == "") return;
if (_id2show == eventItem->getID()) {
setValue(eventItem->value, false);
}
}
IoTValue execute(String command, std::vector<IoTValue> &param) {
if (command == "display") {
_isShow = true;
} else if (command == "noDisplay") {
_isShow = false;
} else if (command == "x") {
if (param.size()) {
_x = param[0].valD;
}
} else if (command == "y") {
if (param.size()) {
_y = param[0].valD;
}
} else if (command == "prefix") {
if (param.size()) {
_prefix = param[0].valS;
}
} else if (command == "postfix") {
if (param.size()) {
_postfix = param[0].valS;
}
} else if (command == "id2show") {
if (param.size()) {
_id2show = param[0].valS;
}
}
doByInterval();
return {};
}
// печать пустой строки нужной длинны для затирания предыдущего значения на экране
void printBlankStr(int strSize) {
String tmpStr = "";
for (int i = 0; i < strSize; i++) tmpStr += " ";
display.setCursor(_x, _y);
display.print(tmpStr);
}
~Oled64(){};
};
void *getAPI_Oled64(String subtype, String param) {
if (subtype == F("Oled64")) {
return new Oled64(param);
} else {
return nullptr;
}
}

97
src/modules/display/Oled64/modinfo.json Normal file
View File

@@ -0,0 +1,97 @@
{
"menuSection": "screens",
"configItem": [
{
"global": 0,
"name": "OLED экран 64 8266",
"type": "Reading",
"subtype": "Oled64",
"id": "Oled",
"widget": "inputTxt",
"page": "screens",
"descr": "OLED Экран",
"addr": "0x3C",
"coord": "0,0",
"size": "1",
"id2show": "",
"prefix": "",
"postfix": ""
}
],
"about": {
"authorName": "Serghei Crasnicov",
"authorContact": "https://t.me/Serghei63",
"authorGit": "https://github.com/Serghei63",
"specialThanks": "Valentin Khandriga @Valiuhaaa",
"moduleName": "Oled64",
"moduleVersion": "1.0",
"usedRam": {
"esp32_4mb": 15,
"esp8266_4mb": 15
},
"title": "Модуль отображения на экранах OLED 64*48",
"moduleDesc": "Позволяет выводить на OLED экраны по указанным позициям значения других элементов конфигурации.",
"propInfo": {
"addr": "Адрес устройства на шине, обычно 0x3C.",
"coord": "Координата позиции для вывода данных элемента конфигурации.",
"id2show": "id элемента конфигурации.",
"size": "Размер шрифта. Допускается 1, 2, 3, 4"
},
"funcInfo": [
{
"name": "x",
"descr": "Устанавливает первую координату",
"params": [
"Номер строки первого символа"
]
},
{
"name": "y",
"descr": "Устанавливает вторую координату",
"params": [
"Номер столбца первого символа"
]
},
{
"name": "descr",
"descr": "Задает приставку слева от значения",
"params": [
"Строка"
]
},
{
"name": "descr1",
"descr1": "Задает приставку справа от значения",
"params": [
"Строка"
]
},
{
"name": "id2show",
"descr": "Задает ИД элемента, значение которого хотим отображать на экране",
"params": [
"Имя элемента конфигурации"
]
}
]
},
"defActive": true,
"usedLibs": {
"esp32_4mb": [
"https://github.com/stblassitude/Adafruit_SSD1306_Wemos_OLED",
"https://github.com/adafruit/Adafruit-GFX-Library"
],
"esp8266_4mb": [
"https://github.com/stblassitude/Adafruit_SSD1306_Wemos_OLED",
"https://github.com/adafruit/Adafruit-GFX-Library"
],
"esp8266_1mb": [
"https://github.com/stblassitude/Adafruit_SSD1306_Wemos_OLED",
"https://github.com/adafruit/Adafruit-GFX-Library"
],
"esp8266_1mb_ota": [
"https://github.com/stblassitude/Adafruit_SSD1306_Wemos_OLED",
"https://github.com/adafruit/Adafruit-GFX-Library"
]
}
}

65
src/modules/exec/HttpGet/HttpGet.cpp
View File

@@ -1,18 +1,12 @@
#include "Global.h"
#include "classes/IoTItem.h"
class HttpGet : public IoTItem
{
public:
HttpGet(String parameters) : IoTItem(parameters)
{
}
void sendHttpPOST(String url, String msg)
{
if (isNetworkActive())
{
class HttpGet : public IoTItem {
public:
HttpGet(String parameters) : IoTItem(parameters) {}
void sendHttpPOST(String url, String msg) {
if (isNetworkActive()) {
WiFiClient client;
HTTPClient http;
http.begin(client, url);
@@ -23,26 +17,23 @@ public:
SerialPrint("<-", F("HttpPOST"), "URL: " + url + ", msg: " + msg);
SerialPrint("->", F("HttpPOST"), "URL: " + url + ", server: " + httpResponseCode);
if (httpResponseCode > 0)
{
if (httpResponseCode > 0) {
value.valS = payload;
value.isDecimal = false;
SerialPrint("->", F("HttpPOST"), "msg from server: " + (String)payload.c_str());
value.valS = payload;
regEvent(value.valS, "HttpGet");
}
http.end();
}
}
void sendHttpGET(String url)
{
void sendHttpGET(String url) {
WiFiClient client;
HTTPClient http;
#if defined ESP8266
if (!http.begin(client, url))
{
if (!http.begin(client, url)) {
#elif defined ESP32
if (!http.begin(url))
{
if (!http.begin(url)) {
#endif
SerialPrint("I", F("HttpGet"), "connection failed ");
@@ -52,31 +43,23 @@ public:
String payload = http.getString();
SerialPrint("<-", F("HttpGET"), "URL: " + url);
SerialPrint("->", F("HttpGET"), "URL: " + url + ", server: " + httpResponseCode);
if (httpResponseCode > 0)
{
if (httpResponseCode > 0) {
value.valS = payload;
value.isDecimal = false;
SerialPrint("->", F("HttpGET"), "msg from server: " + (String)payload.c_str());
value.valS = payload;
regEvent(value.valS, "HttpGet");
}
http.end();
}
IoTValue execute(String command, std::vector<IoTValue> &param)
{
if (param.size() > 0)
{
if (command == "get")
{
if (param.size())
{
IoTValue execute(String command, std::vector<IoTValue> &param) {
if (param.size() > 0) {
if (command == "get") {
if (param.size()) {
sendHttpGET(param[0].valS);
}
}
else if (command == "post")
{
if (param.size())
{
} else if (command == "post") {
if (param.size()) {
sendHttpPOST(param[0].valS, param[1].valS);
}
}
@@ -87,14 +70,10 @@ public:
~HttpGet(){};
};
void *getAPI_HttpGet(String subtype, String param)
{
if (subtype == F("HttpGet"))
{
void *getAPI_HttpGet(String subtype, String param) {
if (subtype == F("HttpGet")) {
return new HttpGet(param);
}
else
{
} else {
return nullptr;
}
}

20
src/modules/virtual/owmWeather/modinfo.json
View File

@@ -1,6 +1,5 @@
{
"menuSection": "virtual_elments",
"configItem": [
{
"global": 0,
@@ -24,7 +23,6 @@
"debug": 0
}
],
"about": {
"authorName": "Serghei Crasnicov, v2.0 Mikhail Bubnov",
"authorContact": "https://t.me/Serghei63",
@@ -60,24 +58,14 @@
"lon": "Долгота, при использовании координат, будет автоматически выбран ближайший город",
"lat": "Широта, при использовании координат, будет автоматически выбран ближайший город",
"lang": "Язык используемый в ответах OpenWetaherMap",
"debug":"1 - выводить дополнительный лог в сериал"
"debug": "1 - выводить дополнительный лог в сериал"
}
},
"defActive": true,
"defActive": false,
"usedLibs": {
"esp32_4mb": [],
"esp32_4mb3f": [],
"esp32s2_4mb": [],
"esp32_16mb": [],
"esp8266_4mb": [],
"esp8266_16mb": [],
"esp8266_1mb": [],
"esp8266_1mb_ota": [],
"esp8285_1mb": [],
"esp8285_1mb_ota": [],
"esp8266_2mb": [],
"esp8266_2mb_ota": []
"esp32_16mb": []
}
}
}

12
src/utils/FileUtils.cpp
View File

@@ -124,8 +124,8 @@ const String readFile(const String& filename, size_t max_size) {
size_t size = file.size();
if (size > max_size) {
file.close();
if (path == "/config.json")
return "[]";
// что это за бред!
if (path == "/config.json") return "[]";
return "large";
}
String temp = file.readString();
@@ -133,9 +133,7 @@ const String readFile(const String& filename, size_t max_size) {
return temp;
}
const String filepath(const String& filename) {
return filename.startsWith("/") ? filename : "/" + filename;
}
const String filepath(const String& filename) { return filename.startsWith("/") ? filename : "/" + filename; }
bool cutFile(const String& src, const String& dst) {
String srcPath = filepath(src);
@@ -288,9 +286,7 @@ String getFilesList(String& directory) {
}
#if defined(ESP8266)
bool getInfo(FSInfo& info) {
return FileFS.info(info);
}
bool getInfo(FSInfo& info) { return FileFS.info(info); }
// Информация о ФС
IoTFSInfo getFSInfo() {

23
src/utils/JsonUtils.cpp
View File

@@ -2,13 +2,9 @@
#include "utils/FileUtils.h"
// new================================================================================
String jsonReadStrDoc(DynamicJsonDocument &doc, String name) {
return doc[name].as<String>();
}
String jsonReadStrDoc(DynamicJsonDocument &doc, String name) { return doc[name].as<String>(); }
void jsonWriteStrDoc(DynamicJsonDocument &doc, String name, String value) {
doc[name] = value;
}
void jsonWriteStrDoc(DynamicJsonDocument &doc, String name, String value) { doc[name] = value; }
// new==============================================================================
bool jsonRead(const String &json, String key, long &value, bool e) {
@@ -114,21 +110,14 @@ bool jsonReadArray(const String &json, String key, std::vector<String> &jArray,
}
return false;
}
// SerialPrint("E", F("jsonReadArray"), key + " doc " + doc[key].as<String>());
if (doc[key].is<JsonArray>()) {
for (int8_t i = 0; i < doc[key].size(); i++)
jArray.push_back(doc[key][i].as<String>());
// SerialPrint("E", F("jsonReadArray"), "isArray"+key + " doc " + doc[key].as<String>());
for (int8_t i = 0; i < doc[key].size(); i++) jArray.push_back(doc[key][i].as<String>());
} else {
jArray.push_back(doc[key].as<String>());
// DynamicJsonDocument docArr(JSON_BUFFER_SIZE/5);
// jArray = doc[key].as<JsonArray>();
// String tmp = doc[key].as<String>();
// jArray.add("dsdsd");
// SerialPrint("E", F("jsonReadArray"), "notArray"+key + " doc " + doc[key].as<String>());
// SerialPrint("E", F("jsonReadArray"), "count: " + String(jArray.size()) +" key: " + key + " arr " + jArray[0]);
}
// SerialPrint("E", F("jsonReadArray"), "count: " + String(jArray.size()) +" key: " + key + " doc " + jArray[0].as<String>());
return true;
}