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

Merge pull request #326 from IoTManagerProject/ver4dev

Browse Source 
добавляем ответ вебу о модулях на устройстве
This commit is contained in:
IoT Manager
2023-10-05 14:55:05 +02:00
committed by GitHub
parent 34b8227bec 6f863663b2
commit 649bceaca6
1 changed files with 388 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

769
src/WsServer.cpp
View File

@@ -4,449 +4,456 @@ 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, void webSocketEvent(uint8_t num, WStype_t type, uint8_t* payload,
size_t length) { size_t length) {
switch (type) { switch (type) {
case WStype_ERROR: { case WStype_ERROR: {
Serial.printf("[%u] Error!\n", num); Serial.printf("[%u] Error!\n", num);
} break; } 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,
sendStringToWs("params", params, num); // "Connected");
} break;
// генерация события подключения в модулях case WStype_TEXT: {
for (std::list<IoTItem*>::iterator it = IoTItems.begin(); bool endOfHeaderFound = false;
it != IoTItems.end(); ++it) { size_t maxAllowedHeaderSize =
if ((*it)->iAmLocal) (*it)->onMqttWsAppConnectEvent(); 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 == "/charts|") { // Страница веб интерфейса dashboard
// обращение к логированию из ядра //----------------------------------------------------------------------//
// отправка данных графиков только в выбранный сокет
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 == "/|") {
//----------------------------------------------------------------------// sendFileToWsByFrames("/layout.json", "layout", "", num,
WEB_SOCKETS_FRAME_SIZE);
}
// отвечаем данными на запрос страницы if (headerStr == "/params|") {
if (headerStr == "/config|") { // публикация всех статус сообщений при подключении svelte приложения
sendFileToWsByFrames("/items.json", "itemsj", "", num, String params = "{}";
WEB_SOCKETS_FRAME_SIZE); for (std::list<IoTItem*>::iterator it = IoTItems.begin();
sendFileToWsByFrames("/widgets.json", "widget", "", num, it != IoTItems.end(); ++it) {
WEB_SOCKETS_FRAME_SIZE); if ((*it)->getSubtype() != "Loging") {
sendFileToWsByFrames("/config.json", "config", "", num, if ((*it)->getSubtype() != "LogingDaily") {
WEB_SOCKETS_FRAME_SIZE); if ((*it)->iAmLocal)
sendFileToWsByFrames("/scenario.txt", "scenar", "", num, jsonWriteStr(params, (*it)->getID(), (*it)->getValue());
WEB_SOCKETS_FRAME_SIZE); }
sendStringToWs("settin", settingsFlashJson, num); }
} }
sendStringToWs("params", params, num);
// обработка кнопки сохранить // генерация события подключения в модулях
if (headerStr == "/gifnoc|") { for (std::list<IoTItem*>::iterator it = IoTItems.begin();
writeFileUint8tByFrames("config.json", payload, length, headerLenth, it != IoTItems.end(); ++it) {
256); if ((*it)->iAmLocal) (*it)->onMqttWsAppConnectEvent();
} }
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 == "/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 == "/connection|") { // Страница веб интерфейса configutation
sendStringToWs("settin", settingsFlashJson, num); //----------------------------------------------------------------------//
sendStringToWs("ssidli", ssidListHeapJson, num);
sendStringToWs("errors", errorsHeapJson, num);
// запуск асинхронного сканирования wifi сетей при переходе на страницу
// соединений RouterFind(jsonReadStr(settingsFlashJson,
// F("routerssid")));
}
// обработка кнопки сохранить settings.json // отвечаем данными на запрос страницы
if (headerStr == "/sgnittes|") { if (headerStr == "/config|") {
writeUint8tToString(payload, length, headerLenth, settingsFlashJson); sendFileToWsByFrames("/items.json", "itemsj", "", num,
writeFileUint8tByFrames("settings.json", payload, length, headerLenth, WEB_SOCKETS_FRAME_SIZE);
256); sendFileToWsByFrames("/widgets.json", "widget", "", num,
sendStringToWs("errors", errorsHeapJson, num); WEB_SOCKETS_FRAME_SIZE);
// если не было создано приема данных по udp - то создадим его sendFileToWsByFrames("/config.json", "config", "", num,
addThisDeviceToList(); WEB_SOCKETS_FRAME_SIZE);
} sendFileToWsByFrames("/scenario.txt", "scenar", "", num,
WEB_SOCKETS_FRAME_SIZE);
sendStringToWs("settin", settingsFlashJson, num);
}
// обработка кнопки сохранить настройки mqtt // обработка кнопки сохранить
if (headerStr == "/mqtt|") { if (headerStr == "/gifnoc|") {
sendStringToWs("settin", settingsFlashJson, writeFileUint8tByFrames("config.json", payload, length, headerLenth,
num); // отправляем в ответ новые полученные настройки 256);
handleMqttStatus(false, 8); // меняем статус на неопределенный }
mqttReconnect(); // начинаем переподключение if (headerStr == "/tuoyal|") {
sendStringToWs("errors", errorsHeapJson, writeFileUint8tByFrames("layout.json", payload, length, headerLenth,
num); // отправляем что статус неопределен 256);
sendStringToWs("ssidli", ssidListHeapJson, num); }
} if (headerStr == "/oiranecs|") {
writeFileUint8tByFrames("scenario.txt", payload, length, headerLenth,
256);
clearConfigure();
configure("/config.json");
iotScen.loadScenario("/scenario.txt");
// создаем событие завершения конфигурирования для возможности
// выполнения блока кода при загрузке
createItemFromNet("onStart", "1", 1);
}
// запуск асинхронного сканирования wifi сетей при нажатии выпадающего //----------------------------------------------------------------------//
// списка // Страница веб интерфейса connection
if (headerStr == "/scan|") { //----------------------------------------------------------------------//
std::vector<String> jArray;
jsonReadArray(settingsFlashJson, "routerssid", jArray);
RouterFind(jArray);
sendStringToWs("ssidli", ssidListHeapJson, num);
}
//----------------------------------------------------------------------// // отвечаем данными на запрос страницы
// Страница веб интерфейса list if (headerStr == "/connection|") {
//----------------------------------------------------------------------// sendStringToWs("settin", settingsFlashJson, num);
sendStringToWs("ssidli", ssidListHeapJson, num);
sendStringToWs("errors", errorsHeapJson, num);
// запуск асинхронного сканирования wifi сетей при переходе на страницу
// соединений RouterFind(jsonReadStr(settingsFlashJson,
// F("routerssid")));
}
// отвечаем данными на запрос страницы list // обработка кнопки сохранить settings.json
if (headerStr == "/list|") { if (headerStr == "/sgnittes|") {
sendStringToWs("settin", settingsFlashJson, num); writeUint8tToString(payload, length, headerLenth, settingsFlashJson);
// отправим список устройств в зависимости от того что выбрал user writeFileUint8tByFrames("settings.json", payload, length, headerLenth,
// sendDeviceList(num); 256);
} sendStringToWs("errors", errorsHeapJson, num);
// если не было создано приема данных по udp - то создадим его
addThisDeviceToList();
}
// отвечаем на запрос списка устройств (это отдельный запрос который // обработка кнопки сохранить настройки mqtt
// делает приложение при подключении) if (headerStr == "/mqtt|") {
if (headerStr == "/devlist|") { sendStringToWs("settin", settingsFlashJson,
// отправим список устройств в зависимости от того что выбрал user num); // отправляем в ответ новые полученные настройки
sendDeviceList(num); handleMqttStatus(false, 8); // меняем статус на неопределенный
} mqttReconnect(); // начинаем переподключение
sendStringToWs("errors", errorsHeapJson,
num); // отправляем что статус неопределен
sendStringToWs("ssidli", ssidListHeapJson, num);
}
// сохраняем данные листа // запуск асинхронного сканирования wifi сетей при нажатии выпадающего
if (headerStr == "/tsil|") { // списка
writeFileUint8tByFrames("devlist.json", payload, length, headerLenth, if (headerStr == "/scan|") {
256); std::vector<String> jArray;
} jsonReadArray(settingsFlashJson, "routerssid", jArray);
RouterFind(jArray);
sendStringToWs("ssidli", ssidListHeapJson, num);
}
//----------------------------------------------------------------------// //----------------------------------------------------------------------//
// Страница веб интерфейса system // Страница веб интерфейса list
//----------------------------------------------------------------------// //----------------------------------------------------------------------//
// отвечаем данными на запрос страницы // отвечаем данными на запрос страницы list
if (headerStr == "/system|") { if (headerStr == "/list|") {
sendStringToWs("errors", errorsHeapJson, num); sendStringToWs("settin", settingsFlashJson, num);
sendStringToWs("settin", settingsFlashJson, num); // отправим список устройств в зависимости от того что выбрал user
} // sendDeviceList(num);
}
//----------------------------------------------------------------------// // отвечаем на запрос списка устройств (это отдельный запрос который
// Страница веб интерфейса dev // делает приложение при подключении)
//----------------------------------------------------------------------// if (headerStr == "/devlist|") {
if (headerStr == "/dev|") { // отправим список устройств в зависимости от того что выбрал user
sendStringToWs("errors", errorsHeapJson, num); sendDeviceList(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 == "/rorre|") { if (headerStr == "/system|") {
writeUint8tValueToJsonString(payload, length, headerLenth, sendStringToWs("errors", errorsHeapJson, num);
errorsHeapJson); sendStringToWs("settin", settingsFlashJson, num);
} }
// команда перезагрузки esp //----------------------------------------------------------------------//
if (headerStr == "/reboot|") { // Страница веб интерфейса dev
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);
}
// команда очистки всех логов esp //----------------------------------------------------------------------//
if (headerStr == "/clean|") { // Страница веб интерфейса update
cleanLogs(); //----------------------------------------------------------------------//
} if (headerStr == "/profile|") {
sendFileToWsByFrames("/myProfile.json", "prfile", "", num,
WEB_SOCKETS_FRAME_SIZE);
}
// команда обновления прошивки esp //----------------------------------------------------------------------//
if (headerStr == "/update|") { // отдельные команды веб интерфейса
upgrade_firmware(3); //----------------------------------------------------------------------//
}
// Прием команд control c dashboard // переписать любое поле в errors json
if (headerStr == "/control|") { if (headerStr == "/rorre|") {
String msg; writeUint8tValueToJsonString(payload, length, headerLenth,
writeUint8tToString(payload, length, headerLenth, msg); errorsHeapJson);
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|") { // команда перезагрузки esp
standWebSocket.sendTXT(num, "/tstr|"); if (headerStr == "/reboot|") {
} ESP.restart();
}
// получаем команду посланную из модуля // команда очистки всех логов esp
if (headerStr == "/order|") { if (headerStr == "/clean|") {
String json; cleanLogs();
writeUint8tToString(payload, length, headerLenth, json); }
String id, key, value; // команда обновления прошивки esp
jsonRead(json, "id", id); if (headerStr == "/update|") {
jsonRead(json, "key", key); upgrade_firmware(3);
jsonRead(json, "value", value); }
SerialPrint("i", F("=>WS"), "Msg from module, id: " + id); // Прием команд 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);
}
for (std::list<IoTItem*>::iterator it = IoTItems.begin(); if (headerStr == "/tst|") {
it != IoTItems.end(); ++it) { standWebSocket.sendTXT(num, "/tstr|");
if ((*it)->getID() == id) { }
(*it)->onModuleOrder(key, value);
}
}
}
} break; // получаем команду посланную из модуля
if (headerStr == "/order|") {
String json;
writeUint8tToString(payload, length, headerLenth, json);
case WStype_BIN: { String id, key, value;
Serial.printf("[%u] get binary length: %u\n", num, length); jsonRead(json, "id", id);
// hexdump(payload, length); jsonRead(json, "key", key);
// standWebSocket.sendBIN(num, payload, length); jsonRead(json, "value", value);
} break;
case WStype_FRAGMENT_TEXT_START: { SerialPrint("i", F("=>WS"), "Msg from module, id: " + id);
Serial.printf("[%u] fragment test start: %u\n", num, length);
} break;
case WStype_FRAGMENT_BIN_START: { for (std::list<IoTItem*>::iterator it = IoTItems.begin();
Serial.printf("[%u] fragment bin start: %u\n", num, length); it != IoTItems.end(); ++it) {
} break; if ((*it)->getID() == id) {
(*it)->onModuleOrder(key, value);
}
}
}
case WStype_FRAGMENT: { } break;
Serial.printf("[%u] fragment: %u\n", num, length);
} break;
case WStype_FRAGMENT_FIN: { case WStype_BIN: {
Serial.printf("[%u] fragment finish: %u\n", num, length); Serial.printf("[%u] get binary length: %u\n", num, length);
} break; // hexdump(payload, length);
// standWebSocket.sendBIN(num, payload, length);
} break;
case WStype_PING: { case WStype_FRAGMENT_TEXT_START: {
Serial.printf("[%u] ping: %u\n", num, length); Serial.printf("[%u] fragment test start: %u\n", num, length);
} break; } break;
case WStype_PONG: { case WStype_FRAGMENT_BIN_START: {
Serial.printf("[%u] pong: %u\n", num, length); Serial.printf("[%u] fragment bin start: %u\n", num, length);
} break; } break;
default: { Serial.printf("[%u] not recognized: %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_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, Serial.printf("\n[HEXDUMP] Address: 0x%08X len: 0x%X (%d)", (ptrdiff_t)src,
len, len); len, len);
for (uint32_t i = 0; i < len; i++) { for (uint32_t i = 0; i < len; i++) {
if (i % cols == 0) { if (i % cols == 0) {
Serial.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i); Serial.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i);
}
Serial.printf("%02X ", *src);
src++;
} }
Serial.printf("%02X ", *src); Serial.printf("\n");
src++;
}
Serial.printf("\n");
} }
#endif #endif
#endif #endif
void sendFileToWsByFrames(const String& filename, const String& header, void sendFileToWsByFrames(const String& filename, const String& header,
const String& json, int client_id, size_t frameSize) { const String& json, int client_id, size_t frameSize) {
if (header.length() != 6) { if (header.length() != 6) {
SerialPrint("E", "FS", F("wrong header size")); SerialPrint("E", "FS", F("wrong header size"));
return; 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];
} }
size_t payloadSize = file.read(payloadBuf, maxPayloadSize); auto path = filepath(filename);
if (payloadSize) { auto file = FileFS.open(path, "r");
size_t size = headerSize + payloadSize; if (!file) {
SerialPrint("E", "FS", F("reed file error"));
bool fin = false; return;
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();
payloadBuf = &frameBuf[0]; // Serial.println("Send file '" + String(filename) + "', file size: " +
delete[] payloadBuf; // String(totalSize));
file.close();
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];
}
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) {
@@ -474,16 +481,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) { 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, sendFileToWsByFrames("/devlist.json", "devlis", "", num,
WEB_SOCKETS_FRAME_SIZE); WEB_SOCKETS_FRAME_SIZE);
SerialPrint("i", "FS", "flash list"); SerialPrint("i", "FS", "flash list");
} }
} }
int getNumWSClients() { int getNumWSClients() {