diff --git a/README.md b/README.md index 6a2a745c4..34f0c6355 100644 --- a/README.md +++ b/README.md @@ -1,40 +1,33 @@ # EMS-ESP version 2.0 -## **Breaking changes** - -- MQTT base has been removed. The hostname is only used -- refresh command renamed to fetch -- have to 'wifi reconnect' after changing wifi in console - ## **New Features in v2** -- A new web interface using React and TypeScript that's now secure as each URL endpoint is protected by issuing a JWT which is then sent using Bearer Authentication. Using a Captive Portal in AP mode or connecting to a local wifi network. +- Supports both ESP8266 and ESP32 +- New MQTT option to support Home Assistant MQTT Discovery (https://www.home-assistant.io/docs/mqtt/discovery/) +- A new web interface using React and TypeScript that's now secure as each URL endpoint is protected by issuing a JWT which is then sent using Bearer Authentication. +- In the Access Point mode there is a web Captive Portal -- A new console. Like in version 1.9 it works with both Serial and Telnet but with a more intuitive Linux shell like behavior. It supports multiple connections and has basic security to prevent any changes to EMS-ESP. A full list of commands is below, here are the key ones: - * `help` lists the commands and keywords - * some commands take you into a new context, a bit like a sub-menu. e.g. `system`, `thermostat`. Use `help` to show which commands this context has and `exit` or CTRL-D to get back to the root. - * To change a setting use the `set` command. Typing `set` shows the current settings. - * `show` shows the data specific to the which context you're in. - * `su` to switch to Admin which enables more commands such as most of the `set` commands. The default password is "ems-esp-neo" which can be changed with `passwd` from the system menu. When in Admin mode the command prompt switches from `$` to `#`. - * `log` sets the logging level. `log off` disables logging. Use `log debug` for debugging commands and actions. - * `watch` will output the incoming Rx telegrams to the console. You can also show these in its 'raw' data format and also watch a particular ID. - * CTRL-D to exit, CTRL-U to remove line, TAB to auto-complete +- A new console. As in version 1.9 it works with both Serial and Telnet but now with a more intuitive Linux shell like behavior. It supports multiple connections and has basic security to prevent any changes to EMS-ESP. A full list of commands is below, here are the key ones: + * `help` lists the commands and keywords. This works in each context. + * `exit` will exit the console or exit the current context. CTRL-D does the same. + * `CTRL-U` for Undo + * `TAB` for auto-complete + * Some specific commands are behind contexts. Think of this as a sub-menu. e.g. `system`, `thermostat`. The path will always show you which context you are in. `$` is the root. + * `su` will switch to super-user or Admin. The default password is "ems-esp-neo" and can be changed with `passwd` from the system menu or via the Web UI (called secret password). When in Admin mode the command prompt switches from `$` to `#`. + * Some settings can be changed in the console. The `set` command will list them. + * `show` shows the data specific to the which context you're in. From the root it will show you all the EMS device information and any external temperature sensors. From a context it will be more specific to that context, e.g. `show mqtt` from `system` will list MQTT subscriptions and show the status and queue. + * `log` sets the logging level. `log off` disables logging. Use `log debug` for debugging commands and actions. This will be reset next time the console is opened. + * `watch` will output the incoming Rx telegrams directly to the console. You can also put on a watch on a specific EMS device ID or telegram ID. Also choose to output as verbose text or raw data bytes. these in its 'raw' data format and also watch a particular ID. -- There is no "serial mode" anymore like with version 1.9. When the Wifi cannot connect to the SSID it will automatically enter a "safe" mode where the Serial console is activated automatically (baud 115200). Note Serial is always available on the ESP32 because it has multiple UARTs. +- There is no "serial mode" anymore like with version 1.9. When the Wifi cannot connect to the SSID it will automatically enter a "safe" mode where the Serial console is automatically activated (note Serial is always available on the ESP32 because it has multiple UARTs). The EMS-ESP will blink fast when in Serial mode. Connect via a USB with baud 115200 to see the serial console. Note in this mode the EMS will be disconnect so there will be no incoming traffic. Use only for debugging or changing settings. - The onboard LED behaves like in 1.9. A solid LED means good connection and EMS data is coming in. A slow pulse means either the WiFi or the EMS bus is not connected yet. A very fast pulse is when the system is booting up and configuring itself, which typically takes 5 seconds. -- Built to work with both EMS8266 and ESP32 - -- Extended MQTT to use MQTT discovery on Home Assistant. - -- For debugging there is an offline mode where the code can be compiled and executed standalone without uploading to an ESP controller. Use `make` (based off GNUMakefile). - ## **Uploading the firmware** - If you're not using PlatformIO, use the command-line and Python. You can download Python from https://www.python.org/downloads/. Make sure you also get: @@ -44,18 +37,24 @@ - Grab the latest firmware binary from https://github.com/proddy/EMS-ESP/releases/tag/travis-v2-build - Uploading directly via USB. - For ESP8266: `esptool.py -p -b 115200 write_flash 0x00000 ` + For ESP8266: `esptool.py -p -b 921600 write_flash 0x00000 ` + note: if this fails try a lower speed like `115200` instead of `921600`. For ESP32: `esptool.py --chip esp32 --port "COM6" --baud 921600 --before default_reset --after hard_reset write_flash -z --flash_mode dio --flash_freq 40m --flash_size detect 0x1000 XX\.platformio\packages\framework-arduinoespressif32\tools\sdk\bin\bootloader_dio_40m.bin 0x8000 XX\.pio\build\esp32\partitions.bin 0xe000 XX\.platformio\packages\framework-arduinoespressif32\tools\partitions\boot_app0.bin 0x10000 ` - Uploading over WiFi: `espota.py --debug --progress --port 8266 --auth ems-esp-neo -i -f ` ## **Setting EMS-ESP up for the first time** - - Connect to the Access Point called ems-esp using the WPA password `ems-esp-neo`. When you see the captive portal sign-in with username `admin` and password `admin`. Set the WiFi credentials and restart the ESP. - - When it connects to your wifi network you can use either the Web UI to further configure the other settings or using Telnet. If using the Telnet console refer to the full set of commands below. To change any settings you need to be admin which can be accessed via the `su` command. The password here is the same as the JWT secret from the Web UI, default `ems-esp-neo`. - - First thing to check is if Tx is working. Use `show ems` and if you have a large number of Tx fails try changing the Tx Mode using `set tx_mode` as admin. Typical values are 1 for EMS1.0, 2 for EMS2.0/EMS+ and 3 for Heatronics. + - Connect to the Access Point called ems-esp using the WPA password `ems-esp-neo`. When you see the captive portal sign-in with username `admin` and password `admin`. Set the WiFi credentials and go back to http://ems-esp + - First thing to check is if Tx is working and that you have a connect to the EMS bus. If it's showing an error try changing the Tx Mode from the settings page. Then check the Status (no need to restart EMS-ESP). -## **List of console commands** +## **The Console** + +Connecting to the console will give you more insight into the EMS bus traffic, MQTT queues and the actual device information. The console is reachable via Telnet (port 22) or via the Serial port if using an USB (on baud 115200). To change any settings in the console you must be admin (use `su` with the default password `ems-esp-neo`). On an ESP8266 the Serial port is disabled by default unless it's unable to connect to the WiFi. + +The `call` command is to execute a command. The command names (`[cmd]`) are the same as the MQTT command listed in the next section. + +(* = available in su/Admin mode) ``` common commands available in all contexts: @@ -66,59 +65,55 @@ common commands available in all contexts: su (from the root) - set - fetch - system (enters a context) - boiler (enters a context) - thermostat (enters a context) - scan devices [deep] - send telegram <"XX XX ..."> - set bus_id - set tx_mode - show - show devices - show ems - show values + system (enters a context) + boiler (enters a context) + thermostat (enters a context) + set + fetch + scan devices [deep] * + send telegram <"XX XX ..."> * + set bus_id * + set tx_mode * + show + show devices + show ems + show values + show mqtt system - set - show - show mqtt - show users - passwd - restart - set wifi hostname - set wifi password - set wifi ssid - wifi reconnect + set + show + format * + show users * + passwd * + restart * + set wifi hostname * + set wifi password * + set wifi ssid * + wifi reconnect * + pin [data] * boiler - comfort - flowtemp - wwactive - wwcirculation - wwonetime - wwtemp - read - maxpower <%> - minpower <%> + read * + call [cmd] [data] * thermostat - set - set master [device ID] - mode [heating circuit] - temp [heating circuit] - read + set + set master [device ID] * + read * + call [cmd] [data] [heating circuit] * + ``` ---------- -### **mqtt commands** +## **MQTT commands** + +Breaking change: The MQTT base has been removed in version 2. The hostname is only used as prefixed to the topic, e.g. `ems-esp/status`. + +All commands must be written as `{"cmd": ,"data":, "id":}`. + +The `id` can be replaced with `hc` for some devices and represented as a string or a number. `cmd` is a string, `data` can be a string or number. -commands can be written as `{"cmd": ,"data": }` or direct. -To set thermostat commands depending on heatingcircuits add `"hc": ` or nest the command. Without `"hc":` the first ative heatingcircuit is set. -These commands are equivalent: -`{"hc":2,"cmd":"daytemp","data":21}` or `{"hc":2,"daytemp":21}`or `{"hc2"{"daytemp":21}}` -In direct commands it's possible to combine commands, i.e. `{"hc1":{"daytemp":21,"nighttemp":17},"hc2":{"daytemp":20}}` ``` *boiler_cmd* comfort @@ -159,35 +154,19 @@ In direct commands it's possible to combine commands, i.e. `{"hc1":{"daytemp":21 holiday date -*cmd* +*system_cmd* send <"0B XX XX .."> - D0 <0 | 1> - D1 <0 | 1> - D2 <0 | 1> - D3 <0 | 1> + pin ``` -### **Basic Design Principles** +## **Basic Design Principles** - The core services like telnet, logging and shell are based off the libraries from @nomis. I also adopted his general design pattens such as making everything as asynchronous as possible so that no one operation should starve another operation of it's time to execute (https://isocpp.org/wiki/faq/ctors#static-init-order). - All EMS devices (e.g. boiler, thermostat, solar modules, mixing units etc) are derived from a factory base class and each class handles its own registering of telegram and mqtt handlers. This makes the EMS device code easier to manage and we can extend with new telegrams types and features. +- For debugging there is an offline mode where the code can be compiled and executed standalone without uploading to an ESP controller. Use `make` (based off GNUMakefile). -### **Things to tidy up in code later** - -- Replace vectors of class objects with shared pointers and use emplace_back since it instantiates during construction. It may have a performance gain. -- Add real unit tests using platformio's [pio-remote](https://docs.platformio.org/en/latest/plus/pio-remote.html) test bed. -- See if it's easier to use timers instead of millis() based timers, using [polledTimeout](https://github.com/esp8266/Arduino/blob/master/libraries/esp8266/examples/BlinkPolledTimeout/BlinkPolledTimeout.ino). -- Port over to ESP-IDF. The Arduino SDK is showing its limitations - -### **Features to add** - -- Multi-language. German, Dutch, French -- Click on a device in the Web UI shows it's details -- Publish time can be customized per device (solar, mixing etc) -- add homeassistant mqtt discovery for Boiler as well - -### **Customizing the Web UI** +## **Customizing the Web UI** The Web is based off Rick's awesome [esp8266-react](https://github.com/rjwats/esp8266-react/) framework. These are the files that are modified: @@ -247,10 +226,5 @@ The Web is based off Rick's awesome [esp8266-react](https://github.com/rjwats/es * `factory_settings.ini` modified with `ems-esp-neo` as password and `ems-esp` everywhere else - UI customization links: - - * icons: https://material-ui.com/components/material-icons/ - * colors: https://material-ui.com/customization/color/ - * tables: https://material-ui.com/components/tables/#dense-table diff --git a/interface/src/project/EMSESPDevicesForm.tsx b/interface/src/project/EMSESPDevicesForm.tsx index 50673747e..2a59dae19 100644 --- a/interface/src/project/EMSESPDevicesForm.tsx +++ b/interface/src/project/EMSESPDevicesForm.tsx @@ -173,7 +173,7 @@ class EMSESPDevicesForm extends Component - No external temperature sensors detected. + No external temperature sensors detected. ) diff --git a/interface/src/project/EMSESPSettingsController.tsx b/interface/src/project/EMSESPSettingsController.tsx index acb7249f9..306555cca 100644 --- a/interface/src/project/EMSESPSettingsController.tsx +++ b/interface/src/project/EMSESPSettingsController.tsx @@ -63,6 +63,19 @@ function EMSESPSettingsControllerForm(props: EMSESPSettingsControllerFormProps) onChange={handleValueChange('tx_mode')} margin="normal" /> + + Service Key (0x0B) + Modem (0x0D) + Terminal (0x0A) + Time Module (0x0F) + Alarm Module (0x12) + { +import { withAuthenticatedContext, AuthenticatedContextProps } from '../authentication'; + +type ProjectProps = AuthenticatedContextProps & RouteComponentProps; + +class ProjectMenu extends Component { render() { + const { authenticatedContext } = this.props; const path = this.props.match.url; return ( - + - + - + ); } } -export default withRouter(ProjectMenu); +export default withRouter(withAuthenticatedContext(ProjectMenu)); diff --git a/interface/src/project/ProjectRouting.tsx b/interface/src/project/ProjectRouting.tsx index a4b157293..b5cb21a22 100644 --- a/interface/src/project/ProjectRouting.tsx +++ b/interface/src/project/ProjectRouting.tsx @@ -20,7 +20,7 @@ class ProjectRouting extends Component { * The "to" property must match one of the routes above for this to work correctly. */ } - + ) } diff --git a/lib/ESPAsyncWebServer/AsyncEventSource.cpp b/lib/ESPAsyncWebServer/AsyncEventSource.cpp new file mode 100644 index 000000000..8230f0ebc --- /dev/null +++ b/lib/ESPAsyncWebServer/AsyncEventSource.cpp @@ -0,0 +1,369 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "Arduino.h" +#include "AsyncEventSource.h" + +static String generateEventMessage(const char *message, const char *event, uint32_t id, uint32_t reconnect){ + String ev; + + if(reconnect){ + ev += F("retry: "); + ev += reconnect; + ev += F("\r\n"); + } + + if(id){ + ev += F("id: "); + ev += String(id); + ev += F("\r\n"); + } + + if(event != NULL){ + ev += F("event: "); + ev += String(event); + ev += F("\r\n"); + } + + if(message != NULL){ + size_t messageLen = strlen(message); + char * lineStart = (char *)message; + char * lineEnd; + do { + char * nextN = strchr(lineStart, '\n'); + char * nextR = strchr(lineStart, '\r'); + if(nextN == NULL && nextR == NULL){ + size_t llen = ((char *)message + messageLen) - lineStart; + char * ldata = (char *)malloc(llen+1); + if(ldata != NULL){ + memcpy(ldata, lineStart, llen); + ldata[llen] = 0; + ev += F("data: "); + ev += ldata; + ev += F("\r\n\r\n"); + free(ldata); + } + lineStart = (char *)message + messageLen; + } else { + char * nextLine = NULL; + if(nextN != NULL && nextR != NULL){ + if(nextR < nextN){ + lineEnd = nextR; + if(nextN == (nextR + 1)) + nextLine = nextN + 1; + else + nextLine = nextR + 1; + } else { + lineEnd = nextN; + if(nextR == (nextN + 1)) + nextLine = nextR + 1; + else + nextLine = nextN + 1; + } + } else if(nextN != NULL){ + lineEnd = nextN; + nextLine = nextN + 1; + } else { + lineEnd = nextR; + nextLine = nextR + 1; + } + + size_t llen = lineEnd - lineStart; + char * ldata = (char *)malloc(llen+1); + if(ldata != NULL){ + memcpy(ldata, lineStart, llen); + ldata[llen] = 0; + ev += F("data: "); + ev += ldata; + ev += F("\r\n"); + free(ldata); + } + lineStart = nextLine; + if(lineStart == ((char *)message + messageLen)) + ev += F("\r\n"); + } + } while(lineStart < ((char *)message + messageLen)); + } + + return ev; +} + +// Message + +AsyncEventSourceMessage::AsyncEventSourceMessage(const char * data, size_t len) +: _data(nullptr), _len(len), _sent(0), _acked(0) +{ + _data = (uint8_t*)malloc(_len+1); + if(_data == nullptr){ + _len = 0; + } else { + memcpy(_data, data, len); + _data[_len] = 0; + } +} + +AsyncEventSourceMessage::~AsyncEventSourceMessage() { + if(_data != NULL) + free(_data); +} + +size_t AsyncEventSourceMessage::ack(size_t len, uint32_t time) { + (void)time; + // If the whole message is now acked... + if(_acked + len > _len){ + // Return the number of extra bytes acked (they will be carried on to the next message) + const size_t extra = _acked + len - _len; + _acked = _len; + return extra; + } + // Return that no extra bytes left. + _acked += len; + return 0; +} + +size_t AsyncEventSourceMessage::send(AsyncClient *client) { + const size_t len = _len - _sent; + if(client->space() < len){ + return 0; + } + size_t sent = client->add((const char *)_data, len); + if(client->canSend()) + client->send(); + _sent += sent; + return sent; +} + +// Client + +AsyncEventSourceClient::AsyncEventSourceClient(AsyncWebServerRequest *request, AsyncEventSource *server) +: _messageQueue(LinkedList([](AsyncEventSourceMessage *m){ delete m; })) +{ + _client = request->client(); + _server = server; + _lastId = 0; + if(request->hasHeader(F("Last-Event-ID"))) + _lastId = atoi(request->getHeader(F("Last-Event-ID"))->value().c_str()); + + _client->setRxTimeout(0); + _client->onError(NULL, NULL); + _client->onAck([](void *r, AsyncClient* c, size_t len, uint32_t time){ (void)c; ((AsyncEventSourceClient*)(r))->_onAck(len, time); }, this); + _client->onPoll([](void *r, AsyncClient* c){ (void)c; ((AsyncEventSourceClient*)(r))->_onPoll(); }, this); + _client->onData(NULL, NULL); + _client->onTimeout([this](void *r, AsyncClient* c __attribute__((unused)), uint32_t time){ ((AsyncEventSourceClient*)(r))->_onTimeout(time); }, this); + _client->onDisconnect([this](void *r, AsyncClient* c){ ((AsyncEventSourceClient*)(r))->_onDisconnect(); delete c; }, this); + + _server->_addClient(this); + delete request; +} + +AsyncEventSourceClient::~AsyncEventSourceClient(){ + _messageQueue.free(); + close(); +} + +void AsyncEventSourceClient::_queueMessage(AsyncEventSourceMessage *dataMessage){ + if(dataMessage == NULL) + return; + if(!connected()){ + delete dataMessage; + return; + } + if(_messageQueue.length() >= SSE_MAX_QUEUED_MESSAGES){ + ets_printf(String(F("ERROR: Too many messages queued\n")).c_str()); + delete dataMessage; + } else { + _messageQueue.add(dataMessage); + } + if(_client->canSend()) + _runQueue(); +} + +void AsyncEventSourceClient::_onAck(size_t len, uint32_t time){ + while(len && !_messageQueue.isEmpty()){ + len = _messageQueue.front()->ack(len, time); + if(_messageQueue.front()->finished()) + _messageQueue.remove(_messageQueue.front()); + } + + _runQueue(); +} + +void AsyncEventSourceClient::_onPoll(){ + if(!_messageQueue.isEmpty()){ + _runQueue(); + } +} + + +void AsyncEventSourceClient::_onTimeout(uint32_t time __attribute__((unused))){ + _client->close(true); +} + +void AsyncEventSourceClient::_onDisconnect(){ + _client = NULL; + _server->_handleDisconnect(this); +} + +void AsyncEventSourceClient::close(){ + if(_client != NULL) + _client->close(); +} + +void AsyncEventSourceClient::write(const char * message, size_t len){ + _queueMessage(new AsyncEventSourceMessage(message, len)); +} + +void AsyncEventSourceClient::send(const char *message, const char *event, uint32_t id, uint32_t reconnect){ + String ev = generateEventMessage(message, event, id, reconnect); + _queueMessage(new AsyncEventSourceMessage(ev.c_str(), ev.length())); +} + +void AsyncEventSourceClient::_runQueue(){ + while(!_messageQueue.isEmpty() && _messageQueue.front()->finished()){ + _messageQueue.remove(_messageQueue.front()); + } + + for(auto i = _messageQueue.begin(); i != _messageQueue.end(); ++i) + { + if(!(*i)->sent()) + (*i)->send(_client); + } +} + + +// Handler + +AsyncEventSource::AsyncEventSource(const String& url) + : _url(url) + , _clients(LinkedList([](AsyncEventSourceClient *c){ delete c; })) + , _connectcb(NULL) +{} + +AsyncEventSource::~AsyncEventSource(){ + close(); +} + +void AsyncEventSource::onConnect(ArEventHandlerFunction cb){ + _connectcb = cb; +} + +void AsyncEventSource::_addClient(AsyncEventSourceClient * client){ + /*char * temp = (char *)malloc(2054); + if(temp != NULL){ + memset(temp+1,' ',2048); + temp[0] = ':'; + temp[2049] = '\r'; + temp[2050] = '\n'; + temp[2051] = '\r'; + temp[2052] = '\n'; + temp[2053] = 0; + client->write((const char *)temp, 2053); + free(temp); + }*/ + + _clients.add(client); + if(_connectcb) + _connectcb(client); +} + +void AsyncEventSource::_handleDisconnect(AsyncEventSourceClient * client){ + _clients.remove(client); +} + +void AsyncEventSource::close(){ + for(const auto &c: _clients){ + if(c->connected()) + c->close(); + } +} + +// pmb fix +size_t AsyncEventSource::avgPacketsWaiting() const { + if(_clients.isEmpty()) + return 0; + + size_t aql=0; + uint32_t nConnectedClients=0; + + for(const auto &c: _clients){ + if(c->connected()) { + aql+=c->packetsWaiting(); + ++nConnectedClients; + } + } +// return aql / nConnectedClients; + return ((aql) + (nConnectedClients/2))/(nConnectedClients); // round up +} + +void AsyncEventSource::send(const char *message, const char *event, uint32_t id, uint32_t reconnect){ + + + String ev = generateEventMessage(message, event, id, reconnect); + for(const auto &c: _clients){ + if(c->connected()) { + c->write(ev.c_str(), ev.length()); + } + } +} + +size_t AsyncEventSource::count() const { + return _clients.count_if([](AsyncEventSourceClient *c){ + return c->connected(); + }); +} + +bool AsyncEventSource::canHandle(AsyncWebServerRequest *request){ + if(request->method() != HTTP_GET || !request->url().equals(_url)) { + return false; + } + request->addInterestingHeader(F("Last-Event-ID")); + return true; +} + +void AsyncEventSource::handleRequest(AsyncWebServerRequest *request){ + if((_username.length() && _password.length()) && !request->authenticate(_username.c_str(), _password.c_str())) { + return request->requestAuthentication(); + } + request->send(new AsyncEventSourceResponse(this)); +} + +// Response + +AsyncEventSourceResponse::AsyncEventSourceResponse(AsyncEventSource *server){ + _server = server; + _code = 200; + _contentType = F("text/event-stream"); + _sendContentLength = false; + addHeader(F("Cache-Control"), F("no-cache")); + addHeader(F("Connection"), F("keep-alive")); +} + +void AsyncEventSourceResponse::_respond(AsyncWebServerRequest *request){ + String out = _assembleHead(request->version()); + request->client()->write(out.c_str(), _headLength); + _state = RESPONSE_WAIT_ACK; +} + +size_t AsyncEventSourceResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time __attribute__((unused))){ + if(len){ + new AsyncEventSourceClient(request, _server); + } + return 0; +} + diff --git a/lib/ESPAsyncWebServer/AsyncEventSource.h b/lib/ESPAsyncWebServer/AsyncEventSource.h new file mode 100644 index 000000000..b097fa623 --- /dev/null +++ b/lib/ESPAsyncWebServer/AsyncEventSource.h @@ -0,0 +1,133 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef ASYNCEVENTSOURCE_H_ +#define ASYNCEVENTSOURCE_H_ + +#include +#ifdef ESP32 +#include +#define SSE_MAX_QUEUED_MESSAGES 32 +#else +#include +#define SSE_MAX_QUEUED_MESSAGES 8 +#endif +#include + +#include "AsyncWebSynchronization.h" + +#ifdef ESP8266 +#include +#ifdef CRYPTO_HASH_h // include Hash.h from espressif framework if the first include was from the crypto library +#include <../src/Hash.h> +#endif +#endif + +#ifdef ESP32 +#define DEFAULT_MAX_SSE_CLIENTS 8 +#else +#define DEFAULT_MAX_SSE_CLIENTS 4 +#endif + +class AsyncEventSource; +class AsyncEventSourceResponse; +class AsyncEventSourceClient; +typedef std::function ArEventHandlerFunction; + +class AsyncEventSourceMessage { + private: + uint8_t * _data; + size_t _len; + size_t _sent; + //size_t _ack; + size_t _acked; + public: + AsyncEventSourceMessage(const char * data, size_t len); + ~AsyncEventSourceMessage(); + size_t ack(size_t len, uint32_t time __attribute__((unused))); + size_t send(AsyncClient *client); + bool finished(){ return _acked == _len; } + bool sent() { return _sent == _len; } +}; + +class AsyncEventSourceClient { + private: + AsyncClient *_client; + AsyncEventSource *_server; + uint32_t _lastId; + LinkedList _messageQueue; + void _queueMessage(AsyncEventSourceMessage *dataMessage); + void _runQueue(); + + public: + + AsyncEventSourceClient(AsyncWebServerRequest *request, AsyncEventSource *server); + ~AsyncEventSourceClient(); + + AsyncClient* client(){ return _client; } + void close(); + void write(const char * message, size_t len); + void send(const char *message, const char *event=NULL, uint32_t id=0, uint32_t reconnect=0); + bool connected() const { return (_client != NULL) && _client->connected(); } + uint32_t lastId() const { return _lastId; } + size_t packetsWaiting() const { return _messageQueue.length(); } + + //system callbacks (do not call) + void _onAck(size_t len, uint32_t time); + void _onPoll(); + void _onTimeout(uint32_t time); + void _onDisconnect(); +}; + +class AsyncEventSource: public AsyncWebHandler { + private: + String _url; + LinkedList _clients; + ArEventHandlerFunction _connectcb; + public: + AsyncEventSource(const String& url); + ~AsyncEventSource(); + + const char * url() const { return _url.c_str(); } + void close(); + void onConnect(ArEventHandlerFunction cb); + void send(const char *message, const char *event=NULL, uint32_t id=0, uint32_t reconnect=0); + size_t count() const; //number clinets connected + size_t avgPacketsWaiting() const; + + //system callbacks (do not call) + void _addClient(AsyncEventSourceClient * client); + void _handleDisconnect(AsyncEventSourceClient * client); + virtual bool canHandle(AsyncWebServerRequest *request) override final; + virtual void handleRequest(AsyncWebServerRequest *request) override final; +}; + +class AsyncEventSourceResponse: public AsyncWebServerResponse { + private: + String _content; + AsyncEventSource *_server; + public: + AsyncEventSourceResponse(AsyncEventSource *server); + void _respond(AsyncWebServerRequest *request); + size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time); + bool _sourceValid() const { return true; } +}; + + +#endif /* ASYNCEVENTSOURCE_H_ */ diff --git a/lib/ESPAsyncWebServer/AsyncJson.h b/lib/ESPAsyncWebServer/AsyncJson.h new file mode 100644 index 000000000..27b4a26f6 --- /dev/null +++ b/lib/ESPAsyncWebServer/AsyncJson.h @@ -0,0 +1,252 @@ +// AsyncJson.h +/* + Async Response to use with ArduinoJson and AsyncWebServer + Written by Andrew Melvin (SticilFace) with help from me-no-dev and BBlanchon. + + Example of callback in use + + server.on("/json", HTTP_ANY, [](AsyncWebServerRequest * request) { + + AsyncJsonResponse * response = new AsyncJsonResponse(); + JsonObject& root = response->getRoot(); + root["key1"] = "key number one"; + JsonObject& nested = root.createNestedObject("nested"); + nested["key1"] = "key number one"; + + response->setLength(); + request->send(response); + }); + + -------------------- + + Async Request to use with ArduinoJson and AsyncWebServer + Written by Arsène von Wyss (avonwyss) + + Example + + AsyncCallbackJsonWebHandler* handler = new AsyncCallbackJsonWebHandler("/rest/endpoint"); + handler->onRequest([](AsyncWebServerRequest *request, JsonVariant &json) { + JsonObject& jsonObj = json.as(); + // ... + }); + server.addHandler(handler); + +*/ +#ifndef ASYNC_JSON_H_ +#define ASYNC_JSON_H_ +#include +#include +#include + +#if ARDUINOJSON_VERSION_MAJOR == 5 + #define ARDUINOJSON_5_COMPATIBILITY +#else + #define DYNAMIC_JSON_DOCUMENT_SIZE 1024 +#endif + +constexpr const char* JSON_MIMETYPE = "application/json"; + +/* + * Json Response + * */ + +class ChunkPrint : public Print { + private: + uint8_t* _destination; + size_t _to_skip; + size_t _to_write; + size_t _pos; + public: + ChunkPrint(uint8_t* destination, size_t from, size_t len) + : _destination(destination), _to_skip(from), _to_write(len), _pos{0} {} + virtual ~ChunkPrint(){} + size_t write(uint8_t c){ + if (_to_skip > 0) { + _to_skip--; + return 1; + } else if (_to_write > 0) { + _to_write--; + _destination[_pos++] = c; + return 1; + } + return 0; + } + size_t write(const uint8_t *buffer, size_t size) + { + return this->Print::write(buffer, size); + } +}; + +class AsyncJsonResponse: public AsyncAbstractResponse { + protected: + +#ifdef ARDUINOJSON_5_COMPATIBILITY + DynamicJsonBuffer _jsonBuffer; +#else + DynamicJsonDocument _jsonBuffer; +#endif + + JsonVariant _root; + bool _isValid; + + public: + +#ifdef ARDUINOJSON_5_COMPATIBILITY + AsyncJsonResponse(bool isArray=false): _isValid{false} { + _code = 200; + _contentType = JSON_MIMETYPE; + if(isArray) + _root = _jsonBuffer.createArray(); + else + _root = _jsonBuffer.createObject(); + } +#else + AsyncJsonResponse(bool isArray=false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE) : _jsonBuffer(maxJsonBufferSize), _isValid{false} { + _code = 200; + _contentType = JSON_MIMETYPE; + if(isArray) + _root = _jsonBuffer.createNestedArray(); + else + _root = _jsonBuffer.createNestedObject(); + } +#endif + + ~AsyncJsonResponse() {} + JsonVariant & getRoot() { return _root; } + bool _sourceValid() const { return _isValid; } + size_t setLength() { + +#ifdef ARDUINOJSON_5_COMPATIBILITY + _contentLength = _root.measureLength(); +#else + _contentLength = measureJson(_root); +#endif + + if (_contentLength) { _isValid = true; } + return _contentLength; + } + + size_t getSize() { return _jsonBuffer.size(); } + + size_t _fillBuffer(uint8_t *data, size_t len){ + ChunkPrint dest(data, _sentLength, len); + +#ifdef ARDUINOJSON_5_COMPATIBILITY + _root.printTo( dest ) ; +#else + serializeJson(_root, dest); +#endif + return len; + } +}; + +class PrettyAsyncJsonResponse: public AsyncJsonResponse { +public: +#ifdef ARDUINOJSON_5_COMPATIBILITY + PrettyAsyncJsonResponse (bool isArray=false) : AsyncJsonResponse{isArray} {} +#else + PrettyAsyncJsonResponse (bool isArray=false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE) : AsyncJsonResponse{isArray, maxJsonBufferSize} {} +#endif + size_t setLength () { +#ifdef ARDUINOJSON_5_COMPATIBILITY + _contentLength = _root.measurePrettyLength (); +#else + _contentLength = measureJsonPretty(_root); +#endif + if (_contentLength) {_isValid = true;} + return _contentLength; + } + size_t _fillBuffer (uint8_t *data, size_t len) { + ChunkPrint dest (data, _sentLength, len); +#ifdef ARDUINOJSON_5_COMPATIBILITY + _root.prettyPrintTo (dest); +#else + serializeJsonPretty(_root, dest); +#endif + return len; + } +}; + +typedef std::function ArJsonRequestHandlerFunction; + +class AsyncCallbackJsonWebHandler: public AsyncWebHandler { +private: +protected: + const String _uri; + WebRequestMethodComposite _method; + ArJsonRequestHandlerFunction _onRequest; + size_t _contentLength; +#ifndef ARDUINOJSON_5_COMPATIBILITY + const size_t maxJsonBufferSize; +#endif + size_t _maxContentLength; +public: +#ifdef ARDUINOJSON_5_COMPATIBILITY + AsyncCallbackJsonWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest) + : _uri(uri), _method(HTTP_POST|HTTP_PUT|HTTP_PATCH), _onRequest(onRequest), _maxContentLength(16384) {} +#else + AsyncCallbackJsonWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest, size_t maxJsonBufferSize=DYNAMIC_JSON_DOCUMENT_SIZE) + : _uri(uri), _method(HTTP_POST|HTTP_PUT|HTTP_PATCH), _onRequest(onRequest), maxJsonBufferSize(maxJsonBufferSize), _maxContentLength(16384) {} +#endif + + void setMethod(WebRequestMethodComposite method){ _method = method; } + void setMaxContentLength(int maxContentLength){ _maxContentLength = maxContentLength; } + void onRequest(ArJsonRequestHandlerFunction fn){ _onRequest = fn; } + + virtual bool canHandle(AsyncWebServerRequest *request) override final{ + if(!_onRequest) + return false; + + if(!(_method & request->method())) + return false; + + if(_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri+"/"))) + return false; + + if ( !request->contentType().equalsIgnoreCase(JSON_MIMETYPE) ) + return false; + + request->addInterestingHeader("ANY"); + return true; + } + + virtual void handleRequest(AsyncWebServerRequest *request) override final { + if(_onRequest) { + if (request->_tempObject != NULL) { + +#ifdef ARDUINOJSON_5_COMPATIBILITY + DynamicJsonBuffer jsonBuffer; + JsonVariant json = jsonBuffer.parse((uint8_t*)(request->_tempObject)); + if (json.success()) { +#else + DynamicJsonDocument jsonBuffer(this->maxJsonBufferSize); + DeserializationError error = deserializeJson(jsonBuffer, (uint8_t*)(request->_tempObject)); + if(!error) { + JsonVariant json = jsonBuffer.as(); +#endif + + _onRequest(request, json); + return; + } + } + request->send(_contentLength > _maxContentLength ? 413 : 400); + } else { + request->send(500); + } + } + virtual void handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final) override final { + } + virtual void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override final { + if (_onRequest) { + _contentLength = total; + if (total > 0 && request->_tempObject == NULL && total < _maxContentLength) { + request->_tempObject = malloc(total); + } + if (request->_tempObject != NULL) { + memcpy((uint8_t*)(request->_tempObject) + index, data, len); + } + } + } + virtual bool isRequestHandlerTrivial() override final {return _onRequest ? false : true;} +}; +#endif diff --git a/lib/ESPAsyncWebServer/AsyncWebSocket.cpp b/lib/ESPAsyncWebServer/AsyncWebSocket.cpp new file mode 100644 index 000000000..48baab476 --- /dev/null +++ b/lib/ESPAsyncWebServer/AsyncWebSocket.cpp @@ -0,0 +1,1312 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "Arduino.h" +#include "AsyncWebSocket.h" + +#include + +#ifndef ESP8266 +extern "C" { +typedef struct { + uint32_t state[5]; + uint32_t count[2]; + unsigned char buffer[64]; +} SHA1_CTX; + +void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]); +void SHA1Init(SHA1_CTX* context); +void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len); +void SHA1Final(unsigned char digest[20], SHA1_CTX* context); +} +#else +#include +#endif + +#define MAX_PRINTF_LEN 64 + +size_t AsyncWebSocketMessageBufferLinkedList::_totalCount = 0; +size_t AsyncWebSocketMessageBufferLinkedList::_totalSize = 0; + +size_t webSocketSendFrameWindow(AsyncClient *client){ + if(!client->canSend()) + return 0; + size_t space = client->space(); + if(space < 9) + return 0; + return space - 8; +} + +size_t webSocketSendFrame(AsyncClient *client, bool final, uint8_t opcode, bool mask, uint8_t *data, size_t len){ + if(!client->canSend()) + return 0; + size_t space = client->space(); + if(space < 2) + return 0; + uint8_t mbuf[4] = {0,0,0,0}; + uint8_t headLen = 2; + if(len && mask){ + headLen += 4; + mbuf[0] = rand() % 0xFF; + mbuf[1] = rand() % 0xFF; + mbuf[2] = rand() % 0xFF; + mbuf[3] = rand() % 0xFF; + } + if(len > 125) + headLen += 2; + if(space < headLen) + return 0; + space -= headLen; + + if(len > space) len = space; + + uint8_t *buf = (uint8_t*)malloc(headLen); + if(buf == NULL){ + //os_printf("could not malloc %u bytes for frame header\n", headLen); + return 0; + } + + buf[0] = opcode & 0x0F; + if(final) + buf[0] |= 0x80; + if(len < 126) + buf[1] = len & 0x7F; + else { + buf[1] = 126; + buf[2] = (uint8_t)((len >> 8) & 0xFF); + buf[3] = (uint8_t)(len & 0xFF); + } + if(len && mask){ + buf[1] |= 0x80; + memcpy(buf + (headLen - 4), mbuf, 4); + } + if(client->add((const char *)buf, headLen) != headLen){ + //os_printf("error adding %lu header bytes\n", headLen); + free(buf); + return 0; + } + free(buf); + + if(len){ + if(len && mask){ + size_t i; + for(i=0;iadd((const char *)data, len) != len){ + //os_printf("error adding %lu data bytes\n", len); + return 0; + } + } + if(!client->send()){ + //os_printf("error sending frame: %lu\n", headLen+len); + return 0; + } + return len; +} + + +/* + * AsyncWebSocketMessageBuffer + */ + + + +AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer() + :_data(nullptr) + ,_len(0) + ,_lock(false) + ,_count(0) +{ + +} + +AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer(uint8_t * data, size_t size) + :_data(nullptr) + ,_len(size) + ,_lock(false) + ,_count(0) +{ + + if (!data) { + return; + } + + _data = new uint8_t[_len + 1]; + + if (_data) { + memcpy(_data, data, _len); + _data[_len] = 0; + } +} + + +AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer(size_t size) + :_data(nullptr) + ,_len(size) + ,_lock(false) + ,_count(0) +{ + _data = new uint8_t[_len + 1]; + + if (_data) { + _data[_len] = 0; + } + +} + +AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer & copy) + :_data(nullptr) + ,_len(0) + ,_lock(false) + ,_count(0) +{ + _len = copy._len; + _lock = copy._lock; + _count = 0; + + if (_len) { + _data = new uint8_t[_len + 1]; + _data[_len] = 0; + } + + if (_data) { + memcpy(_data, copy._data, _len); + _data[_len] = 0; + } + +} + +AsyncWebSocketMessageBuffer::AsyncWebSocketMessageBuffer(AsyncWebSocketMessageBuffer && copy) + :_data(nullptr) + ,_len(0) + ,_lock(false) + ,_count(0) +{ + _len = copy._len; + _lock = copy._lock; + _count = 0; + + if (copy._data) { + _data = copy._data; + copy._data = nullptr; + } + +} + +AsyncWebSocketMessageBuffer::~AsyncWebSocketMessageBuffer() +{ + if (_data) { + delete[] _data; + } +} + +bool AsyncWebSocketMessageBuffer::reserve(size_t size) +{ + _len = size; + + if (_data) { + delete[] _data; + _data = nullptr; + } + + _data = new uint8_t[_len + 1]; + + if (_data) { + _data[_len] = 0; + return true; + } else { + return false; + } + +} + + + +/* + * Control Frame + */ + +class AsyncWebSocketControl { + private: + uint8_t _opcode; + uint8_t *_data; + size_t _len; + bool _mask; + bool _finished; + public: + AsyncWebSocketControl(uint8_t opcode, uint8_t *data=NULL, size_t len=0, bool mask=false) + :_opcode(opcode) + ,_len(len) + ,_mask(len && mask) + ,_finished(false) + { + if(data == NULL) + _len = 0; + if(_len){ + if(_len > 125) + _len = 125; + _data = (uint8_t*)malloc(_len); + if(_data == NULL) + _len = 0; + else memcpy_P(_data, data, len); + } else _data = NULL; + } + virtual ~AsyncWebSocketControl(){ + if(_data != NULL) + free(_data); + } + virtual bool finished() const { return _finished; } + uint8_t opcode(){ return _opcode; } + uint8_t len(){ return _len + 2; } + size_t send(AsyncClient *client){ + _finished = true; + return webSocketSendFrame(client, true, _opcode & 0x0F, _mask, _data, _len); + } +}; + +/* + * Basic Buffered Message + */ + + +AsyncWebSocketBasicMessage::AsyncWebSocketBasicMessage(const char * data, size_t len, uint8_t opcode, bool mask) + :_len(len) + ,_sent(0) + ,_ack(0) + ,_acked(0) +{ + _opcode = opcode & 0x07; + _mask = mask; + _data = (uint8_t*)malloc(_len+1); + if(_data == NULL){ + _len = 0; + _status = WS_MSG_ERROR; + } else { + _status = WS_MSG_SENDING; + memcpy(_data, data, _len); + _data[_len] = 0; + } +} +AsyncWebSocketBasicMessage::AsyncWebSocketBasicMessage(uint8_t opcode, bool mask) + :_len(0) + ,_sent(0) + ,_ack(0) + ,_acked(0) + ,_data(NULL) +{ + _opcode = opcode & 0x07; + _mask = mask; + +} + + +AsyncWebSocketBasicMessage::~AsyncWebSocketBasicMessage() { + if(_data != NULL) + free(_data); +} + + void AsyncWebSocketBasicMessage::ack(size_t len, uint32_t time) { + (void)time; + _acked += len; + if(_sent == _len && _acked == _ack){ + _status = WS_MSG_SENT; + } +} + size_t AsyncWebSocketBasicMessage::send(AsyncClient *client) { + if(_status != WS_MSG_SENDING) + return 0; + if(_acked < _ack){ + return 0; + } + if(_sent == _len){ + if(_acked == _ack) + _status = WS_MSG_SENT; + return 0; + } + if(_sent > _len){ + _status = WS_MSG_ERROR; + return 0; + } + + size_t toSend = _len - _sent; + size_t window = webSocketSendFrameWindow(client); + + if(window < toSend) { + toSend = window; + } + + _sent += toSend; + _ack += toSend + ((toSend < 126)?2:4) + (_mask * 4); + + bool final = (_sent == _len); + uint8_t* dPtr = (uint8_t*)(_data + (_sent - toSend)); + uint8_t opCode = (toSend && _sent == toSend)?_opcode:(uint8_t)WS_CONTINUATION; + + size_t sent = webSocketSendFrame(client, final, opCode, _mask, dPtr, toSend); + _status = WS_MSG_SENDING; + if(toSend && sent != toSend){ + _sent -= (toSend - sent); + _ack -= (toSend - sent); + } + return sent; +} + +// bool AsyncWebSocketBasicMessage::reserve(size_t size) { +// if (size) { +// _data = (uint8_t*)malloc(size +1); +// if (_data) { +// memset(_data, 0, size); +// _len = size; +// _status = WS_MSG_SENDING; +// return true; +// } +// } +// return false; +// } + + +/* + * AsyncWebSocketMultiMessage Message + */ + + +AsyncWebSocketMultiMessage::AsyncWebSocketMultiMessage(AsyncWebSocketMessageBuffer * buffer, uint8_t opcode, bool mask) + :_len(0) + ,_sent(0) + ,_ack(0) + ,_acked(0) + ,_WSbuffer(nullptr) +{ + + _opcode = opcode & 0x07; + _mask = mask; + + if (buffer) { + _WSbuffer = buffer; + (*_WSbuffer)++; + _data = buffer->get(); + _len = buffer->length(); + _status = WS_MSG_SENDING; + //ets_printf("M: %u\n", _len); + } else { + _status = WS_MSG_ERROR; + } + +} + + +AsyncWebSocketMultiMessage::~AsyncWebSocketMultiMessage() { + if (_WSbuffer) { + (*_WSbuffer)--; // decreases the counter. + } +} + + void AsyncWebSocketMultiMessage::ack(size_t len, uint32_t time) { + (void)time; + _acked += len; + if(_sent >= _len && _acked >= _ack){ + _status = WS_MSG_SENT; + } + //ets_printf("A: %u\n", len); +} + size_t AsyncWebSocketMultiMessage::send(AsyncClient *client) { + if(_status != WS_MSG_SENDING) + return 0; + if(_acked < _ack){ + return 0; + } + if(_sent == _len){ + _status = WS_MSG_SENT; + return 0; + } + if(_sent > _len){ + _status = WS_MSG_ERROR; + //ets_printf("E: %u > %u\n", _sent, _len); + return 0; + } + + size_t toSend = _len - _sent; + size_t window = webSocketSendFrameWindow(client); + + if(window < toSend) { + toSend = window; + } + + _sent += toSend; + _ack += toSend + ((toSend < 126)?2:4) + (_mask * 4); + + //ets_printf("W: %u %u\n", _sent - toSend, toSend); + + bool final = (_sent == _len); + uint8_t* dPtr = (uint8_t*)(_data + (_sent - toSend)); + uint8_t opCode = (toSend && _sent == toSend)?_opcode:(uint8_t)WS_CONTINUATION; + + size_t sent = webSocketSendFrame(client, final, opCode, _mask, dPtr, toSend); + _status = WS_MSG_SENDING; + if(toSend && sent != toSend){ + //ets_printf("E: %u != %u\n", toSend, sent); + _sent -= (toSend - sent); + _ack -= (toSend - sent); + } + //ets_printf("S: %u %u\n", _sent, sent); + return sent; +} + + +/* + * Async WebSocket Client + */ + const char *AWSC_PING_PAYLOAD[] PROGMEM = { "ESPAsyncWebServer-PING" }; + const size_t AWSC_PING_PAYLOAD_LEN = 22; + +AsyncWebSocketClient::AsyncWebSocketClient(AsyncWebServerRequest *request, AsyncWebSocket *server) + : _controlQueue(LinkedList([](AsyncWebSocketControl *c){ delete c; })) + , _messageQueue(LinkedList([](AsyncWebSocketMessage *m){ delete m; })) + , _tempObject(NULL) +{ + _client = request->client(); + _server = server; + _clientId = _server->_getNextId(); + _status = WS_CONNECTED; + _pstate = 0; + _lastMessageTime = millis(); + _keepAlivePeriod = 0; + _client->setRxTimeout(0); + _client->onError([](void *r, AsyncClient* c, int8_t error){ (void)c; ((AsyncWebSocketClient*)(r))->_onError(error); }, this); + _client->onAck([](void *r, AsyncClient* c, size_t len, uint32_t time){ (void)c; ((AsyncWebSocketClient*)(r))->_onAck(len, time); }, this); + _client->onDisconnect([](void *r, AsyncClient* c){ ((AsyncWebSocketClient*)(r))->_onDisconnect(); delete c; }, this); + _client->onTimeout([](void *r, AsyncClient* c, uint32_t time){ (void)c; ((AsyncWebSocketClient*)(r))->_onTimeout(time); }, this); + _client->onData([](void *r, AsyncClient* c, void *buf, size_t len){ (void)c; ((AsyncWebSocketClient*)(r))->_onData(buf, len); }, this); + _client->onPoll([](void *r, AsyncClient* c){ (void)c; ((AsyncWebSocketClient*)(r))->_onPoll(); }, this); + _server->_addClient(this); + _server->_handleEvent(this, WS_EVT_CONNECT, request, NULL, 0); + delete request; +} + +AsyncWebSocketClient::~AsyncWebSocketClient(){ + _messageQueue.free(); + _controlQueue.free(); + _server->_handleEvent(this, WS_EVT_DISCONNECT, NULL, NULL, 0); +} + +void AsyncWebSocketClient::_onAck(size_t len, uint32_t time){ + _lastMessageTime = millis(); + if(!_controlQueue.isEmpty()){ + auto head = _controlQueue.front(); + if(head->finished()){ + len -= head->len(); + if(_status == WS_DISCONNECTING && head->opcode() == WS_DISCONNECT){ + _controlQueue.remove(head); + _status = WS_DISCONNECTED; + _client->close(true); + return; + } + _controlQueue.remove(head); + } + } + if(len && !_messageQueue.isEmpty()){ + _messageQueue.front()->ack(len, time); + } + _server->_cleanBuffers(); + _runQueue(); +} + +void AsyncWebSocketClient::_onPoll(){ + if(_client->canSend() && (!_controlQueue.isEmpty() || !_messageQueue.isEmpty())){ + _runQueue(); + } else if(_keepAlivePeriod > 0 && _controlQueue.isEmpty() && _messageQueue.isEmpty() && (millis() - _lastMessageTime) >= _keepAlivePeriod){ + ping((uint8_t *)AWSC_PING_PAYLOAD, AWSC_PING_PAYLOAD_LEN); + } +} + +void AsyncWebSocketClient::_runQueue(){ + while(!_messageQueue.isEmpty() && _messageQueue.front()->finished()){ + _messageQueue.remove(_messageQueue.front()); + } + + if(!_controlQueue.isEmpty() && (_messageQueue.isEmpty() || _messageQueue.front()->betweenFrames()) && webSocketSendFrameWindow(_client) > (size_t)(_controlQueue.front()->len() - 1)){ + _controlQueue.front()->send(_client); + } else if(!_messageQueue.isEmpty() && _messageQueue.front()->betweenFrames() && webSocketSendFrameWindow(_client)){ + _messageQueue.front()->send(_client); + } +} + +bool AsyncWebSocketClient::queueIsFull(){ + if(_queueIsFull() || (_status != WS_CONNECTED) ) return true; + return false; +} + +bool AsyncWebSocketClient::_queueIsFull() const { + return + (_server->getQueuedMessageCount() >= WS_MAX_QUEUED_MESSAGES) || + (_server->getQueuedMessageSize() >= WS_MAX_QUEUED_MESSAGES_SIZE) +#if WS_MAX_QUEUED_MESSAGES_MIN_HEAP + || (ESP.getFreeHeap() < WS_MAX_QUEUED_MESSAGES_MIN_HEAP) +#endif + ; +} + +void AsyncWebSocketClient::_queueMessage(AsyncWebSocketMessage *dataMessage){ + if(dataMessage == NULL) + return; + if(_status != WS_CONNECTED){ + delete dataMessage; + return; + } + if(_queueIsFull()){ +#if DEBUG + ::printf(PSTR("AsyncWebSocketClient: Too many messages queued\n")); +#endif + delete dataMessage; + } else { + _messageQueue.add(dataMessage); + } + if(_client->canSend()) + _runQueue(); +} + +void AsyncWebSocketClient::_queueControl(AsyncWebSocketControl *controlMessage){ + if(controlMessage == NULL) + return; + _controlQueue.add(controlMessage); + if(_client->canSend()) + _runQueue(); +} + +void AsyncWebSocketClient::close(uint16_t code, const char * message){ + if(_status != WS_CONNECTED) + return; + if(code){ + uint8_t packetLen = 2; + if(message != NULL){ + size_t mlen = strlen(message); + if(mlen > 123) mlen = 123; + packetLen += mlen; + } + char * buf = (char*)malloc(packetLen); + if(buf != NULL){ + buf[0] = (uint8_t)(code >> 8); + buf[1] = (uint8_t)(code & 0xFF); + if(message != NULL){ + memcpy(buf+2, message, packetLen -2); + } + _queueControl(new AsyncWebSocketControl(WS_DISCONNECT,(uint8_t*)buf,packetLen)); + free(buf); + return; + } + } + _queueControl(new AsyncWebSocketControl(WS_DISCONNECT)); +} + +void AsyncWebSocketClient::ping(uint8_t *data, size_t len){ + if(_status == WS_CONNECTED) + _queueControl(new AsyncWebSocketControl(WS_PING, data, len)); +} + +void AsyncWebSocketClient::_onError(int8_t){} + +void AsyncWebSocketClient::_onTimeout(uint32_t time){ + (void)time; + _client->close(true); +} + +void AsyncWebSocketClient::_onDisconnect(){ + _client = NULL; + _server->_handleDisconnect(this); +} + +void AsyncWebSocketClient::_onData(void *pbuf, size_t plen){ + _lastMessageTime = millis(); + uint8_t *data = (uint8_t*)pbuf; + while(plen > 0){ + if(!_pstate){ + const uint8_t *fdata = data; + _pinfo.index = 0; + _pinfo.final = (fdata[0] & 0x80) != 0; + _pinfo.opcode = fdata[0] & 0x0F; + _pinfo.masked = (fdata[1] & 0x80) != 0; + _pinfo.len = fdata[1] & 0x7F; + data += 2; + plen -= 2; + if(_pinfo.len == 126){ + _pinfo.len = fdata[3] | (uint16_t)(fdata[2]) << 8; + data += 2; + plen -= 2; + } else if(_pinfo.len == 127){ + _pinfo.len = fdata[9] | (uint16_t)(fdata[8]) << 8 | (uint32_t)(fdata[7]) << 16 | (uint32_t)(fdata[6]) << 24 | (uint64_t)(fdata[5]) << 32 | (uint64_t)(fdata[4]) << 40 | (uint64_t)(fdata[3]) << 48 | (uint64_t)(fdata[2]) << 56; + data += 8; + plen -= 8; + } + + if(_pinfo.masked){ + memcpy(_pinfo.mask, data, 4); + data += 4; + plen -= 4; + } + } + + const size_t datalen = std::min((size_t)(_pinfo.len - _pinfo.index), plen); + const auto datalast = data[datalen]; + + if(_pinfo.masked){ + for(size_t i=0;i_handleEvent(this, WS_EVT_DATA, (void *)&_pinfo, (uint8_t*)data, datalen); + + _pinfo.index += datalen; + } else if((datalen + _pinfo.index) == _pinfo.len){ + _pstate = 0; + if(_pinfo.opcode == WS_DISCONNECT){ + if(datalen){ + uint16_t reasonCode = (uint16_t)(data[0] << 8) + data[1]; + char * reasonString = (char*)(data+2); + if(reasonCode > 1001){ + _server->_handleEvent(this, WS_EVT_ERROR, (void *)&reasonCode, (uint8_t*)reasonString, strlen(reasonString)); + } + } + if(_status == WS_DISCONNECTING){ + _status = WS_DISCONNECTED; + _client->close(true); + } else { + _status = WS_DISCONNECTING; + _client->ackLater(); + _queueControl(new AsyncWebSocketControl(WS_DISCONNECT, data, datalen)); + } + } else if(_pinfo.opcode == WS_PING){ + _queueControl(new AsyncWebSocketControl(WS_PONG, data, datalen)); + } else if(_pinfo.opcode == WS_PONG){ + if(datalen != AWSC_PING_PAYLOAD_LEN || memcmp_P(data, AWSC_PING_PAYLOAD, AWSC_PING_PAYLOAD_LEN) != 0) + _server->_handleEvent(this, WS_EVT_PONG, NULL, data, datalen); + } else if(_pinfo.opcode < 8){//continuation or text/binary frame + _server->_handleEvent(this, WS_EVT_DATA, (void *)&_pinfo, data, datalen); + } + } else { + //os_printf("frame error: len: %u, index: %llu, total: %llu\n", datalen, _pinfo.index, _pinfo.len); + //what should we do? + break; + } + + // restore byte as _handleEvent may have added a null terminator i.e., data[len] = 0; + if (datalen > 0) + data[datalen] = datalast; + + data += datalen; + plen -= datalen; + } +} + +size_t AsyncWebSocketClient::printf(const char *format, ...) { + va_list arg; + va_start(arg, format); + char* temp = new char[MAX_PRINTF_LEN]; + if(!temp){ + va_end(arg); + return 0; + } + char* buffer = temp; + size_t len = vsnprintf(temp, MAX_PRINTF_LEN, format, arg); + va_end(arg); + + if (len > (MAX_PRINTF_LEN - 1)) { + buffer = new char[len + 1]; + if (!buffer) { + delete[] temp; + return 0; + } + va_start(arg, format); + vsnprintf(buffer, len + 1, format, arg); + va_end(arg); + } + text(buffer, len); + if (buffer != temp) { + delete[] buffer; + } + delete[] temp; + return len; +} + +#ifndef ESP32 +size_t AsyncWebSocketClient::printf_P(PGM_P formatP, ...) { + va_list arg; + va_start(arg, formatP); + char* temp = new char[MAX_PRINTF_LEN]; + if(!temp){ + va_end(arg); + return 0; + } + char* buffer = temp; + size_t len = vsnprintf_P(temp, MAX_PRINTF_LEN, formatP, arg); + va_end(arg); + + if (len > (MAX_PRINTF_LEN - 1)) { + buffer = new char[len + 1]; + if (!buffer) { + delete[] temp; + return 0; + } + va_start(arg, formatP); + vsnprintf_P(buffer, len + 1, formatP, arg); + va_end(arg); + } + text(buffer, len); + if (buffer != temp) { + delete[] buffer; + } + delete[] temp; + return len; +} +#endif + +void AsyncWebSocketClient::text(const char * message, size_t len){ + _queueMessage(new AsyncWebSocketBasicMessage(message, len)); +} +void AsyncWebSocketClient::text(const char * message){ + text(message, strlen(message)); +} +void AsyncWebSocketClient::text(uint8_t * message, size_t len){ + text((const char *)message, len); +} +void AsyncWebSocketClient::text(char * message){ + text(message, strlen(message)); +} +void AsyncWebSocketClient::text(const String &message){ + text(message.c_str(), message.length()); +} +void AsyncWebSocketClient::text(const __FlashStringHelper *data){ + text(String(data)); +} +void AsyncWebSocketClient::text(AsyncWebSocketMessageBuffer * buffer) +{ + _queueMessage(new AsyncWebSocketMultiMessage(buffer)); +} + +void AsyncWebSocketClient::binary(const char * message, size_t len){ + _queueMessage(new AsyncWebSocketBasicMessage(message, len, WS_BINARY)); +} +void AsyncWebSocketClient::binary(const char * message){ + binary(message, strlen(message)); +} +void AsyncWebSocketClient::binary(uint8_t * message, size_t len){ + binary((const char *)message, len); +} +void AsyncWebSocketClient::binary(char * message){ + binary(message, strlen(message)); +} +void AsyncWebSocketClient::binary(const String &message){ + binary(message.c_str(), message.length()); +} +void AsyncWebSocketClient::binary(const __FlashStringHelper *data, size_t len){ + PGM_P p = reinterpret_cast(data); + char * message = (char*) malloc(len); + if(message){ + memcpy_P(message, p, len); + binary(message, len); + free(message); + } + +} +void AsyncWebSocketClient::binary(AsyncWebSocketMessageBuffer * buffer) +{ + _queueMessage(new AsyncWebSocketMultiMessage(buffer, WS_BINARY)); +} + +IPAddress AsyncWebSocketClient::remoteIP() { + if(!_client) { + return IPAddress(0U); + } + return _client->remoteIP(); +} + +uint16_t AsyncWebSocketClient::remotePort() { + if(!_client) { + return 0; + } + return _client->remotePort(); +} + + + +/* + * Async Web Socket - Each separate socket location + */ + +AsyncWebSocket::AsyncWebSocket(const String& url) + :_url(url) + ,_clients(LinkedList([](AsyncWebSocketClient *c){ delete c; })) + ,_cNextId(1) + ,_enabled(true) +{ + _eventHandler = NULL; +} + +AsyncWebSocket::~AsyncWebSocket(){} + +void AsyncWebSocket::_handleEvent(AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){ + if(_eventHandler != NULL){ + _eventHandler(this, client, type, arg, data, len); + } +} + +void AsyncWebSocket::_addClient(AsyncWebSocketClient * client){ + _clients.add(client); +} + +void AsyncWebSocket::_handleDisconnect(AsyncWebSocketClient * client){ + + _clients.remove_first([=](AsyncWebSocketClient * c){ + return c->id() == client->id(); + }); +} + +bool AsyncWebSocket::availableForWriteAll(){ + for(const auto& c: _clients){ + if(c->queueIsFull()) return false; + } + return true; +} + +bool AsyncWebSocket::availableForWrite(uint32_t id){ + for(const auto& c: _clients){ + if(c->queueIsFull() && (c->id() == id )) return false; + } + return true; +} + +size_t AsyncWebSocket::count() const { + return _clients.count_if([](AsyncWebSocketClient * c){ + return c->status() == WS_CONNECTED; + }); +} + +AsyncWebSocketClient * AsyncWebSocket::client(uint32_t id){ + for(const auto &c: _clients){ + if(c->id() == id && c->status() == WS_CONNECTED){ + return c; + } + } + return nullptr; +} + + +void AsyncWebSocket::close(uint32_t id, uint16_t code, const char * message){ + AsyncWebSocketClient * c = client(id); + if(c) + c->close(code, message); +} + +void AsyncWebSocket::closeAll(uint16_t code, const char * message){ + for(const auto& c: _clients){ + if(c->status() == WS_CONNECTED) + c->close(code, message); + } +} + +void AsyncWebSocket::cleanupClients(uint16_t maxClients) +{ + if (count() > maxClients){ + _clients.front()->close(); + } +} + +void AsyncWebSocket::ping(uint32_t id, uint8_t *data, size_t len){ + AsyncWebSocketClient * c = client(id); + if(c) + c->ping(data, len); +} + +void AsyncWebSocket::pingAll(uint8_t *data, size_t len){ + for(const auto& c: _clients){ + if(c->status() == WS_CONNECTED) + c->ping(data, len); + } +} + +void AsyncWebSocket::text(uint32_t id, const char * message, size_t len){ + AsyncWebSocketClient * c = client(id); + if(c) + c->text(message, len); +} + +void AsyncWebSocket::textAll(AsyncWebSocketMessageBuffer * buffer){ + if (!buffer) return; + buffer->lock(); + for(const auto& c: _clients){ + if(c->status() == WS_CONNECTED){ + c->text(buffer); + } + } + buffer->unlock(); + _cleanBuffers(); +} + + +void AsyncWebSocket::textAll(const char * message, size_t len){ + AsyncWebSocketMessageBuffer * WSBuffer = makeBuffer((uint8_t *)message, len); + textAll(WSBuffer); +} + +void AsyncWebSocket::binary(uint32_t id, const char * message, size_t len){ + AsyncWebSocketClient * c = client(id); + if(c) + c->binary(message, len); +} + +void AsyncWebSocket::binaryAll(const char * message, size_t len){ + AsyncWebSocketMessageBuffer * buffer = makeBuffer((uint8_t *)message, len); + binaryAll(buffer); +} + +void AsyncWebSocket::binaryAll(AsyncWebSocketMessageBuffer * buffer) +{ + if (!buffer) return; + buffer->lock(); + for(const auto& c: _clients){ + if(c->status() == WS_CONNECTED) + c->binary(buffer); + } + buffer->unlock(); + _cleanBuffers(); +} + +void AsyncWebSocket::message(uint32_t id, AsyncWebSocketMessage *message){ + AsyncWebSocketClient * c = client(id); + if(c) + c->message(message); +} + +void AsyncWebSocket::messageAll(AsyncWebSocketMultiMessage *message){ + for(const auto& c: _clients){ + if(c->status() == WS_CONNECTED) + c->message(message); + } + _cleanBuffers(); +} + +size_t AsyncWebSocket::printf(uint32_t id, const char *format, ...){ + AsyncWebSocketClient * c = client(id); + if(c){ + va_list arg; + va_start(arg, format); + size_t len = c->printf(format, arg); + va_end(arg); + return len; + } + return 0; +} + +size_t AsyncWebSocket::printfAll(const char *format, ...) { + va_list arg; + char* temp = new char[MAX_PRINTF_LEN]; + if(!temp){ + return 0; + } + va_start(arg, format); + size_t len = vsnprintf(temp, MAX_PRINTF_LEN, format, arg); + va_end(arg); + delete[] temp; + + AsyncWebSocketMessageBuffer * buffer = makeBuffer(len); + if (!buffer) { + return 0; + } + + va_start(arg, format); + vsnprintf( (char *)buffer->get(), len + 1, format, arg); + va_end(arg); + + textAll(buffer); + return len; +} + +#ifndef ESP32 +size_t AsyncWebSocket::printf_P(uint32_t id, PGM_P formatP, ...){ + AsyncWebSocketClient * c = client(id); + if(c != NULL){ + va_list arg; + va_start(arg, formatP); + size_t len = c->printf_P(formatP, arg); + va_end(arg); + return len; + } + return 0; +} +#endif + +size_t AsyncWebSocket::printfAll_P(PGM_P formatP, ...) { + va_list arg; + char* temp = new char[MAX_PRINTF_LEN]; + if(!temp){ + return 0; + } + va_start(arg, formatP); + size_t len = vsnprintf_P(temp, MAX_PRINTF_LEN, formatP, arg); + va_end(arg); + delete[] temp; + + AsyncWebSocketMessageBuffer * buffer = makeBuffer(len + 1); + if (!buffer) { + return 0; + } + + va_start(arg, formatP); + vsnprintf_P((char *)buffer->get(), len + 1, formatP, arg); + va_end(arg); + + textAll(buffer); + return len; +} + +void AsyncWebSocket::text(uint32_t id, const char * message){ + text(id, message, strlen(message)); +} +void AsyncWebSocket::text(uint32_t id, uint8_t * message, size_t len){ + text(id, (const char *)message, len); +} +void AsyncWebSocket::text(uint32_t id, char * message){ + text(id, message, strlen(message)); +} +void AsyncWebSocket::text(uint32_t id, const String &message){ + text(id, message.c_str(), message.length()); +} +void AsyncWebSocket::text(uint32_t id, const __FlashStringHelper *message){ + AsyncWebSocketClient * c = client(id); + if(c != NULL) + c->text(message); +} +void AsyncWebSocket::textAll(const char * message){ + textAll(message, strlen(message)); +} +void AsyncWebSocket::textAll(uint8_t * message, size_t len){ + textAll((const char *)message, len); +} +void AsyncWebSocket::textAll(char * message){ + textAll(message, strlen(message)); +} +void AsyncWebSocket::textAll(const String &message){ + textAll(message.c_str(), message.length()); +} +void AsyncWebSocket::textAll(const __FlashStringHelper *message){ + for(const auto& c: _clients){ + if(c->status() == WS_CONNECTED) + c->text(message); + } +} +void AsyncWebSocket::binary(uint32_t id, const char * message){ + binary(id, message, strlen(message)); +} +void AsyncWebSocket::binary(uint32_t id, uint8_t * message, size_t len){ + binary(id, (const char *)message, len); +} +void AsyncWebSocket::binary(uint32_t id, char * message){ + binary(id, message, strlen(message)); +} +void AsyncWebSocket::binary(uint32_t id, const String &message){ + binary(id, message.c_str(), message.length()); +} +void AsyncWebSocket::binary(uint32_t id, const __FlashStringHelper *message, size_t len){ + AsyncWebSocketClient * c = client(id); + if(c != NULL) + c-> binary(message, len); +} +void AsyncWebSocket::binaryAll(const char * message){ + binaryAll(message, strlen(message)); +} +void AsyncWebSocket::binaryAll(uint8_t * message, size_t len){ + binaryAll((const char *)message, len); +} +void AsyncWebSocket::binaryAll(char * message){ + binaryAll(message, strlen(message)); +} +void AsyncWebSocket::binaryAll(const String &message){ + binaryAll(message.c_str(), message.length()); +} +void AsyncWebSocket::binaryAll(const __FlashStringHelper *message, size_t len){ + for(const auto& c: _clients){ + if(c->status() == WS_CONNECTED) + c-> binary(message, len); + } + } + +const char __WS_STR_CONNECTION[] PROGMEM = { "Connection" }; +const char __WS_STR_UPGRADE[] PROGMEM = { "Upgrade" }; +const char __WS_STR_ORIGIN[] PROGMEM = { "Origin" }; +const char __WS_STR_VERSION[] PROGMEM = { "Sec-WebSocket-Version" }; +const char __WS_STR_KEY[] PROGMEM = { "Sec-WebSocket-Key" }; +const char __WS_STR_PROTOCOL[] PROGMEM = { "Sec-WebSocket-Protocol" }; +const char __WS_STR_ACCEPT[] PROGMEM = { "Sec-WebSocket-Accept" }; +const char __WS_STR_UUID[] PROGMEM = { "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" }; + +#define WS_STR_CONNECTION FPSTR(__WS_STR_CONNECTION) +#define WS_STR_UPGRADE FPSTR(__WS_STR_UPGRADE) +#define WS_STR_ORIGIN FPSTR(__WS_STR_ORIGIN) +#define WS_STR_VERSION FPSTR(__WS_STR_VERSION) +#define WS_STR_KEY FPSTR(__WS_STR_KEY) +#define WS_STR_PROTOCOL FPSTR(__WS_STR_PROTOCOL) +#define WS_STR_ACCEPT FPSTR(__WS_STR_ACCEPT) +#define WS_STR_UUID FPSTR(__WS_STR_UUID) + +bool AsyncWebSocket::canHandle(AsyncWebServerRequest *request){ + if(!_enabled) + return false; + + if(request->method() != HTTP_GET || !request->url().equals(_url) || !request->isExpectedRequestedConnType(RCT_WS)) + return false; + + request->addInterestingHeader(WS_STR_CONNECTION); + request->addInterestingHeader(WS_STR_UPGRADE); + request->addInterestingHeader(WS_STR_ORIGIN); + request->addInterestingHeader(WS_STR_VERSION); + request->addInterestingHeader(WS_STR_KEY); + request->addInterestingHeader(WS_STR_PROTOCOL); + return true; +} + +void AsyncWebSocket::handleRequest(AsyncWebServerRequest *request){ + if(!request->hasHeader(WS_STR_VERSION) || !request->hasHeader(WS_STR_KEY)){ + request->send(400); + return; + } + if((_username.length() && _password.length()) && !request->authenticate(_username.c_str(), _password.c_str())){ + return request->requestAuthentication(); + } + AsyncWebHeader* version = request->getHeader(WS_STR_VERSION); + if(version->value().toInt() != 13){ + AsyncWebServerResponse *response = request->beginResponse(400); + response->addHeader(WS_STR_VERSION, F("13")); + request->send(response); + return; + } + AsyncWebHeader* key = request->getHeader(WS_STR_KEY); + AsyncWebServerResponse *response = new AsyncWebSocketResponse(key->value(), this); + if(request->hasHeader(WS_STR_PROTOCOL)){ + AsyncWebHeader* protocol = request->getHeader(WS_STR_PROTOCOL); + //ToDo: check protocol + response->addHeader(WS_STR_PROTOCOL, protocol->value()); + } + request->send(response); +} + +AsyncWebSocketMessageBuffer * AsyncWebSocket::makeBuffer(size_t size) +{ + AsyncWebSocketMessageBuffer * buffer = new AsyncWebSocketMessageBuffer(size); + if (buffer) { + AsyncWebLockGuard l(_lock); + _buffers.add(buffer); + } + return buffer; +} + +AsyncWebSocketMessageBuffer * AsyncWebSocket::makeBuffer(uint8_t * data, size_t size) +{ + AsyncWebSocketMessageBuffer * buffer = new AsyncWebSocketMessageBuffer(data, size); + + if (buffer) { + AsyncWebLockGuard l(_lock); + _buffers.add(buffer); + } + + return buffer; +} + +void AsyncWebSocket::_cleanBuffers() +{ + AsyncWebLockGuard l(_lock); + + for(AsyncWebSocketMessageBuffer * c: _buffers){ + if(c && c->canDelete()){ + _buffers.remove(c); + } + } +} + +AsyncWebSocket::AsyncWebSocketClientLinkedList AsyncWebSocket::getClients() const { + return _clients; +} + +/* + * Response to Web Socket request - sends the authorization and detaches the TCP Client from the web server + * Authentication code from https://github.com/Links2004/arduinoWebSockets/blob/master/src/WebSockets.cpp#L480 + */ + +AsyncWebSocketResponse::AsyncWebSocketResponse(const String& key, AsyncWebSocket *server){ + _server = server; + _code = 101; + _sendContentLength = false; + + uint8_t * hash = (uint8_t*)malloc(20); + if(hash == NULL){ + _state = RESPONSE_FAILED; + return; + } + char * buffer = (char *) malloc(33); + if(buffer == NULL){ + free(hash); + _state = RESPONSE_FAILED; + return; + } +#ifdef ESP8266 + sha1(key + WS_STR_UUID, hash); +#else + (String&)key += WS_STR_UUID; + SHA1_CTX ctx; + SHA1Init(&ctx); + SHA1Update(&ctx, (const unsigned char*)key.c_str(), key.length()); + SHA1Final(hash, &ctx); +#endif + base64_encodestate _state; + base64_init_encodestate(&_state); + int len = base64_encode_block((const char *) hash, 20, buffer, &_state); + len = base64_encode_blockend((buffer + len), &_state); + addHeader(WS_STR_CONNECTION, WS_STR_UPGRADE); + addHeader(WS_STR_UPGRADE, F("websocket")); + addHeader(WS_STR_ACCEPT,buffer); + free(buffer); + free(hash); +} + +void AsyncWebSocketResponse::_respond(AsyncWebServerRequest *request){ + if(_state == RESPONSE_FAILED){ + request->client()->close(true); + return; + } + String out = _assembleHead(request->version()); + request->client()->write(out.c_str(), _headLength); + _state = RESPONSE_WAIT_ACK; +} + +size_t AsyncWebSocketResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){ + (void)time; + if(len){ + new AsyncWebSocketClient(request, _server); + } + return 0; +} diff --git a/lib/ESPAsyncWebServer/AsyncWebSocket.h b/lib/ESPAsyncWebServer/AsyncWebSocket.h new file mode 100644 index 000000000..69dfaa9d0 --- /dev/null +++ b/lib/ESPAsyncWebServer/AsyncWebSocket.h @@ -0,0 +1,448 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef ASYNCWEBSOCKET_H_ +#define ASYNCWEBSOCKET_H_ + +#include +#ifdef ESP32 +#include +#ifndef WS_MAX_QUEUED_MESSAGES +#define WS_MAX_QUEUED_MESSAGES 32 +#endif +#ifndef WS_MAX_QUEUED_MESSAGES_SIZE +#define WS_MAX_QUEUED_MESSAGES_SIZE 65535 +#endif +#else +#include +#ifndef WS_MAX_QUEUED_MESSAGES +#define WS_MAX_QUEUED_MESSAGES 8 +#endif +#ifndef WS_MAX_QUEUED_MESSAGES_SIZE +#define WS_MAX_QUEUED_MESSAGES_SIZE 8192 +#endif +#endif +#include + +// 0 = disable +#ifndef WS_MAX_QUEUED_MESSAGES_MIN_HEAP +#define WS_MAX_QUEUED_MESSAGES_MIN_HEAP 0 +#endif + +#include "AsyncWebSynchronization.h" + +#ifdef ESP8266 +#include +#ifdef CRYPTO_HASH_h // include Hash.h from espressif framework if the first include was from the crypto library +#include <../src/Hash.h> +#endif +#endif + +#ifdef ESP32 +#define DEFAULT_MAX_WS_CLIENTS 8 +#else +#define DEFAULT_MAX_WS_CLIENTS 4 +#endif + +class AsyncWebSocket; +class AsyncWebSocketResponse; +class AsyncWebSocketClient; +class AsyncWebSocketControl; + +typedef struct { + /** Message type as defined by enum AwsFrameType. + * Note: Applications will only see WS_TEXT and WS_BINARY. + * All other types are handled by the library. */ + uint8_t message_opcode; + /** Frame number of a fragmented message. */ + uint32_t num; + /** Is this the last frame in a fragmented message ?*/ + uint8_t final; + /** Is this frame masked? */ + uint8_t masked; + /** Message type as defined by enum AwsFrameType. + * This value is the same as message_opcode for non-fragmented + * messages, but may also be WS_CONTINUATION in a fragmented message. */ + uint8_t opcode; + /** Length of the current frame. + * This equals the total length of the message if num == 0 && final == true */ + uint64_t len; + /** Mask key */ + uint8_t mask[4]; + /** Offset of the data inside the current frame. */ + uint64_t index; +} AwsFrameInfo; + +typedef enum { WS_DISCONNECTED, WS_CONNECTED, WS_DISCONNECTING } AwsClientStatus; +typedef enum { WS_CONTINUATION, WS_TEXT, WS_BINARY, WS_DISCONNECT = 0x08, WS_PING, WS_PONG } AwsFrameType; +typedef enum { WS_MSG_SENDING, WS_MSG_SENT, WS_MSG_ERROR } AwsMessageStatus; +typedef enum { WS_EVT_CONNECT, WS_EVT_DISCONNECT, WS_EVT_PONG, WS_EVT_ERROR, WS_EVT_DATA } AwsEventType; + +class AsyncWebSocketMessageBuffer { + private: + uint8_t * _data; + size_t _len; + bool _lock; + uint32_t _count; + + public: + AsyncWebSocketMessageBuffer(); + AsyncWebSocketMessageBuffer(size_t size); + AsyncWebSocketMessageBuffer(uint8_t * data, size_t size); + AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer &); + AsyncWebSocketMessageBuffer(AsyncWebSocketMessageBuffer &&); + ~AsyncWebSocketMessageBuffer(); + void operator ++(int i) { (void)i; _count++; } + void operator --(int i) { (void)i; if (_count > 0) { _count--; } ; } + bool reserve(size_t size); + void lock() { _lock = true; } + void unlock() { _lock = false; } + uint8_t * get() { return _data; } + size_t length() { return _len; } + uint32_t count() { return _count; } + bool canDelete() { return (!_count && !_lock); } + + friend AsyncWebSocket; + +}; + +class AsyncWebSocketMessage { + protected: + uint8_t _opcode; + bool _mask; + AwsMessageStatus _status; + public: + AsyncWebSocketMessage():_opcode(WS_TEXT),_mask(false),_status(WS_MSG_ERROR){} + virtual ~AsyncWebSocketMessage(){} + virtual void ack(size_t len __attribute__((unused)), uint32_t time __attribute__((unused))){} + virtual size_t send(AsyncClient *client __attribute__((unused))){ return 0; } + virtual bool finished(){ return _status != WS_MSG_SENDING; } + virtual bool betweenFrames() const { return false; } +}; + +class AsyncWebSocketBasicMessage: public AsyncWebSocketMessage { + private: + size_t _len; + size_t _sent; + size_t _ack; + size_t _acked; + uint8_t * _data; +public: + AsyncWebSocketBasicMessage(const char * data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false); + AsyncWebSocketBasicMessage(uint8_t opcode=WS_TEXT, bool mask=false); + virtual ~AsyncWebSocketBasicMessage() override; + virtual bool betweenFrames() const override { return _acked == _ack; } + virtual void ack(size_t len, uint32_t time) override ; + virtual size_t send(AsyncClient *client) override ; +}; + +class AsyncWebSocketMultiMessage: public AsyncWebSocketMessage { + private: + uint8_t * _data; + size_t _len; + size_t _sent; + size_t _ack; + size_t _acked; + AsyncWebSocketMessageBuffer * _WSbuffer; +public: + AsyncWebSocketMultiMessage(AsyncWebSocketMessageBuffer * buffer, uint8_t opcode=WS_TEXT, bool mask=false); + virtual ~AsyncWebSocketMultiMessage() override; + virtual bool betweenFrames() const override { return _acked == _ack; } + virtual void ack(size_t len, uint32_t time) override ; + virtual size_t send(AsyncClient *client) override ; +}; + +class AsyncWebSocketMessageBufferLinkedList : public LinkedList { +public: + using T = AsyncWebSocketMessageBuffer *; + using LT = LinkedList; + +private: + void onRemove(AsyncWebSocketMessageBuffer *t) { + _totalSize -= t->length(); + _totalCount--; + delete t; + } + +public: + AsyncWebSocketMessageBufferLinkedList() : LT([this](AsyncWebSocketMessageBuffer *b){ this->onRemove(b); }) { + } + + void add(const T& t){ + _totalSize += t->length(); + _totalCount++; + LT::add(t); + } + +private: + friend class AsyncWebSocket; + + // counters for all web sockets + static size_t _totalCount; + static size_t _totalSize; +}; + +class AsyncWebSocketClient { + private: + AsyncClient *_client; + AsyncWebSocket *_server; + uint32_t _clientId; + AwsClientStatus _status; + + LinkedList _controlQueue; + LinkedList _messageQueue; + + uint8_t _pstate; + AwsFrameInfo _pinfo; + + uint32_t _lastMessageTime; + uint32_t _keepAlivePeriod; + + void _queueMessage(AsyncWebSocketMessage *dataMessage); + void _queueControl(AsyncWebSocketControl *controlMessage); + void _runQueue(); + + public: + void *_tempObject; + + AsyncWebSocketClient(AsyncWebServerRequest *request, AsyncWebSocket *server); + ~AsyncWebSocketClient(); + + //client id increments for the given server + uint32_t id(){ return _clientId; } + AwsClientStatus status(){ return _status; } + AsyncClient* client(){ return _client; } + AsyncWebSocket *server(){ return _server; } + AwsFrameInfo const &pinfo() const { return _pinfo; } + + IPAddress remoteIP(); + uint16_t remotePort(); + + //control frames + void close(uint16_t code=0, const char * message=NULL); + void ping(uint8_t *data=NULL, size_t len=0); + + //set auto-ping period in seconds. disabled if zero (default) + void keepAlivePeriod(uint16_t seconds){ + _keepAlivePeriod = seconds * 1000; + } + uint16_t keepAlivePeriod(){ + return (uint16_t)(_keepAlivePeriod / 1000); + } + + //data packets + void message(AsyncWebSocketMessage *message){ _queueMessage(message); } + bool queueIsFull(); + + size_t printf(const char *format, ...) __attribute__ ((format (printf, 2, 3))); +#ifndef ESP32 + size_t printf_P(PGM_P formatP, ...) __attribute__ ((format (printf, 2, 3))); +#endif + void text(const char * message, size_t len); + void text(const char * message); + void text(uint8_t * message, size_t len); + void text(char * message); + void text(const String &message); + void text(const __FlashStringHelper *data); + void text(AsyncWebSocketMessageBuffer *buffer); + + void binary(const char * message, size_t len); + void binary(const char * message); + void binary(uint8_t * message, size_t len); + void binary(char * message); + void binary(const String &message); + void binary(const __FlashStringHelper *data, size_t len); + void binary(AsyncWebSocketMessageBuffer *buffer); + + bool canSend() { return !_queueIsFull(); } + + bool _queueIsFull() const; + + //system callbacks (do not call) + void _onAck(size_t len, uint32_t time); + void _onError(int8_t); + void _onPoll(); + void _onTimeout(uint32_t time); + void _onDisconnect(); + void _onData(void *pbuf, size_t plen); +}; + +typedef std::function AwsEventHandler; + +//WebServer Handler implementation that plays the role of a socket server +class AsyncWebSocket: public AsyncWebHandler { + public: + typedef LinkedList AsyncWebSocketClientLinkedList; + private: + String _url; + AsyncWebSocketClientLinkedList _clients; + uint32_t _cNextId; + AwsEventHandler _eventHandler; + bool _enabled; + AsyncWebLock _lock; + + public: + AsyncWebSocket(const String& url); + ~AsyncWebSocket(); + const char * url() const { return _url.c_str(); } + void enable(bool e){ _enabled = e; } + bool enabled() const { return _enabled; } + bool availableForWriteAll(); + bool availableForWrite(uint32_t id); + + size_t count() const; + AsyncWebSocketClient * client(uint32_t id); + bool hasClient(uint32_t id){ return client(id) != NULL; } + + void close(uint32_t id, uint16_t code=0, const char * message=NULL); + void closeAll(uint16_t code=0, const char * message=NULL); + void cleanupClients(uint16_t maxClients = DEFAULT_MAX_WS_CLIENTS); + + void ping(uint32_t id, uint8_t *data=NULL, size_t len=0); + void pingAll(uint8_t *data=NULL, size_t len=0); // done + + void text(uint32_t id, const char * message, size_t len); + void text(uint32_t id, const char * message); + void text(uint32_t id, uint8_t * message, size_t len); + void text(uint32_t id, char * message); + void text(uint32_t id, const String &message); + void text(uint32_t id, const __FlashStringHelper *message); + + void textAll(const char * message, size_t len); + void textAll(const char * message); + void textAll(uint8_t * message, size_t len); + void textAll(char * message); + void textAll(const String &message); + void textAll(const __FlashStringHelper *message); // need to convert + void textAll(AsyncWebSocketMessageBuffer * buffer); + + void binary(uint32_t id, const char * message, size_t len); + void binary(uint32_t id, const char * message); + void binary(uint32_t id, uint8_t * message, size_t len); + void binary(uint32_t id, char * message); + void binary(uint32_t id, const String &message); + void binary(uint32_t id, const __FlashStringHelper *message, size_t len); + + void binaryAll(const char * message, size_t len); + void binaryAll(const char * message); + void binaryAll(uint8_t * message, size_t len); + void binaryAll(char * message); + void binaryAll(const String &message); + void binaryAll(const __FlashStringHelper *message, size_t len); + void binaryAll(AsyncWebSocketMessageBuffer * buffer); + + void message(uint32_t id, AsyncWebSocketMessage *message); + void messageAll(AsyncWebSocketMultiMessage *message); + + size_t printf(uint32_t id, const char *format, ...) __attribute__ ((format (printf, 3, 4))); + size_t printfAll(const char *format, ...) __attribute__ ((format (printf, 2, 3))); +#ifndef ESP32 + size_t printf_P(uint32_t id, PGM_P formatP, ...) __attribute__ ((format (printf, 3, 4))); +#endif + size_t printfAll_P(PGM_P formatP, ...) __attribute__ ((format (printf, 2, 3))); + + //event listener + void onEvent(AwsEventHandler handler){ + _eventHandler = handler; + } + + //system callbacks (do not call) + uint32_t _getNextId(){ return _cNextId++; } + void _addClient(AsyncWebSocketClient * client); + void _handleDisconnect(AsyncWebSocketClient * client); + void _handleEvent(AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len); + virtual bool canHandle(AsyncWebServerRequest *request) override final; + virtual void handleRequest(AsyncWebServerRequest *request) override final; + + + // messagebuffer functions/objects. + AsyncWebSocketMessageBuffer * makeBuffer(size_t size = 0); + AsyncWebSocketMessageBuffer * makeBuffer(uint8_t * data, size_t size); + AsyncWebSocketMessageBufferLinkedList _buffers; + void _cleanBuffers(); + + AsyncWebSocketClientLinkedList getClients() const; + +public: +#ifndef DEBUG_AWS_QUEUE_COUNTERS +#define DEBUG_AWS_QUEUE_COUNTERS 0 +#endif + +#if DEBUG_AWS_QUEUE_COUNTERS + // total for all sockets + size_t getQueuedMessageCount() const { + _verifyCounters(); + return AsyncWebSocketMessageBufferLinkedList::_totalCount; + } + size_t getQueuedMessageSize() const { + _verifyCounters(); + return AsyncWebSocketMessageBufferLinkedList::_totalSize; + } + + static size_t _getQueuedMessageCount() { + return AsyncWebSocketMessageBufferLinkedList::_totalCount; + } + static size_t _getQueuedMessageSize() { + return AsyncWebSocketMessageBufferLinkedList::_totalSize; + } +private: + void _verifyCounters() const { + size_t t=0,c=0; + for(const auto b: _buffers) { + t+=b->length(); + c++; + } + if (AsyncWebSocketMessageBufferLinkedList::_totalSize!=t || AsyncWebSocketMessageBufferLinkedList::_totalCount!=c) { + ::printf(PSTR("AsyncWebSocketMessageBufferLinkedList size %u=%u cnt %u=%u\n"), AsyncWebSocketMessageBufferLinkedList::_totalSize, t,AsyncWebSocketMessageBufferLinkedList::_totalCount, c); + panic(); + } + } +#else + size_t getQueuedMessageCount() const { + return _getQueuedMessageCount(); + } + size_t getQueuedMessageSize() const { + return _getQueuedMessageSize(); + } + + static size_t _getQueuedMessageCount() { + return AsyncWebSocketMessageBufferLinkedList::_totalCount; + } + static size_t _getQueuedMessageSize() { + return AsyncWebSocketMessageBufferLinkedList::_totalSize; + } +#endif + +}; + +//WebServer response to authenticate the socket and detach the tcp client from the web server request +class AsyncWebSocketResponse: public AsyncWebServerResponse { + private: + String _content; + AsyncWebSocket *_server; + public: + AsyncWebSocketResponse(const String& key, AsyncWebSocket *server); + void _respond(AsyncWebServerRequest *request); + size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time); + bool _sourceValid() const { return true; } +}; + + +#endif /* ASYNCWEBSOCKET_H_ */ diff --git a/lib/ESPAsyncWebServer/AsyncWebSynchronization.h b/lib/ESPAsyncWebServer/AsyncWebSynchronization.h new file mode 100644 index 000000000..f36c52dcf --- /dev/null +++ b/lib/ESPAsyncWebServer/AsyncWebSynchronization.h @@ -0,0 +1,87 @@ +#ifndef ASYNCWEBSYNCHRONIZATION_H_ +#define ASYNCWEBSYNCHRONIZATION_H_ + +// Synchronisation is only available on ESP32, as the ESP8266 isn't using FreeRTOS by default + +#include + +#ifdef ESP32 + +// This is the ESP32 version of the Sync Lock, using the FreeRTOS Semaphore +class AsyncWebLock +{ +private: + SemaphoreHandle_t _lock; + mutable void *_lockedBy; + +public: + AsyncWebLock() { + _lock = xSemaphoreCreateBinary(); + _lockedBy = NULL; + xSemaphoreGive(_lock); + } + + ~AsyncWebLock() { + vSemaphoreDelete(_lock); + } + + bool lock() const { + extern void *pxCurrentTCB; + if (_lockedBy != pxCurrentTCB) { + xSemaphoreTake(_lock, portMAX_DELAY); + _lockedBy = pxCurrentTCB; + return true; + } + return false; + } + + void unlock() const { + _lockedBy = NULL; + xSemaphoreGive(_lock); + } +}; + +#else + +// This is the 8266 version of the Sync Lock which is currently unimplemented +class AsyncWebLock +{ + +public: + AsyncWebLock() { + } + + ~AsyncWebLock() { + } + + bool lock() const { + return false; + } + + void unlock() const { + } +}; +#endif + +class AsyncWebLockGuard +{ +private: + const AsyncWebLock *_lock; + +public: + AsyncWebLockGuard(const AsyncWebLock &l) { + if (l.lock()) { + _lock = &l; + } else { + _lock = NULL; + } + } + + ~AsyncWebLockGuard() { + if (_lock) { + _lock->unlock(); + } + } +}; + +#endif // ASYNCWEBSYNCHRONIZATION_H_ \ No newline at end of file diff --git a/lib/ESPAsyncWebServer/ESPAsyncWebServer.h b/lib/ESPAsyncWebServer/ESPAsyncWebServer.h new file mode 100644 index 000000000..327d177e0 --- /dev/null +++ b/lib/ESPAsyncWebServer/ESPAsyncWebServer.h @@ -0,0 +1,487 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef _ESPAsyncWebServer_H_ +#define _ESPAsyncWebServer_H_ + +#include "Arduino.h" + +#include +#include "FS.h" + +#include "StringArray.h" + +#ifdef ESP32 +#include +#include +#elif defined(ESP8266) +#include +#include +#else +#error Platform not supported +#endif + +#ifdef ASYNCWEBSERVER_REGEX +#define ASYNCWEBSERVER_REGEX_ATTRIBUTE +#else +#define ASYNCWEBSERVER_REGEX_ATTRIBUTE __attribute__((warning("ASYNCWEBSERVER_REGEX not defined"))) +#endif + +#define DEBUGF(...) //Serial.printf(__VA_ARGS__) + +class AsyncWebServer; +class AsyncWebServerRequest; +class AsyncWebServerResponse; +class AsyncWebHeader; +class AsyncWebParameter; +class AsyncWebRewrite; +class AsyncWebHandler; +class AsyncStaticWebHandler; +class AsyncCallbackWebHandler; +class AsyncResponseStream; + +#ifndef WEBSERVER_H +typedef enum { + HTTP_GET = 0b00000001, + HTTP_POST = 0b00000010, + HTTP_DELETE = 0b00000100, + HTTP_PUT = 0b00001000, + HTTP_PATCH = 0b00010000, + HTTP_HEAD = 0b00100000, + HTTP_OPTIONS = 0b01000000, + HTTP_ANY = 0b01111111, +} WebRequestMethod; +#endif + +#ifndef HAVE_FS_FILE_OPEN_MODE +namespace fs { + class FileOpenMode { + public: + static const char *read; + static const char *write; + static const char *append; + }; +}; +#else +#include "FileOpenMode.h" +#endif + +//if this value is returned when asked for data, packet will not be sent and you will be asked for data again +#define RESPONSE_TRY_AGAIN 0xFFFFFFFF + +typedef uint8_t WebRequestMethodComposite; +typedef std::function ArDisconnectHandler; + +/* + * PARAMETER :: Chainable object to hold GET/POST and FILE parameters + * */ + +class AsyncWebParameter { + private: + String _name; + String _value; + size_t _size; + bool _isForm; + bool _isFile; + + public: + + AsyncWebParameter(const String& name, const String& value, bool form=false, bool file=false, size_t size=0): _name(name), _value(value), _size(size), _isForm(form), _isFile(file){} + const String& name() const { return _name; } + const String& value() const { return _value; } + size_t size() const { return _size; } + bool isPost() const { return _isForm; } + bool isFile() const { return _isFile; } +}; + +/* + * HEADER :: Chainable object to hold the headers + * */ + +class AsyncWebHeader { + private: + String _name; + String _value; + + public: + AsyncWebHeader(const String& name, const String& value): _name(name), _value(value){} + AsyncWebHeader(const String& data): _name(), _value(){ + if(!data) return; + int index = data.indexOf(':'); + if (index < 0) return; + _name = data.substring(0, index); + _value = data.substring(index + 2); + } + ~AsyncWebHeader(){} + const String& name() const { return _name; } + const String& value() const { return _value; } + String toString() const { return String(_name + F(": ") + _value + F("\r\n")); } +}; + +/* + * REQUEST :: Each incoming Client is wrapped inside a Request and both live together until disconnect + * */ + +typedef enum { RCT_NOT_USED = -1, RCT_DEFAULT = 0, RCT_HTTP, RCT_WS, RCT_EVENT, RCT_MAX } RequestedConnectionType; + +typedef std::function AwsResponseFiller; +typedef std::function AwsTemplateProcessor; + +class AsyncWebServerRequest { + using File = fs::File; + using FS = fs::FS; + friend class AsyncWebServer; + friend class AsyncCallbackWebHandler; + friend class HttpCookieHeader; + private: + AsyncClient* _client; + AsyncWebServer* _server; + AsyncWebHandler* _handler; + AsyncWebServerResponse* _response; + StringArray _interestingHeaders; + ArDisconnectHandler _onDisconnectfn; + + String _temp; + uint8_t _parseState; + + uint8_t _version; + WebRequestMethodComposite _method; + String _url; + String _host; + String _contentType; + String _boundary; + String _authorization; + RequestedConnectionType _reqconntype; + void _removeNotInterestingHeaders(); + bool _isDigest; + bool _isMultipart; + bool _isPlainPost; + bool _expectingContinue; + size_t _contentLength; + size_t _parsedLength; + + LinkedList _headers; + LinkedList _params; + LinkedList _pathParams; + + uint8_t _multiParseState; + uint8_t _boundaryPosition; + size_t _itemStartIndex; + size_t _itemSize; + String _itemName; + String _itemFilename; + String _itemType; + String _itemValue; + uint8_t *_itemBuffer; + size_t _itemBufferIndex; + bool _itemIsFile; + + void _onPoll(); + void _onAck(size_t len, uint32_t time); + void _onError(int8_t error); + void _onTimeout(uint32_t time); + void _onDisconnect(); + void _onData(void *buf, size_t len); + + void _addParam(AsyncWebParameter*); + void _addPathParam(const char *param); + + bool _parseReqHead(); + bool _parseReqHeader(); + void _parseLine(); + void _parsePlainPostChar(uint8_t data); + void _parseMultipartPostByte(uint8_t data, bool last); + void _addGetParams(const String& params); + + void _handleUploadStart(); + void _handleUploadByte(uint8_t data, bool last); + void _handleUploadEnd(); + + public: + File _tempFile; + void *_tempObject; + + AsyncWebServerRequest(AsyncWebServer*, AsyncClient*); + ~AsyncWebServerRequest(); + + AsyncClient* client(){ return _client; } + uint8_t version() const { return _version; } + WebRequestMethodComposite method() const { return _method; } + const String& url() const { return _url; } + const String& host() const { return _host; } + const String& contentType() const { return _contentType; } + size_t contentLength() const { return _contentLength; } + bool multipart() const { return _isMultipart; } + const __FlashStringHelper *methodToString() const; + const __FlashStringHelper *requestedConnTypeToString() const; + RequestedConnectionType requestedConnType() const { return _reqconntype; } + bool isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED); + void onDisconnect (ArDisconnectHandler fn); + + //hash is the string representation of: + // base64(user:pass) for basic or + // user:realm:md5(user:realm:pass) for digest + bool authenticate(const char * hash); + bool authenticate(const char * username, const char * password, const char * realm = NULL, bool passwordIsHash = false); + void requestAuthentication(const char * realm = NULL, bool isDigest = true); + + void setHandler(AsyncWebHandler *handler){ _handler = handler; } + void addInterestingHeader(const String& name); + + void redirect(const String& url); + + void send(AsyncWebServerResponse *response); + void send(int code, const String& contentType=String(), const String& content=String()); + void send(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr); + void send(File content, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr); + void send(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback=nullptr); + void send(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr); + void sendChunked(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr); + void send_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr); + void send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback=nullptr); + + AsyncWebServerResponse *beginResponse(int code, const String& contentType=String(), const String& content=String()); + AsyncWebServerResponse *beginResponse(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr); + AsyncWebServerResponse *beginResponse(File content, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr); + AsyncWebServerResponse *beginResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback=nullptr); + AsyncWebServerResponse *beginResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr); + AsyncWebServerResponse *beginChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr); + AsyncResponseStream *beginResponseStream(const String& contentType, size_t bufferSize=1460); + AsyncWebServerResponse *beginResponse_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr); + AsyncWebServerResponse *beginResponse_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback=nullptr); + + size_t headers() const; // get header count + bool hasHeader(const String& name) const; // check if header exists + bool hasHeader(const __FlashStringHelper * data) const; // check if header exists + + AsyncWebHeader* getHeader(const String& name) const; + AsyncWebHeader* getHeader(const __FlashStringHelper * data) const; + AsyncWebHeader* getHeader(size_t num) const; + + size_t params() const; // get arguments count + bool hasParam(const String& name, bool post=false, bool file=false) const; + bool hasParam(const __FlashStringHelper * data, bool post=false, bool file=false) const; + + AsyncWebParameter* getParam(const String& name, bool post=false, bool file=false) const; + AsyncWebParameter* getParam(const __FlashStringHelper * data, bool post, bool file) const; + AsyncWebParameter* getParam(size_t num) const; + + size_t args() const { return params(); } // get arguments count + const String& arg(const String& name) const; // get request argument value by name + const String& arg(const __FlashStringHelper * data) const; // get request argument value by F(name) + const String& arg(size_t i) const; // get request argument value by number + const String& argName(size_t i) const; // get request argument name by number + bool hasArg(const char* name) const; // check if argument exists + bool hasArg(const __FlashStringHelper * data) const; // check if F(argument) exists + + const String& ASYNCWEBSERVER_REGEX_ATTRIBUTE pathArg(size_t i) const; + + const String& header(const char* name) const;// get request header value by name + const String& header(const __FlashStringHelper * data) const;// get request header value by F(name) + const String& header(size_t i) const; // get request header value by number + const String& headerName(size_t i) const; // get request header name by number + String urlDecode(const String& text) const; +}; + +/* + * FILTER :: Callback to filter AsyncWebRewrite and AsyncWebHandler (done by the Server) + * */ + +typedef std::function ArRequestFilterFunction; + +bool ON_STA_FILTER(AsyncWebServerRequest *request); + +bool ON_AP_FILTER(AsyncWebServerRequest *request); + +/* + * REWRITE :: One instance can be handle any Request (done by the Server) + * */ + +class AsyncWebRewrite { + protected: + String _from; + String _toUrl; + String _params; + ArRequestFilterFunction _filter; + public: + AsyncWebRewrite(const char* from, const char* to): _from(from), _toUrl(to), _params(String()), _filter(NULL){ + int index = _toUrl.indexOf('?'); + if (index > 0) { + _params = _toUrl.substring(index +1); + _toUrl = _toUrl.substring(0, index); + } + } + virtual ~AsyncWebRewrite(){} + AsyncWebRewrite& setFilter(ArRequestFilterFunction fn) { _filter = fn; return *this; } + bool filter(AsyncWebServerRequest *request) const { return _filter == NULL || _filter(request); } + const String& from(void) const { return _from; } + const String& toUrl(void) const { return _toUrl; } + const String& params(void) const { return _params; } + virtual bool match(AsyncWebServerRequest *request) { return from() == request->url() && filter(request); } +}; + +/* + * HANDLER :: One instance can be attached to any Request (done by the Server) + * */ + +class AsyncWebHandler { + protected: + ArRequestFilterFunction _filter; + String _username; + String _password; + public: + AsyncWebHandler():_username(""), _password(""){} + AsyncWebHandler& setFilter(ArRequestFilterFunction fn) { _filter = fn; return *this; } + AsyncWebHandler& setAuthentication(const char *username, const char *password){ _username = String(username);_password = String(password); return *this; }; + bool filter(AsyncWebServerRequest *request){ return _filter == NULL || _filter(request); } + virtual ~AsyncWebHandler(){} + virtual bool canHandle(AsyncWebServerRequest *request __attribute__((unused))){ + return false; + } + virtual void handleRequest(AsyncWebServerRequest *request __attribute__((unused))){} + virtual void handleUpload(AsyncWebServerRequest *request __attribute__((unused)), const String& filename __attribute__((unused)), size_t index __attribute__((unused)), uint8_t *data __attribute__((unused)), size_t len __attribute__((unused)), bool final __attribute__((unused))){} + virtual void handleBody(AsyncWebServerRequest *request __attribute__((unused)), uint8_t *data __attribute__((unused)), size_t len __attribute__((unused)), size_t index __attribute__((unused)), size_t total __attribute__((unused))){} + virtual bool isRequestHandlerTrivial(){return true;} +}; + +/* + * RESPONSE :: One instance is created for each Request (attached by the Handler) + * */ + +typedef enum { + RESPONSE_SETUP, RESPONSE_HEADERS, RESPONSE_CONTENT, RESPONSE_WAIT_ACK, RESPONSE_END, RESPONSE_FAILED +} WebResponseState; + +class AsyncWebServerResponse { + protected: + int _code; + LinkedList _headers; + String _contentType; + size_t _contentLength; + bool _sendContentLength; + bool _chunked; + size_t _headLength; + size_t _sentLength; + size_t _ackedLength; + size_t _writtenLength; + WebResponseState _state; + const char* _responseCodeToString(int code); +public: + static const __FlashStringHelper *responseCodeToString(int code); + + public: + AsyncWebServerResponse(); + virtual ~AsyncWebServerResponse(); + virtual void setCode(int code); + virtual void setContentLength(size_t len); + virtual void setContentType(const String& type); + virtual void addHeader(const String& name, const String& value); + virtual String _assembleHead(uint8_t version); + virtual bool _started() const; + virtual bool _finished() const; + virtual bool _failed() const; + virtual bool _sourceValid() const; + virtual void _respond(AsyncWebServerRequest *request); + virtual size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time); +}; + +/* + * SERVER :: One instance + * */ + +typedef std::function ArRequestHandlerFunction; +typedef std::function ArUploadHandlerFunction; +typedef std::function ArBodyHandlerFunction; + +class AsyncWebServer { + protected: + AsyncServer _server; + LinkedList _rewrites; + LinkedList _handlers; + AsyncCallbackWebHandler* _catchAllHandler; + + public: + AsyncWebServer(uint16_t port); + ~AsyncWebServer(); + + void begin(); + void end(); + +#if ASYNC_TCP_SSL_ENABLED + void onSslFileRequest(AcSSlFileHandler cb, void* arg); + void beginSecure(const char *cert, const char *private_key_file, const char *password); +#endif + + AsyncWebRewrite& addRewrite(AsyncWebRewrite* rewrite); + bool removeRewrite(AsyncWebRewrite* rewrite); + AsyncWebRewrite& rewrite(const char* from, const char* to); + + AsyncWebHandler& addHandler(AsyncWebHandler* handler); + bool removeHandler(AsyncWebHandler* handler); + + AsyncCallbackWebHandler& on(const char* uri, ArRequestHandlerFunction onRequest); + AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest); + AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload); + AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody); + + AsyncStaticWebHandler& serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control = NULL); + + void onNotFound(ArRequestHandlerFunction fn); //called when handler is not assigned + void onFileUpload(ArUploadHandlerFunction fn); //handle file uploads + void onRequestBody(ArBodyHandlerFunction fn); //handle posts with plain body content (JSON often transmitted this way as a request) + + void reset(); //remove all writers and handlers, with onNotFound/onFileUpload/onRequestBody + + void _handleDisconnect(AsyncWebServerRequest *request); + void _attachHandler(AsyncWebServerRequest *request); + void _rewriteRequest(AsyncWebServerRequest *request); +}; + +class DefaultHeaders { + using headers_t = LinkedList; + headers_t _headers; + + DefaultHeaders() + :_headers(headers_t([](AsyncWebHeader *h){ delete h; })) + {} +public: + using ConstIterator = headers_t::ConstIterator; + + void addHeader(const String& name, const String& value){ + _headers.add(new AsyncWebHeader(name, value)); + } + + ConstIterator begin() const { return _headers.begin(); } + ConstIterator end() const { return _headers.end(); } + + DefaultHeaders(DefaultHeaders const &) = delete; + DefaultHeaders &operator=(DefaultHeaders const &) = delete; + static DefaultHeaders &Instance() { + static DefaultHeaders instance; + return instance; + } +}; + +#include "WebResponseImpl.h" +#include "WebHandlerImpl.h" +#include "AsyncWebSocket.h" +#include "AsyncEventSource.h" + +#endif /* _AsyncWebServer_H_ */ diff --git a/lib/ESPAsyncWebServer/README.md b/lib/ESPAsyncWebServer/README.md new file mode 100644 index 000000000..e8cbbb85d --- /dev/null +++ b/lib/ESPAsyncWebServer/README.md @@ -0,0 +1,1526 @@ +# Changes in this fork + +- Optimized memory usage by moving all strings to PROGMEM, saving 1.5-2KB of RAM +- AsyncWebSockets are not limit to the number of messages, but the total size of messages in the queue or free heap (see AsyncWebSocket.h) + +# ESPAsyncWebServer +[![Build Status](https://travis-ci.org/me-no-dev/ESPAsyncWebServer.svg?branch=master)](https://travis-ci.org/me-no-dev/ESPAsyncWebServer) ![](https://github.com/me-no-dev/ESPAsyncWebServer/workflows/ESP%20Async%20Web%20Server%20CI/badge.svg) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/395dd42cfc674e6ca2e326af3af80ffc)](https://www.codacy.com/manual/me-no-dev/ESPAsyncWebServer?utm_source=github.com&utm_medium=referral&utm_content=me-no-dev/ESPAsyncWebServer&utm_campaign=Badge_Grade) + +For help and support [![Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer](https://badges.gitter.im/me-no-dev/ESPAsyncWebServer.svg)](https://gitter.im/me-no-dev/ESPAsyncWebServer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +Async HTTP and WebSocket Server for ESP8266 Arduino + +For ESP8266 it requires [ESPAsyncTCP](https://github.com/me-no-dev/ESPAsyncTCP) +To use this library you might need to have the latest git versions of [ESP8266](https://github.com/esp8266/Arduino) Arduino Core + +For ESP32 it requires [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) to work +To use this library you might need to have the latest git versions of [ESP32](https://github.com/espressif/arduino-esp32) Arduino Core + +## Table of contents +- [ESPAsyncWebServer](#espasyncwebserver) + - [Table of contents](#table-of-contents) + - [Installation](#installation) + - [Using PlatformIO](#using-platformio) + - [Why should you care](#why-should-you-care) + - [Important things to remember](#important-things-to-remember) + - [Principles of operation](#principles-of-operation) + - [The Async Web server](#the-async-web-server) + - [Request Life Cycle](#request-life-cycle) + - [Rewrites and how do they work](#rewrites-and-how-do-they-work) + - [Handlers and how do they work](#handlers-and-how-do-they-work) + - [Responses and how do they work](#responses-and-how-do-they-work) + - [Template processing](#template-processing) + - [Libraries and projects that use AsyncWebServer](#libraries-and-projects-that-use-asyncwebserver) + - [Request Variables](#request-variables) + - [Common Variables](#common-variables) + - [Headers](#headers) + - [GET, POST and FILE parameters](#get-post-and-file-parameters) + - [FILE Upload handling](#file-upload-handling) + - [Body data handling](#body-data-handling) + - [JSON body handling with ArduinoJson](#json-body-handling-with-arduinojson) + - [Responses](#responses) + - [Redirect to another URL](#redirect-to-another-url) + - [Basic response with HTTP Code](#basic-response-with-http-code) + - [Basic response with HTTP Code and extra headers](#basic-response-with-http-code-and-extra-headers) + - [Basic response with string content](#basic-response-with-string-content) + - [Basic response with string content and extra headers](#basic-response-with-string-content-and-extra-headers) + - [Send large webpage from PROGMEM](#send-large-webpage-from-progmem) + - [Send large webpage from PROGMEM and extra headers](#send-large-webpage-from-progmem-and-extra-headers) + - [Send large webpage from PROGMEM containing templates](#send-large-webpage-from-progmem-containing-templates) + - [Send large webpage from PROGMEM containing templates and extra headers](#send-large-webpage-from-progmem-containing-templates-and-extra-headers) + - [Send binary content from PROGMEM](#send-binary-content-from-progmem) + - [Respond with content coming from a Stream](#respond-with-content-coming-from-a-stream) + - [Respond with content coming from a Stream and extra headers](#respond-with-content-coming-from-a-stream-and-extra-headers) + - [Respond with content coming from a Stream containing templates](#respond-with-content-coming-from-a-stream-containing-templates) + - [Respond with content coming from a Stream containing templates and extra headers](#respond-with-content-coming-from-a-stream-containing-templates-and-extra-headers) + - [Respond with content coming from a File](#respond-with-content-coming-from-a-file) + - [Respond with content coming from a File and extra headers](#respond-with-content-coming-from-a-file-and-extra-headers) + - [Respond with content coming from a File containing templates](#respond-with-content-coming-from-a-file-containing-templates) + - [Respond with content using a callback](#respond-with-content-using-a-callback) + - [Respond with content using a callback and extra headers](#respond-with-content-using-a-callback-and-extra-headers) + - [Respond with content using a callback containing templates](#respond-with-content-using-a-callback-containing-templates) + - [Respond with content using a callback containing templates and extra headers](#respond-with-content-using-a-callback-containing-templates-and-extra-headers) + - [Chunked Response](#chunked-response) + - [Chunked Response containing templates](#chunked-response-containing-templates) + - [Print to response](#print-to-response) + - [ArduinoJson Basic Response](#arduinojson-basic-response) + - [ArduinoJson Advanced Response](#arduinojson-advanced-response) + - [Serving static files](#serving-static-files) + - [Serving specific file by name](#serving-specific-file-by-name) + - [Serving files in directory](#serving-files-in-directory) + - [Serving static files with authentication](#serving-static-files-with-authentication) + - [Specifying Cache-Control header](#specifying-cache-control-header) + - [Specifying Date-Modified header](#specifying-date-modified-header) + - [Specifying Template Processor callback](#specifying-template-processor-callback) + - [Param Rewrite With Matching](#param-rewrite-with-matching) + - [Using filters](#using-filters) + - [Serve different site files in AP mode](#serve-different-site-files-in-ap-mode) + - [Rewrite to different index on AP](#rewrite-to-different-index-on-ap) + - [Serving different hosts](#serving-different-hosts) + - [Determine interface inside callbacks](#determine-interface-inside-callbacks) + - [Bad Responses](#bad-responses) + - [Respond with content using a callback without content length to HTTP/1.0 clients](#respond-with-content-using-a-callback-without-content-length-to-http10-clients) + - [Async WebSocket Plugin](#async-websocket-plugin) + - [Async WebSocket Event](#async-websocket-event) + - [Methods for sending data to a socket client](#methods-for-sending-data-to-a-socket-client) + - [Direct access to web socket message buffer](#direct-access-to-web-socket-message-buffer) + - [Limiting the number of web socket clients](#limiting-the-number-of-web-socket-clients) + - [Async Event Source Plugin](#async-event-source-plugin) + - [Setup Event Source on the server](#setup-event-source-on-the-server) + - [Setup Event Source in the browser](#setup-event-source-in-the-browser) + - [Scanning for available WiFi Networks](#scanning-for-available-wifi-networks) + - [Remove handlers and rewrites](#remove-handlers-and-rewrites) + - [Setting up the server](#setting-up-the-server) + - [Setup global and class functions as request handlers](#setup-global-and-class-functions-as-request-handlers) + - [Methods for controlling websocket connections](#methods-for-controlling-websocket-connections) + - [Adding Default Headers](#adding-default-headers) + - [Path variable](#path-variable) + +## Installation + +### Using PlatformIO + +[PlatformIO](http://platformio.org) is an open source ecosystem for IoT development with cross platform build system, library manager and full support for Espressif ESP8266/ESP32 development. It works on the popular host OS: Mac OS X, Windows, Linux 32/64, Linux ARM (like Raspberry Pi, BeagleBone, CubieBoard). + +1. Install [PlatformIO IDE](http://platformio.org/platformio-ide) +2. Create new project using "PlatformIO Home > New Project" +3. Update dev/platform to staging version: + - [Instruction for Espressif 8266](http://docs.platformio.org/en/latest/platforms/espressif8266.html#using-arduino-framework-with-staging-version) + - [Instruction for Espressif 32](http://docs.platformio.org/en/latest/platforms/espressif32.html#using-arduino-framework-with-staging-version) + 4. Add "ESP Async WebServer" to project using [Project Configuration File `platformio.ini`](http://docs.platformio.org/page/projectconf.html) and [lib_deps](http://docs.platformio.org/page/projectconf/section_env_library.html#lib-deps) option: + +```ini +[env:myboard] +platform = espressif... +board = ... +framework = arduino + +# using the latest stable version +lib_deps = ESP Async WebServer + +# or using GIT Url (the latest development version) +lib_deps = https://github.com/me-no-dev/ESPAsyncWebServer.git +``` + 5. Happy coding with PlatformIO! + +## Why should you care +- Using asynchronous network means that you can handle more than one connection at the same time +- You are called once the request is ready and parsed +- When you send the response, you are immediately ready to handle other connections + while the server is taking care of sending the response in the background +- Speed is OMG +- Easy to use API, HTTP Basic and Digest MD5 Authentication (default), ChunkedResponse +- Easily extendible to handle any type of content +- Supports Continue 100 +- Async WebSocket plugin offering different locations without extra servers or ports +- Async EventSource (Server-Sent Events) plugin to send events to the browser +- URL Rewrite plugin for conditional and permanent url rewrites +- ServeStatic plugin that supports cache, Last-Modified, default index and more +- Simple template processing engine to handle templates + +## Important things to remember +- This is fully asynchronous server and as such does not run on the loop thread. +- You can not use yield or delay or any function that uses them inside the callbacks +- The server is smart enough to know when to close the connection and free resources +- You can not send more than one response to a single request + +## Principles of operation + +### The Async Web server +- Listens for connections +- Wraps the new clients into ```Request``` +- Keeps track of clients and cleans memory +- Manages ```Rewrites``` and apply them on the request url +- Manages ```Handlers``` and attaches them to Requests + +### Request Life Cycle +- TCP connection is received by the server +- The connection is wrapped inside ```Request``` object +- When the request head is received (type, url, get params, http version and host), + the server goes through all ```Rewrites``` (in the order they were added) to rewrite the url and inject query parameters, + next, it goes through all attached ```Handlers```(in the order they were added) trying to find one + that ```canHandle``` the given request. If none are found, the default(catch-all) handler is attached. +- The rest of the request is received, calling the ```handleUpload``` or ```handleBody``` methods of the ```Handler``` if they are needed (POST+File/Body) +- When the whole request is parsed, the result is given to the ```handleRequest``` method of the ```Handler``` and is ready to be responded to +- In the ```handleRequest``` method, to the ```Request``` is attached a ```Response``` object (see below) that will serve the response data back to the client +- When the ```Response``` is sent, the client is closed and freed from the memory + +### Rewrites and how do they work +- The ```Rewrites``` are used to rewrite the request url and/or inject get parameters for a specific request url path. +- All ```Rewrites``` are evaluated on the request in the order they have been added to the server. +- The ```Rewrite``` will change the request url only if the request url (excluding get parameters) is fully match + the rewrite url, and when the optional ```Filter``` callback return true. +- Setting a ```Filter``` to the ```Rewrite``` enables to control when to apply the rewrite, decision can be based on + request url, http version, request host/port/target host, get parameters or the request client's localIP or remoteIP. +- Two filter callbacks are provided: ```ON_AP_FILTER``` to execute the rewrite when request is made to the AP interface, + ```ON_STA_FILTER``` to execute the rewrite when request is made to the STA interface. +- The ```Rewrite``` can specify a target url with optional get parameters, e.g. ```/to-url?with=params``` + +### Handlers and how do they work +- The ```Handlers``` are used for executing specific actions to particular requests +- One ```Handler``` instance can be attached to any request and lives together with the server +- Setting a ```Filter``` to the ```Handler``` enables to control when to apply the handler, decision can be based on + request url, http version, request host/port/target host, get parameters or the request client's localIP or remoteIP. +- Two filter callbacks are provided: ```ON_AP_FILTER``` to execute the rewrite when request is made to the AP interface, + ```ON_STA_FILTER``` to execute the rewrite when request is made to the STA interface. +- The ```canHandle``` method is used for handler specific control on whether the requests can be handled + and for declaring any interesting headers that the ```Request``` should parse. Decision can be based on request + method, request url, http version, request host/port/target host and get parameters +- Once a ```Handler``` is attached to given ```Request``` (```canHandle``` returned true) + that ```Handler``` takes care to receive any file/data upload and attach a ```Response``` + once the ```Request``` has been fully parsed +- ```Handlers``` are evaluated in the order they are attached to the server. The ```canHandle``` is called only + if the ```Filter``` that was set to the ```Handler``` return true. +- The first ```Handler``` that can handle the request is selected, not further ```Filter``` and ```canHandle``` are called. + +### Responses and how do they work +- The ```Response``` objects are used to send the response data back to the client +- The ```Response``` object lives with the ```Request``` and is freed on end or disconnect +- Different techniques are used depending on the response type to send the data in packets + returning back almost immediately and sending the next packet when this one is received. + Any time in between is spent to run the user loop and handle other network packets +- Responding asynchronously is probably the most difficult thing for most to understand +- Many different options exist for the user to make responding a background task + +### Template processing +- ESPAsyncWebserver contains simple template processing engine. +- Template processing can be added to most response types. +- Currently it supports only replacing template placeholders with actual values. No conditional processing, cycles, etc. +- Placeholders are delimited with ```%``` symbols. Like this: ```%TEMPLATE_PLACEHOLDER%```. +- It works by extracting placeholder name from response text and passing it to user provided function which should return actual value to be used instead of placeholder. +- Since it's user provided function, it is possible for library users to implement conditional processing and cycles themselves. +- Since it's impossible to know the actual response size after template processing step in advance (and, therefore, to include it in response headers), the response becomes [chunked](#chunked-response). + +## Libraries and projects that use AsyncWebServer +- [WebSocketToSerial](https://github.com/hallard/WebSocketToSerial) - Debug serial devices through the web browser +- [Sattrack](https://github.com/Hopperpop/Sattrack) - Track the ISS with ESP8266 +- [ESP Radio](https://github.com/Edzelf/Esp-radio) - Icecast radio based on ESP8266 and VS1053 +- [VZero](https://github.com/andig/vzero) - the Wireless zero-config controller for volkszaehler.org +- [ESPurna](https://bitbucket.org/xoseperez/espurna) - ESPurna ("spark" in Catalan) is a custom C firmware for ESP8266 based smart switches. It was originally developed with the ITead Sonoff in mind. +- [fauxmoESP](https://bitbucket.org/xoseperez/fauxmoesp) - Belkin WeMo emulator library for ESP8266. +- [ESP-RFID](https://github.com/omersiar/esp-rfid) - MFRC522 RFID Access Control Management project for ESP8266. + +## Request Variables + +### Common Variables +```cpp +request->version(); // uint8_t: 0 = HTTP/1.0, 1 = HTTP/1.1 +request->method(); // enum: HTTP_GET, HTTP_POST, HTTP_DELETE, HTTP_PUT, HTTP_PATCH, HTTP_HEAD, HTTP_OPTIONS +request->url(); // String: URL of the request (not including host, port or GET parameters) +request->host(); // String: The requested host (can be used for virtual hosting) +request->contentType(); // String: ContentType of the request (not avaiable in Handler::canHandle) +request->contentLength(); // size_t: ContentLength of the request (not avaiable in Handler::canHandle) +request->multipart(); // bool: True if the request has content type "multipart" +``` + +### Headers +```cpp +//List all collected headers +int headers = request->headers(); +int i; +for(i=0;igetHeader(i); + Serial.printf("HEADER[%s]: %s\n", h->name().c_str(), h->value().c_str()); +} + +//get specific header by name +if(request->hasHeader("MyHeader")){ + AsyncWebHeader* h = request->getHeader("MyHeader"); + Serial.printf("MyHeader: %s\n", h->value().c_str()); +} + +//List all collected headers (Compatibility) +int headers = request->headers(); +int i; +for(i=0;iheaderName(i).c_str(), request->header(i).c_str()); +} + +//get specific header by name (Compatibility) +if(request->hasHeader("MyHeader")){ + Serial.printf("MyHeader: %s\n", request->header("MyHeader").c_str()); +} +``` + +### GET, POST and FILE parameters +```cpp +//List all parameters +int params = request->params(); +for(int i=0;igetParam(i); + if(p->isFile()){ //p->isPost() is also true + Serial.printf("FILE[%s]: %s, size: %u\n", p->name().c_str(), p->value().c_str(), p->size()); + } else if(p->isPost()){ + Serial.printf("POST[%s]: %s\n", p->name().c_str(), p->value().c_str()); + } else { + Serial.printf("GET[%s]: %s\n", p->name().c_str(), p->value().c_str()); + } +} + +//Check if GET parameter exists +if(request->hasParam("download")) + AsyncWebParameter* p = request->getParam("download"); + +//Check if POST (but not File) parameter exists +if(request->hasParam("download", true)) + AsyncWebParameter* p = request->getParam("download", true); + +//Check if FILE was uploaded +if(request->hasParam("download", true, true)) + AsyncWebParameter* p = request->getParam("download", true, true); + +//List all parameters (Compatibility) +int args = request->args(); +for(int i=0;iargName(i).c_str(), request->arg(i).c_str()); +} + +//Check if parameter exists (Compatibility) +if(request->hasArg("download")) + String arg = request->arg("download"); +``` + +### FILE Upload handling +```cpp +void handleUpload(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final){ + if(!index){ + Serial.printf("UploadStart: %s\n", filename.c_str()); + } + for(size_t i=0; i(); + // ... +}); +server.addHandler(handler); +``` + +## Responses +### Redirect to another URL +```cpp +//to local url +request->redirect("/login"); + +//to external url +request->redirect("http://esp8266.com"); +``` + +### Basic response with HTTP Code +```cpp +request->send(404); //Sends 404 File Not Found +``` + +### Basic response with HTTP Code and extra headers +```cpp +AsyncWebServerResponse *response = request->beginResponse(404); //Sends 404 File Not Found +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Basic response with string content +```cpp +request->send(200, "text/plain", "Hello World!"); +``` + +### Basic response with string content and extra headers +```cpp +AsyncWebServerResponse *response = request->beginResponse(200, "text/plain", "Hello World!"); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Send large webpage from PROGMEM +```cpp +const char index_html[] PROGMEM = "..."; // large char array, tested with 14k +request->send_P(200, "text/html", index_html); +``` + +### Send large webpage from PROGMEM and extra headers +```cpp +const char index_html[] PROGMEM = "..."; // large char array, tested with 14k +AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", index_html); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Send large webpage from PROGMEM containing templates +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +const char index_html[] PROGMEM = "..."; // large char array, tested with 14k +request->send_P(200, "text/html", index_html, processor); +``` + +### Send large webpage from PROGMEM containing templates and extra headers +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +const char index_html[] PROGMEM = "..."; // large char array, tested with 14k +AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", index_html, processor); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Send binary content from PROGMEM +```cpp + +//File: favicon.ico.gz, Size: 726 +#define favicon_ico_gz_len 726 +const uint8_t favicon_ico_gz[] PROGMEM = { + 0x1F, 0x8B, 0x08, 0x08, 0x0B, 0x87, 0x90, 0x57, 0x00, 0x03, 0x66, 0x61, 0x76, 0x69, 0x63, 0x6F, + 0x6E, 0x2E, 0x69, 0x63, 0x6F, 0x00, 0xCD, 0x53, 0x5F, 0x48, 0x9A, 0x51, 0x14, 0xBF, 0x62, 0x6D, + 0x86, 0x96, 0xA9, 0x64, 0xD3, 0xFE, 0xA8, 0x99, 0x65, 0x1A, 0xB4, 0x8A, 0xA8, 0x51, 0x54, 0x23, + 0xA8, 0x11, 0x49, 0x51, 0x8A, 0x34, 0x62, 0x93, 0x85, 0x31, 0x58, 0x44, 0x12, 0x45, 0x2D, 0x58, + 0xF5, 0x52, 0x41, 0x10, 0x23, 0x82, 0xA0, 0x20, 0x98, 0x2F, 0xC1, 0x26, 0xED, 0xA1, 0x20, 0x89, + 0x04, 0xD7, 0x83, 0x58, 0x20, 0x28, 0x04, 0xAB, 0xD1, 0x9B, 0x8C, 0xE5, 0xC3, 0x60, 0x32, 0x64, + 0x0E, 0x56, 0xBF, 0x9D, 0xEF, 0xF6, 0x30, 0x82, 0xED, 0xAD, 0x87, 0xDD, 0x8F, 0xF3, 0xDD, 0x8F, + 0x73, 0xCF, 0xEF, 0x9C, 0xDF, 0x39, 0xBF, 0xFB, 0x31, 0x26, 0xA2, 0x27, 0x37, 0x97, 0xD1, 0x5B, + 0xCF, 0x9E, 0x67, 0x30, 0xA6, 0x66, 0x8C, 0x99, 0xC9, 0xC8, 0x45, 0x9E, 0x6B, 0x3F, 0x5F, 0x74, + 0xA6, 0x94, 0x5E, 0xDB, 0xFF, 0xB2, 0xE6, 0xE7, 0xE7, 0xF9, 0xDE, 0xD6, 0xD6, 0x96, 0xDB, 0xD8, + 0xD8, 0x78, 0xBF, 0xA1, 0xA1, 0xC1, 0xDA, 0xDC, 0xDC, 0x2C, 0xEB, 0xED, 0xED, 0x15, 0x9B, 0xCD, + 0xE6, 0x4A, 0x83, 0xC1, 0xE0, 0x2E, 0x29, 0x29, 0x99, 0xD6, 0x6A, 0xB5, 0x4F, 0x75, 0x3A, 0x9D, + 0x61, 0x75, 0x75, 0x95, 0xB5, 0xB7, 0xB7, 0xDF, 0xC8, 0xD1, 0xD4, 0xD4, 0xF4, 0xB0, 0xBA, 0xBA, + 0xFA, 0x83, 0xD5, 0x6A, 0xFD, 0x5A, 0x5E, 0x5E, 0x9E, 0x28, 0x2D, 0x2D, 0x0D, 0x10, 0xC6, 0x4B, + 0x98, 0x78, 0x5E, 0x5E, 0xDE, 0x95, 0x42, 0xA1, 0x40, 0x4E, 0x4E, 0xCE, 0x65, 0x76, 0x76, 0xF6, + 0x47, 0xB5, 0x5A, 0x6D, 0x4F, 0x26, 0x93, 0xA2, 0xD6, 0xD6, 0x56, 0x8E, 0x6D, 0x69, 0x69, 0xD1, + 0x11, 0x36, 0x62, 0xB1, 0x58, 0x60, 0x32, 0x99, 0xA0, 0xD7, 0xEB, 0x51, 0x58, 0x58, 0x88, 0xFC, + 0xFC, 0x7C, 0x10, 0x16, 0x02, 0x56, 0x2E, 0x97, 0x43, 0x2A, 0x95, 0x42, 0x2C, 0x16, 0x23, 0x33, + 0x33, 0x33, 0xAE, 0x52, 0xA9, 0x1E, 0x64, 0x65, 0x65, 0x71, 0x7C, 0x7D, 0x7D, 0xBD, 0x93, 0xEA, + 0xFE, 0x30, 0x1A, 0x8D, 0xE8, 0xEC, 0xEC, 0xC4, 0xE2, 0xE2, 0x22, 0x6A, 0x6A, 0x6A, 0x40, 0x39, + 0x41, 0xB5, 0x38, 0x4E, 0xC8, 0x33, 0x3C, 0x3C, 0x0C, 0x87, 0xC3, 0xC1, 0x6B, 0x54, 0x54, 0x54, + 0xBC, 0xE9, 0xEB, 0xEB, 0x93, 0x5F, 0x5C, 0x5C, 0x30, 0x8A, 0x9D, 0x2E, 0x2B, 0x2B, 0xBB, 0xA2, + 0x3E, 0x41, 0xBD, 0x21, 0x1E, 0x8F, 0x63, 0x6A, 0x6A, 0x0A, 0x81, 0x40, 0x00, 0x94, 0x1B, 0x3D, + 0x3D, 0x3D, 0x42, 0x3C, 0x96, 0x96, 0x96, 0x70, 0x7E, 0x7E, 0x8E, 0xE3, 0xE3, 0x63, 0xF8, 0xFD, + 0xFE, 0xB4, 0xD7, 0xEB, 0xF5, 0x8F, 0x8F, 0x8F, 0x5B, 0x68, 0x5E, 0x6F, 0x05, 0xCE, 0xB4, 0xE3, + 0xE8, 0xE8, 0x08, 0x27, 0x27, 0x27, 0xD8, 0xDF, 0xDF, 0xC7, 0xD9, 0xD9, 0x19, 0x6C, 0x36, 0x1B, + 0x36, 0x36, 0x36, 0x38, 0x9F, 0x85, 0x85, 0x05, 0xAC, 0xAF, 0xAF, 0x23, 0x1A, 0x8D, 0x22, 0x91, + 0x48, 0x20, 0x16, 0x8B, 0xFD, 0xDA, 0xDA, 0xDA, 0x7A, 0x41, 0x33, 0x7E, 0x57, 0x50, 0x50, 0x80, + 0x89, 0x89, 0x09, 0x84, 0xC3, 0x61, 0x6C, 0x6F, 0x6F, 0x23, 0x12, 0x89, 0xE0, 0xE0, 0xE0, 0x00, + 0x43, 0x43, 0x43, 0x58, 0x5E, 0x5E, 0xE6, 0x9C, 0x7D, 0x3E, 0x1F, 0x46, 0x47, 0x47, 0x79, 0xBE, + 0xBD, 0xBD, 0x3D, 0xE1, 0x3C, 0x1D, 0x0C, 0x06, 0x9F, 0x10, 0xB7, 0xC7, 0x84, 0x4F, 0xF6, 0xF7, + 0xF7, 0x63, 0x60, 0x60, 0x00, 0x83, 0x83, 0x83, 0x18, 0x19, 0x19, 0xC1, 0xDC, 0xDC, 0x1C, 0x8F, + 0x17, 0x7C, 0xA4, 0x27, 0xE7, 0x34, 0x39, 0x39, 0x89, 0x9D, 0x9D, 0x1D, 0x6E, 0x54, 0xE3, 0x13, + 0xE5, 0x34, 0x11, 0x37, 0x49, 0x51, 0x51, 0xD1, 0x4B, 0xA5, 0x52, 0xF9, 0x45, 0x26, 0x93, 0x5D, + 0x0A, 0xF3, 0x92, 0x48, 0x24, 0xA0, 0x6F, 0x14, 0x17, 0x17, 0xA3, 0xB6, 0xB6, 0x16, 0x5D, 0x5D, + 0x5D, 0x7C, 0x1E, 0xBB, 0xBB, 0xBB, 0x9C, 0xD7, 0xE1, 0xE1, 0x21, 0x42, 0xA1, 0xD0, 0x6B, 0xD2, + 0x45, 0x4C, 0x33, 0x12, 0x34, 0xCC, 0xA0, 0x19, 0x54, 0x92, 0x56, 0x0E, 0xD2, 0xD9, 0x43, 0xF8, + 0xCF, 0x82, 0x56, 0xC2, 0xDC, 0xEB, 0xEA, 0xEA, 0x38, 0x7E, 0x6C, 0x6C, 0x4C, 0xE0, 0xFE, 0x9D, + 0xB8, 0xBF, 0xA7, 0xFA, 0xAF, 0x56, 0x56, 0x56, 0xEE, 0x6D, 0x6E, 0x6E, 0xDE, 0xB8, 0x47, 0x55, + 0x55, 0x55, 0x6C, 0x66, 0x66, 0x46, 0x44, 0xDA, 0x3B, 0x34, 0x1A, 0x4D, 0x94, 0xB0, 0x3F, 0x09, + 0x7B, 0x45, 0xBD, 0xA5, 0x5D, 0x2E, 0x57, 0x8C, 0x7A, 0x73, 0xD9, 0xED, 0xF6, 0x3B, 0x84, 0xFF, + 0xE7, 0x7D, 0xA6, 0x3A, 0x2C, 0x95, 0x4A, 0xB1, 0x8E, 0x8E, 0x0E, 0x6D, 0x77, 0x77, 0xB7, 0xCD, + 0xE9, 0x74, 0x3E, 0x73, 0xBB, 0xDD, 0x8F, 0x3C, 0x1E, 0x8F, 0xE6, 0xF4, 0xF4, 0x94, 0xAD, 0xAD, + 0xAD, 0xDD, 0xDE, 0xCF, 0x73, 0x0B, 0x0B, 0xB8, 0xB6, 0xE0, 0x5D, 0xC6, 0x66, 0xC5, 0xE4, 0x10, + 0x4C, 0xF4, 0xF7, 0xD8, 0x59, 0xF2, 0x7F, 0xA3, 0xB8, 0xB4, 0xFC, 0x0F, 0xEE, 0x37, 0x70, 0xEC, + 0x16, 0x4A, 0x7E, 0x04, 0x00, 0x00 +}; + +AsyncWebServerResponse *response = request->beginResponse_P(200, "image/x-icon", favicon_ico_gz, favicon_ico_gz_len); +response->addHeader("Content-Encoding", "gzip"); +request->send(response); +``` + +### Respond with content coming from a Stream +```cpp +//read 12 bytes from Serial and send them as Content Type text/plain +request->send(Serial, "text/plain", 12); +``` + +### Respond with content coming from a Stream and extra headers +```cpp +//read 12 bytes from Serial and send them as Content Type text/plain +AsyncWebServerResponse *response = request->beginResponse(Serial, "text/plain", 12); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Respond with content coming from a Stream containing templates +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//read 12 bytes from Serial and send them as Content Type text/plain +request->send(Serial, "text/plain", 12, processor); +``` + +### Respond with content coming from a Stream containing templates and extra headers +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//read 12 bytes from Serial and send them as Content Type text/plain +AsyncWebServerResponse *response = request->beginResponse(Serial, "text/plain", 12, processor); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Respond with content coming from a File +```cpp +//Send index.htm with default content type +request->send(SPIFFS, "/index.htm"); + +//Send index.htm as text +request->send(SPIFFS, "/index.htm", "text/plain"); + +//Download index.htm +request->send(SPIFFS, "/index.htm", String(), true); +``` + +### Respond with content coming from a File and extra headers +```cpp +//Send index.htm with default content type +AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/index.htm"); + +//Send index.htm as text +AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/index.htm", "text/plain"); + +//Download index.htm +AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/index.htm", String(), true); + +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Respond with content coming from a File containing templates +Internally uses [Chunked Response](#chunked-response). + +Index.htm contents: +``` +%HELLO_FROM_TEMPLATE% +``` + +Somewhere in source files: +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//Send index.htm with template processor function +request->send(SPIFFS, "/index.htm", String(), false, processor); +``` + +### Respond with content using a callback +```cpp +//send 128 bytes as plain text +request->send("text/plain", 128, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will not be asked for more bytes once the content length has been reached. + //Keep in mind that you can not delay or yield waiting for more data! + //Send what you currently have and you will be asked for more again + return mySource.read(buffer, maxLen); +}); +``` + +### Respond with content using a callback and extra headers +```cpp +//send 128 bytes as plain text +AsyncWebServerResponse *response = request->beginResponse("text/plain", 128, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will not be asked for more bytes once the content length has been reached. + //Keep in mind that you can not delay or yield waiting for more data! + //Send what you currently have and you will be asked for more again + return mySource.read(buffer, maxLen); +}); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Respond with content using a callback containing templates +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//send 128 bytes as plain text +request->send("text/plain", 128, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will not be asked for more bytes once the content length has been reached. + //Keep in mind that you can not delay or yield waiting for more data! + //Send what you currently have and you will be asked for more again + return mySource.read(buffer, maxLen); +}, processor); +``` + +### Respond with content using a callback containing templates and extra headers +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +//send 128 bytes as plain text +AsyncWebServerResponse *response = request->beginResponse("text/plain", 128, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will not be asked for more bytes once the content length has been reached. + //Keep in mind that you can not delay or yield waiting for more data! + //Send what you currently have and you will be asked for more again + return mySource.read(buffer, maxLen); +}, processor); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Chunked Response +Used when content length is unknown. Works best if the client supports HTTP/1.1 +```cpp +AsyncWebServerResponse *response = request->beginChunkedResponse("text/plain", [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will be asked for more data until 0 is returned + //Keep in mind that you can not delay or yield waiting for more data! + return mySource.read(buffer, maxLen); +}); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Chunked Response containing templates +Used when content length is unknown. Works best if the client supports HTTP/1.1 +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +AsyncWebServerResponse *response = request->beginChunkedResponse("text/plain", [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //index equals the amount of bytes that have been already sent + //You will be asked for more data until 0 is returned + //Keep in mind that you can not delay or yield waiting for more data! + return mySource.read(buffer, maxLen); +}, processor); +response->addHeader("Server","ESP Async Web Server"); +request->send(response); +``` + +### Print to response +```cpp +AsyncResponseStream *response = request->beginResponseStream("text/html"); +response->addHeader("Server","ESP Async Web Server"); +response->printf("Webpage at %s", request->url().c_str()); + +response->print("

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

"); + +response->print("

General

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

Headers

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

Parameters

"); +response->print("
    "); +int params = request->params(); +for(int i=0;igetParam(i); + if(p->isFile()){ + response->printf("
  • FILE[%s]: %s, size: %u
    • ", p->name().c_str(), p->value().c_str(), p->size()); + } else if(p->isPost()){ + response->printf("
  • POST[%s]: %s
    • ", p->name().c_str(), p->value().c_str()); + } else { + response->printf("
  • GET[%s]: %s
    • ", p->name().c_str(), p->value().c_str()); + } +} +response->print("
"); + +response->print(""); +//send the response last +request->send(response); +``` + +### ArduinoJson Basic Response +This way of sending Json is great for when the result is below 4KB +```cpp +#include "AsyncJson.h" +#include "ArduinoJson.h" + + +AsyncResponseStream *response = request->beginResponseStream("application/json"); +DynamicJsonBuffer jsonBuffer; +JsonObject &root = jsonBuffer.createObject(); +root["heap"] = ESP.getFreeHeap(); +root["ssid"] = WiFi.SSID(); +root.printTo(*response); +request->send(response); +``` + +### ArduinoJson Advanced Response +This response can handle really large Json objects (tested to 40KB) +There isn't any noticeable speed decrease for small results with the method above +Since ArduinoJson does not allow reading parts of the string, the whole Json has to +be passed every time a chunks needs to be sent, which shows speed decrease proportional +to the resulting json packets +```cpp +#include "AsyncJson.h" +#include "ArduinoJson.h" + + +AsyncJsonResponse * response = new AsyncJsonResponse(); +response->addHeader("Server","ESP Async Web Server"); +JsonObject& root = response->getRoot(); +root["heap"] = ESP.getFreeHeap(); +root["ssid"] = WiFi.SSID(); +response->setLength(); +request->send(response); +``` + +## Serving static files +In addition to serving files from SPIFFS as described above, the server provide a dedicated handler that optimize the +performance of serving files from SPIFFS - ```AsyncStaticWebHandler```. Use ```server.serveStatic()``` function to +initialize and add a new instance of ```AsyncStaticWebHandler``` to the server. +The Handler will not handle the request if the file does not exists, e.g. the server will continue to look for another +handler that can handle the request. +Notice that you can chain setter functions to setup the handler, or keep a pointer to change it at a later time. + +### Serving specific file by name +```cpp +// Serve the file "/www/page.htm" when request url is "/page.htm" +server.serveStatic("/page.htm", SPIFFS, "/www/page.htm"); +``` + +### Serving files in directory +To serve files in a directory, the path to the files should specify a directory in SPIFFS and ends with "/". +```cpp +// Serve files in directory "/www/" when request url starts with "/" +// Request to the root or none existing files will try to server the defualt +// file name "index.htm" if exists +server.serveStatic("/", SPIFFS, "/www/"); + +// Server with different default file +server.serveStatic("/", SPIFFS, "/www/").setDefaultFile("default.html"); +``` + +### Serving static files with authentication + +```cpp +server + .serveStatic("/", SPIFFS, "/www/") + .setDefaultFile("default.html") + .setAuthentication("user", "pass"); +``` + +### Specifying Cache-Control header +It is possible to specify Cache-Control header value to reduce the number of calls to the server once the client loaded +the files. For more information on Cache-Control values see [Cache-Control](https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) +```cpp +// Cache responses for 10 minutes (600 seconds) +server.serveStatic("/", SPIFFS, "/www/").setCacheControl("max-age=600"); + +//*** Change Cache-Control after server setup *** + +// During setup - keep a pointer to the handler +AsyncStaticWebHandler* handler = &server.serveStatic("/", SPIFFS, "/www/").setCacheControl("max-age=600"); + +// At a later event - change Cache-Control +handler->setCacheControl("max-age=30"); +``` + +### Specifying Date-Modified header +It is possible to specify Date-Modified header to enable the server to return Not-Modified (304) response for requests +with "If-Modified-Since" header with the same value, instead of responding with the actual file content. +```cpp +// Update the date modified string every time files are updated +server.serveStatic("/", SPIFFS, "/www/").setLastModified("Mon, 20 Jun 2016 14:00:00 GMT"); + +//*** Chage last modified value at a later stage *** + +// During setup - read last modified value from config or EEPROM +String date_modified = loadDateModified(); +AsyncStaticWebHandler* handler = &server.serveStatic("/", SPIFFS, "/www/"); +handler->setLastModified(date_modified); + +// At a later event when files are updated +String date_modified = getNewDateModfied(); +saveDateModified(date_modified); // Save for next reset +handler->setLastModified(date_modified); +``` + +### Specifying Template Processor callback +It is possible to specify template processor for static files. For information on template processor see +[Respond with content coming from a File containing templates](#respond-with-content-coming-from-a-file-containing-templates). +```cpp +String processor(const String& var) +{ + if(var == "HELLO_FROM_TEMPLATE") + return F("Hello world!"); + return String(); +} + +// ... + +server.serveStatic("/", SPIFFS, "/www/").setTemplateProcessor(processor); +``` + +## Param Rewrite With Matching +It is possible to rewrite the request url with parameter matchg. Here is an example with one parameter: +Rewrite for example "/radio/{frequence}" -> "/radio?f={frequence}" + +```cpp +class OneParamRewrite : public AsyncWebRewrite +{ + protected: + String _urlPrefix; + int _paramIndex; + String _paramsBackup; + + public: + OneParamRewrite(const char* from, const char* to) + : AsyncWebRewrite(from, to) { + + _paramIndex = _from.indexOf('{'); + + if( _paramIndex >=0 && _from.endsWith("}")) { + _urlPrefix = _from.substring(0, _paramIndex); + int index = _params.indexOf('{'); + if(index >= 0) { + _params = _params.substring(0, index); + } + } else { + _urlPrefix = _from; + } + _paramsBackup = _params; + } + + bool match(AsyncWebServerRequest *request) override { + if(request->url().startsWith(_urlPrefix)) { + if(_paramIndex >= 0) { + _params = _paramsBackup + request->url().substring(_paramIndex); + } else { + _params = _paramsBackup; + } + return true; + + } else { + return false; + } + } +}; +``` + +Usage: + +```cpp + server.addRewrite( new OneParamRewrite("/radio/{frequence}", "/radio?f={frequence}") ); +``` + +## Using filters +Filters can be set to `Rewrite` or `Handler` in order to control when to apply the rewrite and consider the handler. +A filter is a callback function that evaluates the request and return a boolean `true` to include the item +or `false` to exclude it. +Two filter callback are provided for convince: +* `ON_STA_FILTER` - return true when requests are made to the STA (station mode) interface. +* `ON_AP_FILTER` - return true when requests are made to the AP (access point) interface. + +### Serve different site files in AP mode +```cpp +server.serveStatic("/", SPIFFS, "/www/").setFilter(ON_STA_FILTER); +server.serveStatic("/", SPIFFS, "/ap/").setFilter(ON_AP_FILTER); +``` + +### Rewrite to different index on AP +```cpp +// Serve the file "/www/index-ap.htm" in AP, and the file "/www/index.htm" on STA +server.rewrite("/", "index.htm"); +server.rewrite("/index.htm", "index-ap.htm").setFilter(ON_AP_FILTER); +server.serveStatic("/", SPIFFS, "/www/"); +``` + +### Serving different hosts +```cpp +// Filter callback using request host +bool filterOnHost1(AsyncWebServerRequest *request) { return request->host() == "host1"; } + +// Server setup: server files in "/host1/" to requests for "host1", and files in "/www/" otherwise. +server.serveStatic("/", SPIFFS, "/host1/").setFilter(filterOnHost1); +server.serveStatic("/", SPIFFS, "/www/"); +``` + +### Determine interface inside callbacks +```cpp + String RedirectUrl = "http://"; + if (ON_STA_FILTER(request)) { + RedirectUrl += WiFi.localIP().toString(); + } else { + RedirectUrl += WiFi.softAPIP().toString(); + } + RedirectUrl += "/index.htm"; + request->redirect(RedirectUrl); +``` + +## Bad Responses +Some responses are implemented, but you should not use them, because they do not conform to HTTP. +The following example will lead to unclean close of the connection and more time wasted +than providing the length of the content + +### Respond with content using a callback without content length to HTTP/1.0 clients +```cpp +//This is used as fallback for chunked responses to HTTP/1.0 Clients +request->send("text/plain", 0, [](uint8_t *buffer, size_t maxLen, size_t index) -> size_t { + //Write up to "maxLen" bytes into "buffer" and return the amount written. + //You will be asked for more data until 0 is returned + //Keep in mind that you can not delay or yield waiting for more data! + return mySource.read(buffer, maxLen); +}); +``` + +## Async WebSocket Plugin +The server includes a web socket plugin which lets you define different WebSocket locations to connect to +without starting another listening service or using different port + +### Async WebSocket Event +```cpp + +void onEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){ + if(type == WS_EVT_CONNECT){ + //client connected + os_printf("ws[%s][%u] connect\n", server->url(), client->id()); + client->printf("Hello Client %u :)", client->id()); + client->ping(); + } else if(type == WS_EVT_DISCONNECT){ + //client disconnected + os_printf("ws[%s][%u] disconnect: %u\n", server->url(), client->id()); + } else if(type == WS_EVT_ERROR){ + //error was received from the other end + os_printf("ws[%s][%u] error(%u): %s\n", server->url(), client->id(), *((uint16_t*)arg), (char*)data); + } else if(type == WS_EVT_PONG){ + //pong message was received (in response to a ping request maybe) + os_printf("ws[%s][%u] pong[%u]: %s\n", server->url(), client->id(), len, (len)?(char*)data:""); + } else if(type == WS_EVT_DATA){ + //data packet + AwsFrameInfo * info = (AwsFrameInfo*)arg; + if(info->final && info->index == 0 && info->len == len){ + //the whole message is in a single frame and we got all of it's data + os_printf("ws[%s][%u] %s-message[%llu]: ", server->url(), client->id(), (info->opcode == WS_TEXT)?"text":"binary", info->len); + if(info->opcode == WS_TEXT){ + data[len] = 0; + os_printf("%s\n", (char*)data); + } else { + for(size_t i=0; i < info->len; i++){ + os_printf("%02x ", data[i]); + } + os_printf("\n"); + } + if(info->opcode == WS_TEXT) + client->text("I got your text message"); + else + client->binary("I got your binary message"); + } else { + //message is comprised of multiple frames or the frame is split into multiple packets + if(info->index == 0){ + if(info->num == 0) + os_printf("ws[%s][%u] %s-message start\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary"); + os_printf("ws[%s][%u] frame[%u] start[%llu]\n", server->url(), client->id(), info->num, info->len); + } + + os_printf("ws[%s][%u] frame[%u] %s[%llu - %llu]: ", server->url(), client->id(), info->num, (info->message_opcode == WS_TEXT)?"text":"binary", info->index, info->index + len); + if(info->message_opcode == WS_TEXT){ + data[len] = 0; + os_printf("%s\n", (char*)data); + } else { + for(size_t i=0; i < len; i++){ + os_printf("%02x ", data[i]); + } + os_printf("\n"); + } + + if((info->index + len) == info->len){ + os_printf("ws[%s][%u] frame[%u] end[%llu]\n", server->url(), client->id(), info->num, info->len); + if(info->final){ + os_printf("ws[%s][%u] %s-message end\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary"); + if(info->message_opcode == WS_TEXT) + client->text("I got your text message"); + else + client->binary("I got your binary message"); + } + } + } + } +} +``` + +### Methods for sending data to a socket client +```cpp + + + +//Server methods +AsyncWebSocket ws("/ws"); +//printf to a client +ws.printf((uint32_t)client_id, arguments...); +//printf to all clients +ws.printfAll(arguments...); +//printf_P to a client +ws.printf_P((uint32_t)client_id, PSTR(format), arguments...); +//printfAll_P to all clients +ws.printfAll_P(PSTR(format), arguments...); +//send text to a client +ws.text((uint32_t)client_id, (char*)text); +ws.text((uint32_t)client_id, (uint8_t*)text, (size_t)len); +//send text from PROGMEM to a client +ws.text((uint32_t)client_id, PSTR("text")); +const char flash_text[] PROGMEM = "Text to send" +ws.text((uint32_t)client_id, FPSTR(flash_text)); +//send text to all clients +ws.textAll((char*)text); +ws.textAll((uint8_t*)text, (size_t)len); +//send binary to a client +ws.binary((uint32_t)client_id, (char*)binary); +ws.binary((uint32_t)client_id, (uint8_t*)binary, (size_t)len); +//send binary from PROGMEM to a client +const uint8_t flash_binary[] PROGMEM = { 0x01, 0x02, 0x03, 0x04 }; +ws.binary((uint32_t)client_id, flash_binary, 4); +//send binary to all clients +ws.binaryAll((char*)binary); +ws.binaryAll((uint8_t*)binary, (size_t)len); +//HTTP Authenticate before switch to Websocket protocol +ws.setAuthentication("user", "pass"); + +//client methods +AsyncWebSocketClient * client; +//printf +client->printf(arguments...); +//printf_P +client->printf_P(PSTR(format), arguments...); +//send text +client->text((char*)text); +client->text((uint8_t*)text, (size_t)len); +//send text from PROGMEM +client->text(PSTR("text")); +const char flash_text[] PROGMEM = "Text to send"; +client->text(FPSTR(flash_text)); +//send binary +client->binary((char*)binary); +client->binary((uint8_t*)binary, (size_t)len); +//send binary from PROGMEM +const uint8_t flash_binary[] PROGMEM = { 0x01, 0x02, 0x03, 0x04 }; +client->binary(flash_binary, 4); +``` + +### Direct access to web socket message buffer +When sending a web socket message using the above methods a buffer is created. Under certain circumstances you might want to manipulate or populate this buffer directly from your application, for example to prevent unnecessary duplications of the data. This example below shows how to create a buffer and print data to it from an ArduinoJson object then send it. + +```cpp +void sendDataWs(AsyncWebSocketClient * client) +{ + DynamicJsonBuffer jsonBuffer; + JsonObject& root = jsonBuffer.createObject(); + root["a"] = "abc"; + root["b"] = "abcd"; + root["c"] = "abcde"; + root["d"] = "abcdef"; + root["e"] = "abcdefg"; + size_t len = root.measureLength(); + AsyncWebSocketMessageBuffer * buffer = ws.makeBuffer(len); // creates a buffer (len + 1) for you. + if (buffer) { + root.printTo((char *)buffer->get(), len + 1); + if (client) { + client->text(buffer); + } else { + ws.textAll(buffer); + } + } +} +``` + +### Limiting the number of web socket clients +Browsers sometimes do not correctly close the websocket connection, even when the close() function is called in javascript. This will eventually exhaust the web server's resources and will cause the server to crash. Periodically calling the cleanClients() function from the main loop() function limits the number of clients by closing the oldest client when the maximum number of clients has been exceeded. This can called be every cycle, however, if you wish to use less power, then calling as infrequently as once per second is sufficient. + +```cpp +void loop(){ + ws.cleanupClients(); +} +``` + + +## Async Event Source Plugin +The server includes EventSource (Server-Sent Events) plugin which can be used to send short text events to the browser. +Difference between EventSource and WebSockets is that EventSource is single direction, text-only protocol. + +### Setup Event Source on the server +```cpp +AsyncWebServer server(80); +AsyncEventSource events("/events"); + +void setup(){ + // setup ...... + events.onConnect([](AsyncEventSourceClient *client){ + if(client->lastId()){ + Serial.printf("Client reconnected! Last message ID that it gat is: %u\n", client->lastId()); + } + //send event with message "hello!", id current millis + // and set reconnect delay to 1 second + client->send("hello!",NULL,millis(),1000); + }); + //HTTP Basic authentication + events.setAuthentication("user", "pass"); + server.addHandler(&events); + // setup ...... +} + +void loop(){ + if(eventTriggered){ // your logic here + //send event "myevent" + events.send("my event content","myevent",millis()); + } +} +``` + +### Setup Event Source in the browser +```javascript +if (!!window.EventSource) { + var source = new EventSource('/events'); + + source.addEventListener('open', function(e) { + console.log("Events Connected"); + }, false); + + source.addEventListener('error', function(e) { + if (e.target.readyState != EventSource.OPEN) { + console.log("Events Disconnected"); + } + }, false); + + source.addEventListener('message', function(e) { + console.log("message", e.data); + }, false); + + source.addEventListener('myevent', function(e) { + console.log("myevent", e.data); + }, false); +} +``` + +## Scanning for available WiFi Networks +```cpp +//First request will return 0 results unless you start scan from somewhere else (loop/setup) +//Do not request more often than 3-5 seconds +server.on("/scan", HTTP_GET, [](AsyncWebServerRequest *request){ + String json = "["; + int n = WiFi.scanComplete(); + if(n == -2){ + WiFi.scanNetworks(true); + } else if(n){ + for (int i = 0; i < n; ++i){ + if(i) json += ","; + json += "{"; + json += "\"rssi\":"+String(WiFi.RSSI(i)); + json += ",\"ssid\":\""+WiFi.SSID(i)+"\""; + json += ",\"bssid\":\""+WiFi.BSSIDstr(i)+"\""; + json += ",\"channel\":"+String(WiFi.channel(i)); + json += ",\"secure\":"+String(WiFi.encryptionType(i)); + json += ",\"hidden\":"+String(WiFi.isHidden(i)?"true":"false"); + json += "}"; + } + WiFi.scanDelete(); + if(WiFi.scanComplete() == -2){ + WiFi.scanNetworks(true); + } + } + json += "]"; + request->send(200, "application/json", json); + json = String(); +}); +``` + +## Remove handlers and rewrites + +Server goes through handlers in same order as they were added. You can't simple add handler with same path to override them. +To remove handler: +```arduino +// save callback for particular URL path +auto handler = server.on("/some/path", [](AsyncWebServerRequest *request){ + //do something useful +}); +// when you don't need handler anymore remove it +server.removeHandler(&handler); + +// same with rewrites +server.removeRewrite(&someRewrite); + +server.onNotFound([](AsyncWebServerRequest *request){ + request->send(404); +}); + +// remove server.onNotFound handler +server.onNotFound(NULL); + +// remove all rewrites, handlers and onNotFound/onFileUpload/onRequestBody callbacks +server.reset(); +``` + +## Setting up the server +```cpp +#include "ESPAsyncTCP.h" +#include "ESPAsyncWebServer.h" + +AsyncWebServer server(80); +AsyncWebSocket ws("/ws"); // access at ws://[esp ip]/ws +AsyncEventSource events("/events"); // event source (Server-Sent events) + +const char* ssid = "your-ssid"; +const char* password = "your-pass"; +const char* http_username = "admin"; +const char* http_password = "admin"; + +//flag to use from web update to reboot the ESP +bool shouldReboot = false; + +void onRequest(AsyncWebServerRequest *request){ + //Handle Unknown Request + request->send(404); +} + +void onBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total){ + //Handle body +} + +void onUpload(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final){ + //Handle upload +} + +void onEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){ + //Handle WebSocket event +} + +void setup(){ + Serial.begin(115200); + WiFi.mode(WIFI_STA); + WiFi.begin(ssid, password); + if (WiFi.waitForConnectResult() != WL_CONNECTED) { + Serial.printf("WiFi Failed!\n"); + return; + } + + // attach AsyncWebSocket + ws.onEvent(onEvent); + server.addHandler(&ws); + + // attach AsyncEventSource + server.addHandler(&events); + + // respond to GET requests on URL /heap + server.on("/heap", HTTP_GET, [](AsyncWebServerRequest *request){ + request->send(200, "text/plain", String(ESP.getFreeHeap())); + }); + + // upload a file to /upload + server.on("/upload", HTTP_POST, [](AsyncWebServerRequest *request){ + request->send(200); + }, onUpload); + + // send a file when /index is requested + server.on("/index", HTTP_ANY, [](AsyncWebServerRequest *request){ + request->send(SPIFFS, "/index.htm"); + }); + + // HTTP basic authentication + server.on("/login", HTTP_GET, [](AsyncWebServerRequest *request){ + if(!request->authenticate(http_username, http_password)) + return request->requestAuthentication(); + request->send(200, "text/plain", "Login Success!"); + }); + + // Simple Firmware Update Form + server.on("/update", HTTP_GET, [](AsyncWebServerRequest *request){ + request->send(200, "text/html", "
"); + }); + server.on("/update", HTTP_POST, [](AsyncWebServerRequest *request){ + shouldReboot = !Update.hasError(); + AsyncWebServerResponse *response = request->beginResponse(200, "text/plain", shouldReboot?"OK":"FAIL"); + response->addHeader("Connection", "close"); + request->send(response); + },[](AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final){ + if(!index){ + Serial.printf("Update Start: %s\n", filename.c_str()); + Update.runAsync(true); + if(!Update.begin((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000)){ + Update.printError(Serial); + } + } + if(!Update.hasError()){ + if(Update.write(data, len) != len){ + Update.printError(Serial); + } + } + if(final){ + if(Update.end(true)){ + Serial.printf("Update Success: %uB\n", index+len); + } else { + Update.printError(Serial); + } + } + }); + + // attach filesystem root at URL /fs + server.serveStatic("/fs", SPIFFS, "/"); + + // Catch-All Handlers + // Any request that can not find a Handler that canHandle it + // ends in the callbacks below. + server.onNotFound(onRequest); + server.onFileUpload(onUpload); + server.onRequestBody(onBody); + + server.begin(); +} + +void loop(){ + if(shouldReboot){ + Serial.println("Rebooting..."); + delay(100); + ESP.restart(); + } + static char temp[128]; + sprintf(temp, "Seconds since boot: %u", millis()/1000); + events.send(temp, "time"); //send event "time" +} +``` + +### Setup global and class functions as request handlers + +```cpp +#include +#include +#include +#include + +void handleRequest(AsyncWebServerRequest *request){} + +class WebClass { +public : + AsyncWebServer classWebServer = AsyncWebServer(81); + + WebClass(){}; + + void classRequest (AsyncWebServerRequest *request){} + + void begin(){ + // attach global request handler + classWebServer.on("/example", HTTP_ANY, handleRequest); + + // attach class request handler + classWebServer.on("/example", HTTP_ANY, std::bind(&WebClass::classRequest, this, std::placeholders::_1)); + } +}; + +AsyncWebServer globalWebServer(80); +WebClass webClassInstance; + +void setup() { + // attach global request handler + globalWebServer.on("/example", HTTP_ANY, handleRequest); + + // attach class request handler + globalWebServer.on("/example", HTTP_ANY, std::bind(&WebClass::classRequest, webClassInstance, std::placeholders::_1)); +} + +void loop() { + +} +``` + +### Methods for controlling websocket connections + +```cpp + // Disable client connections if it was activated + if ( ws.enabled() ) + ws.enable(false); + + // enable client connections if it was disabled + if ( !ws.enabled() ) + ws.enable(true); +``` + +Example of OTA code + +```cpp + // OTA callbacks + ArduinoOTA.onStart([]() { + // Clean SPIFFS + SPIFFS.end(); + + // Disable client connections + ws.enable(false); + + // Advertise connected clients what's going on + ws.textAll("OTA Update Started"); + + // Close them + ws.closeAll(); + + }); + +``` + +### Adding Default Headers + +In some cases, such as when working with CORS, or with some sort of custom authentication system, +you might need to define a header that should get added to all responses (including static, websocket and EventSource). +The DefaultHeaders singleton allows you to do this. + +Example: + +```cpp +DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", "*"); +webServer.begin(); +``` + +*NOTE*: You will still need to respond to the OPTIONS method for CORS pre-flight in most cases. (unless you are only using GET) + +This is one option: + +```cpp +webServer.onNotFound([](AsyncWebServerRequest *request) { + if (request->method() == HTTP_OPTIONS) { + request->send(200); + } else { + request->send(404); + } +}); +``` + +### Path variable + +With path variable you can create a custom regex rule for a specific parameter in a route. +For example we want a `sensorId` parameter in a route rule to match only a integer. + +```cpp + server.on("^\\/sensor\\/([0-9]+)$", HTTP_GET, [] (AsyncWebServerRequest *request) { + String sensorId = request->pathArg(0); + }); +``` +*NOTE*: All regex patterns starts with `^` and ends with `$` + +To enable the `Path variable` support, you have to define the buildflag `-DASYNCWEBSERVER_REGEX`. + + +For Arduino IDE create/update `platform.local.txt`: + +`Windows`: C:\Users\(username)\AppData\Local\Arduino15\packages\\`{espxxxx}`\hardware\\`espxxxx`\\`{version}`\platform.local.txt + +`Linux`: ~/.arduino15/packages/`{espxxxx}`/hardware/`{espxxxx}`/`{version}`/platform.local.txt + +Add/Update the following line: +``` + compiler.cpp.extra_flags=-DDASYNCWEBSERVER_REGEX +``` + +For platformio modify `platformio.ini`: +```ini +[env:myboard] +build_flags = + -DASYNCWEBSERVER_REGEX +``` +*NOTE*: By enabling `ASYNCWEBSERVER_REGEX`, `` will be included. This will add an 100k to your binary. diff --git a/lib/ESPAsyncWebServer/SPIFFSEditor.cpp b/lib/ESPAsyncWebServer/SPIFFSEditor.cpp new file mode 100644 index 000000000..a84fa87dd --- /dev/null +++ b/lib/ESPAsyncWebServer/SPIFFSEditor.cpp @@ -0,0 +1,544 @@ +#include "SPIFFSEditor.h" +#include + +//File: edit.htm.gz, Size: 4151 +#define edit_htm_gz_len 4151 +const uint8_t edit_htm_gz[] PROGMEM = { + 0x1F, 0x8B, 0x08, 0x08, 0xB8, 0x94, 0xB1, 0x59, 0x00, 0x03, 0x65, 0x64, 0x69, 0x74, 0x2E, 0x68, + 0x74, 0x6D, 0x00, 0xB5, 0x3A, 0x0B, 0x7B, 0xDA, 0xB8, 0xB2, 0x7F, 0xC5, 0x71, 0xCF, 0x66, 0xED, + 0x83, 0x31, 0x90, 0xA4, 0xD9, 0xD6, 0xC4, 0xC9, 0x42, 0x92, 0x36, 0x6D, 0xF3, 0x6A, 0x80, 0xB6, + 0x69, 0x4F, 0xEE, 0x7E, 0xC2, 0x16, 0xA0, 0xC6, 0x96, 0x5D, 0x5B, 0x0E, 0x49, 0x59, 0xFE, 0xFB, + 0x9D, 0x91, 0x6C, 0xB0, 0x09, 0x69, 0x77, 0xCF, 0xBD, 0xBB, 0xDD, 0x2D, 0x92, 0x46, 0x33, 0x9A, + 0x19, 0xCD, 0x53, 0xDE, 0xBD, 0x8D, 0xA3, 0x8B, 0xC3, 0xFE, 0xF5, 0xE5, 0xB1, 0x36, 0x11, 0x61, + 0xB0, 0xBF, 0x87, 0x7F, 0x6B, 0x01, 0xE1, 0x63, 0x97, 0xF2, 0xFD, 0x3D, 0xC1, 0x44, 0x40, 0xF7, + 0x8F, 0x7B, 0x97, 0xDA, 0xB1, 0xCF, 0x44, 0x94, 0xEC, 0x35, 0xD4, 0xCA, 0x5E, 0x2A, 0x1E, 0x02, + 0xAA, 0x85, 0xD4, 0x67, 0xC4, 0x4D, 0xBD, 0x84, 0xC2, 0x66, 0xDB, 0x0B, 0x67, 0xDF, 0xEB, 0x8C, + 0xFB, 0xF4, 0xDE, 0xD9, 0x6E, 0x36, 0xDB, 0x71, 0x94, 0x32, 0xC1, 0x22, 0xEE, 0x90, 0x61, 0x1A, + 0x05, 0x99, 0xA0, 0xED, 0x80, 0x8E, 0x84, 0xF3, 0x3C, 0xBE, 0x6F, 0x0F, 0xA3, 0xC4, 0xA7, 0x89, + 0xD3, 0x8A, 0xEF, 0x35, 0x00, 0x31, 0x5F, 0x7B, 0xB6, 0xB3, 0xB3, 0xD3, 0x1E, 0x12, 0xEF, 0x76, + 0x9C, 0x44, 0x19, 0xF7, 0xEB, 0x5E, 0x14, 0x44, 0x89, 0xF3, 0x6C, 0xF4, 0x1C, 0xFF, 0xB4, 0x7D, + 0x96, 0xC6, 0x01, 0x79, 0x70, 0x78, 0xC4, 0x29, 0xE0, 0xDE, 0xD7, 0xD3, 0x09, 0xF1, 0xA3, 0xA9, + 0xD3, 0xD4, 0x9A, 0x5A, 0xAB, 0x09, 0x44, 0x92, 0xF1, 0x90, 0x18, 0x4D, 0x0B, 0xFF, 0xD8, 0x3B, + 0x66, 0x7B, 0x14, 0x71, 0x51, 0x4F, 0xD9, 0x77, 0xEA, 0xB4, 0xB6, 0xE0, 0x34, 0x39, 0x1D, 0x91, + 0x90, 0x05, 0x0F, 0x4E, 0x4A, 0x78, 0x5A, 0x4F, 0x69, 0xC2, 0x46, 0x6A, 0x79, 0x4A, 0xD9, 0x78, + 0x22, 0x9C, 0xDF, 0x9A, 0xCD, 0x39, 0xF0, 0xAF, 0x65, 0xC1, 0x2C, 0x60, 0x29, 0x20, 0xA3, 0x78, + 0xEA, 0x3C, 0x11, 0xC5, 0x4E, 0x53, 0xB1, 0xDE, 0x6C, 0x87, 0x24, 0x19, 0x33, 0x0E, 0x83, 0x98, + 0xF8, 0x3E, 0xE3, 0x63, 0x47, 0xA1, 0x05, 0x6C, 0xB6, 0x90, 0x36, 0xA1, 0x01, 0x11, 0xEC, 0x8E, + 0xB6, 0x43, 0xC6, 0xEB, 0x53, 0xE6, 0x8B, 0x89, 0xB3, 0x0B, 0x3C, 0xB6, 0xBD, 0x2C, 0x49, 0x41, + 0xA6, 0x38, 0x62, 0x5C, 0xD0, 0x44, 0xA2, 0xA5, 0x31, 0xE1, 0xB3, 0x5C, 0x54, 0x54, 0x40, 0x21, + 0x27, 0xE3, 0x01, 0xE3, 0xB4, 0x3E, 0x0C, 0x22, 0xEF, 0x76, 0x71, 0xD2, 0x6E, 0x7C, 0x9F, 0x9F, + 0xE5, 0x4C, 0xA2, 0x3B, 0x9A, 0xCC, 0x96, 0xEA, 0x92, 0xD8, 0x15, 0x60, 0x85, 0x34, 0xA5, 0x74, + 0x6E, 0x8B, 0xBB, 0x0C, 0xA0, 0x96, 0xFC, 0x05, 0x29, 0x17, 0xFC, 0x2F, 0x45, 0x5A, 0x11, 0x5C, + 0xA1, 0x30, 0x1E, 0x67, 0x62, 0xF6, 0xF8, 0x2A, 0xA3, 0x98, 0x78, 0x4C, 0x3C, 0xA0, 0xFC, 0xB0, + 0x6D, 0x86, 0xBA, 0x04, 0xAC, 0x24, 0x24, 0x81, 0x86, 0x3A, 0xD7, 0x3E, 0xD0, 0xC4, 0x27, 0x9C, + 0x58, 0x9D, 0x84, 0x91, 0xC0, 0xEA, 0x2D, 0xB5, 0x5E, 0x0F, 0xA3, 0xEF, 0xF5, 0x0C, 0xC6, 0x30, + 0x0F, 0xA8, 0x27, 0x94, 0x92, 0xE1, 0x1E, 0x86, 0xB7, 0x4C, 0x3C, 0x06, 0x3C, 0x5A, 0x28, 0xA9, + 0x4B, 0x2A, 0x69, 0xA2, 0x2E, 0xB0, 0x25, 0xD5, 0x83, 0x1C, 0x4B, 0xC9, 0x95, 0x50, 0xF5, 0x61, + 0x24, 0x44, 0x14, 0x4A, 0x93, 0x5B, 0x08, 0xAC, 0x49, 0xAB, 0x79, 0xF1, 0xE8, 0x46, 0xD6, 0x6B, + 0xBF, 0x44, 0xBE, 0x0D, 0x7A, 0x15, 0xCC, 0x23, 0x41, 0x9D, 0x04, 0x6C, 0xCC, 0x9D, 0x90, 0xF9, + 0x7E, 0x40, 0x4B, 0x56, 0xEB, 0x64, 0x49, 0x60, 0xF8, 0x44, 0x10, 0x87, 0x85, 0x64, 0x4C, 0x1B, + 0x31, 0x1F, 0x03, 0x34, 0xA5, 0xBB, 0x3B, 0x16, 0xFB, 0xD0, 0xBD, 0xB8, 0x9A, 0x36, 0xDF, 0xBD, + 0x1E, 0x47, 0x1D, 0xF8, 0xE7, 0xBC, 0x37, 0x98, 0x1C, 0x0F, 0xC6, 0x30, 0xEA, 0xE2, 0xB4, 0xF3, + 0xFE, 0xB0, 0xF3, 0x1E, 0x7E, 0x0E, 0x5B, 0xB5, 0xAF, 0xA3, 0x6F, 0xB8, 0xD0, 0x7D, 0xED, 0x77, + 0xFB, 0x83, 0xE3, 0x4E, 0xE7, 0x5D, 0xE3, 0xCD, 0xF9, 0xF4, 0xE3, 0xBB, 0x5D, 0x04, 0x77, 0x83, + 0xE6, 0xD5, 0x87, 0x49, 0x73, 0xB0, 0xF5, 0x32, 0xF4, 0x4F, 0xFC, 0x89, 0x17, 0x0E, 0x3A, 0xEF, + 0x3F, 0x5E, 0xDD, 0x5D, 0x87, 0x83, 0x71, 0xEF, 0x63, 0x6B, 0xF2, 0x79, 0xEB, 0x43, 0xEF, 0xF3, + 0xC7, 0x57, 0xB7, 0xF4, 0xD3, 0xC9, 0xDB, 0xCF, 0xFD, 0x29, 0x20, 0x1C, 0x45, 0xBD, 0xC1, 0x55, + 0xF7, 0x43, 0x77, 0xFC, 0xB9, 0xEB, 0x1D, 0xDF, 0x0F, 0x83, 0xF3, 0xEE, 0xEB, 0xCE, 0xB0, 0xB3, + 0xE5, 0x51, 0x3A, 0xEE, 0x5F, 0x75, 0xB3, 0x37, 0xEF, 0x2E, 0xC6, 0x8C, 0x4D, 0x7A, 0x9F, 0xCF, + 0xFB, 0xDE, 0xE1, 0xF3, 0xD3, 0xC1, 0x49, 0x87, 0x4D, 0xCE, 0xDF, 0x5E, 0x35, 0x6F, 0x5F, 0xBF, + 0x3B, 0x3C, 0xF2, 0xAE, 0xDF, 0x5E, 0xEF, 0x1E, 0x6D, 0x37, 0x7E, 0xFB, 0xED, 0xCC, 0xBF, 0x60, + 0xBC, 0x7F, 0xF7, 0xBD, 0x33, 0x3E, 0x9C, 0xBE, 0x78, 0x48, 0xFB, 0x93, 0x37, 0x77, 0xBC, 0xF1, + 0x21, 0xFA, 0xFA, 0xE6, 0xE1, 0x0C, 0xFE, 0xBB, 0xBC, 0xAC, 0x0D, 0x7B, 0xAD, 0x74, 0xF0, 0xFE, + 0xCD, 0x87, 0xAD, 0xF4, 0xE5, 0xF3, 0xB8, 0x7B, 0x74, 0x74, 0x17, 0x0E, 0x2F, 0x1B, 0xA1, 0x7F, + 0x3B, 0x12, 0x2F, 0xB6, 0x45, 0x7C, 0x3D, 0xCE, 0x3E, 0x7F, 0x7B, 0xFE, 0x76, 0xD2, 0xB8, 0xA0, + 0xE4, 0x7A, 0x52, 0x7B, 0xF8, 0xFE, 0xF0, 0x62, 0xD2, 0x3F, 0xB9, 0x3B, 0x0F, 0xC8, 0xFD, 0xF9, + 0xB9, 0xF7, 0x3D, 0xAC, 0x05, 0xE4, 0xE5, 0x45, 0x3F, 0x20, 0x49, 0x6B, 0xE0, 0x77, 0x1A, 0xB5, + 0xC3, 0xAD, 0xCE, 0x8E, 0x48, 0xAE, 0x0E, 0xF9, 0xD1, 0xF6, 0xD7, 0xDE, 0x8B, 0x6E, 0xB7, 0x15, + 0x0D, 0xBF, 0x6D, 0xBD, 0xBE, 0xDD, 0x7D, 0x3D, 0xD8, 0x7D, 0x3F, 0x7C, 0xDF, 0xE9, 0xED, 0x74, + 0x07, 0xE4, 0xBA, 0xF7, 0xBE, 0x33, 0xDA, 0x19, 0x4E, 0x26, 0xEF, 0xDE, 0xF5, 0x5F, 0xF9, 0x9D, + 0xEF, 0x49, 0xE7, 0x62, 0xDA, 0xB9, 0x3F, 0x1E, 0x74, 0x4E, 0x6A, 0xEF, 0x8E, 0xCF, 0x9A, 0xAD, + 0xDE, 0xF5, 0xF6, 0xF8, 0x6C, 0x77, 0xDA, 0x4D, 0x8F, 0x3B, 0xEF, 0xBB, 0xCD, 0xF1, 0xDB, 0x5A, + 0x48, 0x3E, 0x47, 0x87, 0xDB, 0xE3, 0x37, 0xBB, 0xEC, 0xF2, 0x9A, 0x74, 0xDE, 0x74, 0xDF, 0xA6, + 0xEC, 0x2A, 0x3C, 0x19, 0x34, 0x3B, 0x9D, 0xD3, 0x0B, 0xFA, 0xEA, 0x70, 0x9B, 0xBC, 0xDB, 0xF2, + 0x3E, 0x82, 0xFE, 0x07, 0x9F, 0xE8, 0x6F, 0xB5, 0xCE, 0xF4, 0xA2, 0x19, 0x78, 0x2F, 0x69, 0xFF, + 0xE4, 0xBA, 0x2F, 0x6F, 0xE7, 0x38, 0x78, 0xD5, 0xBF, 0xED, 0x65, 0xEF, 0xC3, 0xC3, 0x43, 0x53, + 0xE3, 0x51, 0x3D, 0xA1, 0x31, 0x25, 0xA2, 0x1C, 0xAE, 0x16, 0xFE, 0x01, 0xB6, 0xB5, 0xB4, 0xC2, + 0xDC, 0x4F, 0x05, 0xBD, 0x17, 0x75, 0x9F, 0x7A, 0x51, 0x42, 0xE4, 0x1E, 0x40, 0xA0, 0x09, 0x9A, + 0xD8, 0xFC, 0x77, 0x19, 0x3F, 0x35, 0x15, 0x3F, 0x35, 0xC2, 0x7D, 0xCD, 0x28, 0x1C, 0x01, 0x83, + 0x87, 0x4F, 0xEF, 0x98, 0x47, 0xEB, 0x31, 0xBB, 0xA7, 0x41, 0x5D, 0x22, 0x3B, 0x4D, 0x73, 0x26, + 0xFD, 0xAD, 0xD8, 0x46, 0x38, 0x98, 0x9A, 0xA4, 0x5A, 0x2C, 0xF8, 0x5F, 0x89, 0x47, 0x21, 0xB0, + 0x81, 0xCB, 0x84, 0xF8, 0xAB, 0x7C, 0x27, 0x4A, 0xEA, 0xC3, 0x6C, 0x3C, 0x62, 0xF7, 0xE0, 0xD0, + 0x23, 0xC6, 0x99, 0xA0, 0x5A, 0x2B, 0x9D, 0xFF, 0x5E, 0x90, 0xB9, 0xA5, 0x0F, 0xA3, 0x84, 0x84, + 0x34, 0xD5, 0xFE, 0x22, 0x99, 0xD9, 0x28, 0x89, 0xC2, 0x65, 0x10, 0x99, 0x8B, 0xA8, 0x34, 0x99, + 0xCF, 0x9F, 0x65, 0x71, 0x10, 0x11, 0x10, 0x73, 0x4D, 0xE4, 0x50, 0xF1, 0x34, 0x91, 0x6E, 0xB5, + 0x88, 0xAB, 0xB9, 0x9B, 0x6D, 0xA1, 0x5B, 0x96, 0xDD, 0x7A, 0x6B, 0x67, 0xE9, 0xBA, 0x75, 0xB9, + 0x17, 0xE3, 0xFD, 0x9A, 0x4C, 0x81, 0xF1, 0xA0, 0x14, 0xEE, 0x9E, 0x09, 0x50, 0xE9, 0x13, 0x87, + 0xCB, 0x43, 0xF2, 0xC8, 0xB0, 0x60, 0x40, 0x05, 0xEA, 0x96, 0x8C, 0xD4, 0x85, 0x24, 0xB0, 0x6F, + 0xFE, 0x8C, 0xCA, 0xBC, 0x67, 0x3D, 0x8B, 0x13, 0xB8, 0x0D, 0x3A, 0xFD, 0x11, 0xCD, 0x42, 0xA6, + 0x2A, 0x6D, 0x45, 0x53, 0x65, 0xBC, 0x5C, 0x84, 0x65, 0xDA, 0x93, 0xBC, 0x16, 0xA4, 0x1F, 0x4B, + 0x05, 0xE0, 0x05, 0x37, 0xCF, 0x91, 0x9B, 0x1F, 0x6A, 0x75, 0x7B, 0xF7, 0x97, 0x9C, 0x87, 0x9D, + 0xE6, 0x2F, 0x73, 0x3B, 0xDF, 0x5B, 0xA4, 0xE4, 0x56, 0x13, 0xFE, 0x29, 0x32, 0xEF, 0x8B, 0x25, + 0x0B, 0xC3, 0xE7, 0xF8, 0xA7, 0x60, 0x10, 0xE9, 0x94, 0x80, 0xDB, 0x3B, 0x2F, 0x5F, 0xF8, 0xC3, + 0x02, 0x98, 0x0B, 0xF6, 0x24, 0x3C, 0x21, 0x3E, 0xCB, 0x52, 0xE7, 0x79, 0xF3, 0x97, 0x5C, 0x9F, + 0x5B, 0x3B, 0x28, 0xFB, 0xE2, 0x2E, 0x71, 0xB2, 0xB4, 0xD8, 0x34, 0x66, 0x5C, 0xDB, 0x4A, 0x35, + 0xBC, 0x6F, 0x92, 0x2C, 0x0C, 0xB3, 0x92, 0xED, 0xE7, 0xBF, 0x2F, 0x4D, 0x13, 0xF7, 0xCF, 0x9A, + 0xBF, 0xCC, 0x44, 0x02, 0xD9, 0x64, 0x04, 0xB9, 0xC6, 0x49, 0x22, 0x41, 0x04, 0x35, 0x9A, 0xE6, + 0x1C, 0x84, 0x5B, 0x03, 0xD8, 0xDE, 0x6D, 0xFA, 0x74, 0x6C, 0xCE, 0xE7, 0x7B, 0x0D, 0x99, 0xD7, + 0xA0, 0x6C, 0xF1, 0x12, 0x16, 0x8B, 0xFD, 0x51, 0xC6, 0x3D, 0xE4, 0x41, 0x1B, 0x53, 0x83, 0x9A, + 0xB3, 0x84, 0x8A, 0x2C, 0xE1, 0x9A, 0x1F, 0x79, 0x19, 0x1A, 0xBB, 0x3D, 0xA6, 0xE2, 0x58, 0xD9, + 0x7D, 0xF7, 0xE1, 0x8D, 0x0F, 0x3B, 0xE6, 0x0B, 0x04, 0x6F, 0x2D, 0x02, 0x38, 0x30, 0x9C, 0x97, + 0xE3, 0x54, 0xF6, 0x43, 0x82, 0x01, 0x22, 0xEF, 0xE8, 0x83, 0x41, 0x2D, 0xB1, 0x40, 0xA4, 0x36, + 0xAE, 0x1B, 0xC5, 0x2E, 0x80, 0x71, 0x73, 0x76, 0x07, 0x4A, 0x20, 0x2E, 0xFD, 0x22, 0x6E, 0x2C, + 0xE6, 0x72, 0xF8, 0x69, 0xE7, 0xBB, 0xC9, 0x1E, 0x3B, 0xA8, 0xB7, 0x1C, 0xB2, 0xCF, 0x0E, 0x5A, + 0xE0, 0x5E, 0x65, 0x6E, 0xE4, 0xB9, 0xAF, 0x58, 0x40, 0x07, 0xB9, 0xC3, 0xE1, 0x31, 0x48, 0x6C, + 0xB1, 0x85, 0x28, 0xE2, 0x5B, 0xCD, 0xE6, 0x86, 0x4B, 0x0F, 0x48, 0x00, 0x39, 0xCC, 0xD0, 0x8F, + 0xAF, 0xAE, 0x2E, 0xAE, 0xBE, 0xE8, 0x35, 0x5A, 0xD3, 0x6F, 0x1C, 0x4D, 0xAF, 0x71, 0xD3, 0x11, + 0x76, 0x42, 0x47, 0x09, 0x4D, 0x27, 0x97, 0x44, 0x4C, 0x8C, 0xD4, 0xBE, 0x23, 0x41, 0x56, 0x16, + 0x84, 0xA1, 0xDC, 0xC8, 0xA2, 0x70, 0x39, 0x9D, 0x6A, 0xAF, 0x40, 0xCD, 0x47, 0x90, 0xEA, 0xDA, + 0xC2, 0x26, 0x71, 0x4C, 0xB9, 0x6F, 0xE8, 0x31, 0x20, 0xEA, 0x16, 0x35, 0xAD, 0x84, 0x7E, 0xCB, + 0x68, 0x2A, 0x52, 0x1B, 0x2C, 0xD7, 0xD0, 0x2F, 0x07, 0x7D, 0xDD, 0xD2, 0x1B, 0xE8, 0x47, 0x3A, + 0xF0, 0x46, 0xCC, 0x39, 0x52, 0x89, 0x5C, 0xD0, 0xA4, 0x3E, 0xCC, 0xC0, 0xA0, 0xB8, 0x6E, 0xB6, + 0x23, 0x9B, 0x71, 0x4E, 0x93, 0x93, 0xFE, 0xD9, 0xA9, 0xAB, 0x5F, 0x29, 0x46, 0xB4, 0x53, 0x28, + 0x48, 0x74, 0x4B, 0x5E, 0x51, 0x7E, 0xC8, 0xE1, 0x84, 0x05, 0xBE, 0x11, 0x99, 0x6D, 0x24, 0xE1, + 0x49, 0x12, 0xB2, 0x40, 0x01, 0x0A, 0x9E, 0x2D, 0x1E, 0x62, 0xEA, 0xEA, 0x23, 0x50, 0x86, 0x6E, + 0x79, 0x76, 0x98, 0x05, 0x82, 0xC5, 0x01, 0x75, 0x37, 0x5A, 0x30, 0xE3, 0x60, 0x41, 0xAE, 0x8E, + 0xB9, 0x19, 0x61, 0xCC, 0x77, 0x75, 0x15, 0xA1, 0xF2, 0xB8, 0xB6, 0xEE, 0x14, 0x4F, 0x9D, 0x92, + 0x56, 0x4E, 0x49, 0xCB, 0xB8, 0x4A, 0xE0, 0x34, 0x3F, 0x18, 0xC3, 0x3C, 0xCE, 0xD4, 0x51, 0x05, + 0xCC, 0xA7, 0x23, 0x02, 0x9C, 0x7C, 0x40, 0x6D, 0xBA, 0x7A, 0x63, 0xDD, 0x41, 0xA9, 0x3A, 0xC8, + 0xAF, 0x6A, 0xC4, 0x2F, 0x6B, 0x44, 0xDD, 0xEE, 0x3A, 0x64, 0x5F, 0x21, 0x07, 0x55, 0xE4, 0xA0, + 0x8C, 0x7C, 0x28, 0x8D, 0x64, 0x1D, 0x72, 0xA0, 0x90, 0x93, 0x8A, 0x88, 0x89, 0x14, 0x51, 0x85, + 0xBD, 0x3A, 0x6A, 0x13, 0x05, 0xD2, 0xAD, 0xA4, 0x22, 0x66, 0x62, 0x83, 0x97, 0x92, 0x61, 0x40, + 0x7D, 0x77, 0xA3, 0x09, 0x33, 0x2C, 0xB6, 0xDD, 0xAD, 0xE6, 0x9A, 0x33, 0x12, 0x75, 0x46, 0x56, + 0x65, 0x30, 0x2B, 0x33, 0xA8, 0xF5, 0xC8, 0x1D, 0xD5, 0xD6, 0x31, 0x98, 0x99, 0x56, 0x60, 0x47, + 0xDC, 0x0B, 0x98, 0x77, 0xEB, 0x2E, 0xBD, 0xC5, 0x9C, 0xB1, 0x85, 0x85, 0x5A, 0x5C, 0x06, 0xBA, + 0x01, 0x94, 0x5E, 0x8B, 0xA5, 0x7C, 0x80, 0xFA, 0x9E, 0x5B, 0xD9, 0x5A, 0x02, 0xDC, 0xA6, 0xF7, + 0xD4, 0x3B, 0x8C, 0xC2, 0x90, 0xA0, 0xED, 0xA6, 0xC0, 0x41, 0x3E, 0xD1, 0xCD, 0xB9, 0x15, 0xAD, + 0xC5, 0x79, 0xC2, 0x45, 0x2C, 0x7F, 0x3D, 0x8B, 0x23, 0x03, 0x5C, 0xCE, 0xF5, 0x6C, 0xD4, 0x61, + 0x6A, 0x83, 0x1E, 0xC7, 0x62, 0xF2, 0x13, 0x17, 0x2A, 0x0C, 0x54, 0xA2, 0x7C, 0x69, 0xDE, 0x58, + 0x0B, 0x91, 0x56, 0x7C, 0xEA, 0xA2, 0xB7, 0xE2, 0x54, 0xA8, 0xBC, 0x8A, 0x5D, 0x9A, 0x4B, 0x1D, + 0x94, 0x61, 0xB9, 0xBD, 0x2F, 0xA0, 0xFA, 0x7C, 0x0E, 0xE7, 0x01, 0xFF, 0x13, 0x68, 0xF9, 0xE8, + 0x5F, 0x17, 0x60, 0xC9, 0xA3, 0x34, 0x78, 0x8B, 0xBB, 0x0D, 0xE3, 0xC0, 0xF9, 0x8F, 0x6D, 0x7C, + 0xF9, 0x1F, 0xFB, 0xA6, 0x66, 0x9A, 0x07, 0xFF, 0x6A, 0x48, 0x0D, 0x1B, 0xC2, 0xFC, 0xD2, 0xBA, + 0xB1, 0x08, 0x80, 0xED, 0x7F, 0x9B, 0xFF, 0xB1, 0x25, 0xB8, 0x02, 0x6B, 0xDF, 0x45, 0x90, 0x49, + 0xF0, 0x24, 0x34, 0xB0, 0x68, 0xA4, 0x91, 0xCD, 0x4D, 0x43, 0xB8, 0xA4, 0x72, 0x8D, 0x35, 0x51, + 0xD3, 0x6D, 0x88, 0x53, 0x50, 0x5B, 0xAC, 0x04, 0xBF, 0x3E, 0x24, 0x7A, 0x15, 0x5B, 0x17, 0x00, + 0xC9, 0x3D, 0xCA, 0x0C, 0x3D, 0x22, 0x97, 0x52, 0xCB, 0x0C, 0x02, 0x42, 0xA7, 0x89, 0xE7, 0x2A, + 0xAD, 0x1D, 0x14, 0x30, 0x17, 0xA2, 0xE0, 0xBC, 0x1C, 0x2D, 0x15, 0xEA, 0xAA, 0xFD, 0x17, 0x0A, + 0xA3, 0xD6, 0x12, 0x8A, 0x04, 0x31, 0xAD, 0xD8, 0x79, 0xC6, 0x72, 0x75, 0x4C, 0x59, 0xBA, 0x35, + 0x59, 0x5D, 0x96, 0xAD, 0x04, 0xAE, 0x2F, 0x8D, 0xFE, 0xD7, 0x3D, 0x16, 0x8E, 0xB5, 0x12, 0x3F, + 0xF8, 0x97, 0xFB, 0x2B, 0x46, 0xE4, 0xCD, 0x3F, 0xBC, 0x21, 0x70, 0x05, 0xA6, 0x41, 0x6D, 0x1E, + 0x4D, 0x0D, 0xB3, 0xF6, 0xAB, 0xAE, 0x49, 0x8A, 0xAE, 0x1E, 0x92, 0xFB, 0xBC, 0xA7, 0xC4, 0x8C, + 0xD7, 0xD6, 0x70, 0x5E, 0xB4, 0x28, 0xF9, 0x82, 0xEC, 0xE6, 0x48, 0x26, 0xA2, 0xB6, 0x56, 0x64, + 0x52, 0xD5, 0xCA, 0xE8, 0x5A, 0x63, 0xFF, 0xD7, 0x4A, 0x40, 0xB7, 0x98, 0xBA, 0x4E, 0x15, 0x8C, + 0xB3, 0x00, 0x1C, 0x93, 0x3E, 0x1D, 0x69, 0x03, 0x26, 0x03, 0x75, 0x35, 0x46, 0x5A, 0x81, 0xC1, + 0xCC, 0x03, 0xC3, 0x2B, 0xFB, 0xF3, 0x1E, 0x16, 0xBF, 0xFB, 0x97, 0xAA, 0xAA, 0x81, 0xD4, 0x8B, + 0x33, 0x5D, 0x59, 0x59, 0xD5, 0x4B, 0xE0, 0xD2, 0x08, 0xA0, 0x5B, 0x8B, 0x3C, 0x3A, 0x8C, 0xFC, + 0x87, 0x52, 0xF6, 0x4D, 0xBB, 0x0F, 0x87, 0x01, 0x49, 0xD3, 0x73, 0xB8, 0x01, 0x43, 0xF7, 0x42, + 0x50, 0xB8, 0xB2, 0xC2, 0xFD, 0xE6, 0xE6, 0x66, 0x15, 0x29, 0xA1, 0x21, 0x14, 0xDB, 0x8A, 0x2B, + 0xF0, 0x49, 0xD3, 0xF1, 0x81, 0x30, 0x18, 0xD2, 0x1A, 0xC6, 0xF0, 0x25, 0xE3, 0x47, 0x5C, 0x71, + 0xF4, 0xF4, 0x22, 0xA6, 0xFC, 0x33, 0xDC, 0x95, 0x32, 0xCB, 0x1A, 0xAD, 0xA6, 0x68, 0xFA, 0x8F, + 0xD8, 0x3E, 0xCA, 0x0D, 0x76, 0xC1, 0x7A, 0xBA, 0x56, 0xA1, 0xFC, 0x9F, 0x61, 0xB9, 0x94, 0x28, + 0xD6, 0x70, 0x9C, 0x40, 0x80, 0x5A, 0xC3, 0x31, 0xC4, 0x1A, 0x41, 0x17, 0xFC, 0x26, 0x6B, 0xF9, + 0xCD, 0xFE, 0x19, 0x7E, 0x97, 0x76, 0x1E, 0x15, 0x25, 0x91, 0xAA, 0xAF, 0x50, 0x02, 0x9F, 0xDD, + 0xE9, 0xA6, 0x15, 0xB9, 0x55, 0x0A, 0x50, 0x1B, 0x46, 0x41, 0xD0, 0x8F, 0xE2, 0x83, 0x27, 0xD6, + 0x9D, 0xC5, 0x7A, 0x31, 0xC8, 0xD9, 0x5C, 0x6E, 0xB1, 0xBC, 0xB5, 0x44, 0x4F, 0xA1, 0xEC, 0x5F, + 0x4B, 0x15, 0x01, 0x3F, 0x23, 0x8B, 0x7B, 0xAC, 0xD4, 0xA5, 0x36, 0x28, 0x0F, 0x56, 0x3F, 0xD5, + 0x3C, 0xCB, 0x5F, 0xCC, 0xAE, 0x6B, 0x51, 0x9B, 0xC0, 0x38, 0x57, 0x92, 0x8B, 0x4A, 0xB2, 0xC8, + 0x13, 0x01, 0xA8, 0x58, 0xC7, 0x2E, 0xC4, 0x4D, 0x6B, 0x7A, 0x7C, 0xBF, 0x5C, 0x83, 0xC2, 0xDF, + 0xF5, 0xD5, 0x12, 0x33, 0x08, 0xC4, 0xD3, 0x95, 0x4B, 0x29, 0x5F, 0x37, 0x29, 0x8A, 0x0E, 0x62, + 0x47, 0xA3, 0x51, 0x4A, 0xC5, 0x47, 0x0C, 0x49, 0x56, 0xB2, 0x98, 0x9F, 0xC8, 0x90, 0x04, 0x8C, + 0x45, 0x3C, 0x8C, 0xB2, 0x94, 0x46, 0x99, 0xA8, 0xA4, 0x16, 0x63, 0x21, 0xCC, 0x5E, 0xFA, 0xE7, + 0x9F, 0x8B, 0xC9, 0x7E, 0x5A, 0x0B, 0x96, 0xD3, 0xEB, 0x3D, 0xBF, 0x34, 0xD9, 0xF7, 0x6B, 0x89, + 0xB9, 0x7A, 0xE9, 0xFF, 0x67, 0x4B, 0x21, 0x65, 0x4B, 0xF1, 0xB0, 0x54, 0x2E, 0x62, 0x62, 0x29, + 0xE6, 0xC9, 0x82, 0x91, 0x97, 0x7C, 0x16, 0x0D, 0x1A, 0x2B, 0x25, 0x55, 0x9E, 0x97, 0x7D, 0x95, + 0x43, 0x40, 0x59, 0x71, 0xE5, 0x35, 0x11, 0x06, 0x34, 0xE0, 0x63, 0x64, 0xF2, 0x41, 0xEB, 0xA7, + 0xD1, 0x94, 0x26, 0x87, 0x24, 0xA5, 0x06, 0x24, 0xCD, 0x65, 0xDC, 0x41, 0xA8, 0xE9, 0x04, 0xEB, + 0x76, 0x6D, 0x6E, 0x12, 0x05, 0xCE, 0x33, 0x77, 0xC4, 0xB1, 0x26, 0x03, 0xF9, 0xB2, 0xCA, 0x09, + 0xD4, 0xC6, 0xBE, 0x12, 0xA4, 0x3E, 0x52, 0x25, 0xA8, 0x61, 0x5A, 0xD0, 0x76, 0xC0, 0x35, 0x5F, + 0x26, 0x51, 0x4C, 0xC6, 0xB2, 0x07, 0x83, 0x35, 0x74, 0x0F, 0xA4, 0x66, 0x6D, 0x34, 0x91, 0x60, + 0xA9, 0x73, 0x29, 0xFC, 0x66, 0xD9, 0xC2, 0x70, 0x4B, 0x57, 0xC9, 0xB0, 0xBD, 0xF4, 0xA5, 0x35, + 0x59, 0x83, 0xE0, 0x0B, 0x6C, 0x62, 0xE0, 0x1E, 0x68, 0x64, 0xF2, 0x7B, 0x00, 0x77, 0x6B, 0xB6, + 0xA3, 0x3D, 0xD6, 0x8E, 0x6A, 0x35, 0x53, 0x55, 0xE9, 0xAE, 0x0B, 0x6D, 0x4E, 0x74, 0x23, 0x0B, + 0x4B, 0x10, 0xAA, 0x9A, 0x59, 0x0C, 0x38, 0x1B, 0x81, 0xAA, 0xBA, 0xC0, 0x11, 0xD6, 0x98, 0x66, + 0xA9, 0x23, 0xF1, 0x97, 0x1D, 0xC9, 0x13, 0xB5, 0x07, 0x95, 0xF5, 0x05, 0xD4, 0x31, 0xAB, 0x25, + 0x86, 0x30, 0xD3, 0x29, 0x13, 0xDE, 0x04, 0x03, 0x90, 0x07, 0x5A, 0xD5, 0x05, 0x14, 0xB5, 0x8E, + 0x1C, 0x4D, 0x44, 0xB8, 0x1C, 0x05, 0xF9, 0xF0, 0x6B, 0x9A, 0x0F, 0xBC, 0xB4, 0x18, 0xDD, 0x97, + 0x80, 0x50, 0xD2, 0xE6, 0xE0, 0x88, 0x8F, 0xF2, 0x21, 0xF4, 0xB2, 0x05, 0x9D, 0x02, 0x58, 0xFC, + 0xC6, 0x71, 0x3E, 0x8A, 0x27, 0xC5, 0x68, 0x42, 0xEF, 0x17, 0x78, 0x51, 0x01, 0xF5, 0xA9, 0xEE, + 0x28, 0x1B, 0xDB, 0x68, 0xCE, 0xF3, 0x41, 0x6B, 0x29, 0x7F, 0xF0, 0xFF, 0x28, 0x7F, 0xCC, 0xC7, + 0x85, 0x34, 0x71, 0x31, 0x1A, 0xB3, 0x42, 0x96, 0x61, 0x18, 0xFF, 0x90, 0x93, 0xA4, 0xD4, 0x13, + 0x97, 0x7A, 0x5A, 0xF1, 0xB3, 0xB6, 0x53, 0x98, 0x8E, 0x31, 0xAA, 0xF8, 0xE3, 0xC8, 0xF6, 0xF0, + 0xF7, 0x3C, 0xF2, 0x65, 0x6D, 0x69, 0x5A, 0xA1, 0x31, 0x82, 0x3A, 0x57, 0x37, 0xCB, 0x7E, 0x9A, + 0xFD, 0xB7, 0xAD, 0xE8, 0xD1, 0xF1, 0xE9, 0x71, 0xFF, 0xB8, 0x5C, 0x38, 0x23, 0xE7, 0x25, 0x93, + 0x8A, 0x2B, 0x5D, 0xFA, 0xB2, 0x22, 0x80, 0x02, 0x1B, 0x45, 0x01, 0x7B, 0xDD, 0xDC, 0x54, 0x7E, + 0xF1, 0xB6, 0x77, 0x71, 0x6E, 0xC7, 0x24, 0x01, 0x8F, 0x24, 0x15, 0xE6, 0xC2, 0x82, 0x44, 0xF9, + 0xE0, 0xD7, 0xC7, 0xA5, 0x72, 0x5D, 0x7E, 0x61, 0x70, 0xC4, 0xDC, 0x52, 0xA7, 0xA9, 0x7E, 0x78, + 0xE2, 0x62, 0x5D, 0x99, 0xBF, 0x04, 0x41, 0x72, 0x1A, 0x2D, 0x13, 0x55, 0x11, 0x67, 0x46, 0xE5, + 0x30, 0x2F, 0xEE, 0xB2, 0x75, 0x0D, 0xD3, 0xC8, 0xB4, 0xC4, 0x84, 0xA5, 0xE5, 0x46, 0xA5, 0x12, + 0x14, 0xFE, 0xA2, 0xB6, 0xE7, 0x8B, 0x91, 0x24, 0xB7, 0x5A, 0x73, 0xAB, 0x6F, 0x41, 0x2A, 0x3E, + 0x58, 0x04, 0x23, 0x66, 0x39, 0xDB, 0x16, 0x77, 0xA3, 0x43, 0xEE, 0x61, 0x5C, 0x7F, 0xBA, 0x35, + 0x78, 0xD2, 0x3C, 0x79, 0x61, 0x9E, 0xFC, 0xB1, 0x7B, 0x2E, 0x1C, 0x45, 0xF9, 0xDA, 0xE2, 0x98, + 0xF6, 0x10, 0x58, 0xBB, 0x6D, 0x2F, 0x7D, 0x18, 0x20, 0xD2, 0x83, 0xCB, 0x00, 0xF4, 0x63, 0x58, + 0xFF, 0x4A, 0xEE, 0x88, 0x7A, 0x09, 0xAA, 0xA2, 0xAD, 0x73, 0x54, 0xD8, 0xEE, 0xFD, 0x81, 0xA3, + 0xF2, 0xCE, 0x65, 0x18, 0x48, 0x97, 0xC3, 0x92, 0x37, 0x8B, 0x75, 0xC1, 0x61, 0x19, 0x31, 0x64, + 0x6C, 0x00, 0xE3, 0xCD, 0x5D, 0x49, 0x13, 0xD5, 0x1C, 0xB4, 0xF0, 0x1B, 0x08, 0x8A, 0x4F, 0x39, + 0xCE, 0x9A, 0x38, 0xAD, 0x62, 0x72, 0xC5, 0x23, 0xC8, 0x4A, 0x67, 0x89, 0xC0, 0x6E, 0x10, 0x0D, + 0x0D, 0x7C, 0x64, 0x9A, 0xA1, 0xB6, 0x1D, 0x3E, 0x37, 0xD7, 0xBC, 0xD9, 0x54, 0xFA, 0x4B, 0x62, + 0x79, 0xD5, 0xB0, 0x8B, 0x1C, 0x56, 0xCC, 0x75, 0x7D, 0x1F, 0xF4, 0xA3, 0x4E, 0x29, 0xAF, 0x48, + 0xA4, 0x53, 0xD1, 0x83, 0xC4, 0x86, 0xA2, 0x41, 0xBE, 0x91, 0x40, 0x44, 0x72, 0x4A, 0x33, 0x5D, + 0xC7, 0xCA, 0xD2, 0x0B, 0x28, 0x49, 0x7A, 0xB2, 0x73, 0x95, 0x49, 0x6B, 0x25, 0x06, 0xFE, 0xC8, + 0xD7, 0xF0, 0xC7, 0xA1, 0xD0, 0xA3, 0x83, 0x9B, 0x49, 0x2B, 0x83, 0xA4, 0x23, 0x64, 0x83, 0xA9, + 0x37, 0xE4, 0xBB, 0xA8, 0x2D, 0x2F, 0xCB, 0xB4, 0x16, 0x50, 0x70, 0x71, 0x83, 0xBB, 0x11, 0x30, + 0x52, 0x5A, 0xC4, 0x9E, 0x94, 0xA8, 0xC7, 0x8F, 0x10, 0x1F, 0x53, 0x4A, 0x20, 0x06, 0x20, 0xA6, + 0x40, 0xD0, 0xA7, 0x42, 0x8A, 0x54, 0xE6, 0x92, 0x53, 0x2A, 0x20, 0xCA, 0x48, 0xCD, 0xE2, 0xC1, + 0x85, 0x78, 0xD4, 0x46, 0xD6, 0x80, 0xFD, 0xDC, 0xBD, 0x73, 0x33, 0xDE, 0x90, 0x68, 0x09, 0x56, + 0x36, 0x3D, 0x9A, 0xA6, 0x52, 0x5C, 0x54, 0xC7, 0x19, 0xF8, 0xA8, 0xA1, 0x03, 0x5A, 0x23, 0x84, + 0x11, 0x1E, 0x84, 0x8A, 0x01, 0x40, 0x7F, 0x42, 0xC3, 0x1C, 0x22, 0x70, 0x08, 0x20, 0x82, 0xA0, + 0x7F, 0x49, 0x0D, 0xF7, 0x64, 0x05, 0xC9, 0xF8, 0xD8, 0x6D, 0x35, 0xF0, 0x9D, 0x66, 0x95, 0xEC, + 0x20, 0xA5, 0xBD, 0x68, 0x24, 0xFA, 0x64, 0x98, 0x1A, 0x50, 0x00, 0xAC, 0xD9, 0x01, 0xA0, 0x1E, + 0x24, 0x5E, 0x63, 0x2B, 0x3F, 0xEF, 0x04, 0x2A, 0xBB, 0x00, 0xAB, 0xBB, 0x8E, 0x87, 0x5F, 0x39, + 0x4F, 0x19, 0xA7, 0x39, 0x26, 0x00, 0x7B, 0x93, 0x68, 0x7A, 0x99, 0x30, 0x2E, 0xCE, 0x64, 0x1B, + 0x6A, 0x6C, 0xB4, 0xE4, 0xF5, 0xA9, 0x87, 0x15, 0x79, 0x3F, 0xC5, 0x8B, 0xCB, 0x0C, 0xF3, 0xBA, + 0x53, 0x79, 0x77, 0xB1, 0x86, 0x70, 0x21, 0x50, 0x66, 0x38, 0xB3, 0x29, 0x74, 0xB0, 0xFA, 0xA1, + 0x48, 0x82, 0x7A, 0x4F, 0xB7, 0x42, 0xE2, 0xC1, 0x44, 0xED, 0x81, 0xF9, 0xDC, 0xC2, 0xD8, 0xE1, + 0x94, 0x83, 0x5A, 0x0A, 0xB5, 0x02, 0x45, 0xC6, 0x95, 0xCD, 0x98, 0x35, 0x1D, 0x6A, 0x58, 0x88, + 0x61, 0xE0, 0xAF, 0xFE, 0x05, 0x0F, 0x1E, 0x1C, 0xC8, 0x55, 0x3F, 0xE1, 0x23, 0xE3, 0x7E, 0xF4, + 0x23, 0x3E, 0x3E, 0xAF, 0xF0, 0xF1, 0x79, 0x1D, 0x1F, 0xB4, 0xAA, 0x3C, 0x98, 0x0C, 0x80, 0xEC, + 0x19, 0xE1, 0x64, 0x4C, 0x13, 0x58, 0xC0, 0x43, 0x50, 0x25, 0x7F, 0x8B, 0xB3, 0x84, 0xFE, 0x98, + 0xB3, 0xDE, 0x84, 0x8D, 0xC4, 0x23, 0xFE, 0x8A, 0xD5, 0xFF, 0x82, 0x4B, 0x3C, 0x70, 0x3D, 0x97, + 0x79, 0x6D, 0x5A, 0x49, 0x28, 0x3F, 0x7E, 0x2B, 0x91, 0x7E, 0xE4, 0x42, 0x78, 0xA9, 0x38, 0xC8, + 0xDF, 0xB7, 0xF4, 0x00, 0xBC, 0x11, 0xF8, 0x29, 0x35, 0x75, 0xBC, 0x0B, 0xA5, 0xFC, 0x29, 0x30, + 0x64, 0xA8, 0xC0, 0x47, 0xDD, 0xD9, 0xDC, 0x12, 0xAE, 0x01, 0x8A, 0xF1, 0xA3, 0x29, 0xB0, 0xEA, + 0xC9, 0x02, 0xD7, 0x9E, 0x40, 0x26, 0x04, 0x91, 0xE0, 0x48, 0xC8, 0xA7, 0x8D, 0x2F, 0x07, 0x9B, + 0x37, 0x35, 0xC8, 0x43, 0x2E, 0xFC, 0x98, 0x2E, 0x0C, 0x36, 0x6F, 0xFE, 0x6D, 0x36, 0xC6, 0xCC, + 0x5A, 0x76, 0xA4, 0x96, 0x4C, 0xF6, 0xF4, 0x0B, 0xBF, 0x71, 0x09, 0x48, 0x5D, 0x49, 0x78, 0x45, + 0x34, 0x03, 0x6B, 0x43, 0x61, 0xE1, 0x07, 0xFF, 0x47, 0x09, 0xF8, 0x91, 0x9E, 0x07, 0xCE, 0xBD, + 0xE6, 0x3D, 0x5E, 0x2F, 0x3E, 0x85, 0xE9, 0x56, 0xE9, 0xC1, 0x4A, 0xC7, 0xEF, 0x53, 0x3A, 0x76, + 0x59, 0xA2, 0x14, 0x4A, 0x14, 0x59, 0x88, 0x1A, 0x6A, 0x50, 0x0E, 0x51, 0x98, 0x89, 0x17, 0xCD, + 0x81, 0x02, 0x9B, 0x73, 0x34, 0x5B, 0x3A, 0x02, 0x0F, 0xF4, 0xF5, 0x45, 0xEE, 0xFC, 0x74, 0x76, + 0x7A, 0x22, 0x44, 0x7C, 0xA5, 0x62, 0x22, 0xD0, 0xAA, 0x2E, 0x2C, 0x2F, 0xCF, 0x9C, 0x89, 0xE4, + 0xA1, 0x28, 0x75, 0x30, 0x31, 0x28, 0x87, 0xFE, 0x74, 0x31, 0xFC, 0x0A, 0x71, 0xD6, 0xD0, 0xCF, + 0x52, 0x48, 0x58, 0x5B, 0x36, 0xA2, 0xF7, 0xFB, 0x97, 0xF6, 0xAE, 0xDD, 0x84, 0xBA, 0x00, 0xB4, + 0x0A, 0x69, 0x19, 0xEE, 0x7D, 0xFE, 0xB7, 0x90, 0xB7, 0xFF, 0x1E, 0x32, 0x83, 0xA8, 0x95, 0x42, + 0x58, 0x2A, 0xF0, 0xAB, 0xB8, 0x93, 0x24, 0x9A, 0x4A, 0xB4, 0xE3, 0x24, 0xC1, 0x4B, 0xE9, 0x43, + 0x85, 0xA2, 0x0D, 0x61, 0x31, 0xA5, 0x89, 0xE6, 0x47, 0x34, 0xD5, 0x78, 0x24, 0xB4, 0x34, 0x8B, + 0x63, 0x68, 0x5C, 0x56, 0xF4, 0x61, 0xEB, 0xC5, 0xEB, 0xCB, 0xFB, 0x8C, 0x66, 0xD4, 0xCF, 0x97, + 0x69, 0x52, 0xD1, 0x0B, 0x56, 0x50, 0xDF, 0x10, 0xEE, 0x7E, 0xB9, 0xC9, 0xEB, 0xA9, 0x8C, 0x73, + 0x8C, 0xA2, 0x1B, 0x2D, 0x35, 0x07, 0xE9, 0x26, 0x40, 0xD5, 0xE5, 0x59, 0x10, 0xCC, 0xDB, 0x2B, + 0xB4, 0xA0, 0xF1, 0x8A, 0x44, 0x24, 0x9F, 0xCB, 0x67, 0x7F, 0xE4, 0xC9, 0xA9, 0xE2, 0x82, 0x50, + 0xF2, 0x54, 0xA9, 0x36, 0xAD, 0x0D, 0x63, 0x83, 0x6A, 0x8C, 0xA7, 0x82, 0x70, 0x0F, 0xAF, 0x51, + 0xE9, 0xC2, 0x2C, 0x6A, 0x29, 0xDC, 0xDE, 0x46, 0x5F, 0xCB, 0x6D, 0xE9, 0x89, 0x7C, 0x2A, 0x25, + 0xE3, 0xAE, 0xAE, 0x63, 0x55, 0x45, 0xB1, 0x3E, 0x25, 0x61, 0x5A, 0x26, 0x5B, 0x54, 0x06, 0x26, + 0x77, 0x0B, 0x70, 0x9B, 0x06, 0x29, 0x1C, 0xBD, 0x7E, 0x7F, 0xCE, 0x46, 0xD1, 0xCE, 0x11, 0x80, + 0x69, 0xC5, 0x3E, 0x93, 0xD7, 0xE0, 0x24, 0xCC, 0x73, 0x07, 0x32, 0xE9, 0x4A, 0x03, 0x0E, 0xA9, + 0x98, 0x44, 0xFE, 0x81, 0x7E, 0xA0, 0x3B, 0x3A, 0xFC, 0xBB, 0x09, 0x35, 0x47, 0xCD, 0xA5, 0xD0, + 0xA4, 0xFA, 0x74, 0x70, 0xF5, 0x06, 0xC2, 0x53, 0x0C, 0xA5, 0x01, 0x17, 0x50, 0x34, 0xD7, 0x74, + 0x7C, 0x7A, 0x7D, 0x0C, 0x29, 0xC8, 0x7F, 0x21, 0x37, 0x66, 0xBB, 0xAA, 0x6C, 0xB8, 0xF3, 0xEA, + 0x75, 0x56, 0x2E, 0x03, 0x7A, 0x61, 0x8C, 0x58, 0x0F, 0x29, 0x7E, 0xFB, 0x7B, 0xF4, 0x9E, 0x8D, + 0x15, 0xD2, 0x6A, 0x5D, 0x6F, 0xCE, 0x76, 0x90, 0x67, 0x89, 0xD5, 0x43, 0x2C, 0x70, 0x97, 0x1F, + 0x29, 0x59, 0x95, 0x35, 0xDC, 0xF6, 0x48, 0x10, 0xE0, 0xC7, 0x5A, 0x03, 0x1B, 0x6A, 0x22, 0xB2, + 0xD4, 0x42, 0x22, 0x29, 0x08, 0x90, 0xD2, 0x3E, 0x84, 0x39, 0xD3, 0x92, 0x65, 0x86, 0xB2, 0xA1, + 0xBC, 0xFF, 0xC5, 0x9A, 0xA3, 0x64, 0x46, 0xE8, 0xCE, 0xF9, 0x6C, 0x73, 0x53, 0xD8, 0x85, 0x99, + 0x18, 0x05, 0x52, 0x8A, 0x01, 0x1C, 0x9A, 0x7D, 0x68, 0x2D, 0x8C, 0xB2, 0x90, 0x58, 0xAB, 0x3D, + 0xD2, 0xB6, 0x51, 0x55, 0x03, 0x54, 0x7C, 0x46, 0x01, 0x03, 0xCE, 0xB2, 0x24, 0x80, 0xA8, 0x8B, + 0x39, 0xBA, 0xB2, 0x2D, 0xC5, 0xBA, 0xD0, 0x84, 0x0E, 0xEC, 0x67, 0xC8, 0x12, 0x95, 0x97, 0xAD, + 0xA2, 0x27, 0x12, 0xC5, 0x77, 0x95, 0x9E, 0xC8, 0x6F, 0xE5, 0x84, 0xAA, 0xC8, 0x77, 0x88, 0x2F, + 0x13, 0x5C, 0xD4, 0xD1, 0x13, 0xA0, 0x24, 0x83, 0x52, 0x34, 0x60, 0x2A, 0x2C, 0x37, 0xEE, 0xEB, + 0xD3, 0xE9, 0xB4, 0x8E, 0xDF, 0x6A, 0xEB, 0x70, 0x82, 0xB2, 0x02, 0x5F, 0x5F, 0xC7, 0x21, 0x47, + 0x15, 0x58, 0xF8, 0x6E, 0xE1, 0xAC, 0xBA, 0xE8, 0x42, 0x7F, 0x2B, 0xDE, 0xD4, 0xAA, 0xD2, 0x59, + 0xE1, 0x73, 0x79, 0xDB, 0x7B, 0x3B, 0x2B, 0x20, 0x32, 0xC4, 0xAF, 0xB2, 0x90, 0x69, 0x20, 0x0D, + 0x3B, 0xE5, 0x46, 0x56, 0x25, 0x85, 0x65, 0x5C, 0xB0, 0xE3, 0x2C, 0x9D, 0x18, 0x33, 0x60, 0xDD, + 0x11, 0x96, 0xD2, 0x95, 0x43, 0x2D, 0x65, 0xB7, 0x0E, 0xB7, 0x0A, 0xFB, 0x70, 0x30, 0x83, 0x94, + 0x79, 0xFB, 0xF3, 0x4F, 0x39, 0x5B, 0xDE, 0xF6, 0x92, 0x62, 0x71, 0xE1, 0xF3, 0xFC, 0xA9, 0x35, + 0xAF, 0x69, 0xA5, 0xD1, 0xAF, 0xC4, 0x97, 0xBD, 0x46, 0xFE, 0x19, 0x3B, 0xFF, 0x9C, 0xAD, 0x81, + 0xB1, 0x43, 0x23, 0x2A, 0xDC, 0x4C, 0x8C, 0xEA, 0x2F, 0x34, 0xE6, 0x63, 0x79, 0x29, 0xBF, 0x2D, + 0xA0, 0x54, 0xA9, 0xD3, 0x68, 0x78, 0x3E, 0xFF, 0x9A, 0x42, 0x19, 0x1D, 0x65, 0xFE, 0x28, 0x20, + 0x09, 0xC5, 0x82, 0xA3, 0x41, 0xBE, 0x92, 0xFB, 0x46, 0xC0, 0x86, 0x69, 0x03, 0x93, 0x6D, 0xCB, + 0xDE, 0xB2, 0x77, 0x71, 0x64, 0x7F, 0x4D, 0xF7, 0x57, 0x4F, 0xD8, 0x5F, 0x34, 0x69, 0x58, 0x0B, + 0xE7, 0xB5, 0xAB, 0x8A, 0x4D, 0x6A, 0x83, 0xFB, 0xC4, 0xA7, 0x70, 0x3D, 0x6F, 0xB3, 0xCC, 0xB6, + 0x1A, 0xE4, 0x5F, 0x60, 0xD4, 0x31, 0xBA, 0x95, 0x2F, 0x92, 0xF4, 0x81, 0x7B, 0x18, 0x5B, 0x17, + 0x54, 0x26, 0x70, 0x49, 0xD5, 0x87, 0x34, 0xB9, 0xD3, 0x9C, 0x2F, 0x39, 0xC3, 0xB7, 0x3C, 0xA8, + 0x03, 0xE4, 0x37, 0x9C, 0x72, 0x39, 0xB0, 0xBF, 0x07, 0x5D, 0x33, 0x2A, 0x41, 0x79, 0xB1, 0x26, + 0x9B, 0xE6, 0x7C, 0x02, 0x82, 0x01, 0x70, 0xB1, 0xA3, 0x48, 0xCD, 0x2B, 0xCB, 0x98, 0x9B, 0x57, + 0x96, 0x54, 0xE2, 0x5F, 0x59, 0xCC, 0xDB, 0x9F, 0xFC, 0xDB, 0x4C, 0xF9, 0x7F, 0x5B, 0x28, 0x36, + 0x32, 0xF9, 0xE1, 0x09, 0xF7, 0x56, 0x3F, 0x45, 0xAD, 0x47, 0x51, 0xBB, 0xF7, 0xFF, 0x17, 0x53, + 0xE8, 0x9D, 0x36, 0x92, 0x29, 0x00, 0x00 +}; + +#define SPIFFS_MAXLENGTH_FILEPATH 32 +const char *excludeListFile = "/.exclude.files"; + +typedef struct ExcludeListS { + char *item; + ExcludeListS *next; +} ExcludeList; + +static ExcludeList *excludes = NULL; + +static bool matchWild(const char *pattern, const char *testee) { + const char *nxPat = NULL, *nxTst = NULL; + + while (*testee) { + if (( *pattern == '?' ) || (*pattern == *testee)){ + pattern++;testee++; + continue; + } + if (*pattern=='*'){ + nxPat=pattern++; nxTst=testee; + continue; + } + if (nxPat){ + pattern = nxPat+1; testee=++nxTst; + continue; + } + return false; + } + while (*pattern=='*'){pattern++;} + return (*pattern == 0); +} + +static bool addExclude(const char *item){ + size_t len = strlen(item); + if(!len){ + return false; + } + ExcludeList *e = (ExcludeList *)malloc(sizeof(ExcludeList)); + if(!e){ + return false; + } + e->item = (char *)malloc(len+1); + if(!e->item){ + free(e); + return false; + } + memcpy(e->item, item, len+1); + e->next = excludes; + excludes = e; + return true; +} + +static void loadExcludeList(fs::FS &_fs, const char *filename){ + static char linebuf[SPIFFS_MAXLENGTH_FILEPATH]; + fs::File excludeFile=_fs.open(filename, "r"); + if(!excludeFile){ + //addExclude("/*.js.gz"); + return; + } +#ifdef ESP32 + if(excludeFile.isDirectory()){ + excludeFile.close(); + return; + } +#endif + if (excludeFile.size() > 0){ + uint8_t idx; + bool isOverflowed = false; + while (excludeFile.available()){ + linebuf[0] = '\0'; + idx = 0; + int lastChar; + do { + lastChar = excludeFile.read(); + if(lastChar != '\r'){ + linebuf[idx++] = (char) lastChar; + } + } while ((lastChar >= 0) && (lastChar != '\n') && (idx < SPIFFS_MAXLENGTH_FILEPATH)); + + if(isOverflowed){ + isOverflowed = (lastChar != '\n'); + continue; + } + isOverflowed = (idx >= SPIFFS_MAXLENGTH_FILEPATH); + linebuf[idx-1] = '\0'; + if(!addExclude(linebuf)){ + excludeFile.close(); + return; + } + } + } + excludeFile.close(); +} + +static bool isExcluded(fs::FS &_fs, const char *filename) { + if(excludes == NULL){ + loadExcludeList(_fs, excludeListFile); + } + ExcludeList *e = excludes; + while(e){ + if (matchWild(e->item, filename)){ + return true; + } + e = e->next; + } + return false; +} + +// WEB HANDLER IMPLEMENTATION + +#ifdef ESP32 +SPIFFSEditor::SPIFFSEditor(const fs::FS& fs, const String& username, const String& password) +#else +SPIFFSEditor::SPIFFSEditor(const String& username, const String& password, const fs::FS& fs) +#endif +:_fs(fs) +,_username(username) +,_password(password) +,_authenticated(false) +,_startTime(0) +{} + +bool SPIFFSEditor::canHandle(AsyncWebServerRequest *request){ + if(request->url().equalsIgnoreCase("/edit")){ + if(request->method() == HTTP_GET){ + if(request->hasParam("list")) + return true; + if(request->hasParam("edit")){ + request->_tempFile = _fs.open(request->arg("edit"), "r"); + if(!request->_tempFile){ + return false; + } +#ifdef ESP32 + if(request->_tempFile.isDirectory()){ + request->_tempFile.close(); + return false; + } +#endif + } + if(request->hasParam("download")){ + request->_tempFile = _fs.open(request->arg("download"), "r"); + if(!request->_tempFile){ + return false; + } +#ifdef ESP32 + if(request->_tempFile.isDirectory()){ + request->_tempFile.close(); + return false; + } +#endif + } + request->addInterestingHeader("If-Modified-Since"); + return true; + } + else if(request->method() == HTTP_POST) + return true; + else if(request->method() == HTTP_DELETE) + return true; + else if(request->method() == HTTP_PUT) + return true; + + } + return false; +} + + +void SPIFFSEditor::handleRequest(AsyncWebServerRequest *request){ + if(_username.length() && _password.length() && !request->authenticate(_username.c_str(), _password.c_str())) + return request->requestAuthentication(); + + if(request->method() == HTTP_GET){ + if(request->hasParam("list")){ + String path = request->getParam("list")->value(); +#ifdef ESP32 + File dir = _fs.open(path); +#else + Dir dir = _fs.openDir(path); +#endif + path = String(); + String output = "["; +#ifdef ESP32 + File entry = dir.openNextFile(); + while(entry){ +#else + while(dir.next()){ + fs::File entry = dir.openFile("r"); +#endif + if (isExcluded(_fs, entry.name())) { +#ifdef ESP32 + entry = dir.openNextFile(); +#endif + continue; + } + if (output != "[") output += ','; + output += "{\"type\":\""; + output += "file"; + output += "\",\"name\":\""; + output += String(entry.name()); + output += "\",\"size\":"; + output += String(entry.size()); + output += "}"; +#ifdef ESP32 + entry = dir.openNextFile(); +#else + entry.close(); +#endif + } +#ifdef ESP32 + dir.close(); +#endif + output += "]"; + request->send(200, "application/json", output); + output = String(); + } + else if(request->hasParam("edit") || request->hasParam("download")){ + request->send(request->_tempFile, request->_tempFile.name(), String(), request->hasParam("download")); + } + else { + const char * buildTime = __DATE__ " " __TIME__ " GMT"; + if (request->header("If-Modified-Since").equals(buildTime)) { + request->send(304); + } else { + AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", edit_htm_gz, edit_htm_gz_len); + response->addHeader("Content-Encoding", "gzip"); + response->addHeader("Last-Modified", buildTime); + request->send(response); + } + } + } else if(request->method() == HTTP_DELETE){ + if(request->hasParam("path", true)){ + _fs.remove(request->getParam("path", true)->value()); + request->send(200, "", "DELETE: "+request->getParam("path", true)->value()); + } else + request->send(404); + } else if(request->method() == HTTP_POST){ + if(request->hasParam("data", true, true) && _fs.exists(request->getParam("data", true, true)->value())) + request->send(200, "", "UPLOADED: "+request->getParam("data", true, true)->value()); + else + request->send(500); + } else if(request->method() == HTTP_PUT){ + if(request->hasParam("path", true)){ + String filename = request->getParam("path", true)->value(); + if(_fs.exists(filename)){ + request->send(200); + } else { + fs::File f = _fs.open(filename, "w"); + if(f){ + f.write((uint8_t)0x00); + f.close(); + request->send(200, "", "CREATE: "+filename); + } else { + request->send(500); + } + } + } else + request->send(400); + } +} + +void SPIFFSEditor::handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final){ + if(!index){ + if(!_username.length() || request->authenticate(_username.c_str(),_password.c_str())){ + _authenticated = true; + request->_tempFile = _fs.open(filename, "w"); + _startTime = millis(); + } + } + if(_authenticated && request->_tempFile){ + if(len){ + request->_tempFile.write(data,len); + } + if(final){ + request->_tempFile.close(); + } + } +} diff --git a/lib/ESPAsyncWebServer/SPIFFSEditor.h b/lib/ESPAsyncWebServer/SPIFFSEditor.h new file mode 100644 index 000000000..3586429e1 --- /dev/null +++ b/lib/ESPAsyncWebServer/SPIFFSEditor.h @@ -0,0 +1,24 @@ +#ifndef SPIFFSEditor_H_ +#define SPIFFSEditor_H_ +#include + +class SPIFFSEditor: public AsyncWebHandler { + private: + fs::FS _fs; + String _username; + String _password; + bool _authenticated; + uint32_t _startTime; + public: +#ifdef ESP32 + SPIFFSEditor(const fs::FS& fs, const String& username=String(), const String& password=String()); +#else + SPIFFSEditor(const String& username=String(), const String& password=String(), const fs::FS& fs=SPIFFS); +#endif + virtual bool canHandle(AsyncWebServerRequest *request) override final; + virtual void handleRequest(AsyncWebServerRequest *request) override final; + virtual void handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final) override final; + virtual bool isRequestHandlerTrivial() override final {return false;} +}; + +#endif diff --git a/lib/ESPAsyncWebServer/StringArray.h b/lib/ESPAsyncWebServer/StringArray.h new file mode 100644 index 000000000..58b81a3ca --- /dev/null +++ b/lib/ESPAsyncWebServer/StringArray.h @@ -0,0 +1,193 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef STRINGARRAY_H_ +#define STRINGARRAY_H_ + +#include "stddef.h" +#include "WString.h" + +template +class LinkedListNode { + T _value; + public: + LinkedListNode* next; + LinkedListNode(const T val): _value(val), next(nullptr) {} + ~LinkedListNode(){} + const T& value() const { return _value; }; + T& value(){ return _value; } +}; + +template class Item = LinkedListNode> +class LinkedList { + public: + typedef Item ItemType; + typedef std::function OnRemove; + typedef std::function Predicate; + private: + ItemType* _root; + OnRemove _onRemove; + + class Iterator { + ItemType* _node; + public: + Iterator(ItemType* current = nullptr) : _node(current) {} + Iterator(const Iterator& i) : _node(i._node) {} + Iterator& operator ++() { _node = _node->next; return *this; } + bool operator != (const Iterator& i) const { return _node != i._node; } + const T& operator * () const { return _node->value(); } + const T* operator -> () const { return &_node->value(); } + }; + + public: + typedef const Iterator ConstIterator; + ConstIterator begin() const { return ConstIterator(_root); } + ConstIterator end() const { return ConstIterator(nullptr); } + + LinkedList(OnRemove onRemove) : _root(nullptr), _onRemove(onRemove) {} + ~LinkedList(){} + void add(const T& t){ + auto it = new ItemType(t); + if(!_root){ + _root = it; + } else { + auto i = _root; + while(i->next) i = i->next; + i->next = it; + } + } + T& front() const { + return _root->value(); + } + + bool isEmpty() const { + return _root == nullptr; + } + size_t length() const { + size_t i = 0; + auto it = _root; + while(it){ + i++; + it = it->next; + } + return i; + } + size_t count_if(Predicate predicate) const { + size_t i = 0; + auto it = _root; + while(it){ + if (!predicate){ + i++; + } + else if (predicate(it->value())) { + i++; + } + it = it->next; + } + return i; + } + const T* nth(size_t N) const { + size_t i = 0; + auto it = _root; + while(it){ + if(i++ == N) + return &(it->value()); + it = it->next; + } + return nullptr; + } + bool remove(const T& t){ + auto it = _root; + auto pit = _root; + while(it){ + if(it->value() == t){ + if(it == _root){ + _root = _root->next; + } else { + pit->next = it->next; + } + + if (_onRemove) { + _onRemove(it->value()); + } + + delete it; + return true; + } + pit = it; + it = it->next; + } + return false; + } + bool remove_first(Predicate predicate){ + auto it = _root; + auto pit = _root; + while(it){ + if(predicate(it->value())){ + if(it == _root){ + _root = _root->next; + } else { + pit->next = it->next; + } + if (_onRemove) { + _onRemove(it->value()); + } + delete it; + return true; + } + pit = it; + it = it->next; + } + return false; + } + + void free(){ + while(_root != nullptr){ + auto it = _root; + _root = _root->next; + if (_onRemove) { + _onRemove(it->value()); + } + delete it; + } + _root = nullptr; + } +}; + + +class StringArray : public LinkedList { +public: + + StringArray() : LinkedList(nullptr) {} + + bool containsIgnoreCase(const String& str){ + for (const auto& s : *this) { + if (str.equalsIgnoreCase(s)) { + return true; + } + } + return false; + } +}; + + + + +#endif /* STRINGARRAY_H_ */ diff --git a/lib/ESPAsyncWebServer/WebAuthentication.cpp b/lib/ESPAsyncWebServer/WebAuthentication.cpp new file mode 100644 index 000000000..a88dde133 --- /dev/null +++ b/lib/ESPAsyncWebServer/WebAuthentication.cpp @@ -0,0 +1,235 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "WebAuthentication.h" +#include +#ifdef ESP32 +#include "mbedtls/md5.h" +#else +#include "md5.h" +#endif + + +// Basic Auth hash = base64("username:password") + +bool checkBasicAuthentication(const char * hash, const char * username, const char * password){ + if(username == NULL || password == NULL || hash == NULL) + return false; + + size_t toencodeLen = strlen(username)+strlen(password)+1; + size_t encodedLen = base64_encode_expected_len(toencodeLen); + if(strlen(hash) != encodedLen) + return false; + + char *toencode = new char[toencodeLen+1]; + if(toencode == NULL){ + return false; + } + char *encoded = new char[base64_encode_expected_len(toencodeLen)+1]; + if(encoded == NULL){ + delete[] toencode; + return false; + } + sprintf_P(toencode, PSTR("%s:%s"), username, password); + if(base64_encode_chars(toencode, toencodeLen, encoded) > 0 && memcmp(hash, encoded, encodedLen) == 0){ + delete[] toencode; + delete[] encoded; + return true; + } + delete[] toencode; + delete[] encoded; + return false; +} + +static bool getMD5(uint8_t * data, uint16_t len, char * output){//33 bytes or more +#ifdef ESP32 + mbedtls_md5_context _ctx; +#else + md5_context_t _ctx; +#endif + uint8_t i; + uint8_t * _buf = (uint8_t*)malloc(16); + if(_buf == NULL) + return false; + memset(_buf, 0x00, 16); +#ifdef ESP32 + mbedtls_md5_init(&_ctx); + mbedtls_md5_starts(&_ctx); + mbedtls_md5_update(&_ctx, data, len); + mbedtls_md5_finish(&_ctx, _buf); +#else + MD5Init(&_ctx); + MD5Update(&_ctx, data, len); + MD5Final(_buf, &_ctx); +#endif + for(i = 0; i < 16; i++) { + sprintf_P(output + (i * 2), PSTR("%02x"), _buf[i]); + } + free(_buf); + return true; +} + +static String genRandomMD5(){ +#ifdef ESP8266 + uint32_t r = RANDOM_REG32; +#else + uint32_t r = rand(); +#endif + char * out = (char*)malloc(33); + if(out == NULL || !getMD5((uint8_t*)(&r), 4, out)) + return emptyString; + String res = String(out); + free(out); + return res; +} + +static String stringMD5(const String& in){ + char * out = (char*)malloc(33); + if(out == NULL || !getMD5((uint8_t*)(in.c_str()), in.length(), out)) + return emptyString; + String res = String(out); + free(out); + return res; +} + +String generateDigestHash(const char * username, const char * password, const char * realm){ + if(username == NULL || password == NULL || realm == NULL){ + return emptyString; + } + char * out = (char*)malloc(33); + String res = String(username); + res += ':'; + res.concat(realm); + res += ':'; + String in = res; + in.concat(password); + if(out == NULL || !getMD5((uint8_t*)(in.c_str()), in.length(), out)) + return emptyString; + res.concat(out); + free(out); + return res; +} + +String requestDigestAuthentication(const char * realm){ + String header = F("realm=\""); + if(realm == NULL) + header.concat(F("asyncesp")); + else + header.concat(realm); + header.concat(F("\", qop=\"auth\", nonce=\"")); + header.concat(genRandomMD5()); + header.concat(F("\", opaque=\"")); + header.concat(genRandomMD5()); + header += '"'; + return header; +} + +bool checkDigestAuthentication(const char * header, const __FlashStringHelper *method, const char * username, const char * password, const char * realm, bool passwordIsHash, const char * nonce, const char * opaque, const char * uri){ + if(username == NULL || password == NULL || header == NULL || method == NULL){ + //os_printf("AUTH FAIL: missing requred fields\n"); + return false; + } + + String myHeader = String(header); + int nextBreak = myHeader.indexOf(','); + if(nextBreak < 0){ + //os_printf("AUTH FAIL: no variables\n"); + return false; + } + + String myUsername = String(); + String myRealm = String(); + String myNonce = String(); + String myUri = String(); + String myResponse = String(); + String myQop = String(); + String myNc = String(); + String myCnonce = String(); + + myHeader += F(", "); + do { + String avLine = myHeader.substring(0, nextBreak); + avLine.trim(); + myHeader = myHeader.substring(nextBreak+1); + nextBreak = myHeader.indexOf(','); + + int eqSign = avLine.indexOf('='); + if(eqSign < 0){ + //os_printf("AUTH FAIL: no = sign\n"); + return false; + } + String varName = avLine.substring(0, eqSign); + avLine = avLine.substring(eqSign + 1); + if(avLine.startsWith(String('"'))){ + avLine = avLine.substring(1, avLine.length() - 1); + } + + if(varName.equals(F("username"))){ + if(!avLine.equals(username)){ + //os_printf("AUTH FAIL: username\n"); + return false; + } + myUsername = avLine; + } else if(varName.equals(F("realm"))){ + if(realm != NULL && !avLine.equals(realm)){ + //os_printf("AUTH FAIL: realm\n"); + return false; + } + myRealm = avLine; + } else if(varName.equals(F("nonce"))){ + if(nonce != NULL && !avLine.equals(nonce)){ + //os_printf("AUTH FAIL: nonce\n"); + return false; + } + myNonce = avLine; + } else if(varName.equals(F("opaque"))){ + if(opaque != NULL && !avLine.equals(opaque)){ + //os_printf("AUTH FAIL: opaque\n"); + return false; + } + } else if(varName.equals(F("uri"))){ + if(uri != NULL && !avLine.equals(uri)){ + //os_printf("AUTH FAIL: uri\n"); + return false; + } + myUri = avLine; + } else if(varName.equals(F("response"))){ + myResponse = avLine; + } else if(varName.equals(F("qop"))){ + myQop = avLine; + } else if(varName.equals(F("nc"))){ + myNc = avLine; + } else if(varName.equals(F("cnonce"))){ + myCnonce = avLine; + } + } while(nextBreak > 0); + + String ha1 = (passwordIsHash) ? String(password) : stringMD5(myUsername + ':' + myRealm + ':' + String(password)); + String ha2 = String(method) + ':' + myUri; + String response = ha1 + ':' + myNonce + ':' + myNc + ':' + myCnonce + ':' + myQop + ':' + stringMD5(ha2); + + if(myResponse.equals(stringMD5(response))){ + //os_printf("AUTH SUCCESS\n"); + return true; + } + + //os_printf("AUTH FAIL: password\n"); + return false; +} diff --git a/lib/ESPAsyncWebServer/WebAuthentication.h b/lib/ESPAsyncWebServer/WebAuthentication.h new file mode 100644 index 000000000..a6f1966e3 --- /dev/null +++ b/lib/ESPAsyncWebServer/WebAuthentication.h @@ -0,0 +1,34 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef WEB_AUTHENTICATION_H_ +#define WEB_AUTHENTICATION_H_ + +#include "Arduino.h" + +bool checkBasicAuthentication(const char * header, const char * username, const char * password); +String requestDigestAuthentication(const char * realm); +bool checkDigestAuthentication(const char * header, const __FlashStringHelper *method, const char * username, const char * password, const char * realm, bool passwordIsHash, const char * nonce, const char * opaque, const char * uri); + +//for storing hashed versions on the device that can be authenticated against +String generateDigestHash(const char * username, const char * password, const char * realm); + +#endif diff --git a/lib/ESPAsyncWebServer/WebHandlerImpl.h b/lib/ESPAsyncWebServer/WebHandlerImpl.h new file mode 100644 index 000000000..d121fa7a3 --- /dev/null +++ b/lib/ESPAsyncWebServer/WebHandlerImpl.h @@ -0,0 +1,138 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef ASYNCWEBSERVERHANDLERIMPL_H_ +#define ASYNCWEBSERVERHANDLERIMPL_H_ + +#include +#ifdef ASYNCWEBSERVER_REGEX +#include +#endif + +#include "stddef.h" +#include + +class AsyncStaticWebHandler: public AsyncWebHandler { + using File = fs::File; + using FS = fs::FS; + private: + bool _getFile(AsyncWebServerRequest *request); + bool _fileExists(AsyncWebServerRequest *request, const String& path); + uint8_t _countBits(const uint8_t value) const; + protected: + FS _fs; + String _uri; + String _path; + String _default_file; + String _cache_control; + String _last_modified; + AwsTemplateProcessor _callback; + bool _isDir; + bool _gzipFirst; + uint8_t _gzipStats; + public: + AsyncStaticWebHandler(const char* uri, FS& fs, const char* path, const char* cache_control); + virtual bool canHandle(AsyncWebServerRequest *request) override final; + virtual void handleRequest(AsyncWebServerRequest *request) override final; + AsyncStaticWebHandler& setIsDir(bool isDir); + AsyncStaticWebHandler& setDefaultFile(const char* filename); + AsyncStaticWebHandler& setCacheControl(const char* cache_control); + AsyncStaticWebHandler& setLastModified(const char* last_modified); + AsyncStaticWebHandler& setLastModified(struct tm* last_modified); + #ifdef ESP8266 + AsyncStaticWebHandler& setLastModified(time_t last_modified); + AsyncStaticWebHandler& setLastModified(); //sets to current time. Make sure sntp is runing and time is updated + #endif + AsyncStaticWebHandler& setTemplateProcessor(AwsTemplateProcessor newCallback) {_callback = newCallback; return *this;} +}; + +class AsyncCallbackWebHandler: public AsyncWebHandler { + private: + protected: + String _uri; + WebRequestMethodComposite _method; + ArRequestHandlerFunction _onRequest; + ArUploadHandlerFunction _onUpload; + ArBodyHandlerFunction _onBody; + bool _isRegex; + public: + AsyncCallbackWebHandler() : _uri(), _method(HTTP_ANY), _onRequest(NULL), _onUpload(NULL), _onBody(NULL), _isRegex(false) {} + void setUri(const String& uri){ + _uri = uri; + _isRegex = uri.startsWith("^") && uri.endsWith("$"); + } + void setMethod(WebRequestMethodComposite method){ _method = method; } + void onRequest(ArRequestHandlerFunction fn){ _onRequest = fn; } + void onUpload(ArUploadHandlerFunction fn){ _onUpload = fn; } + void onBody(ArBodyHandlerFunction fn){ _onBody = fn; } + + virtual bool canHandle(AsyncWebServerRequest *request) override final{ + + if(!_onRequest) + return false; + + if(!(_method & request->method())) + return false; + +#ifdef ASYNCWEBSERVER_REGEX + if (_isRegex) { + std::regex pattern(_uri.c_str()); + std::smatch matches; + std::string s(request->url().c_str()); + if(std::regex_search(s, matches, pattern)) { + for (size_t i = 1; i < matches.size(); ++i) { // start from 1 + request->_addPathParam(matches[i].str().c_str()); + } + } else { + return false; + } + } else +#endif + if (_uri.length() && _uri.endsWith("*")) { + String uriTemplate = String(_uri); + uriTemplate = uriTemplate.substring(0, uriTemplate.length() - 1); + if (!request->url().startsWith(uriTemplate)) + return false; + } + else if(_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri+"/"))) + return false; + + request->addInterestingHeader("ANY"); + return true; + } + + virtual void handleRequest(AsyncWebServerRequest *request) override final { + if(_onRequest) + _onRequest(request); + else + request->send(500); + } + virtual void handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final) override final { + if(_onUpload) + _onUpload(request, filename, index, data, len, final); + } + virtual void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override final { + if(_onBody) + _onBody(request, data, len, index, total); + } + virtual bool isRequestHandlerTrivial() override final {return _onRequest ? false : true;} +}; + +#endif /* ASYNCWEBSERVERHANDLERIMPL_H_ */ diff --git a/lib/ESPAsyncWebServer/WebHandlers.cpp b/lib/ESPAsyncWebServer/WebHandlers.cpp new file mode 100644 index 000000000..952d65eb9 --- /dev/null +++ b/lib/ESPAsyncWebServer/WebHandlers.cpp @@ -0,0 +1,224 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "ESPAsyncWebServer.h" +#include "WebHandlerImpl.h" + +AsyncStaticWebHandler::AsyncStaticWebHandler(const char* uri, FS& fs, const char* path, const char* cache_control) + : _fs(fs), _uri(uri), _path(path), _default_file(F("index.htm")), _cache_control(cache_control), _last_modified(), _callback(nullptr) +{ + // Ensure leading '/' + if (_uri.length() == 0 || _uri[0] != '/') _uri = String('/') + _uri; + if (_path.length() == 0 || _path[0] != '/') _path = String('/') + _path; + + // If path ends with '/' we assume a hint that this is a directory to improve performance. + // However - if it does not end with '/' we, can't assume a file, path can still be a directory. + _isDir = _path[_path.length()-1] == '/'; + + // Remove the trailing '/' so we can handle default file + // Notice that root will be "" not "/" + if (_uri[_uri.length()-1] == '/') _uri = _uri.substring(0, _uri.length()-1); + if (_path[_path.length()-1] == '/') _path = _path.substring(0, _path.length()-1); + + // Reset stats + _gzipFirst = false; + _gzipStats = 0xF8; +} + +AsyncStaticWebHandler& AsyncStaticWebHandler::setIsDir(bool isDir){ + _isDir = isDir; + return *this; +} + +AsyncStaticWebHandler& AsyncStaticWebHandler::setDefaultFile(const char* filename){ + _default_file = String(filename); + return *this; +} + +AsyncStaticWebHandler& AsyncStaticWebHandler::setCacheControl(const char* cache_control){ + _cache_control = String(cache_control); + return *this; +} + +AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(const char* last_modified){ + _last_modified = String(last_modified); + return *this; +} + +AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(struct tm* last_modified){ + auto formatP = PSTR("%a, %d %b %Y %H:%M:%S %Z"); + char format[strlen_P(formatP) + 1]; + strcpy_P(format, formatP); + + char result[30]; + strftime(result, sizeof(result), format, last_modified); + return setLastModified((const char *)result); +} + +#ifdef ESP8266 +AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(time_t last_modified){ + return setLastModified((struct tm *)gmtime(&last_modified)); +} + +AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(){ + time_t last_modified; + if(time(&last_modified) == 0) //time is not yet set + return *this; + return setLastModified(last_modified); +} +#endif +bool AsyncStaticWebHandler::canHandle(AsyncWebServerRequest *request){ + if(request->method() != HTTP_GET + || !request->url().startsWith(_uri) + || !request->isExpectedRequestedConnType(RCT_DEFAULT, RCT_HTTP) + ){ + return false; + } + if (_getFile(request)) { + // We interested in "If-Modified-Since" header to check if file was modified + if (_last_modified.length()) + request->addInterestingHeader(F("If-Modified-Since")); + + if(_cache_control.length()) + request->addInterestingHeader(F("If-None-Match")); + + DEBUGF("[AsyncStaticWebHandler::canHandle] TRUE\n"); + return true; + } + + return false; +} + +bool AsyncStaticWebHandler::_getFile(AsyncWebServerRequest *request) +{ + // Remove the found uri + String path = request->url().substring(_uri.length()); + + // We can skip the file check and look for default if request is to the root of a directory or that request path ends with '/' + bool canSkipFileCheck = (_isDir && path.length() == 0) || (path.length() && path[path.length()-1] == '/'); + + path = _path + path; + + // Do we have a file or .gz file + if (!canSkipFileCheck && _fileExists(request, path)) + return true; + + // Can't handle if not default file + if (_default_file.length() == 0) + return false; + + // Try to add default file, ensure there is a trailing '/' ot the path. + if (path.length() == 0 || path[path.length()-1] != '/') + path += String('/'); + path += _default_file; + + return _fileExists(request, path); +} + +#ifdef ESP32 +#define FILE_IS_REAL(f) (f == true && !f.isDirectory()) +#else +#define FILE_IS_REAL(f) (f == true) +#endif + +bool AsyncStaticWebHandler::_fileExists(AsyncWebServerRequest *request, const String& path) +{ + bool fileFound = false; + bool gzipFound = false; + + String gzip = path + F(".gz"); + + if (_gzipFirst) { + request->_tempFile = _fs.open(gzip, fs::FileOpenMode::read); + gzipFound = FILE_IS_REAL(request->_tempFile); + if (!gzipFound){ + request->_tempFile = _fs.open(path, fs::FileOpenMode::read); + fileFound = FILE_IS_REAL(request->_tempFile); + } + } else { + request->_tempFile = _fs.open(path, fs::FileOpenMode::read); + fileFound = FILE_IS_REAL(request->_tempFile); + if (!fileFound){ + request->_tempFile = _fs.open(gzip, fs::FileOpenMode::read); + gzipFound = FILE_IS_REAL(request->_tempFile); + } + } + + bool found = fileFound || gzipFound; + + if (found) { + // Extract the file name from the path and keep it in _tempObject + size_t pathLen = path.length(); + char * _tempPath = (char*)malloc(pathLen+1); + snprintf_P(_tempPath, pathLen+1, PSTR("%s"), path.c_str()); + request->_tempObject = (void*)_tempPath; + + // Calculate gzip statistic + _gzipStats = (_gzipStats << 1) + (gzipFound ? 1 : 0); + if (_gzipStats == 0x00) _gzipFirst = false; // All files are not gzip + else if (_gzipStats == 0xFF) _gzipFirst = true; // All files are gzip + else _gzipFirst = _countBits(_gzipStats) > 4; // IF we have more gzip files - try gzip first + } + + return found; +} + +uint8_t AsyncStaticWebHandler::_countBits(const uint8_t value) const +{ + uint8_t w = value; + uint8_t n; + for (n=0; w!=0; n++) w&=w-1; + return n; +} + +void AsyncStaticWebHandler::handleRequest(AsyncWebServerRequest *request) +{ + // Get the filename from request->_tempObject and free it + String filename = String((char*)request->_tempObject); + free(request->_tempObject); + request->_tempObject = NULL; + if((_username.length() && _password.length()) && !request->authenticate(_username.c_str(), _password.c_str())) + return request->requestAuthentication(); + + if (request->_tempFile == true) { + String etag = String(request->_tempFile.size()); + if (_last_modified.length() && _last_modified == request->header(F("If-Modified-Since"))) { + request->_tempFile.close(); + request->send(304); // Not modified + } else if (_cache_control.length() && request->hasHeader(F("If-None-Match")) && request->header(F("If-None-Match")).equals(etag)) { + request->_tempFile.close(); + AsyncWebServerResponse * response = new AsyncBasicResponse(304); // Not modified + response->addHeader(F("Cache-Control"), _cache_control); + response->addHeader(F("ETag"), etag); + request->send(response); + } else { + AsyncWebServerResponse * response = new AsyncFileResponse(request->_tempFile, filename, String(), false, _callback); + if (_last_modified.length()) + response->addHeader(F("Last-Modified"), _last_modified); + if (_cache_control.length()){ + response->addHeader(F("Cache-Control"), _cache_control); + response->addHeader(F("ETag"), etag); + } + request->send(response); + } + } else { + request->send(404); + } +} diff --git a/lib/ESPAsyncWebServer/WebRequest.cpp b/lib/ESPAsyncWebServer/WebRequest.cpp new file mode 100644 index 000000000..9acec396a --- /dev/null +++ b/lib/ESPAsyncWebServer/WebRequest.cpp @@ -0,0 +1,930 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "ESPAsyncWebServer.h" +#include "WebResponseImpl.h" +#include "WebAuthentication.h" + +#ifndef ESP8266 +#define os_strlen strlen +#endif + +#define __is_param_char(c) ((c) && ((c) != '{') && ((c) != '[') && ((c) != '&') && ((c) != '=')) + +enum { PARSE_REQ_START, PARSE_REQ_HEADERS, PARSE_REQ_BODY, PARSE_REQ_END, PARSE_REQ_FAIL }; + +AsyncWebServerRequest::AsyncWebServerRequest(AsyncWebServer* s, AsyncClient* c) + : _client(c) + , _server(s) + , _handler(NULL) + , _response(NULL) + , _temp() + , _parseState(0) + , _version(0) + , _method(HTTP_ANY) + , _url() + , _host() + , _contentType() + , _boundary() + , _authorization() + , _reqconntype(RCT_HTTP) + , _isDigest(false) + , _isMultipart(false) + , _isPlainPost(false) + , _expectingContinue(false) + , _contentLength(0) + , _parsedLength(0) + , _headers(LinkedList([](AsyncWebHeader *h){ delete h; })) + , _params(LinkedList([](AsyncWebParameter *p){ delete p; })) + , _pathParams(LinkedList([](String *p){ delete p; })) + , _multiParseState(0) + , _boundaryPosition(0) + , _itemStartIndex(0) + , _itemSize(0) + , _itemName() + , _itemFilename() + , _itemType() + , _itemValue() + , _itemBuffer(0) + , _itemBufferIndex(0) + , _itemIsFile(false) + , _tempObject(NULL) +{ + c->onError([](void *r, AsyncClient* c, int8_t error){ (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onError(error); }, this); + c->onAck([](void *r, AsyncClient* c, size_t len, uint32_t time){ (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onAck(len, time); }, this); + c->onDisconnect([](void *r, AsyncClient* c){ AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onDisconnect(); delete c; }, this); + c->onTimeout([](void *r, AsyncClient* c, uint32_t time){ (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onTimeout(time); }, this); + c->onData([](void *r, AsyncClient* c, void *buf, size_t len){ (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onData(buf, len); }, this); + c->onPoll([](void *r, AsyncClient* c){ (void)c; AsyncWebServerRequest *req = ( AsyncWebServerRequest*)r; req->_onPoll(); }, this); +} + +AsyncWebServerRequest::~AsyncWebServerRequest(){ + _headers.free(); + + _params.free(); + _pathParams.free(); + + _interestingHeaders.free(); + + if(_response != NULL){ + delete _response; + } + + if(_tempObject != NULL){ + free(_tempObject); + } + + if(_tempFile){ + _tempFile.close(); + } +} + +void AsyncWebServerRequest::_onData(void *buf, size_t len){ + size_t i = 0; + while (true) { + + if(_parseState < PARSE_REQ_BODY){ + // Find new line in buf + char *str = (char*)buf; + for (i = 0; i < len; i++) { + if (str[i] == '\n') { + break; + } + } + if (i == len) { // No new line, just add the buffer in _temp + char ch = str[len-1]; + str[len-1] = 0; + _temp.reserve(_temp.length()+len); + _temp.concat(str); + _temp.concat(ch); + } else { // Found new line - extract it and parse + str[i] = 0; // Terminate the string at the end of the line. + _temp.concat(str); + _temp.trim(); + _parseLine(); + if (++i < len) { + // Still have more buffer to process + buf = str+i; + len-= i; + continue; + } + } + } else if(_parseState == PARSE_REQ_BODY){ + // A handler should be already attached at this point in _parseLine function. + // If handler does nothing (_onRequest is NULL), we don't need to really parse the body. + const bool needParse = _handler && !_handler->isRequestHandlerTrivial(); + if(_isMultipart){ + if(needParse){ + size_t i; + for(i=0; i end) equal = end; + String name = params.substring(start, equal); + String value = equal + 1 < end ? params.substring(equal + 1, end) : String(); + _addParam(new AsyncWebParameter(urlDecode(name), urlDecode(value))); + start = end + 1; + } +} + +bool AsyncWebServerRequest::_parseReqHead(){ + // Split the head into method, url and version + int index = _temp.indexOf(' '); + String m = _temp.substring(0, index); + index = _temp.indexOf(' ', index+1); + String u = _temp.substring(m.length()+1, index); + _temp = _temp.substring(index+1); + + if(m == F("GET")){ + _method = HTTP_GET; + } else if(m == F("POST")){ + _method = HTTP_POST; + } else if(m == F("DELETE")){ + _method = HTTP_DELETE; + } else if(m == F("PUT")){ + _method = HTTP_PUT; + } else if(m == F("PATCH")){ + _method = HTTP_PATCH; + } else if(m == F("HEAD")){ + _method = HTTP_HEAD; + } else if(m == F("OPTIONS")){ + _method = HTTP_OPTIONS; + } + + String g; + index = u.indexOf('?'); + if(index > 0){ + g = u.substring(index +1); + u = u.substring(0, index); + } + _url = urlDecode(u); + _addGetParams(g); + + if(!_temp.startsWith(F("HTTP/1.0"))) + _version = 1; + + _temp = String(); + return true; +} + +bool strContains(const String &src, const String &find, bool mindcase = true) { + int pos=0, i=0; + const int slen = src.length(); + const int flen = find.length(); + + if (slen < flen) return false; + while (pos <= (slen - flen)) { + for (i=0; i < flen; i++) { + if (mindcase) { + if (src[pos+i] != find[i]) i = flen + 1; // no match + } + else if (tolower(src[pos+i]) != tolower(find[i])) { + i = flen + 1; // no match + } + } + if (i == flen) return true; + pos++; + } + return false; +} + +bool AsyncWebServerRequest::_parseReqHeader(){ + int index = _temp.indexOf(':'); + if(index){ + String name = _temp.substring(0, index); + String value = _temp.substring(index + 2); + if(name.equalsIgnoreCase("Host")){ + _host = value; + } else if(name.equalsIgnoreCase(F("Content-Type"))){ + _contentType = value.substring(0, value.indexOf(';')); + if (value.startsWith(F("multipart/"))){ + _boundary = value.substring(value.indexOf('=')+1); + _boundary.replace(String('"'), String()); + _isMultipart = true; + } + } else if(name.equalsIgnoreCase(F("Content-Length"))){ + _contentLength = atoi(value.c_str()); + } else if(name.equalsIgnoreCase(F("Expect")) && value == F("100-continue")){ + _expectingContinue = true; + } else if(name.equalsIgnoreCase(F("Authorization"))){ + if(value.length() > 5 && value.substring(0,5).equalsIgnoreCase(F("Basic"))){ + _authorization = value.substring(6); + } else if(value.length() > 6 && value.substring(0,6).equalsIgnoreCase(F("Digest"))){ + _isDigest = true; + _authorization = value.substring(7); + } + } else { + if(name.equalsIgnoreCase(F("Upgrade")) && value.equalsIgnoreCase(F("websocket"))){ + // WebSocket request can be uniquely identified by header: [Upgrade: websocket] + _reqconntype = RCT_WS; + } else { + if(name.equalsIgnoreCase(F("Accept")) && strContains(value, F("text/event-stream"), false)){ + // WebEvent request can be uniquely identified by header: [Accept: text/event-stream] + _reqconntype = RCT_EVENT; + } + } + } + _headers.add(new AsyncWebHeader(name, value)); + } + _temp = String(); + return true; +} + +void AsyncWebServerRequest::_parsePlainPostChar(uint8_t data){ + if(data && (char)data != '&') + _temp += (char)data; + if(!data || (char)data == '&' || _parsedLength == _contentLength){ + String name = F("body"); + String value = _temp; + if(!_temp.startsWith(String('{')) && !_temp.startsWith(String('[')) && _temp.indexOf('=') > 0){ + name = _temp.substring(0, _temp.indexOf('=')); + value = _temp.substring(_temp.indexOf('=') + 1); + } + _addParam(new AsyncWebParameter(urlDecode(name), urlDecode(value), true)); + _temp = String(); + } +} + +void AsyncWebServerRequest::_handleUploadByte(uint8_t data, bool last){ + _itemBuffer[_itemBufferIndex++] = data; + + if(last || _itemBufferIndex == 1460){ + //check if authenticated before calling the upload + if(_handler) + _handler->handleUpload(this, _itemFilename, _itemSize - _itemBufferIndex, _itemBuffer, _itemBufferIndex, false); + _itemBufferIndex = 0; + } +} + +enum { + EXPECT_BOUNDARY, + PARSE_HEADERS, + WAIT_FOR_RETURN1, + EXPECT_FEED1, + EXPECT_DASH1, + EXPECT_DASH2, + BOUNDARY_OR_DATA, + DASH3_OR_RETURN2, + EXPECT_FEED2, + PARSING_FINISHED, + PARSE_ERROR +}; + +void AsyncWebServerRequest::_parseMultipartPostByte(uint8_t data, bool last){ +#define itemWriteByte(b) do { _itemSize++; if(_itemIsFile) _handleUploadByte(b, last); else _itemValue+=(char)(b); } while(0) + + if(!_parsedLength){ + _multiParseState = EXPECT_BOUNDARY; + _temp = String(); + _itemName = String(); + _itemFilename = String(); + _itemType = String(); + } + + if(_multiParseState == WAIT_FOR_RETURN1){ + if(data != '\r'){ + itemWriteByte(data); + } else { + _multiParseState = EXPECT_FEED1; + } + } else if(_multiParseState == EXPECT_BOUNDARY){ + if(_parsedLength < 2 && data != '-'){ + _multiParseState = PARSE_ERROR; + return; + } else if(_parsedLength - 2 < _boundary.length() && _boundary.c_str()[_parsedLength - 2] != data){ + _multiParseState = PARSE_ERROR; + return; + } else if(_parsedLength - 2 == _boundary.length() && data != '\r'){ + _multiParseState = PARSE_ERROR; + return; + } else if(_parsedLength - 3 == _boundary.length()){ + if(data != '\n'){ + _multiParseState = PARSE_ERROR; + return; + } + _multiParseState = PARSE_HEADERS; + _itemIsFile = false; + } + } else if(_multiParseState == PARSE_HEADERS){ + if((char)data != '\r' && (char)data != '\n') + _temp += (char)data; + if((char)data == '\n'){ + if(_temp.length()){ + if(_temp.length() > 12 && _temp.substring(0, 12).equalsIgnoreCase(F("Content-Type"))){ + _itemType = _temp.substring(14); + _itemIsFile = true; + } else if(_temp.length() > 19 && _temp.substring(0, 19).equalsIgnoreCase(F("Content-Disposition"))){ + _temp = _temp.substring(_temp.indexOf(';') + 2); + while(_temp.indexOf(';') > 0){ + String name = _temp.substring(0, _temp.indexOf('=')); + String nameVal = _temp.substring(_temp.indexOf('=') + 2, _temp.indexOf(';') - 1); + if(name == F("name")){ + _itemName = nameVal; + } else if(name == F("filename")){ + _itemFilename = nameVal; + _itemIsFile = true; + } + _temp = _temp.substring(_temp.indexOf(';') + 2); + } + String name = _temp.substring(0, _temp.indexOf('=')); + String nameVal = _temp.substring(_temp.indexOf('=') + 2, _temp.length() - 1); + if(name == F("name")){ + _itemName = nameVal; + } else if(name == F("filename")){ + _itemFilename = nameVal; + _itemIsFile = true; + } + } + _temp = String(); + } else { + _multiParseState = WAIT_FOR_RETURN1; + //value starts from here + _itemSize = 0; + _itemStartIndex = _parsedLength; + _itemValue = String(); + if(_itemIsFile){ + if(_itemBuffer) + free(_itemBuffer); + _itemBuffer = (uint8_t*)malloc(1460); + if(_itemBuffer == NULL){ + _multiParseState = PARSE_ERROR; + return; + } + _itemBufferIndex = 0; + } + } + } + } else if(_multiParseState == EXPECT_FEED1){ + if(data != '\n'){ + _multiParseState = WAIT_FOR_RETURN1; + itemWriteByte('\r'); _parseMultipartPostByte(data, last); + } else { + _multiParseState = EXPECT_DASH1; + } + } else if(_multiParseState == EXPECT_DASH1){ + if(data != '-'){ + _multiParseState = WAIT_FOR_RETURN1; + itemWriteByte('\r'); itemWriteByte('\n'); _parseMultipartPostByte(data, last); + } else { + _multiParseState = EXPECT_DASH2; + } + } else if(_multiParseState == EXPECT_DASH2){ + if(data != '-'){ + _multiParseState = WAIT_FOR_RETURN1; + itemWriteByte('\r'); itemWriteByte('\n'); itemWriteByte('-'); _parseMultipartPostByte(data, last); + } else { + _multiParseState = BOUNDARY_OR_DATA; + _boundaryPosition = 0; + } + } else if(_multiParseState == BOUNDARY_OR_DATA){ + if(_boundaryPosition < _boundary.length() && _boundary.c_str()[_boundaryPosition] != data){ + _multiParseState = WAIT_FOR_RETURN1; + itemWriteByte('\r'); itemWriteByte('\n'); itemWriteByte('-'); itemWriteByte('-'); + uint8_t i; + for(i=0; i<_boundaryPosition; i++) + itemWriteByte(_boundary.c_str()[i]); + _parseMultipartPostByte(data, last); + } else if(_boundaryPosition == _boundary.length() - 1){ + _multiParseState = DASH3_OR_RETURN2; + if(!_itemIsFile){ + _addParam(new AsyncWebParameter(_itemName, _itemValue, true)); + } else { + if(_itemSize){ + //check if authenticated before calling the upload + if(_handler) _handler->handleUpload(this, _itemFilename, _itemSize - _itemBufferIndex, _itemBuffer, _itemBufferIndex, true); + _itemBufferIndex = 0; + _addParam(new AsyncWebParameter(_itemName, _itemFilename, true, true, _itemSize)); + } + free(_itemBuffer); + _itemBuffer = NULL; + } + + } else { + _boundaryPosition++; + } + } else if(_multiParseState == DASH3_OR_RETURN2){ + if(data == '-' && (_contentLength - _parsedLength - 4) != 0){ + //os_printf("ERROR: The parser got to the end of the POST but is expecting %u bytes more!\nDrop an issue so we can have more info on the matter!\n", _contentLength - _parsedLength - 4); + _contentLength = _parsedLength + 4;//lets close the request gracefully + } + if(data == '\r'){ + _multiParseState = EXPECT_FEED2; + } else if(data == '-' && _contentLength == (_parsedLength + 4)){ + _multiParseState = PARSING_FINISHED; + } else { + _multiParseState = WAIT_FOR_RETURN1; + itemWriteByte('\r'); itemWriteByte('\n'); itemWriteByte('-'); itemWriteByte('-'); + uint8_t i; for(i=0; i<_boundary.length(); i++) itemWriteByte(_boundary.c_str()[i]); + _parseMultipartPostByte(data, last); + } + } else if(_multiParseState == EXPECT_FEED2){ + if(data == '\n'){ + _multiParseState = PARSE_HEADERS; + _itemIsFile = false; + } else { + _multiParseState = WAIT_FOR_RETURN1; + itemWriteByte('\r'); itemWriteByte('\n'); itemWriteByte('-'); itemWriteByte('-'); + uint8_t i; for(i=0; i<_boundary.length(); i++) itemWriteByte(_boundary.c_str()[i]); + itemWriteByte('\r'); _parseMultipartPostByte(data, last); + } + } +} + +void AsyncWebServerRequest::_parseLine(){ + if(_parseState == PARSE_REQ_START){ + if(!_temp.length()){ + _parseState = PARSE_REQ_FAIL; + _client->close(); + } else { + _parseReqHead(); + _parseState = PARSE_REQ_HEADERS; + } + return; + } + + if(_parseState == PARSE_REQ_HEADERS){ + if(!_temp.length()){ + //end of headers + _server->_rewriteRequest(this); + _server->_attachHandler(this); + _removeNotInterestingHeaders(); + if(_expectingContinue){ + String response = F("HTTP/1.1 100 Continue\r\n\r\n"); + _client->write(response.c_str(), response.length()); + } + //check handler for authentication + if(_contentLength){ + _parseState = PARSE_REQ_BODY; + } else { + _parseState = PARSE_REQ_END; + if(_handler) _handler->handleRequest(this); + else send(501); + } + } else _parseReqHeader(); + } +} + +size_t AsyncWebServerRequest::headers() const{ + return _headers.length(); +} + +bool AsyncWebServerRequest::hasHeader(const String& name) const { + for(const auto& h: _headers){ + if(h->name().equalsIgnoreCase(name)){ + return true; + } + } + return false; +} + +bool AsyncWebServerRequest::hasHeader(const __FlashStringHelper * data) const { + return hasHeader(String(data)); +} + +AsyncWebHeader* AsyncWebServerRequest::getHeader(const String& name) const { + for(const auto& h: _headers){ + if(h->name().equalsIgnoreCase(name)){ + return h; + } + } + return nullptr; +} + +AsyncWebHeader* AsyncWebServerRequest::getHeader(const __FlashStringHelper * data) const { + return getHeader(String(data)); +} + +AsyncWebHeader* AsyncWebServerRequest::getHeader(size_t num) const { + auto header = _headers.nth(num); + return header ? *header : nullptr; +} + +size_t AsyncWebServerRequest::params() const { + return _params.length(); +} + +bool AsyncWebServerRequest::hasParam(const String& name, bool post, bool file) const { + for(const auto& p: _params){ + if(p->name() == name && p->isPost() == post && p->isFile() == file){ + return true; + } + } + return false; +} + +bool AsyncWebServerRequest::hasParam(const __FlashStringHelper * data, bool post, bool file) const { + return hasParam(String(data).c_str(), post, file); +} + +AsyncWebParameter* AsyncWebServerRequest::getParam(const String& name, bool post, bool file) const { + for(const auto& p: _params){ + if(p->name() == name && p->isPost() == post && p->isFile() == file){ + return p; + } + } + return nullptr; +} + +AsyncWebParameter* AsyncWebServerRequest::getParam(const __FlashStringHelper * data, bool post, bool file) const { + return getParam(String(data).c_str(), post, file); +} + +AsyncWebParameter* AsyncWebServerRequest::getParam(size_t num) const { + auto param = _params.nth(num); + return param ? *param : nullptr; +} + +void AsyncWebServerRequest::addInterestingHeader(const String& name){ + if(!_interestingHeaders.containsIgnoreCase(name)) + _interestingHeaders.add(name); +} + +void AsyncWebServerRequest::send(AsyncWebServerResponse *response){ + _response = response; + if(_response == NULL){ + _client->close(true); + _onDisconnect(); + return; + } + if(!_response->_sourceValid()){ + delete response; + _response = NULL; + send(500); + } + else { + _client->setRxTimeout(0); + _response->_respond(this); + } +} + +AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(int code, const String& contentType, const String& content){ + return new AsyncBasicResponse(code, contentType, content); +} + +AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(FS &fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback){ + if(fs.exists(path) || (!download && fs.exists(path+F(".gz")))) + return new AsyncFileResponse(fs, path, contentType, download, callback); + return NULL; +} + +AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(File content, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback){ + if(content == true) + return new AsyncFileResponse(content, path, contentType, download, callback); + return NULL; +} + +AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback){ + return new AsyncStreamResponse(stream, contentType, len, callback); +} + +AsyncWebServerResponse * AsyncWebServerRequest::beginResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback){ + return new AsyncCallbackResponse(contentType, len, callback, templateCallback); +} + +AsyncWebServerResponse * AsyncWebServerRequest::beginChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback){ + if(_version) + return new AsyncChunkedResponse(contentType, callback, templateCallback); + return new AsyncCallbackResponse(contentType, 0, callback, templateCallback); +} + +AsyncResponseStream * AsyncWebServerRequest::beginResponseStream(const String& contentType, size_t bufferSize){ + return new AsyncResponseStream(contentType, bufferSize); +} + +AsyncWebServerResponse * AsyncWebServerRequest::beginResponse_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback){ + return new AsyncProgmemResponse(code, contentType, content, len, callback); +} + +AsyncWebServerResponse * AsyncWebServerRequest::beginResponse_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback){ + return beginResponse_P(code, contentType, (const uint8_t *)content, strlen_P(content), callback); +} + +void AsyncWebServerRequest::send(int code, const String& contentType, const String& content){ + send(beginResponse(code, contentType, content)); +} + +void AsyncWebServerRequest::send(FS &fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback){ + if(fs.exists(path) || (!download && fs.exists(path+F(".gz")))){ + send(beginResponse(fs, path, contentType, download, callback)); + } else send(404); +} + +void AsyncWebServerRequest::send(File content, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback){ + if(content == true){ + send(beginResponse(content, path, contentType, download, callback)); + } else send(404); +} + +void AsyncWebServerRequest::send(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback){ + send(beginResponse(stream, contentType, len, callback)); +} + +void AsyncWebServerRequest::send(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback){ + send(beginResponse(contentType, len, callback, templateCallback)); +} + +void AsyncWebServerRequest::sendChunked(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback){ + send(beginChunkedResponse(contentType, callback, templateCallback)); +} + +void AsyncWebServerRequest::send_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback){ + send(beginResponse_P(code, contentType, content, len, callback)); +} + +void AsyncWebServerRequest::send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback){ + send(beginResponse_P(code, contentType, content, callback)); +} + +void AsyncWebServerRequest::redirect(const String& url){ + AsyncWebServerResponse * response = beginResponse(302); + response->addHeader(F("Location"), url); + send(response); +} + +bool AsyncWebServerRequest::authenticate(const char * username, const char * password, const char * realm, bool passwordIsHash){ + if(_authorization.length()){ + if(_isDigest) + return checkDigestAuthentication(_authorization.c_str(), methodToString(), username, password, realm, passwordIsHash, NULL, NULL, NULL); + else if(!passwordIsHash) + return checkBasicAuthentication(_authorization.c_str(), username, password); + else + return _authorization.equals(password); + } + return false; +} + +bool AsyncWebServerRequest::authenticate(const char * hash){ + if(!_authorization.length() || hash == NULL) + return false; + + if(_isDigest){ + String hStr = String(hash); + int separator = hStr.indexOf(':'); + if(separator <= 0) + return false; + String username = hStr.substring(0, separator); + hStr = hStr.substring(separator + 1); + separator = hStr.indexOf(':'); + if(separator <= 0) + return false; + String realm = hStr.substring(0, separator); + hStr = hStr.substring(separator + 1); + return checkDigestAuthentication(_authorization.c_str(), methodToString(), username.c_str(), hStr.c_str(), realm.c_str(), true, NULL, NULL, NULL); + } + + return (_authorization.equals(hash)); +} + +void AsyncWebServerRequest::requestAuthentication(const char * realm, bool isDigest){ + AsyncWebServerResponse * r = beginResponse(401); + if(!isDigest && realm == NULL){ + r->addHeader(F("WWW-Authenticate"), F("Basic realm=\"Login Required\"")); + } else if(!isDigest){ + String header = F("Basic realm=\""); + header.concat(realm); + header += '"'; + r->addHeader(F("WWW-Authenticate"), header); + } else { + String header = F("Digest "); + header.concat(requestDigestAuthentication(realm)); + r->addHeader(F("WWW-Authenticate"), header); + } + send(r); +} + +bool AsyncWebServerRequest::hasArg(const char* name) const { + for(const auto& arg: _params){ + if(arg->name() == name){ + return true; + } + } + return false; +} + +bool AsyncWebServerRequest::hasArg(const __FlashStringHelper * data) const { + return hasArg(String(data).c_str()); +} + + +const String& AsyncWebServerRequest::arg(const String& name) const { + for(const auto& arg: _params){ + if(arg->name() == name){ + return arg->value(); + } + } + return emptyString; +} + +const String& AsyncWebServerRequest::arg(const __FlashStringHelper * data) const { + return arg(String(data).c_str()); +} + +const String& AsyncWebServerRequest::arg(size_t i) const { + return getParam(i)->value(); +} + +const String& AsyncWebServerRequest::argName(size_t i) const { + return getParam(i)->name(); +} + +const String& AsyncWebServerRequest::pathArg(size_t i) const { + auto param = _pathParams.nth(i); + return param ? **param : emptyString; +} + +const String& AsyncWebServerRequest::header(const char* name) const { + AsyncWebHeader* h = getHeader(String(name)); + return h ? h->value() : emptyString; +} + +const String& AsyncWebServerRequest::header(const __FlashStringHelper * data) const { + return header(String(data).c_str()); +}; + + +const String& AsyncWebServerRequest::header(size_t i) const { + AsyncWebHeader* h = getHeader(i); + return h ? h->value() : emptyString; +} + +const String& AsyncWebServerRequest::headerName(size_t i) const { + AsyncWebHeader* h = getHeader(i); + return h ? h->name() : emptyString; +} + +String AsyncWebServerRequest::urlDecode(const String& text) const { + char temp[] = "0x00"; + unsigned int len = text.length(); + unsigned int i = 0; + String decoded = String(); + decoded.reserve(len); // Allocate the string internal buffer - never longer from source text + while (i < len){ + char decodedChar; + char encodedChar = text.charAt(i++); + if ((encodedChar == '%') && (i + 1 < len)){ + temp[2] = text.charAt(i++); + temp[3] = text.charAt(i++); + decodedChar = strtol(temp, NULL, 16); + } else if (encodedChar == '+') { + decodedChar = ' '; + } else { + decodedChar = encodedChar; // normal ascii char + } + decoded.concat(decodedChar); + } + return decoded; +} + + +const __FlashStringHelper *AsyncWebServerRequest::methodToString() const { + if(_method == HTTP_ANY) return F("ANY"); + else if(_method & HTTP_GET) return F("GET"); + else if(_method & HTTP_POST) return F("POST"); + else if(_method & HTTP_DELETE) return F("DELETE"); + else if(_method & HTTP_PUT) return F("PUT"); + else if(_method & HTTP_PATCH) return F("PATCH"); + else if(_method & HTTP_HEAD) return F("HEAD"); + else if(_method & HTTP_OPTIONS) return F("OPTIONS"); + return F("UNKNOWN"); +} + +const __FlashStringHelper *AsyncWebServerRequest::requestedConnTypeToString() const { + switch (_reqconntype) { + case RCT_NOT_USED: return F("RCT_NOT_USED"); + case RCT_DEFAULT: return F("RCT_DEFAULT"); + case RCT_HTTP: return F("RCT_HTTP"); + case RCT_WS: return F("RCT_WS"); + case RCT_EVENT: return F("RCT_EVENT"); + default: return F("ERROR"); + } +} + +bool AsyncWebServerRequest::isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2, RequestedConnectionType erct3) { + bool res = false; + if ((erct1 != RCT_NOT_USED) && (erct1 == _reqconntype)) res = true; + if ((erct2 != RCT_NOT_USED) && (erct2 == _reqconntype)) res = true; + if ((erct3 != RCT_NOT_USED) && (erct3 == _reqconntype)) res = true; + return res; +} diff --git a/lib/ESPAsyncWebServer/WebResponseImpl.h b/lib/ESPAsyncWebServer/WebResponseImpl.h new file mode 100644 index 000000000..9a64e3a52 --- /dev/null +++ b/lib/ESPAsyncWebServer/WebResponseImpl.h @@ -0,0 +1,136 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#ifndef ASYNCWEBSERVERRESPONSEIMPL_H_ +#define ASYNCWEBSERVERRESPONSEIMPL_H_ + +#ifdef Arduino_h +// arduino is not compatible with std::vector +#undef min +#undef max +#endif +#include +// It is possible to restore these defines, but one can use _min and _max instead. Or std::min, std::max. + +class AsyncBasicResponse: public AsyncWebServerResponse { + private: + String _content; + public: + AsyncBasicResponse(int code, const String& contentType=String(), const String& content=String()); + void _respond(AsyncWebServerRequest *request); + size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time); + bool _sourceValid() const { return true; } +}; + +class AsyncAbstractResponse: public AsyncWebServerResponse { + private: + String _head; + // Data is inserted into cache at begin(). + // This is inefficient with vector, but if we use some other container, + // we won't be able to access it as contiguous array of bytes when reading from it, + // so by gaining performance in one place, we'll lose it in another. + std::vector _cache; + size_t _readDataFromCacheOrContent(uint8_t* data, const size_t len); + size_t _fillBufferAndProcessTemplates(uint8_t* buf, size_t maxLen); + protected: + AwsTemplateProcessor _callback; + public: + AsyncAbstractResponse(AwsTemplateProcessor callback=nullptr); + void _respond(AsyncWebServerRequest *request); + size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time); + bool _sourceValid() const { return false; } + virtual size_t _fillBuffer(uint8_t *buf __attribute__((unused)), size_t maxLen __attribute__((unused))) { return 0; } +}; + +#ifndef TEMPLATE_PLACEHOLDER +#define TEMPLATE_PLACEHOLDER '%' +#endif + +#define TEMPLATE_PARAM_NAME_LENGTH 32 +class AsyncFileResponse: public AsyncAbstractResponse { + using File = fs::File; + using FS = fs::FS; + private: + File _content; + String _path; + void _setContentType(const String& path); + public: + AsyncFileResponse(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr); + AsyncFileResponse(File content, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr); + ~AsyncFileResponse(); + bool _sourceValid() const { return !!(_content); } + virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override; +}; + +class AsyncStreamResponse: public AsyncAbstractResponse { + private: + Stream *_content; + public: + AsyncStreamResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback=nullptr); + bool _sourceValid() const { return !!(_content); } + virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override; +}; + +class AsyncCallbackResponse: public AsyncAbstractResponse { + private: + AwsResponseFiller _content; + size_t _filledLength; + public: + AsyncCallbackResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr); + bool _sourceValid() const { return !!(_content); } + virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override; +}; + +class AsyncChunkedResponse: public AsyncAbstractResponse { + private: + AwsResponseFiller _content; + size_t _filledLength; + public: + AsyncChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr); + bool _sourceValid() const { return !!(_content); } + virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override; +}; + +class AsyncProgmemResponse: public AsyncAbstractResponse { + private: + const uint8_t * _content; + size_t _readLength; + public: + AsyncProgmemResponse(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr); + bool _sourceValid() const { return true; } + virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override; +}; + +class cbuf; + +class AsyncResponseStream: public AsyncAbstractResponse, public Print { + private: + cbuf *_content; + public: + AsyncResponseStream(const String& contentType, size_t bufferSize); + ~AsyncResponseStream(); + bool _sourceValid() const { return (_state < RESPONSE_END); } + virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override; + size_t write(const uint8_t *data, size_t len); + size_t write(uint8_t data); + using Print::write; +}; + +#endif /* ASYNCWEBSERVERRESPONSEIMPL_H_ */ diff --git a/lib/ESPAsyncWebServer/WebResponses.cpp b/lib/ESPAsyncWebServer/WebResponses.cpp new file mode 100644 index 000000000..adeab988b --- /dev/null +++ b/lib/ESPAsyncWebServer/WebResponses.cpp @@ -0,0 +1,708 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "ESPAsyncWebServer.h" +#include "WebResponseImpl.h" +#include "cbuf.h" + +// Since ESP8266 does not link memchr by default, here's its implementation. +void* memchr(void* ptr, int ch, size_t count) +{ + unsigned char* p = static_cast(ptr); + while(count--) + if(*p++ == static_cast(ch)) + return --p; + return nullptr; +} + + +/* + * Abstract Response + * */ +const char* AsyncWebServerResponse::_responseCodeToString(int code) { + return reinterpret_cast(responseCodeToString(code)); +} + +const __FlashStringHelper *AsyncWebServerResponse::responseCodeToString(int code) { + switch (code) { + case 100: return F("Continue"); + case 101: return F("Switching Protocols"); + case 200: return F("OK"); + case 201: return F("Created"); + case 202: return F("Accepted"); + case 203: return F("Non-Authoritative Information"); + case 204: return F("No Content"); + case 205: return F("Reset Content"); + case 206: return F("Partial Content"); + case 300: return F("Multiple Choices"); + case 301: return F("Moved Permanently"); + case 302: return F("Found"); + case 303: return F("See Other"); + case 304: return F("Not Modified"); + case 305: return F("Use Proxy"); + case 307: return F("Temporary Redirect"); + case 400: return F("Bad Request"); + case 401: return F("Unauthorized"); + case 402: return F("Payment Required"); + case 403: return F("Forbidden"); + case 404: return F("Not Found"); + case 405: return F("Method Not Allowed"); + case 406: return F("Not Acceptable"); + case 407: return F("Proxy Authentication Required"); + case 408: return F("Request Time-out"); + case 409: return F("Conflict"); + case 410: return F("Gone"); + case 411: return F("Length Required"); + case 412: return F("Precondition Failed"); + case 413: return F("Request Entity Too Large"); + case 414: return F("Request-URI Too Large"); + case 415: return F("Unsupported Media Type"); + case 416: return F("Requested range not satisfiable"); + case 417: return F("Expectation Failed"); + case 500: return F("Internal Server Error"); + case 501: return F("Not Implemented"); + case 502: return F("Bad Gateway"); + case 503: return F("Service Unavailable"); + case 504: return F("Gateway Time-out"); + case 505: return F("HTTP Version not supported"); + default: return F(""); + } +} + +AsyncWebServerResponse::AsyncWebServerResponse() + : _code(0) + , _headers(LinkedList([](AsyncWebHeader *h){ delete h; })) + , _contentType() + , _contentLength(0) + , _sendContentLength(true) + , _chunked(false) + , _headLength(0) + , _sentLength(0) + , _ackedLength(0) + , _writtenLength(0) + , _state(RESPONSE_SETUP) +{ + for(auto header: DefaultHeaders::Instance()) { + _headers.add(new AsyncWebHeader(header->name(), header->value())); + } +} + +AsyncWebServerResponse::~AsyncWebServerResponse(){ + _headers.free(); +} + +void AsyncWebServerResponse::setCode(int code){ + if(_state == RESPONSE_SETUP) + _code = code; +} + +void AsyncWebServerResponse::setContentLength(size_t len){ + if(_state == RESPONSE_SETUP) + _contentLength = len; +} + +void AsyncWebServerResponse::setContentType(const String& type){ + if(_state == RESPONSE_SETUP) + _contentType = type; +} + +void AsyncWebServerResponse::addHeader(const String& name, const String& value){ + _headers.add(new AsyncWebHeader(name, value)); +} + +String AsyncWebServerResponse::_assembleHead(uint8_t version){ + if(version){ + addHeader(F("Accept-Ranges"), F("none")); + if(_chunked) + addHeader(F("Transfer-Encoding"), F("chunked")); + } + String out = String(); + int bufSize = 300; + char buf[bufSize]; + + snprintf_P(buf, bufSize, PSTR("HTTP/1.%d %d %s\r\n"), version, _code, _responseCodeToString(_code)); + out.concat(buf); + + if(_sendContentLength) { + snprintf_P(buf, bufSize, PSTR("Content-Length: %d\r\n"), _contentLength); + out.concat(buf); + } + if(_contentType.length()) { + snprintf_P(buf, bufSize, PSTR("Content-Type: %s\r\n"), _contentType.c_str()); + out.concat(buf); + } + + for(const auto& header: _headers){ + snprintf_P(buf, bufSize, PSTR("%s: %s\r\n"), header->name().c_str(), header->value().c_str()); + out.concat(buf); + } + _headers.free(); + + out.concat(F("\r\n")); + _headLength = out.length(); + return out; +} + +bool AsyncWebServerResponse::_started() const { return _state > RESPONSE_SETUP; } +bool AsyncWebServerResponse::_finished() const { return _state > RESPONSE_WAIT_ACK; } +bool AsyncWebServerResponse::_failed() const { return _state == RESPONSE_FAILED; } +bool AsyncWebServerResponse::_sourceValid() const { return false; } +void AsyncWebServerResponse::_respond(AsyncWebServerRequest *request){ _state = RESPONSE_END; request->client()->close(); } +size_t AsyncWebServerResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){ (void)request; (void)len; (void)time; return 0; } + +/* + * String/Code Response + * */ +AsyncBasicResponse::AsyncBasicResponse(int code, const String& contentType, const String& content){ + _code = code; + _content = content; + _contentType = contentType; + if(_content.length()){ + _contentLength = _content.length(); + if(!_contentType.length()) + _contentType = F("text/plain"); + } + addHeader(F("Connection"), F("close")); +} + +void AsyncBasicResponse::_respond(AsyncWebServerRequest *request){ + _state = RESPONSE_HEADERS; + String out = _assembleHead(request->version()); + size_t outLen = out.length(); + size_t space = request->client()->space(); + if(!_contentLength && space >= outLen){ + _writtenLength += request->client()->write(out.c_str(), outLen); + _state = RESPONSE_WAIT_ACK; + } else if(_contentLength && space >= outLen + _contentLength){ + out += _content; + outLen += _contentLength; + _writtenLength += request->client()->write(out.c_str(), outLen); + _state = RESPONSE_WAIT_ACK; + } else if(space && space < outLen){ + String partial = out.substring(0, space); + _content = out.substring(space) + _content; + _contentLength += outLen - space; + _writtenLength += request->client()->write(partial.c_str(), partial.length()); + _state = RESPONSE_CONTENT; + } else if(space > outLen && space < (outLen + _contentLength)){ + size_t shift = space - outLen; + outLen += shift; + _sentLength += shift; + out += _content.substring(0, shift); + _content = _content.substring(shift); + _writtenLength += request->client()->write(out.c_str(), outLen); + _state = RESPONSE_CONTENT; + } else { + _content = out + _content; + _contentLength += outLen; + _state = RESPONSE_CONTENT; + } +} + +size_t AsyncBasicResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){ + (void)time; + _ackedLength += len; + if(_state == RESPONSE_CONTENT){ + size_t available = _contentLength - _sentLength; + size_t space = request->client()->space(); + //we can fit in this packet + if(space > available){ + _writtenLength += request->client()->write(_content.c_str(), available); + _content = String(); + _state = RESPONSE_WAIT_ACK; + return available; + } + //send some data, the rest on ack + String out = _content.substring(0, space); + _content = _content.substring(space); + _sentLength += space; + _writtenLength += request->client()->write(out.c_str(), space); + return space; + } else if(_state == RESPONSE_WAIT_ACK){ + if(_ackedLength >= _writtenLength){ + _state = RESPONSE_END; + } + } + return 0; +} + + +/* + * Abstract Response + * */ + +AsyncAbstractResponse::AsyncAbstractResponse(AwsTemplateProcessor callback): _callback(callback) +{ + // In case of template processing, we're unable to determine real response size + if(callback) { + _contentLength = 0; + _sendContentLength = false; + _chunked = true; + } +} + +void AsyncAbstractResponse::_respond(AsyncWebServerRequest *request){ + addHeader(F("Connection"), F("close")); + _head = _assembleHead(request->version()); + _state = RESPONSE_HEADERS; + _ack(request, 0, 0); +} + +size_t AsyncAbstractResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){ + (void)time; + if(!_sourceValid()){ + _state = RESPONSE_FAILED; + request->client()->close(); + return 0; + } + _ackedLength += len; + size_t space = request->client()->space(); + + size_t headLen = _head.length(); + if(_state == RESPONSE_HEADERS){ + if(space >= headLen){ + _state = RESPONSE_CONTENT; + space -= headLen; + } else { + String out = _head.substring(0, space); + _head = _head.substring(space); + _writtenLength += request->client()->write(out.c_str(), out.length()); + return out.length(); + } + } + + if(_state == RESPONSE_CONTENT){ + size_t outLen; + if(_chunked){ + if(space <= 8){ + return 0; + } + outLen = space; + } else if(!_sendContentLength){ + outLen = space; + } else { + outLen = ((_contentLength - _sentLength) > space)?space:(_contentLength - _sentLength); + } + + uint8_t *buf = (uint8_t *)malloc(outLen+headLen); + if (!buf) { + // os_printf("_ack malloc %d failed\n", outLen+headLen); + return 0; + } + + if(headLen){ + memcpy(buf, _head.c_str(), _head.length()); + } + + size_t readLen = 0; + + if(_chunked){ + // HTTP 1.1 allows leading zeros in chunk length. Or spaces may be added. + // See RFC2616 sections 2, 3.6.1. + readLen = _fillBufferAndProcessTemplates(buf+headLen+6, outLen - 8); + if(readLen == RESPONSE_TRY_AGAIN){ + free(buf); + return 0; + } + outLen = sprintf_P((char*)buf+headLen, PSTR("%x"), readLen) + headLen; + while(outLen < headLen + 4) buf[outLen++] = ' '; + buf[outLen++] = '\r'; + buf[outLen++] = '\n'; + outLen += readLen; + buf[outLen++] = '\r'; + buf[outLen++] = '\n'; + } else { + readLen = _fillBufferAndProcessTemplates(buf+headLen, outLen); + if(readLen == RESPONSE_TRY_AGAIN){ + free(buf); + return 0; + } + outLen = readLen + headLen; + } + + if(headLen){ + _head = String(); + } + + if(outLen){ + _writtenLength += request->client()->write((const char*)buf, outLen); + } + + if(_chunked){ + _sentLength += readLen; + } else { + _sentLength += outLen - headLen; + } + + free(buf); + + if((_chunked && readLen == 0) || (!_sendContentLength && outLen == 0) || (!_chunked && _sentLength == _contentLength)){ + _state = RESPONSE_WAIT_ACK; + } + return outLen; + + } else if(_state == RESPONSE_WAIT_ACK){ + if(!_sendContentLength || _ackedLength >= _writtenLength){ + _state = RESPONSE_END; + if(!_chunked && !_sendContentLength) + request->client()->close(true); + } + } + return 0; +} + +size_t AsyncAbstractResponse::_readDataFromCacheOrContent(uint8_t* data, const size_t len) +{ + // If we have something in cache, copy it to buffer + const size_t readFromCache = std::min(len, _cache.size()); + if(readFromCache) { + memcpy(data, _cache.data(), readFromCache); + _cache.erase(_cache.begin(), _cache.begin() + readFromCache); + } + // If we need to read more... + const size_t needFromFile = len - readFromCache; + const size_t readFromContent = _fillBuffer(data + readFromCache, needFromFile); + return readFromCache + readFromContent; +} + +size_t AsyncAbstractResponse::_fillBufferAndProcessTemplates(uint8_t* data, size_t len) +{ + if(!_callback) + return _fillBuffer(data, len); + + const size_t originalLen = len; + len = _readDataFromCacheOrContent(data, len); + // Now we've read 'len' bytes, either from cache or from file + // Search for template placeholders + uint8_t* pTemplateStart = data; + while((pTemplateStart < &data[len]) && (pTemplateStart = (uint8_t*)memchr(pTemplateStart, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart + 1))) { // data[0] ... data[len - 1] + uint8_t* pTemplateEnd = (pTemplateStart < &data[len - 1]) ? (uint8_t*)memchr(pTemplateStart + 1, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart) : nullptr; + // temporary buffer to hold parameter name + uint8_t buf[TEMPLATE_PARAM_NAME_LENGTH + 1]; + String paramName; + // If closing placeholder is found: + if(pTemplateEnd) { + // prepare argument to callback + const size_t paramNameLength = std::min((size_t)sizeof(buf) - 1, (size_t)(pTemplateEnd - pTemplateStart - 1)); + if(paramNameLength) { + memcpy(buf, pTemplateStart + 1, paramNameLength); + buf[paramNameLength] = 0; + paramName = String(reinterpret_cast(buf)); + } else { // double percent sign encountered, this is single percent sign escaped. + // remove the 2nd percent sign + memmove(pTemplateEnd, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1); + len += _readDataFromCacheOrContent(&data[len - 1], 1) - 1; + ++pTemplateStart; + } + } else if(&data[len - 1] - pTemplateStart + 1 < TEMPLATE_PARAM_NAME_LENGTH + 2) { // closing placeholder not found, check if it's in the remaining file data + memcpy(buf, pTemplateStart + 1, &data[len - 1] - pTemplateStart); + const size_t readFromCacheOrContent = _readDataFromCacheOrContent(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PARAM_NAME_LENGTH + 2 - (&data[len - 1] - pTemplateStart + 1)); + if(readFromCacheOrContent) { + pTemplateEnd = (uint8_t*)memchr(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PLACEHOLDER, readFromCacheOrContent); + if(pTemplateEnd) { + // prepare argument to callback + *pTemplateEnd = 0; + paramName = String(reinterpret_cast(buf)); + // Copy remaining read-ahead data into cache + _cache.insert(_cache.begin(), pTemplateEnd + 1, buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent); + pTemplateEnd = &data[len - 1]; + } + else // closing placeholder not found in file data, store found percent symbol as is and advance to the next position + { + // but first, store read file data in cache + _cache.insert(_cache.begin(), buf + (&data[len - 1] - pTemplateStart), buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent); + ++pTemplateStart; + } + } + else // closing placeholder not found in content data, store found percent symbol as is and advance to the next position + ++pTemplateStart; + } + else // closing placeholder not found in content data, store found percent symbol as is and advance to the next position + ++pTemplateStart; + if(paramName.length()) { + // call callback and replace with result. + // Everything in range [pTemplateStart, pTemplateEnd] can be safely replaced with parameter value. + // Data after pTemplateEnd may need to be moved. + // The first byte of data after placeholder is located at pTemplateEnd + 1. + // It should be located at pTemplateStart + numBytesCopied (to begin right after inserted parameter value). + const String paramValue(_callback(paramName)); + const char* pvstr = paramValue.c_str(); + const unsigned int pvlen = paramValue.length(); + const size_t numBytesCopied = std::min(pvlen, static_cast(&data[originalLen - 1] - pTemplateStart + 1)); + // make room for param value + // 1. move extra data to cache if parameter value is longer than placeholder AND if there is no room to store + if((pTemplateEnd + 1 < pTemplateStart + numBytesCopied) && (originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1) < len)) { + _cache.insert(_cache.begin(), &data[originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1)], &data[len]); + //2. parameter value is longer than placeholder text, push the data after placeholder which not saved into cache further to the end + memmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[originalLen] - pTemplateStart - numBytesCopied); + len = originalLen; // fix issue with truncated data, not sure if it has any side effects + } else if(pTemplateEnd + 1 != pTemplateStart + numBytesCopied) + //2. Either parameter value is shorter than placeholder text OR there is enough free space in buffer to fit. + // Move the entire data after the placeholder + memmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1); + // 3. replace placeholder with actual value + memcpy(pTemplateStart, pvstr, numBytesCopied); + // If result is longer than buffer, copy the remainder into cache (this could happen only if placeholder text itself did not fit entirely in buffer) + if(numBytesCopied < pvlen) { + _cache.insert(_cache.begin(), pvstr + numBytesCopied, pvstr + pvlen); + } else if(pTemplateStart + numBytesCopied < pTemplateEnd + 1) { // result is copied fully; if result is shorter than placeholder text... + // there is some free room, fill it from cache + const size_t roomFreed = pTemplateEnd + 1 - pTemplateStart - numBytesCopied; + const size_t totalFreeRoom = originalLen - len + roomFreed; + len += _readDataFromCacheOrContent(&data[len - roomFreed], totalFreeRoom) - roomFreed; + } else { // result is copied fully; it is longer than placeholder text + const size_t roomTaken = pTemplateStart + numBytesCopied - pTemplateEnd - 1; + len = std::min(len + roomTaken, originalLen); + } + } + } // while(pTemplateStart) + return len; +} + + +/* + * File Response + * */ + +AsyncFileResponse::~AsyncFileResponse(){ + if(_content) + _content.close(); +} + +void AsyncFileResponse::_setContentType(const String& path){ +#if HAVE_EXTERN_GET_CONTENT_TYPE_FUNCTION + extern const __FlashStringHelper *getContentType(const String &path); + _contentType = getContentType(path); +#else + if (path.endsWith(F(".html"))) _contentType = F("text/html"); + else if (path.endsWith(F(".htm"))) _contentType = F("text/html"); + else if (path.endsWith(F(".css"))) _contentType = F("text/css"); + else if (path.endsWith(F(".json"))) _contentType = F("application/json"); + else if (path.endsWith(F(".js"))) _contentType = F("application/javascript"); + else if (path.endsWith(F(".png"))) _contentType = F("image/png"); + else if (path.endsWith(F(".gif"))) _contentType = F("image/gif"); + else if (path.endsWith(F(".jpg"))) _contentType = F("image/jpeg"); + else if (path.endsWith(F(".ico"))) _contentType = F("image/x-icon"); + else if (path.endsWith(F(".svg"))) _contentType = F("image/svg+xml"); + else if (path.endsWith(F(".eot"))) _contentType = F("font/eot"); + else if (path.endsWith(F(".woff"))) _contentType = F("font/woff"); + else if (path.endsWith(F(".woff2"))) _contentType = F("font/woff2"); + else if (path.endsWith(F(".ttf"))) _contentType = F("font/ttf"); + else if (path.endsWith(F(".xml"))) _contentType = F("text/xml"); + else if (path.endsWith(F(".pdf"))) _contentType = F("application/pdf"); + else if (path.endsWith(F(".zip"))) _contentType = F("application/zip"); + else if(path.endsWith(F(".gz"))) _contentType = F("application/x-gzip"); + else _contentType = F("text/plain"); +#endif +} + +AsyncFileResponse::AsyncFileResponse(FS &fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback): AsyncAbstractResponse(callback){ + _code = 200; + _path = path; + + if(!download && !fs.exists(_path) && fs.exists(_path + F(".gz"))){ + _path = _path + F(".gz"); + addHeader(F("Content-Encoding"), F("gzip")); + _callback = nullptr; // Unable to process zipped templates + _sendContentLength = true; + _chunked = false; + } + + _content = fs.open(_path, fs::FileOpenMode::read); + _contentLength = _content.size(); + + if(contentType.length() == 0) + _setContentType(path); + else + _contentType = contentType; + + int filenameStart = path.lastIndexOf('/') + 1; + char buf[26+path.length()-filenameStart]; + char* filename = (char*)path.c_str() + filenameStart; + + if(download) { + // set filename and force download + snprintf_P(buf, sizeof (buf), PSTR("attachment; filename=\"%s\""), filename); + } else { + // set filename and force rendering + snprintf_P(buf, sizeof (buf), PSTR("inline; filename=\"%s\""), filename); + } + addHeader(F("Content-Disposition"), buf); +} + +AsyncFileResponse::AsyncFileResponse(File content, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback): AsyncAbstractResponse(callback){ + _code = 200; + _path = path; + + if(!download && String(content.name()).endsWith(F(".gz")) && !path.endsWith(F(".gz"))){ + addHeader(F("Content-Encoding"), F("gzip")); + _callback = nullptr; // Unable to process gzipped templates + _sendContentLength = true; + _chunked = false; + } + + _content = content; + _contentLength = _content.size(); + + if(contentType.length() == 0) + _setContentType(path); + else + _contentType = contentType; + + int filenameStart = path.lastIndexOf('/') + 1; + char buf[26+path.length()-filenameStart]; + char* filename = (char*)path.c_str() + filenameStart; + + if(download) { + snprintf_P(buf, sizeof (buf), PSTR("attachment; filename=\"%s\""), filename); + } else { + snprintf_P(buf, sizeof (buf), PSTR("inline; filename=\"%s\""), filename); + } + addHeader(F("Content-Disposition"), buf); +} + +size_t AsyncFileResponse::_fillBuffer(uint8_t *data, size_t len){ + return _content.read(data, len); +} + +/* + * Stream Response + * */ + +AsyncStreamResponse::AsyncStreamResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback): AsyncAbstractResponse(callback) { + _code = 200; + _content = &stream; + _contentLength = len; + _contentType = contentType; +} + +size_t AsyncStreamResponse::_fillBuffer(uint8_t *data, size_t len){ + size_t available = _content->available(); + size_t outLen = (available > len)?len:available; + size_t i; + for(i=0;iread(); + return outLen; +} + +/* + * Callback Response + * */ + +AsyncCallbackResponse::AsyncCallbackResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback): AsyncAbstractResponse(templateCallback) { + _code = 200; + _content = callback; + _contentLength = len; + if(!len) + _sendContentLength = false; + _contentType = contentType; + _filledLength = 0; +} + +size_t AsyncCallbackResponse::_fillBuffer(uint8_t *data, size_t len){ + size_t ret = _content(data, len, _filledLength); + if(ret != RESPONSE_TRY_AGAIN){ + _filledLength += ret; + } + return ret; +} + +/* + * Chunked Response + * */ + +AsyncChunkedResponse::AsyncChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor processorCallback): AsyncAbstractResponse(processorCallback) { + _code = 200; + _content = callback; + _contentLength = 0; + _contentType = contentType; + _sendContentLength = false; + _chunked = true; + _filledLength = 0; +} + +size_t AsyncChunkedResponse::_fillBuffer(uint8_t *data, size_t len){ + size_t ret = _content(data, len, _filledLength); + if(ret != RESPONSE_TRY_AGAIN){ + _filledLength += ret; + } + return ret; +} + +/* + * Progmem Response + * */ + +AsyncProgmemResponse::AsyncProgmemResponse(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback): AsyncAbstractResponse(callback) { + _code = code; + _content = content; + _contentType = contentType; + _contentLength = len; + _readLength = 0; +} + +size_t AsyncProgmemResponse::_fillBuffer(uint8_t *data, size_t len){ + size_t left = _contentLength - _readLength; + if (left > len) { + memcpy_P(data, _content + _readLength, len); + _readLength += len; + return len; + } + memcpy_P(data, _content + _readLength, left); + _readLength += left; + return left; +} + + +/* + * Response Stream (You can print/write/printf to it, up to the contentLen bytes) + * */ + +AsyncResponseStream::AsyncResponseStream(const String& contentType, size_t bufferSize){ + _code = 200; + _contentLength = 0; + _contentType = contentType; + _content = new cbuf(bufferSize); +} + +AsyncResponseStream::~AsyncResponseStream(){ + delete _content; +} + +size_t AsyncResponseStream::_fillBuffer(uint8_t *buf, size_t maxLen){ + return _content->read((char*)buf, maxLen); +} + +size_t AsyncResponseStream::write(const uint8_t *data, size_t len){ + if(_started()) + return 0; + + if(len > _content->room()){ + size_t needed = len - _content->room(); + _content->resizeAdd(needed); + } + size_t written = _content->write((const char*)data, len); + _contentLength += written; + return written; +} + +size_t AsyncResponseStream::write(uint8_t data){ + return write(&data, 1); +} diff --git a/lib/ESPAsyncWebServer/WebServer.cpp b/lib/ESPAsyncWebServer/WebServer.cpp new file mode 100644 index 000000000..62e85b23a --- /dev/null +++ b/lib/ESPAsyncWebServer/WebServer.cpp @@ -0,0 +1,198 @@ +/* + Asynchronous WebServer library for Espressif MCUs + + Copyright (c) 2016 Hristo Gochkov. All rights reserved. + This file is part of the esp8266 core for Arduino environment. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include "ESPAsyncWebServer.h" +#include "WebHandlerImpl.h" + +bool ON_STA_FILTER(AsyncWebServerRequest *request) { + return WiFi.localIP() == request->client()->localIP(); +} + +bool ON_AP_FILTER(AsyncWebServerRequest *request) { + return WiFi.localIP() != request->client()->localIP(); +} + +#ifndef HAVE_FS_FILE_OPEN_MODE +const char *fs::FileOpenMode::read = "r"; +const char *fs::FileOpenMode::write = "w"; +const char *fs::FileOpenMode::append = "a"; +#endif + +AsyncWebServer::AsyncWebServer(uint16_t port) + : _server(port) + , _rewrites(LinkedList([](AsyncWebRewrite* r){ delete r; })) + , _handlers(LinkedList([](AsyncWebHandler* h){ delete h; })) +{ + _catchAllHandler = new AsyncCallbackWebHandler(); + if(_catchAllHandler == NULL) + return; + _server.onClient([](void *s, AsyncClient* c){ + if(c == NULL) + return; + c->setRxTimeout(3); + AsyncWebServerRequest *r = new AsyncWebServerRequest((AsyncWebServer*)s, c); + if(r == NULL){ + c->close(true); + c->free(); + delete c; + } + }, this); +} + +AsyncWebServer::~AsyncWebServer(){ + reset(); + end(); + if(_catchAllHandler) delete _catchAllHandler; +} + +AsyncWebRewrite& AsyncWebServer::addRewrite(AsyncWebRewrite* rewrite){ + _rewrites.add(rewrite); + return *rewrite; +} + +bool AsyncWebServer::removeRewrite(AsyncWebRewrite *rewrite){ + return _rewrites.remove(rewrite); +} + +AsyncWebRewrite& AsyncWebServer::rewrite(const char* from, const char* to){ + return addRewrite(new AsyncWebRewrite(from, to)); +} + +AsyncWebHandler& AsyncWebServer::addHandler(AsyncWebHandler* handler){ + _handlers.add(handler); + return *handler; +} + +bool AsyncWebServer::removeHandler(AsyncWebHandler *handler){ + return _handlers.remove(handler); +} + +void AsyncWebServer::begin(){ + _server.setNoDelay(true); + _server.begin(); +} + +void AsyncWebServer::end(){ + _server.end(); +} + +#if ASYNC_TCP_SSL_ENABLED +void AsyncWebServer::onSslFileRequest(AcSSlFileHandler cb, void* arg){ + _server.onSslFileRequest(cb, arg); +} + +void AsyncWebServer::beginSecure(const char *cert, const char *key, const char *password){ + _server.beginSecure(cert, key, password); +} +#endif + +void AsyncWebServer::_handleDisconnect(AsyncWebServerRequest *request){ + delete request; +} + +void AsyncWebServer::_rewriteRequest(AsyncWebServerRequest *request){ + for(const auto& r: _rewrites){ + if (r->match(request)){ + request->_url = r->toUrl(); + request->_addGetParams(r->params()); + } + } +} + +void AsyncWebServer::_attachHandler(AsyncWebServerRequest *request){ + for(const auto& h: _handlers){ + if (h->filter(request) && h->canHandle(request)){ + request->setHandler(h); + return; + } + } + + request->addInterestingHeader(F("ANY")); + request->setHandler(_catchAllHandler); +} + + +AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody){ + AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler(); + handler->setUri(uri); + handler->setMethod(method); + handler->onRequest(onRequest); + handler->onUpload(onUpload); + handler->onBody(onBody); + addHandler(handler); + return *handler; +} + +AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload){ + AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler(); + handler->setUri(uri); + handler->setMethod(method); + handler->onRequest(onRequest); + handler->onUpload(onUpload); + addHandler(handler); + return *handler; +} + +AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest){ + AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler(); + handler->setUri(uri); + handler->setMethod(method); + handler->onRequest(onRequest); + addHandler(handler); + return *handler; +} + +AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, ArRequestHandlerFunction onRequest){ + AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler(); + handler->setUri(uri); + handler->onRequest(onRequest); + addHandler(handler); + return *handler; +} + +AsyncStaticWebHandler& AsyncWebServer::serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control){ + AsyncStaticWebHandler* handler = new AsyncStaticWebHandler(uri, fs, path, cache_control); + addHandler(handler); + return *handler; +} + +void AsyncWebServer::onNotFound(ArRequestHandlerFunction fn){ + _catchAllHandler->onRequest(fn); +} + +void AsyncWebServer::onFileUpload(ArUploadHandlerFunction fn){ + _catchAllHandler->onUpload(fn); +} + +void AsyncWebServer::onRequestBody(ArBodyHandlerFunction fn){ + _catchAllHandler->onBody(fn); +} + +void AsyncWebServer::reset(){ + _rewrites.free(); + _handlers.free(); + + if (_catchAllHandler != NULL){ + _catchAllHandler->onRequest(NULL); + _catchAllHandler->onUpload(NULL); + _catchAllHandler->onBody(NULL); + } +} + diff --git a/lib/OneWire/OneWire.cpp b/lib/OneWire/OneWire.cpp index cd9dc8448..e5d19ff05 100644 --- a/lib/OneWire/OneWire.cpp +++ b/lib/OneWire/OneWire.cpp @@ -202,7 +202,7 @@ uint8_t OneWire::reset(void) { #ifdef ARDUINO_ARCH_ESP32 void IRAM_ATTR OneWire::write_bit(uint8_t v) { #else -void OneWire::write_bit(uint8_t v) { +void OneWire::write_bit(uint8_t v) { #endif IO_REG_TYPE mask IO_REG_MASK_ATTR = bitmask; volatile IO_REG_TYPE * reg IO_REG_BASE_ATTR = baseReg; @@ -578,4 +578,4 @@ uint16_t OneWire::crc16(const uint8_t * input, uint16_t len, uint16_t crc) { #endif -#pragma GCC diagnostic pop +#pragma GCC diagnostic pop \ No newline at end of file diff --git a/lib/OneWire/OneWire.h b/lib/OneWire/OneWire.h index 436eecd1f..52db16c53 100644 --- a/lib/OneWire/OneWire.h +++ b/lib/OneWire/OneWire.h @@ -105,10 +105,10 @@ class OneWire { // Write a bit. The bus is always left powered at the end, see // note in write() about that. - #ifdef ARDUINO_ARCH_ESP32 - void IRAM_ATTR write_bit(uint8_t v); - #else - void write_bit(uint8_t v); +#ifdef ARDUINO_ARCH_ESP32 + void IRAM_ATTR write_bit(uint8_t v); +#else + void write_bit(uint8_t v); #endif // Read a bit. @@ -192,4 +192,4 @@ class OneWire { #endif #endif // __cplusplus -#endif // OneWire_h +#endif // OneWire_h \ No newline at end of file diff --git a/lib/framework/NTPSettingsService.cpp b/lib/framework/NTPSettingsService.cpp index cf53a0769..ec3a1efa0 100644 --- a/lib/framework/NTPSettingsService.cpp +++ b/lib/framework/NTPSettingsService.cpp @@ -54,7 +54,7 @@ void NTPSettingsService::onStationModeDisconnected(const WiFiEventStationModeDis void NTPSettingsService::configureNTP() { if (WiFi.isConnected() && _state.enabled) { - Serial.println(F("Starting NTP...")); + // Serial.println(F("Starting NTP...")); #ifdef ESP32 configTzTime(_state.tzFormat.c_str(), _state.server.c_str()); #elif defined(ESP8266) diff --git a/lib_standalone/ArduinoJson/extras/tests/MsgPackSerializer/serializeObject.cpp b/lib_standalone/ArduinoJson/extras/tests/MsgPackSerializer/serializeObject.cpp index dbe746432..617c5a6ac 100644 --- a/lib_standalone/ArduinoJson/extras/tests/MsgPackSerializer/serializeObject.cpp +++ b/lib_standalone/ArduinoJson/extras/tests/MsgPackSerializer/serializeObject.cpp @@ -22,11 +22,6 @@ static void check(const JsonObject object, const char (&expected_data)[N]) { check(object, expected_data, expected_len); } -// TODO: used by the commented test -// static void check(const JsonObject object, const std::string& expected) { -// check(object, expected.data(), expected.length()); -//} - TEST_CASE("serialize MsgPack object") { DynamicJsonDocument doc(4096); JsonObject object = doc.to(); @@ -54,23 +49,6 @@ TEST_CASE("serialize MsgPack object") { "iC\x0C\xA2iD\x0D\xA2iE\x0E\xA2iF\x0F"); } - // TODO: improve performance and uncomment - // SECTION("map 32") { - // std::string expected("\xDF\x00\x01\x00\x00", 5); - // - // for (int i = 0; i < 65536; ++i) { - // char kv[16]; - // sprintf(kv, "%04x", i); - // object[kv] = kv; - // expected += '\xA4'; - // expected += kv; - // expected += '\xA4'; - // expected += kv; - // } - // - // check(object, expected); - // } - SECTION("serialized(const char*)") { object["hello"] = serialized("\xDB\x00\x01\x00\x00", 5); check(object, "\x81\xA5hello\xDB\x00\x01\x00\x00"); diff --git a/lib_standalone/ArduinoJson/extras/tests/catch/catch.hpp b/lib_standalone/ArduinoJson/extras/tests/catch/catch.hpp index 7c351e931..f97a3fedb 100644 --- a/lib_standalone/ArduinoJson/extras/tests/catch/catch.hpp +++ b/lib_standalone/ArduinoJson/extras/tests/catch/catch.hpp @@ -10323,7 +10323,6 @@ namespace Catch { virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { StreamingReporterBase::testGroupEnded( testGroupStats ); - // TODO: Check testGroupStats.aborting and act accordingly. m_xml.scopedElement( "OverallResults" ) .writeAttribute( "successes", testGroupStats.totals.assertions.passed ) .writeAttribute( "failures", testGroupStats.totals.assertions.failed ) diff --git a/lib_standalone/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp b/lib_standalone/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp index ed328913a..0c46e9b2b 100644 --- a/lib_standalone/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp +++ b/lib_standalone/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp @@ -23,7 +23,6 @@ class MsgPackDeserializer { TStringStorage stringStorage) : _pool(&pool), _reader(reader), _stringStorage(stringStorage) {} - // TODO: add support for filter DeserializationError parse(VariantData &variant, AllowAllFilter, NestingLimit nestingLimit) { return parse(variant, nestingLimit); @@ -40,7 +39,6 @@ class MsgPackDeserializer { } if ((code & 0xe0) == 0xe0) { - // TODO: add setNegativeInteger() variant.setSignedInteger(static_cast(code)); return DeserializationError::Ok; } diff --git a/media/web_devices.PNG b/media/web_devices.PNG index 4a9796a7b..24710a5ee 100644 Binary files a/media/web_devices.PNG and b/media/web_devices.PNG differ diff --git a/platformio.ini b/platformio.ini index 9df1b635a..3c3112337 100644 --- a/platformio.ini +++ b/platformio.ini @@ -1,8 +1,8 @@ ; PlatformIO Project Configuration File for EMS-ESP [platformio] -; default_envs = esp8266 -default_envs = esp32 +default_envs = esp8266 +; default_envs = esp32 # override any settings with your own local ones in pio_local.ini extra_configs = @@ -23,6 +23,7 @@ build_flags = -D FT_SECURITY=1 -D FT_MQTT=1 -D FT_OTA=1 + -D FT_NTP=1 -D FT_UPLOAD_FIRMWARE=1 -D ONEWIRE_CRC16=0 -D NO_GLOBAL_ARDUINOOTA @@ -34,7 +35,6 @@ build_flags = libs_core = ArduinoJson - ESP Async WebServer AsyncMqttClient [env] @@ -44,7 +44,9 @@ extra_scripts = framework = arduino monitor_speed = 115200 -upload_speed = 115200 + +; on OSX with non-native drivers use upload_speed = 115200 +upload_speed = 921600 lib_ldf_mode = chain+ @@ -76,15 +78,15 @@ board_build.f_cpu = 160000000L ; 160MHz ; eagle.flash.4m1m.ld = 1019 KB sketch, 1000 KB SPIFFS. 4KB EEPROM, 4KB RFCAL, 12KB WIFI stack, 2052 KB OTA & buffer ; eagle.flash.4m2m.ld = 1019 KB sketch, 2024 KB SPIFFS. 4KB EEPROM, 4KB RFCAL, 12KB WIFI stack, 1028 KB OTA & buffer ; board_build.ldscript = eagle.flash.4m2m.ld -build_flags = ${common.build_flags} ${common.debug_flags} -DFT_NTP=0 +build_flags = ${common.build_flags} ${common.debug_flags} lib_ignore = AsyncTCP [env:esp32] board = esp32dev build_type = release -; platform = espressif32 -platform = https://github.com/platformio/platform-espressif32.git +platform = espressif32 +; platform = https://github.com/platformio/platform-espressif32.git board_build.partitions = min_spiffs.csv ; https://github.com/espressif/arduino-esp32/blob/master/tools/partitions/ lib_deps = ${common.libs_core} -build_flags = ${common.build_flags} ${common.debug_flags} -DFT_NTP=1 +build_flags = ${common.build_flags} ${common.debug_flags} diff --git a/scripts/build.sh b/scripts/build.sh old mode 100755 new mode 100644 diff --git a/src/EMSESPDevicesService.cpp b/src/EMSESPDevicesService.cpp index 8fccbdc32..40896ae7d 100644 --- a/src/EMSESPDevicesService.cpp +++ b/src/EMSESPDevicesService.cpp @@ -22,6 +22,8 @@ namespace emsesp { +using namespace std::placeholders; // for `_1` etc + EMSESPDevicesService::EMSESPDevicesService(AsyncWebServer * server, SecurityManager * securityManager) : _device_dataHandler(DEVICE_DATA_SERVICE_PATH, securityManager->wrapCallback(std::bind(&EMSESPDevicesService::device_data, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) { @@ -39,7 +41,7 @@ EMSESPDevicesService::EMSESPDevicesService(AsyncWebServer * server, SecurityMana } void EMSESPDevicesService::scan_devices(AsyncWebServerRequest * request) { - EMSESP::send_read_request(EMSdevice::EMS_TYPE_UBADevices, EMSdevice::EMS_DEVICE_ID_BOILER); + EMSESP::scan_devices(); request->send(200); } @@ -55,7 +57,7 @@ void EMSESPDevicesService::all_devices(AsyncWebServerRequest * request) { obj["type"] = emsdevice->device_type_name(); obj["brand"] = emsdevice->brand_to_string(); obj["name"] = emsdevice->name(); - obj["deviceid"] = emsdevice->device_id(); + obj["deviceid"] = emsdevice->get_device_id(); obj["productid"] = emsdevice->product_id(); obj["version"] = emsdevice->version(); } @@ -76,10 +78,9 @@ void EMSESPDevicesService::all_devices(AsyncWebServerRequest * request) { void EMSESPDevicesService::device_data(AsyncWebServerRequest * request, JsonVariant & json) { if (json.is()) { - uint8_t id = json["id"]; // get id from selected table row - AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_EMSESP_DEVICE_SIZE); #ifndef EMSESP_STANDALONE + uint8_t id = json["id"]; // get id from selected table row EMSESP::device_info(id, (JsonObject &)response->getRoot()); #endif response->setLength(); diff --git a/src/EMSESPDevicesService.h b/src/EMSESPDevicesService.h index b542e82fc..6d058dcd2 100644 --- a/src/EMSESPDevicesService.h +++ b/src/EMSESPDevicesService.h @@ -24,8 +24,7 @@ #include #include -// #define MAX_EMSESP_STATUS_SIZE 1024 -#define MAX_EMSESP_DEVICE_SIZE 1280 +#define MAX_EMSESP_DEVICE_SIZE 1536 #define EMSESP_DEVICES_SERVICE_PATH "/rest/allDevices" #define SCAN_DEVICES_SERVICE_PATH "/rest/scanDevices" @@ -33,8 +32,6 @@ namespace emsesp { -using namespace std::placeholders; // for `_1` - class EMSESPDevicesService { public: EMSESPDevicesService(AsyncWebServer * server, SecurityManager * securityManager); diff --git a/src/EMSESPSettingsService.cpp b/src/EMSESPSettingsService.cpp index 9cf40cf9e..18cf19eaa 100644 --- a/src/EMSESPSettingsService.cpp +++ b/src/EMSESPSettingsService.cpp @@ -51,10 +51,11 @@ StateUpdateResult EMSESPSettings::update(JsonObject & root, EMSESPSettings & set return StateUpdateResult::CHANGED; } -// this is called after the settings have been persisted to the filesystem +// this is called after any of the settings have been persisted to the filesystem +// either via the Web UI or via the Console void EMSESPSettingsService::onUpdate() { EMSESP::shower_.start(); - EMSESP::system_.syslog_init(); + // EMSESP::system_.syslog_init(); // changing SysLog will require a restart EMSESP::reset_tx(); } diff --git a/src/console.cpp b/src/console.cpp index c594e5ba2..0878ca24f 100644 --- a/src/console.cpp +++ b/src/console.cpp @@ -20,7 +20,7 @@ #include "emsesp.h" #include "version.h" -#ifdef EMSESP_STANDALONE +#if defined(EMSESP_DEBUG) #include "test/test.h" #endif @@ -140,6 +140,11 @@ void EMSESPShell::add_console_commands() { flash_string_vector{F_(show), F_(values)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { EMSESP::show_device_values(shell); }); + commands->add_command(ShellContext::MAIN, + CommandFlags::USER, + flash_string_vector{F_(show), F_(mqtt)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { Mqtt::show_mqtt(shell); }); + commands->add_command( ShellContext::MAIN, CommandFlags::ADMIN, @@ -180,21 +185,22 @@ void EMSESPShell::add_console_commands() { EMSESP::emsespSettingsService.update( [&](EMSESPSettings & settings) { settings.tx_mode = tx_mode; + shell.printfln(F_(tx_mode_fmt), settings.tx_mode); return StateUpdateResult::CHANGED; }, "local"); - EMSESP::reset_tx(); // reset counters and set tx_mode }); commands->add_command(ShellContext::MAIN, - CommandFlags::USER, + CommandFlags::ADMIN, flash_string_vector{F_(scan), F_(devices)}, flash_string_vector{F_(deep_optional)}, [](Shell & shell, const std::vector & arguments) { if (arguments.size() == 0) { - EMSESP::send_read_request(EMSdevice::EMS_TYPE_UBADevices, EMSdevice::EMS_DEVICE_ID_BOILER); + EMSESP::scan_devices(); } else { shell.printfln(F("Performing a deep scan...")); + EMSESP::clear_all_devices(); std::vector Device_Ids; Device_Ids.push_back(0x08); // Boilers - 0x08 @@ -283,13 +289,17 @@ void Console::enter_custom_context(Shell & shell, unsigned int context) { // each custom context has the common commands like log, help, exit, su etc void Console::load_standard_commands(unsigned int context) { -#ifdef EMSESP_STANDALONE +#if defined(EMSESP_DEBUG) EMSESPShell::commands->add_command(context, - CommandFlags::ADMIN, + CommandFlags::USER, flash_string_vector{F_(test)}, - flash_string_vector{F_(name_mandatory)}, + flash_string_vector{F_(name_optional)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - Test::run_test(shell, arguments.front()); + if (arguments.size() == 0) { + Test::run_test(shell, "default"); + } else { + Test::run_test(shell, arguments.front()); + } }); #endif @@ -307,8 +317,17 @@ void Console::load_standard_commands(unsigned int context) { shell.printfln(F_(invalid_log_level)); return; } + } else { + shell.print(F("levels: ")); + std::vector v = uuid::log::levels_lowercase(); + size_t i = v.size(); + while (i--) { + shell.printf(v[i].c_str()); + shell.print(' '); + } + shell.println(); } - shell.printfln(F_(log_level_fmt), uuid::log::format_level_uppercase(shell.log_level())); + shell.printfln(F_(log_level_fmt), uuid::log::format_level_lowercase(shell.log_level())); }, [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> std::vector { return uuid::log::levels_lowercase(); @@ -362,7 +381,7 @@ void Console::load_standard_commands(unsigned int context) { }); EMSESPShell::commands->add_command(context, - CommandFlags::USER, + CommandFlags::ADMIN, flash_string_vector{F_(send), F_(telegram)}, flash_string_vector{F_(data_mandatory)}, [](Shell & shell __attribute__((unused)), const std::vector & arguments) { @@ -372,29 +391,32 @@ void Console::load_standard_commands(unsigned int context) { EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(watch)}, - flash_string_vector{F_(watch_format_mandatory), F_(watchid_optional)}, + flash_string_vector{F_(watch_format_optional), F_(watchid_optional)}, [](Shell & shell, const std::vector & arguments) { - // get raw/pretty - if (arguments[0] == read_flash_string(F_(raw))) { - emsesp::EMSESP::watch(EMSESP::WATCH_RAW); // raw - } else if (arguments[0] == read_flash_string(F_(on))) { - emsesp::EMSESP::watch(EMSESP::WATCH_ON); // on - } else if (arguments[0] == read_flash_string(F_(off))) { - emsesp::EMSESP::watch(EMSESP::WATCH_OFF); // off - } else { - shell.printfln(F_(invalid_watch)); - return; - } - uint16_t watch_id; - if (arguments.size() == 2) { - // get the watch_id if its set - watch_id = Helpers::hextoint(arguments[1].c_str()); - } else { - watch_id = WATCH_ID_NONE; - } - emsesp::EMSESP::watch_id(watch_id); + if (!arguments.empty()) { + // get raw/pretty + if (arguments[0] == read_flash_string(F_(raw))) { + emsesp::EMSESP::watch(EMSESP::WATCH_RAW); // raw + } else if (arguments[0] == read_flash_string(F_(on))) { + emsesp::EMSESP::watch(EMSESP::WATCH_ON); // on + } else if (arguments[0] == read_flash_string(F_(off))) { + emsesp::EMSESP::watch(EMSESP::WATCH_OFF); // off + } else { + shell.printfln(F_(invalid_watch)); + return; + } + + if (arguments.size() == 2) { + // get the watch_id if its set + watch_id = Helpers::hextoint(arguments[1].c_str()); + } else { + watch_id = WATCH_ID_NONE; + } + + emsesp::EMSESP::watch_id(watch_id); + } uint8_t watch = emsesp::EMSESP::watch(); if (watch == EMSESP::WATCH_OFF) { @@ -516,9 +538,11 @@ void Console::start() { shell->start(); #endif +#ifndef ESP8266 #if defined(EMSESP_DEBUG) shell->log_level(uuid::log::Level::DEBUG); // order is: err, warning, notice, info, debug, trace, all #endif +#endif #if defined(EMSESP_STANDALONE) // always start in su/admin mode when running tests diff --git a/src/console.h b/src/console.h index e7458abf0..1b4fd7304 100644 --- a/src/console.h +++ b/src/console.h @@ -50,69 +50,8 @@ using uuid::log::Level; #define F_(string_name) FPSTR(__pstr__##string_name) // clang-format on -// common words -MAKE_PSTR_WORD(exit) -MAKE_PSTR_WORD(help) -MAKE_PSTR_WORD(settings) -MAKE_PSTR_WORD(log) -MAKE_PSTR_WORD(logout) -MAKE_PSTR_WORD(enabled) -MAKE_PSTR_WORD(disabled) -MAKE_PSTR_WORD(yes) -MAKE_PSTR_WORD(no) -MAKE_PSTR_WORD(set) -MAKE_PSTR_WORD(show) -MAKE_PSTR_WORD(on) -MAKE_PSTR_WORD(off) -MAKE_PSTR_WORD(su) -MAKE_PSTR_WORD(name) -MAKE_PSTR_WORD(auto) -MAKE_PSTR_WORD(scan) -MAKE_PSTR_WORD(password) -MAKE_PSTR_WORD(read) -MAKE_PSTR_WORD(version) -MAKE_PSTR_WORD(values) -MAKE_PSTR_WORD(system) -MAKE_PSTR_WORD(fetch) -MAKE_PSTR_WORD(restart) -MAKE_PSTR_WORD(format) -MAKE_PSTR_WORD(raw) -MAKE_PSTR_WORD(watch) -MAKE_PSTR_WORD(mqtt) -MAKE_PSTR_WORD(send) -MAKE_PSTR_WORD(telegram) -MAKE_PSTR_WORD(bus_id) -MAKE_PSTR_WORD(tx_mode) -MAKE_PSTR_WORD(ems) -MAKE_PSTR_WORD(devices) - -MAKE_PSTR(deep_optional, "[deep]") -MAKE_PSTR(tx_mode_fmt, "Tx mode = %d") -MAKE_PSTR(bus_id_fmt, "Bus ID = %02X") -MAKE_PSTR(watchid_optional, "[ID]") -MAKE_PSTR(watch_format_mandatory, "") -MAKE_PSTR(invalid_watch, "Invalid watch type") -MAKE_PSTR(data_mandatory, "<\"XX XX ...\">") -MAKE_PSTR(percent, "%") -MAKE_PSTR(degrees, "°C") -MAKE_PSTR(degrees_mandatory, "") -MAKE_PSTR(asterisks, "********") -MAKE_PSTR(n_mandatory, "") -MAKE_PSTR(n_optional, "[n]") -MAKE_PSTR(bool_mandatory, "") -MAKE_PSTR(typeid_mandatory, "") -MAKE_PSTR(deviceid_mandatory, "") -MAKE_PSTR(deviceid_optional, "[device ID]") -MAKE_PSTR(invalid_log_level, "Invalid log level") -MAKE_PSTR(port_mandatory, "") -MAKE_PSTR(log_level_fmt, "Log level = %s") -MAKE_PSTR(log_level_optional, "[level]") -MAKE_PSTR(name_mandatory, "") -MAKE_PSTR(name_optional, "[name]") -MAKE_PSTR(new_password_prompt1, "Enter new password: ") -MAKE_PSTR(new_password_prompt2, "Retype new password: ") -MAKE_PSTR(password_prompt, "Password: ") -MAKE_PSTR(unset, "") +// localizations +#include "locale_EN.h" #ifdef LOCAL #undef LOCAL diff --git a/src/device_library.h b/src/device_library.h index 67c5e476d..af8a6377d 100644 --- a/src/device_library.h +++ b/src/device_library.h @@ -31,6 +31,7 @@ {115, DeviceType::BOILER, F("Topline/GB162"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {122, DeviceType::BOILER, F("Proline"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {123, DeviceType::BOILER, F("GBx72/Trendline/Cerapur/Greenstar Si/27i"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, +{131, DeviceType::BOILER, F("GB212"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {133, DeviceType::BOILER, F("GB125/Logamatic MC110"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {170, DeviceType::BOILER, F("Logano GB212"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {172, DeviceType::BOILER, F("Enviline/Compress 6000AW"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, @@ -39,11 +40,28 @@ {208, DeviceType::BOILER, F("Logamax Plus/GB192/Condens GC9000"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {234, DeviceType::BOILER, F("Logamax Plus GB122"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, +// Controllers - 0x09 / 0x10 / 0x50 +{ 68, DeviceType::CONTROLLER, F("BC10/RFM20"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{ 89, DeviceType::CONTROLLER, F("BC10 GB142"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{ 95, DeviceType::CONTROLLER, F("HT3"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{114, DeviceType::CONTROLLER, F("BC10"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{125, DeviceType::CONTROLLER, F("BC25"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{152, DeviceType::CONTROLLER, F("Controller"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{169, DeviceType::CONTROLLER, F("BC40"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{190, DeviceType::CONTROLLER, F("BC10"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{194, DeviceType::CONTROLLER, F("BC10"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{207, DeviceType::CONTROLLER, F("Sense II/CS200"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x10 +{209, DeviceType::CONTROLLER, F("ErP"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{218, DeviceType::CONTROLLER, F("M200/RFM200"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x50 +{224, DeviceType::CONTROLLER, F("9000i"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{230, DeviceType::CONTROLLER, F("BC Base"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 +{241, DeviceType::CONTROLLER, F("Condens 5000i"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 + // Thermostat - not currently supporting write operations, like the Easy/100 types - 0x18 {202, DeviceType::THERMOSTAT, F("Logamatic TC100/Moduline Easy"), DeviceFlags::EMS_DEVICE_FLAG_EASY | DeviceFlags::EMS_DEVICE_FLAG_NO_WRITE}, // 0x18, cannot write {203, DeviceType::THERMOSTAT, F("EasyControl CT200"), DeviceFlags::EMS_DEVICE_FLAG_EASY | DeviceFlags::EMS_DEVICE_FLAG_NO_WRITE}, // 0x18, cannot write -// Thermostat - Common for Buderus/Nefit/Bosch specific - 0x17 / 0x10 / 0x18 +// Thermostat - Buderus/Nefit/Bosch specific - 0x17 / 0x10 / 0x18 / 0x19 { 67, DeviceType::THERMOSTAT, F("RC30"), DeviceFlags::EMS_DEVICE_FLAG_RC30_1},// 0x10 - based on RC35 { 77, DeviceType::THERMOSTAT, F("RC20/Moduline 300"), DeviceFlags::EMS_DEVICE_FLAG_RC20},// 0x17 { 78, DeviceType::THERMOSTAT, F("Moduline 400"), DeviceFlags::EMS_DEVICE_FLAG_RC30}, // 0x10 @@ -51,6 +69,7 @@ { 80, DeviceType::THERMOSTAT, F("Moduline 200"), DeviceFlags::EMS_DEVICE_FLAG_RC10}, // 0x17 { 86, DeviceType::THERMOSTAT, F("RC35"), DeviceFlags::EMS_DEVICE_FLAG_RC35}, // 0x10 { 93, DeviceType::THERMOSTAT, F("RC20RF"), DeviceFlags::EMS_DEVICE_FLAG_RC20}, // 0x19 +{ 94, DeviceType::THERMOSTAT, F("RFM20 Remote"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x18 {157, DeviceType::THERMOSTAT, F("RC200/CW100"), DeviceFlags::EMS_DEVICE_FLAG_RC100}, // 0x18 {158, DeviceType::THERMOSTAT, F("RC300/RC310/Moduline 3000/CW400/Sense II"), DeviceFlags::EMS_DEVICE_FLAG_RC300}, // 0x10 {165, DeviceType::THERMOSTAT, F("RC100/Moduline 1000/1010"), DeviceFlags::EMS_DEVICE_FLAG_RC100}, // 0x18, 0x38 @@ -87,22 +106,6 @@ {200, DeviceType::HEATPUMP, F("HP Module"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {252, DeviceType::HEATPUMP, F("HP Module"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, -// Controllers - 0x09 / 0x10 / 0x50 -{ 68, DeviceType::CONTROLLER, F("BC10/RFM20"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{ 89, DeviceType::CONTROLLER, F("BC10 GB142"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{ 95, DeviceType::CONTROLLER, F("HT3"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{114, DeviceType::CONTROLLER, F("BC10"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{125, DeviceType::CONTROLLER, F("BC25"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{152, DeviceType::CONTROLLER, F("Controller"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{169, DeviceType::CONTROLLER, F("BC40"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{190, DeviceType::CONTROLLER, F("BC10"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{207, DeviceType::CONTROLLER, F("Sense II/CS200"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x10 -{209, DeviceType::CONTROLLER, F("ErP"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{218, DeviceType::CONTROLLER, F("M200/RFM200"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x50 -{224, DeviceType::CONTROLLER, F("9000i"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{230, DeviceType::CONTROLLER, F("BC Base"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 -{241, DeviceType::CONTROLLER, F("Condens 5000i"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x09 - // Connect devices - 0x02 {171, DeviceType::CONNECT, F("OpenTherm Converter"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, {205, DeviceType::CONNECT, F("Moduline Easy Connect"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, @@ -111,9 +114,7 @@ // Switches - 0x11 { 71, DeviceType::SWITCH, F("WM10"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, -// Gateways - 0x48 / 0x18 -{ 94, DeviceType::GATEWAY, F("RFM20 Remote"), DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x18 -{189, DeviceType::GATEWAY, F("KM200/MB LAN 2"), DeviceFlags::EMS_DEVICE_FLAG_NONE} // 0x48 - +// Gateways - 0x48 +{189, DeviceType::GATEWAY, F("KM200/MB LAN 2"), DeviceFlags::EMS_DEVICE_FLAG_NONE} // clang-format on diff --git a/src/devices/boiler.cpp b/src/devices/boiler.cpp index 64adca5d2..24ad6002e 100644 --- a/src/devices/boiler.cpp +++ b/src/devices/boiler.cpp @@ -18,65 +18,52 @@ #include "boiler.h" -MAKE_PSTR_WORD(boiler) -MAKE_PSTR_WORD(wwtemp) -MAKE_PSTR_WORD(flowtemp) -MAKE_PSTR_WORD(wwactive) -MAKE_PSTR_WORD(wwonetime) -MAKE_PSTR_WORD(wwcirculation) -MAKE_PSTR_WORD(comfort) -MAKE_PSTR_WORD(eco) -MAKE_PSTR_WORD(intelligent) -MAKE_PSTR_WORD(hot) -MAKE_PSTR_WORD(maxpower) -MAKE_PSTR_WORD(minpower) - -MAKE_PSTR(comfort_mandatory, "") - -// shower -MAKE_PSTR_WORD(shower) -MAKE_PSTR_WORD(timer) -MAKE_PSTR_WORD(alert) -MAKE_PSTR(shower_timer_fmt, "Shower Timer is %s") -MAKE_PSTR(shower_alert_fmt, "Shower Alert is %s") - namespace emsesp { REGISTER_FACTORY(Boiler, EMSdevice::DeviceType::BOILER) -MAKE_PSTR(logger_name, "boiler") -uuid::log::Logger Boiler::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; + +uuid::log::Logger Boiler::logger_{F_(boiler), uuid::log::Facility::CONSOLE}; Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - LOG_DEBUG(F("Registering new Boiler with device ID 0x%02X"), device_id); + this->reserve_mem(20); // reserve some space for the telegram registries, to avoid memory fragmentation + + LOG_DEBUG(F("Adding new Boiler with device ID 0x%02X"), device_id); // the telegram handlers... - register_telegram_type(0x10, F("UBAErrorMessage1"), false, std::bind(&Boiler::process_UBAErrorMessage, this, _1)); - register_telegram_type(0x11, F("UBAErrorMessage2"), false, std::bind(&Boiler::process_UBAErrorMessage, this, _1)); - register_telegram_type(0x18, F("UBAMonitorFast"), false, std::bind(&Boiler::process_UBAMonitorFast, this, _1)); - register_telegram_type(0x19, F("UBAMonitorSlow"), true, std::bind(&Boiler::process_UBAMonitorSlow, this, _1)); - register_telegram_type(0x34, F("UBAMonitorWW"), false, std::bind(&Boiler::process_UBAMonitorWW, this, _1)); - register_telegram_type(0x1C, F("UBAMaintenanceStatus"), false, std::bind(&Boiler::process_UBAMaintenanceStatus, this, _1)); - register_telegram_type(0x2A, F("MC10Status"), false, std::bind(&Boiler::process_MC10Status, this, _1)); - register_telegram_type(0x33, F("UBAParameterWW"), true, std::bind(&Boiler::process_UBAParameterWW, this, _1)); - register_telegram_type(0x14, F("UBATotalUptime"), false, std::bind(&Boiler::process_UBATotalUptime, this, _1)); - register_telegram_type(0x35, F("UBAFlags"), false, std::bind(&Boiler::process_UBAFlags, this, _1)); - register_telegram_type(0x15, F("UBAMaintenanceData"), false, std::bind(&Boiler::process_UBAMaintenanceData, this, _1)); - register_telegram_type(0x16, F("UBAParameters"), true, std::bind(&Boiler::process_UBAParameters, this, _1)); - register_telegram_type(0x1A, F("UBASetPoints"), false, std::bind(&Boiler::process_UBASetPoints, this, _1)); - register_telegram_type(0xD1, F("UBAOutdoorTemp"), false, std::bind(&Boiler::process_UBAOutdoorTemp, this, _1)); - register_telegram_type(0xE3, F("UBAMonitorSlowPlus"), false, std::bind(&Boiler::process_UBAMonitorSlowPlus2, this, _1)); - register_telegram_type(0xE4, F("UBAMonitorFastPlus"), false, std::bind(&Boiler::process_UBAMonitorFastPlus, this, _1)); - register_telegram_type(0xE5, F("UBAMonitorSlowPlus"), false, std::bind(&Boiler::process_UBAMonitorSlowPlus, this, _1)); + register_telegram_type(0x10, F("UBAErrorMessage1"), false, [&](std::shared_ptr t) { process_UBAErrorMessage(t); }); + register_telegram_type(0x11, F("UBAErrorMessage2"), false, [&](std::shared_ptr t) { process_UBAErrorMessage(t); }); + register_telegram_type(0x18, F("UBAMonitorFast"), false, [&](std::shared_ptr t) { process_UBAMonitorFast(t); }); + register_telegram_type(0x19, F("UBAMonitorSlow"), true, [&](std::shared_ptr t) { process_UBAMonitorSlow(t); }); + register_telegram_type(0x34, F("UBAMonitorWW"), false, [&](std::shared_ptr t) { process_UBAMonitorWW(t); }); + register_telegram_type(0x1C, F("UBAMaintenanceStatus"), false, [&](std::shared_ptr t) { process_UBAMaintenanceStatus(t); }); + register_telegram_type(0x2A, F("MC10Status"), false, [&](std::shared_ptr t) { process_MC10Status(t); }); + register_telegram_type(0x33, F("UBAParameterWW"), true, [&](std::shared_ptr t) { process_UBAParameterWW(t); }); + register_telegram_type(0x14, F("UBATotalUptime"), false, [&](std::shared_ptr t) { process_UBATotalUptime(t); }); + register_telegram_type(0x35, F("UBAFlags"), false, [&](std::shared_ptr t) { process_UBAFlags(t); }); + register_telegram_type(0x15, F("UBAMaintenanceData"), false, [&](std::shared_ptr t) { process_UBAMaintenanceData(t); }); + register_telegram_type(0x16, F("UBAParameters"), true, [&](std::shared_ptr t) { process_UBAParameters(t); }); + register_telegram_type(0x1A, F("UBASetPoints"), false, [&](std::shared_ptr t) { process_UBASetPoints(t); }); + register_telegram_type(0xD1, F("UBAOutdoorTemp"), false, [&](std::shared_ptr t) { process_UBAOutdoorTemp(t); }); + register_telegram_type(0xE3, F("UBAMonitorSlowPlus"), false, [&](std::shared_ptr t) { process_UBAMonitorSlowPlus2(t); }); + register_telegram_type(0xE4, F("UBAMonitorFastPlus"), false, [&](std::shared_ptr t) { process_UBAMonitorFastPlus(t); }); + register_telegram_type(0xE5, F("UBAMonitorSlowPlus"), false, [&](std::shared_ptr t) { process_UBAMonitorSlowPlus(t); }); + register_telegram_type(0xE9, F("UBADHWStatus"), false, [&](std::shared_ptr t) { process_UBADHWStatus(t); }); - register_telegram_type(0xE9, F("UBADHWStatus"), false, std::bind(&Boiler::process_UBADHWStatus, this, _1)); - - // MQTT callbacks - register_mqtt_topic("boiler_cmd", std::bind(&Boiler::boiler_cmd, this, _1)); - register_mqtt_topic("boiler_cmd_wwactivated", std::bind(&Boiler::boiler_cmd_wwactivated, this, _1)); - register_mqtt_topic("boiler_cmd_wwonetime", std::bind(&Boiler::boiler_cmd_wwonetime, this, _1)); - register_mqtt_topic("boiler_cmd_wwcirculation", std::bind(&Boiler::boiler_cmd_wwcirculation, this, _1)); - register_mqtt_topic("boiler_cmd_wwtemp", std::bind(&Boiler::boiler_cmd_wwtemp, this, _1)); + // MQTT commands for boiler_cmd topic + register_mqtt_cmd(F("comfort"), [&](const char * value, const int8_t id) { set_warmwater_mode(value, id); }); + register_mqtt_cmd(F("wwactivated"), [&](const char * value, const int8_t id) { set_warmwater_activated(value, id); }); + register_mqtt_cmd(F("wwtapactivated"), [&](const char * value, const int8_t id) { set_tapwarmwater_activated(value, id); }); + register_mqtt_cmd(F("wwonetime"), [&](const char * value, const int8_t id) { set_warmwater_onetime(value, id); }); + register_mqtt_cmd(F("wwcirculation"), [&](const char * value, const int8_t id) { set_warmwater_circulation(value, id); }); + register_mqtt_cmd(F("flowtemp"), [&](const char * value, const int8_t id) { set_flow_temp(value, id); }); + register_mqtt_cmd(F("wwtemp"), [&](const char * value, const int8_t id) { set_warmwater_temp(value, id); }); + register_mqtt_cmd(F("burnmaxpower"), [&](const char * value, const int8_t id) { set_max_power(value, id); }); + register_mqtt_cmd(F("burnminpower"), [&](const char * value, const int8_t id) { set_min_power(value, id); }); + register_mqtt_cmd(F("boilhyston"), [&](const char * value, const int8_t id) { set_hyst_on(value, id); }); + register_mqtt_cmd(F("boilhystoff"), [&](const char * value, const int8_t id) { set_hyst_off(value, id); }); + register_mqtt_cmd(F("burnperiod"), [&](const char * value, const int8_t id) { set_burn_period(value, id); }); + register_mqtt_cmd(F("pumpdelay"), [&](const char * value, const int8_t id) { set_pump_delay(value, id); }); } // add submenu context @@ -86,166 +73,24 @@ void Boiler::add_context_menu() { flash_string_vector{F_(boiler)}, [&](Shell & shell, const std::vector & arguments __attribute__((unused))) { Boiler::console_commands(shell, ShellContext::BOILER); + add_context_commands(ShellContext::BOILER); }); } -// boiler_cmd topic -void Boiler::boiler_cmd(const char * message) { - StaticJsonDocument doc; - DeserializationError error = deserializeJson(doc, message); - if (error) { - LOG_DEBUG(F("MQTT error: payload %s, error %s"), message, error.c_str()); - return; - } - if (nullptr != doc["flowtemp"]) { - uint8_t t = doc["flowtemp"]; - set_flow_temp(t); - } - if (nullptr != doc["wwtemp"]) { - uint8_t t = doc["wwtemp"]; - set_warmwater_temp(t); - } - if (nullptr != doc["boilhyston"]) { - int8_t t = doc["boilhyston"]; - set_hyst_on(t); - } - if (nullptr != doc["boilhystoff"]) { - uint8_t t = doc["boilhystoff"]; - set_hyst_off(t); - } - if (nullptr != doc["burnperiod"]) { - uint8_t t = doc["burnperiod"]; - set_burn_period(t); - } - if (nullptr != doc["burnminpower"]) { - uint8_t p = doc["burnminpower"]; - set_min_power(p); - } - if (nullptr != doc["burnmaxpower"]) { - uint8_t p = doc["burnmaxpower"]; - set_max_power(p); - } - if (nullptr != doc["pumpdelay"]) { - uint8_t t = doc["pumpdelay"]; - set_pump_delay(t); - } - - if (nullptr != doc["comfort"]) { - const char * data = doc["comfort"]; - if (strcmp((char *)data, "hot") == 0) { - set_warmwater_mode(1); - } else if (strcmp((char *)data, "eco") == 0) { - set_warmwater_mode(2); - } else if (strcmp((char *)data, "intelligent") == 0) { - set_warmwater_mode(3); - } - } - - const char * command = doc["cmd"]; - if (command == nullptr || doc["data"] == nullptr) { - return; - } - - // boiler ww comfort setting - if (strcmp(command, "comfort") == 0) { - const char * data = doc["data"]; - if (strcmp((char *)data, "hot") == 0) { - set_warmwater_mode(1); - } else if (strcmp((char *)data, "eco") == 0) { - set_warmwater_mode(2); - } else if (strcmp((char *)data, "intelligent") == 0) { - set_warmwater_mode(3); - } - return; - } - - // boiler flowtemp setting - if (strcmp(command, "flowtemp") == 0) { - uint8_t t = doc["data"]; - set_flow_temp(t); - return; - } - if (strcmp(command, "wwtemp") == 0) { - uint8_t t = doc["data"]; - set_warmwater_temp(t); - return; - } - // boiler max power setting - if (strcmp(command, "burnmaxpower") == 0) { - uint8_t p = doc["data"]; - set_max_power(p); - return; - } - - // boiler min power setting - if (strcmp(command, "burnminpower") == 0) { - uint8_t p = doc["data"]; - set_min_power(p); - return; - } - if (strcmp(command, "boilhyston") == 0) { - int8_t t = doc["data"]; - set_hyst_on(t); - return; - } - if (strcmp(command, "boilhystoff") == 0) { - uint8_t t = doc["data"]; - set_hyst_off(t); - return; - } - if (strcmp(command, "burnperiod") == 0) { - uint8_t t = doc["data"]; - set_burn_period(t); - return; - } - if (strcmp(command, "pumpdelay") == 0) { - uint8_t t = doc["data"]; - set_pump_delay(t); - return; - } -} - -void Boiler::boiler_cmd_wwactivated(const char * message) { - if ((message[0] == '1' || strcmp(message, "on") == 0) || (strcmp(message, "auto") == 0)) { - set_warmwater_activated(true); - } else if (message[0] == '0' || strcmp(message, "off") == 0) { - set_warmwater_activated(false); - } -} - -void Boiler::boiler_cmd_wwonetime(const char * message) { - if (message[0] == '1' || strcmp(message, "on") == 0) { - set_warmwater_onetime(true); - } else if (message[0] == '0' || strcmp(message, "off") == 0) { - set_warmwater_onetime(false); - } -} - -void Boiler::boiler_cmd_wwcirculation(const char * message) { - if (message[0] == '1' || strcmp(message, "on") == 0) { - set_warmwater_circulation(true); - } else if (message[0] == '0' || strcmp(message, "off") == 0) { - set_warmwater_circulation(false); - } -} - -void Boiler::boiler_cmd_wwtemp(const char * message) { - uint8_t t = atoi((char *)message); - if (t) { - set_warmwater_temp(t); - } -} - void Boiler::device_info(JsonArray & root) { JsonObject dataElement; - dataElement = root.createNestedObject(); - dataElement["name"] = F("Hot tap water"); - dataElement["value"] = tap_water_active_ ? F("running") : F("off"); + if (Helpers::hasValue(tap_water_active_, EMS_VALUE_BOOL)) { + dataElement = root.createNestedObject(); + dataElement["name"] = F("Hot tap water"); + dataElement["value"] = tap_water_active_ ? F("running") : F("off"); + } - dataElement = root.createNestedObject(); - dataElement["name"] = F("Central heating"); - dataElement["value"] = heating_active_ ? F("active") : F("off"); + if (Helpers::hasValue(heating_active_, EMS_VALUE_BOOL)) { + dataElement = root.createNestedObject(); + dataElement["name"] = F("Central heating"); + dataElement["value"] = heating_active_ ? F("active") : F("off"); + } render_value_json(root, "", F("Selected flow temperature"), selFlowTemp_, F_(degrees)); render_value_json(root, "", F("Current flow temperature"), curFlowTemp_, F_(degrees), 10); @@ -256,8 +101,9 @@ void Boiler::device_info(JsonArray & root) { // publish values via MQTT void Boiler::publish_values() { - const size_t capacity = JSON_OBJECT_SIZE(56); // must recalculate if more objects addded https://arduinojson.org/v6/assistant/ - DynamicJsonDocument doc(capacity); + // const size_t capacity = JSON_OBJECT_SIZE(56); // must recalculate if more objects addded https://arduinojson.org/v6/assistant/ + // DynamicJsonDocument doc(capacity); + StaticJsonDocument doc; char s[10]; // for formatting strings @@ -295,16 +141,16 @@ void Boiler::publish_values() { if (Helpers::hasValue(pumpMod2_)) { doc["pumpMod2"] = pumpMod2_; } - if (Helpers::hasValue(wWCircPump_, VALUE_BOOL)) { + if (Helpers::hasValue(wWCircPump_, EMS_VALUE_BOOL)) { doc["wWCircPump"] = Helpers::render_value(s, wWCircPump_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(wWCircPumpType_, VALUE_BOOL)) { + if (Helpers::hasValue(wWCircPumpType_, EMS_VALUE_BOOL)) { doc["wWCiPuType"] = wWCircPumpType_ ? "valve" : "pump"; } if (Helpers::hasValue(wWCircPumpMode_)) { doc["wWCiPuMode"] = wWCircPumpMode_; } - if (Helpers::hasValue(wWCirc_, VALUE_BOOL)) { + if (Helpers::hasValue(wWCirc_, EMS_VALUE_BOOL)) { doc["wWCirc"] = Helpers::render_value(s, wWCirc_, EMS_VALUE_BOOL); } if (Helpers::hasValue(extTemp_)) { @@ -340,43 +186,43 @@ void Boiler::publish_values() { if (Helpers::hasValue(exhaustTemp_)) { doc["exhaustTemp"] = (float)exhaustTemp_ / 10; } - if (Helpers::hasValue(wWActivated_, VALUE_BOOL)) { + if (Helpers::hasValue(wWActivated_, EMS_VALUE_BOOL)) { doc["wWActivated"] = Helpers::render_value(s, wWActivated_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(wWOneTime_, VALUE_BOOL)) { + if (Helpers::hasValue(wWOneTime_, EMS_VALUE_BOOL)) { doc["wWOnetime"] = Helpers::render_value(s, wWOneTime_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(wWDesinfecting_, VALUE_BOOL)) { + if (Helpers::hasValue(wWDesinfecting_, EMS_VALUE_BOOL)) { doc["wWDesinfecting"] = Helpers::render_value(s, wWDesinfecting_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(wWReadiness_, VALUE_BOOL)) { + if (Helpers::hasValue(wWReadiness_, EMS_VALUE_BOOL)) { doc["wWReady"] = Helpers::render_value(s, wWReadiness_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(wWRecharging_, VALUE_BOOL)) { + if (Helpers::hasValue(wWRecharging_, EMS_VALUE_BOOL)) { doc["wWRecharge"] = Helpers::render_value(s, wWRecharging_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(wWTemperatureOK_, VALUE_BOOL)) { + if (Helpers::hasValue(wWTemperatureOK_, EMS_VALUE_BOOL)) { doc["wWTempOK"] = Helpers::render_value(s, wWTemperatureOK_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(wWCirc_, VALUE_BOOL)) { + if (Helpers::hasValue(wWCirc_, EMS_VALUE_BOOL)) { doc["wWCirc"] = Helpers::render_value(s, wWCirc_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(burnGas_, VALUE_BOOL)) { + if (Helpers::hasValue(burnGas_, EMS_VALUE_BOOL)) { doc["burnGas"] = Helpers::render_value(s, burnGas_, EMS_VALUE_BOOL); } if (Helpers::hasValue(flameCurr_)) { doc["flameCurr"] = (float)(int16_t)flameCurr_ / 10; } - if (Helpers::hasValue(heatPmp_, VALUE_BOOL)) { + if (Helpers::hasValue(heatPmp_, EMS_VALUE_BOOL)) { doc["heatPump"] = Helpers::render_value(s, heatPmp_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(fanWork_, VALUE_BOOL)) { + if (Helpers::hasValue(fanWork_, EMS_VALUE_BOOL)) { doc["fanWork"] = Helpers::render_value(s, fanWork_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(ignWork_, VALUE_BOOL)) { + if (Helpers::hasValue(ignWork_, EMS_VALUE_BOOL)) { doc["ignWork"] = Helpers::render_value(s, ignWork_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(wWHeat_, VALUE_BOOL)) { + if (Helpers::hasValue(wWHeat_, EMS_VALUE_BOOL)) { doc["wWHeat"] = Helpers::render_value(s, wWHeat_, EMS_VALUE_BOOL); } if (Helpers::hasValue(heating_temp_)) { @@ -450,16 +296,16 @@ bool Boiler::updated_values() { void Boiler::show_values(uuid::console::Shell & shell) { EMSdevice::show_values(shell); // for showing the header - if (Helpers::hasValue(tap_water_active_, VALUE_BOOL)) { + if (Helpers::hasValue(tap_water_active_, EMS_VALUE_BOOL)) { print_value(shell, 2, F("Hot tap water"), tap_water_active_ ? F("running") : F("off")); } - if (Helpers::hasValue(heating_active_, VALUE_BOOL)) { + if (Helpers::hasValue(heating_active_, EMS_VALUE_BOOL)) { print_value(shell, 2, F("Central heating"), heating_active_ ? F("active") : F("off")); } print_value(shell, 2, F("Warm Water activated"), wWActivated_, nullptr, EMS_VALUE_BOOL); - if (Helpers::hasValue(wWCircPumpType_, VALUE_BOOL)) { + if (Helpers::hasValue(wWCircPumpType_, EMS_VALUE_BOOL)) { print_value(shell, 2, F("Warm Water charging type"), wWCircPumpType_ ? F("3-way valve") : F("charge pump")); } print_value(shell, 2, F("Warm Water circulation pump available"), wWCircPump_, nullptr, EMS_VALUE_BOOL); @@ -557,6 +403,8 @@ void Boiler::show_values(uuid::console::Shell & shell) { if (Helpers::hasValue(UBAuptime_)) { shell.printfln(F(" Total UBA working time: %d days %d hours %d minutes"), UBAuptime_ / 1440, (UBAuptime_ % 1440) / 60, UBAuptime_ % 60); } + + shell.println(); } /* @@ -579,7 +427,7 @@ void Boiler::check_active() { // see if the heating or hot tap water has changed, if so send // last_boilerActive stores heating in bit 1 and tap water in bit 2 - if (Helpers::hasValue(tap_water_active_, VALUE_BOOL) && Helpers::hasValue(heating_active_, VALUE_BOOL)) { + if (Helpers::hasValue(tap_water_active_, EMS_VALUE_BOOL) && Helpers::hasValue(heating_active_, EMS_VALUE_BOOL)) { uint8_t latest_boilerState = (tap_water_active_ << 1) + heating_active_; if (latest_boilerState != last_boilerState) { last_boilerState = latest_boilerState; @@ -650,12 +498,12 @@ void Boiler::process_UBATotalUptime(std::shared_ptr telegram) { */ void Boiler::process_UBAParameters(std::shared_ptr telegram) { telegram->read_value(heating_temp_, 1); - telegram->read_value(burnPowermax_,2); - telegram->read_value(burnPowermin_,3); - telegram->read_value(boilTemp_off_,4); - telegram->read_value(boilTemp_on_,5); - telegram->read_value(burnPeriod_,6); - telegram->read_value(pumpDelay_,8); + telegram->read_value(burnPowermax_, 2); + telegram->read_value(burnPowermin_, 3); + telegram->read_value(boilTemp_off_, 4); + telegram->read_value(boilTemp_on_, 5); + telegram->read_value(burnPeriod_, 6); + telegram->read_value(pumpDelay_, 8); telegram->read_value(pump_mod_max_, 9); telegram->read_value(pump_mod_min_, 10); } @@ -804,7 +652,7 @@ void Boiler::process_UBAMaintenanceStatus(std::shared_ptr telegr // 0x10, 0x11, 0x12 // not yet implemented void Boiler::process_UBAErrorMessage(std::shared_ptr telegram) { - // data: displaycode(2), errornumner(2), year, month, hour, day, minute, duration(2), src-addr + // data: displaycode(2), errornumber(2), year, month, hour, day, minute, duration(2), src-addr } #pragma GCC diagnostic pop @@ -818,67 +666,113 @@ void Boiler::process_UBAMaintenanceData(std::shared_ptr telegram } } +/* + * Commands + */ + + // Set the warm water temperature 0x33 -void Boiler::set_warmwater_temp(const uint8_t temperature) { - LOG_INFO(F("Setting boiler warm water temperature to %d C"), temperature); - write_command(EMS_TYPE_UBAParameterWW, 2, temperature); - write_command(EMS_TYPE_UBAFlags, 3, temperature); // for i9000, see #397 +void Boiler::set_warmwater_temp(const char * value, const int8_t id) { + int v = 0; + if (!Helpers::value2number(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler warm water temperature to %d C"), v); + write_command(EMS_TYPE_UBAParameterWW, 2, v); + write_command(EMS_TYPE_UBAFlags, 3, v); // for i9000, see #397 } // flow temp -void Boiler::set_flow_temp(const uint8_t temperature) { - LOG_INFO(F("Setting boiler flow temperature to %d C"), temperature); - write_command(EMS_TYPE_UBASetPoints, 0, temperature); +void Boiler::set_flow_temp(const char * value, const int8_t id) { + int v = 0; + if (!Helpers::value2number(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler flow temperature to %d C"), v); + write_command(EMS_TYPE_UBASetPoints, 0, v); } // set min boiler output -void Boiler::set_min_power(const uint8_t power) { - LOG_INFO(F("Setting boiler min power to "), power); - write_command(EMS_TYPE_UBAParameters, 3, power); +void Boiler::set_min_power(const char * value, const int8_t id) { + int v = 0; + if (!Helpers::value2number(value, v)) { + return; + } + LOG_INFO(F("Setting boiler min power to "), v); + write_command(EMS_TYPE_UBAParameters, 3, v); } // set max temp -void Boiler::set_max_power(const uint8_t power) { - LOG_INFO(F("Setting boiler max power to %d C"), power); - write_command(EMS_TYPE_UBAParameters, 2, power); +void Boiler::set_max_power(const char * value, const int8_t id) { + int v = 0; + if (!Helpers::value2number(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler max power to %d C"), v); + write_command(EMS_TYPE_UBAParameters, 2, v); } // set oiler on hysteresis -void Boiler::set_hyst_on(const uint8_t temp) { - LOG_INFO(F("Setting boiler hysteresis on to %d C"), temp); - write_command(EMS_TYPE_UBAParameters, 5, temp); +void Boiler::set_hyst_on(const char * value, const int8_t id) { + int v = 0; + if (!Helpers::value2number(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler hysteresis on to %d C"), v); + write_command(EMS_TYPE_UBAParameters, 5, v); } // set boiler off hysteresis -void Boiler::set_hyst_off(const uint8_t temp) { - LOG_INFO(F("Setting boiler hysteresis off to %d C"), temp); - write_command(EMS_TYPE_UBAParameters, 4, temp); +void Boiler::set_hyst_off(const char * value, const int8_t id) { + int v = 0; + if (!Helpers::value2number(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler hysteresis off to %d C"), v); + write_command(EMS_TYPE_UBAParameters, 4, v); } // set min burner period -void Boiler::set_burn_period(const uint8_t t) { - LOG_INFO(F("Setting burner min. period to %d min"), t); - write_command(EMS_TYPE_UBAParameters, 6, t); +void Boiler::set_burn_period(const char * value, const int8_t id) { + int v = 0; + if (!Helpers::value2number(value, v)) { + return; + } + + LOG_INFO(F("Setting burner min. period to %d min"), v); + write_command(EMS_TYPE_UBAParameters, 6, v); } // set pump delay -void Boiler::set_pump_delay(const uint8_t t) { - LOG_INFO(F("Setting boiler pump delay to %d min"), t); - write_command(EMS_TYPE_UBAParameters, 8, t); +void Boiler::set_pump_delay(const char * value, const int8_t id) { + int v = 0; + if (!Helpers::value2number(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler pump delay to %d min"), v); + write_command(EMS_TYPE_UBAParameters, 8, v); } -// 1=hot, 2=eco, 3=intelligent // note some boilers do not have this setting, than it's done by thermostat -// on a RC35 it's by EMSESP::send_write_request(0x37, 0x10, 2, &set, 1, 0); (set is 1,2,3) -void Boiler::set_warmwater_mode(const uint8_t comfort) { +// on a RC35 it's by EMSESP::send_write_request(0x37, 0x10, 2, &set, 1, 0); (set is 1,2,3) 1=hot, 2=eco, 3=intelligent +void Boiler::set_warmwater_mode(const char * value, const int8_t id) { + if (value == nullptr) { + return; + } uint8_t set; - if (comfort == 1) { + if (strcmp(value, "hot") == 0) { LOG_INFO(F("Setting boiler warm water to Hot")); set = 0x00; - } else if (comfort == 2) { + } else if (strcmp(value, "eco") == 0) { LOG_INFO(F("Setting boiler warm water to Eco")); set = 0xD8; - } else if (comfort == 3) { + } else if (strcmp(value, "intelligent") == 0) { LOG_INFO(F("Setting boiler warm water to Intelligent")); set = 0xEC; } else { @@ -888,24 +782,33 @@ void Boiler::set_warmwater_mode(const uint8_t comfort) { } // turn on/off warm water -void Boiler::set_warmwater_activated(const bool activated) { - LOG_INFO(F("Setting boiler warm water %s"), activated ? "on" : "off"); - uint8_t value; +void Boiler::set_warmwater_activated(const char * value, const int8_t id) { + bool v = false; + if (!Helpers::value2bool(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler warm water %s"), v ? "on" : "off"); // https://github.com/proddy/EMS-ESP/issues/268 + uint8_t n; if (EMSbus::is_ht3()) { - value = (activated ? 0x08 : 0x00); // 0x08 is on, 0x00 is off + n = (v ? 0x08 : 0x00); // 0x08 is on, 0x00 is off } else { - value = (activated ? 0xFF : 0x00); // 0xFF is on, 0x00 is off + n = (v ? 0xFF : 0x00); // 0xFF is on, 0x00 is off } - write_command(EMS_TYPE_UBAParameterWW, 1, value); + write_command(EMS_TYPE_UBAParameterWW, 1, n); } // Activate / De-activate the Warm Tap Water -// true = on, false = off // Note: Using the type 0x1D to put the boiler into Test mode. This may be shown on the boiler with a flashing 'T' -void Boiler::set_tapwarmwater_activated(const bool activated) { - LOG_INFO(F("Setting boiler warm tap water %s"), activated ? "on" : "off"); +void Boiler::set_tapwarmwater_activated(const char * value, const int8_t id) { + bool v = false; + if (!Helpers::value2bool(value, v)) { + return; + } + + LOG_INFO(F("Setting tap warm tap water %s"), v ? "on" : "off"); uint8_t message_data[EMS_MAX_TELEGRAM_MESSAGE_LENGTH]; for (uint8_t i = 0; i < sizeof(message_data); i++) { message_data[i] = 0x00; @@ -914,7 +817,7 @@ void Boiler::set_tapwarmwater_activated(const bool activated) { // we use the special test mode 0x1D for this. Setting the first data to 5A puts the system into test mode and // a setting of 0x00 puts it back into normal operating mode // when in test mode we're able to mess around with the 3-way valve settings - if (!activated) { + if (!v) { // on message_data[0] = 0x5A; // test mode on message_data[1] = 0x00; // burner output 0% @@ -932,16 +835,26 @@ void Boiler::set_tapwarmwater_activated(const bool activated) { // Activate / De-activate One Time warm water 0x35 // true = on, false = off // See also https://github.com/proddy/EMS-ESP/issues/341#issuecomment-596245458 for Junkers -void Boiler::set_warmwater_onetime(const bool activated) { - LOG_INFO(F("Setting boiler warm water OneTime loading %s"), activated ? "on" : "off"); - write_command(EMS_TYPE_UBAFlags, 0, (activated ? 0x22 : 0x02)); +void Boiler::set_warmwater_onetime(const char * value, const int8_t id) { + bool v = false; + if (!Helpers::value2bool(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler warm water OneTime loading %s"), v ? "on" : "off"); + write_command(EMS_TYPE_UBAFlags, 0, (v ? 0x22 : 0x02)); } // Activate / De-activate circulation of warm water 0x35 // true = on, false = off -void Boiler::set_warmwater_circulation(const bool activated) { - LOG_INFO(F("Setting boiler warm water circulation %s"), activated ? "on" : "off"); - write_command(EMS_TYPE_UBAFlags, 1, (activated ? 0x22 : 0x02)); +void Boiler::set_warmwater_circulation(const char * value, const int8_t id) { + bool v = false; + if (!Helpers::value2bool(value, v)) { + return; + } + + LOG_INFO(F("Setting boiler warm water circulation %s"), v ? "on" : "off"); + write_command(EMS_TYPE_UBAFlags, 1, (v ? 0x22 : 0x02)); } // add console commands @@ -952,118 +865,10 @@ void Boiler::console_commands(Shell & shell, unsigned int context) { flash_string_vector{F_(typeid_mandatory)}, [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { uint16_t type_id = Helpers::hextoint(arguments.front().c_str()); - EMSESP::send_read_request(type_id, device_id()); + EMSESP::set_read_id(type_id); + EMSESP::send_read_request(type_id, get_device_id()); }); - EMSESPShell::commands->add_command(ShellContext::BOILER, - CommandFlags::ADMIN, - flash_string_vector{F_(wwtemp)}, - flash_string_vector{F_(degrees_mandatory)}, - [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { - set_warmwater_temp(Helpers::atoint(arguments.front().c_str())); - }); - - EMSESPShell::commands->add_command(ShellContext::BOILER, - CommandFlags::ADMIN, - flash_string_vector{F_(flowtemp)}, - flash_string_vector{F_(degrees_mandatory)}, - [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { - set_flow_temp(Helpers::atoint(arguments.front().c_str())); - }); - - EMSESPShell::commands->add_command(ShellContext::BOILER, - CommandFlags::ADMIN, - flash_string_vector{F_(maxpower)}, - flash_string_vector{F_(n_mandatory)}, - [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { - set_max_power(Helpers::atoint(arguments.front().c_str())); - }); - - EMSESPShell::commands->add_command(ShellContext::BOILER, - CommandFlags::ADMIN, - flash_string_vector{F_(minpower)}, - flash_string_vector{F_(n_mandatory)}, - [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { - set_min_power(Helpers::atoint(arguments.front().c_str())); - }); - - EMSESPShell::commands->add_command( - ShellContext::BOILER, - CommandFlags::ADMIN, - flash_string_vector{F_(wwactive)}, - flash_string_vector{F_(bool_mandatory)}, - [=](Shell & shell, const std::vector & arguments) { - if (arguments[0] == read_flash_string(F_(on))) { - set_warmwater_activated(true); - } else if (arguments[0] == read_flash_string(F_(off))) { - set_warmwater_activated(false); - } else { - shell.println(F("Must be on or off")); - return; - } - }, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> const std::vector { - return std::vector{read_flash_string(F_(on)), read_flash_string(F_(off))}; - }); - - EMSESPShell::commands->add_command( - ShellContext::BOILER, - CommandFlags::ADMIN, - flash_string_vector{F_(wwonetime)}, - flash_string_vector{F_(bool_mandatory)}, - [=](Shell & shell, const std::vector & arguments) { - if (arguments[0] == read_flash_string(F_(on))) { - set_warmwater_onetime(true); - } else if (arguments[0] == read_flash_string(F_(off))) { - set_warmwater_onetime(false); - } else { - shell.println(F("Must be on or off")); - return; - } - }, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> const std::vector { - return std::vector{read_flash_string(F_(on)), read_flash_string(F_(off))}; - }); - - EMSESPShell::commands->add_command( - ShellContext::BOILER, - CommandFlags::ADMIN, - flash_string_vector{F_(wwcirculation)}, - flash_string_vector{F_(bool_mandatory)}, - [=](Shell & shell, const std::vector & arguments) { - if (arguments[0] == read_flash_string(F_(on))) { - set_warmwater_circulation(true); - } else if (arguments[0] == read_flash_string(F_(off))) { - set_warmwater_circulation(false); - } else { - shell.println(F("Must be on or off")); - return; - } - }, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> const std::vector { - return std::vector{read_flash_string(F_(on)), read_flash_string(F_(off))}; - }); - - EMSESPShell::commands->add_command( - ShellContext::BOILER, - CommandFlags::ADMIN, - flash_string_vector{F_(comfort)}, - flash_string_vector{F_(comfort_mandatory)}, - [=](Shell & shell, const std::vector & arguments) { - if (arguments[0] == read_flash_string(F_(hot))) { - set_warmwater_mode(1); - } else if (arguments[0] == read_flash_string(F_(eco))) { - set_warmwater_mode(2); - } else if (arguments[0] == read_flash_string(F_(intelligent))) { - set_warmwater_mode(3); - } else { - shell.println(F("Invalid value. Must be hot, eco or intelligent")); - } - }, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> const std::vector { - return std::vector{read_flash_string(F_(hot)), read_flash_string(F_(eco)), read_flash_string(F_(intelligent))}; - }); - EMSESPShell::commands->add_command(ShellContext::BOILER, CommandFlags::USER, flash_string_vector{F_(show)}, diff --git a/src/devices/boiler.h b/src/devices/boiler.h index fc77d7e28..7a22c0513 100644 --- a/src/devices/boiler.h +++ b/src/devices/boiler.h @@ -124,7 +124,7 @@ class Boiler : public EMSdevice { uint8_t burnPowermin_ = EMS_VALUE_UINT_NOTSET; uint8_t burnPowermax_ = EMS_VALUE_UINT_NOTSET; int8_t boilTemp_off_ = EMS_VALUE_INT_NOTSET; - int8_t boilTemp_on_ = EMS_VALUE_UINT_NOTSET; + int8_t boilTemp_on_ = EMS_VALUE_INT_NOTSET; uint8_t burnPeriod_ = EMS_VALUE_UINT_NOTSET; uint8_t pumpDelay_ = EMS_VALUE_UINT_NOTSET; @@ -160,27 +160,20 @@ class Boiler : public EMSdevice { void check_active(); - void set_warmwater_temp(const uint8_t temperature); - void set_flow_temp(const uint8_t temperature); - void set_warmwater_mode(const uint8_t comfort); - void set_warmwater_activated(const bool activated); - void set_tapwarmwater_activated(const bool activated); - void set_warmwater_onetime(const bool activated); - void set_warmwater_circulation(const bool activated); - void set_min_power(const uint8_t power); - void set_max_power(const uint8_t power); - void set_hyst_on(const uint8_t temp); - void set_hyst_off(const uint8_t temp); - void set_burn_period(const uint8_t t); - void set_pump_delay(const uint8_t t); - - - // mqtt callbacks - void boiler_cmd(const char * message); - void boiler_cmd_wwactivated(const char * message); - void boiler_cmd_wwonetime(const char * message); - void boiler_cmd_wwcirculation(const char * message); - void boiler_cmd_wwtemp(const char * message); + // commands - none of these use the additional id parameter + void set_warmwater_mode(const char * value, const int8_t id); + void set_warmwater_activated(const char * value, const int8_t id); + void set_tapwarmwater_activated(const char * value, const int8_t id); + void set_warmwater_onetime(const char * value, const int8_t id); + void set_warmwater_circulation(const char * value, const int8_t id); + void set_warmwater_temp(const char * value, const int8_t id); + void set_flow_temp(const char * value, const int8_t id); + void set_min_power(const char * value, const int8_t id); + void set_max_power(const char * value, const int8_t id); + void set_hyst_on(const char * value, const int8_t id); + void set_hyst_off(const char * value, const int8_t id); + void set_burn_period(const char * value, const int8_t id); + void set_pump_delay(const char * value, const int8_t id); }; } // namespace emsesp diff --git a/src/devices/connect.cpp b/src/devices/connect.cpp index d8da0d612..60b8de5c3 100644 --- a/src/devices/connect.cpp +++ b/src/devices/connect.cpp @@ -22,16 +22,10 @@ namespace emsesp { REGISTER_FACTORY(Connect, EMSdevice::DeviceType::CONNECT); -MAKE_PSTR(logger_name, "connect") -uuid::log::Logger Connect::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger Connect::logger_{F_(connect), uuid::log::Facility::CONSOLE}; Connect::Connect(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - // telegram handlers - // register_telegram_type(EMS_TYPE_XX, "XX", false, std::bind(&Controller::process_XX, this, _1)); - - // MQTT callbacks - // register_mqtt_topic("topic", std::bind(&Connect::cmd, this, _1)); } void Connect::device_info(JsonArray & root) { @@ -42,7 +36,7 @@ void Connect::add_context_menu() { // display all values into the shell console void Connect::show_values(uuid::console::Shell & shell) { - EMSdevice::show_values(shell); // always call this to show header + // EMSdevice::show_values(shell); // always call this to show header } // publish values via MQTT diff --git a/src/devices/controller.cpp b/src/devices/controller.cpp index a6796ce8b..07bd9879c 100644 --- a/src/devices/controller.cpp +++ b/src/devices/controller.cpp @@ -18,22 +18,14 @@ #include "controller.h" -// MAKE_PSTR_WORD(controller) - namespace emsesp { REGISTER_FACTORY(Controller, EMSdevice::DeviceType::CONTROLLER); -MAKE_PSTR(logger_name, "controller") -uuid::log::Logger Controller::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger Controller::logger_{F_(controller), uuid::log::Facility::CONSOLE}; Controller::Controller(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - // telegram handlers - // register_telegram_type(EMS_TYPE_XX, "XX", false, std::bind(&Controller::process_XX, this, _1)); - - // MQTT callbacks - // register_mqtt_topic("topic", std::bind(&Controller::cmd, this, _1)); } void Controller::add_context_menu() { @@ -44,7 +36,7 @@ void Controller::device_info(JsonArray & root) { // display all values into the shell console void Controller::show_values(uuid::console::Shell & shell) { - EMSdevice::show_values(shell); // always call this to show header + // EMSdevice::show_values(shell); // always call this to show header } // publish values via MQTT diff --git a/src/devices/gateway.cpp b/src/devices/gateway.cpp index aa8bec0bf..e36e40c38 100644 --- a/src/devices/gateway.cpp +++ b/src/devices/gateway.cpp @@ -18,22 +18,14 @@ #include "gateway.h" -// MAKE_PSTR_WORD(gateway) - namespace emsesp { REGISTER_FACTORY(Gateway, EMSdevice::DeviceType::GATEWAY); -MAKE_PSTR(logger_name, "gateway") -uuid::log::Logger Gateway::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger Gateway::logger_{F_(gateway), uuid::log::Facility::CONSOLE}; Gateway::Gateway(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - // telegram handlers - // register_telegram_type(EMS_TYPE_XX, "XX", false, std::bind(&Controller::process_XX, this, _1)); - - // MQTT callbacks - // register_mqtt_topic("topic", std::bind(&Gateway::cmd, this, _1)); } void Gateway::add_context_menu() { diff --git a/src/devices/heatpump.cpp b/src/devices/heatpump.cpp index 14b8e74ea..112a27963 100644 --- a/src/devices/heatpump.cpp +++ b/src/devices/heatpump.cpp @@ -18,32 +18,19 @@ #include "heatpump.h" -// MAKE_PSTR_WORD(heatpump) - -/* - example telegrams 0x32B, 0x37B - "38 10 FF 00 03 7B 08 24 00 4B", - "38 10 FF 00 03 2B 00 C7 07 C3 01", - "38 10 FF 00 03 2B 00 D1 08 2A 01", -*/ - namespace emsesp { REGISTER_FACTORY(Heatpump, EMSdevice::DeviceType::HEATPUMP); -MAKE_PSTR(logger_name, "heatpump") -uuid::log::Logger Heatpump::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger Heatpump::logger_{F_(heatpump), uuid::log::Facility::CONSOLE}; Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - LOG_DEBUG(F("Registering new Heat Pump module with device ID 0x%02X"), device_id); + LOG_DEBUG(F("Adding new Heat Pump module with device ID 0x%02X"), device_id); // telegram handlers - register_telegram_type(0x047B, F("HP1"), true, std::bind(&Heatpump::process_HPMonitor1, this, _1)); - register_telegram_type(0x042B, F("HP2"), true, std::bind(&Heatpump::process_HPMonitor2, this, _1)); - - // MQTT callbacks - // register_mqtt_topic("topic", std::bind(&Heatpump::cmd, this, _1)); + register_telegram_type(0x047B, F("HP1"), true, [&](std::shared_ptr t) { process_HPMonitor1(t); }); + register_telegram_type(0x042B, F("HP2"), true, [&](std::shared_ptr t) { process_HPMonitor2(t); }); } // context submenu @@ -55,7 +42,7 @@ void Heatpump::device_info(JsonArray & root) { // display all values into the shell console void Heatpump::show_values(uuid::console::Shell & shell) { - EMSdevice::show_values(shell); // always call this to show header + // EMSdevice::show_values(shell); // always call this to show header } // publish values via MQTT diff --git a/src/devices/mixing.cpp b/src/devices/mixing.cpp index 7fc8e4424..81e3f3d53 100644 --- a/src/devices/mixing.cpp +++ b/src/devices/mixing.cpp @@ -22,35 +22,37 @@ namespace emsesp { REGISTER_FACTORY(Mixing, EMSdevice::DeviceType::MIXING); -MAKE_PSTR(logger_name, "mixing") -uuid::log::Logger Mixing::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger Mixing::logger_{F_(mixing), uuid::log::Facility::CONSOLE}; Mixing::Mixing(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - LOG_DEBUG(F("Registering new Mixing module with device ID 0x%02X"), device_id); + LOG_DEBUG(F("Adding new Mixing module with device ID 0x%02X"), device_id); if (flags == EMSdevice::EMS_DEVICE_FLAG_MMPLUS) { if (device_id <= 0x27) { // telegram handlers 0x20 - 0x27 for HC - register_telegram_type(device_id - 0x20 + 0x02D7, F("MMPLUSStatusMessage_HC"), true, std::bind(&Mixing::process_MMPLUSStatusMessage_HC, this, _1)); + register_telegram_type(device_id - 0x20 + 0x02D7, F("MMPLUSStatusMessage_HC"), true, [&](std::shared_ptr t) { + process_MMPLUSStatusMessage_HC(t); + }); } else { // telegram handlers for warm water/DHW 0x28, 0x29 - register_telegram_type(device_id - 0x28 + 0x0331, F("MMPLUSStatusMessage_WWC"), true, std::bind(&Mixing::process_MMPLUSStatusMessage_WWC, this, _1)); + register_telegram_type(device_id - 0x28 + 0x0331, F("MMPLUSStatusMessage_WWC"), true, [&](std::shared_ptr t) { + process_MMPLUSStatusMessage_WWC(t); + }); } } + // EMS 1.0 if (flags == EMSdevice::EMS_DEVICE_FLAG_MM10) { - register_telegram_type(0x00AA, F("MMConfigMessage"), false, std::bind(&Mixing::process_MMConfigMessage, this, _1)); - register_telegram_type(0x00AB, F("MMStatusMessage"), true, std::bind(&Mixing::process_MMStatusMessage, this, _1)); - register_telegram_type(0x00AC, F("MMSetMessage"), false, std::bind(&Mixing::process_MMSetMessage, this, _1)); - } - // HT3 - if (flags == EMSdevice::EMS_DEVICE_FLAG_IPM) { - register_telegram_type(0x010C, F("IPMSetMessage"), false, std::bind(&Mixing::process_IPMStatusMessage, this, _1)); + register_telegram_type(0x00AA, F("MMConfigMessage"), false, [&](std::shared_ptr t) { process_MMConfigMessage(t); }); + register_telegram_type(0x00AB, F("MMStatusMessage"), true, [&](std::shared_ptr t) { process_MMStatusMessage(t); }); + register_telegram_type(0x00AC, F("MMSetMessage"), false, [&](std::shared_ptr t) { process_MMSetMessage(t); }); } - // MQTT callbacks - // register_mqtt_topic("topic", std::bind(&Mixing::cmd, this, _1)); + // HT3 + if (flags == EMSdevice::EMS_DEVICE_FLAG_IPM) { + register_telegram_type(0x010C, F("IPMSetMessage"), false, [&](std::shared_ptr t) { process_IPMStatusMessage(t); }); + } } // add context submenu @@ -68,11 +70,11 @@ void Mixing::device_info(JsonArray & root) { } else { render_value_json(root, "", F("Heating Circuit"), hc_, nullptr); } + render_value_json(root, "", F("Current flow temperature"), flowTemp_, F_(degrees), 10); render_value_json(root, "", F("Setpoint flow temperature"), flowSetTemp_, F_(degrees)); render_value_json(root, "", F("Current pump modulation"), pumpMod_, F_(percent)); render_value_json(root, "", F("Current valve status"), status_, nullptr); - } // check to see if values have been updated @@ -97,16 +99,19 @@ void Mixing::show_values(uuid::console::Shell & shell) { } else { print_value(shell, 2, F("Heating Circuit"), hc_, nullptr); } + print_value(shell, 4, F("Current flow temperature"), flowTemp_, F_(degrees), 10); print_value(shell, 4, F("Setpoint flow temperature"), flowSetTemp_, F_(degrees)); print_value(shell, 4, F("Current pump modulation"), pumpMod_, F_(percent)); print_value(shell, 4, F("Current valve status"), status_, nullptr); + + shell.println(); } // publish values via MQTT // ideally we should group up all the mixing units together into a nested JSON but for now we'll send them individually void Mixing::publish_values() { - DynamicJsonDocument doc(EMSESP_MAX_JSON_SIZE_SMALL); + StaticJsonDocument doc; switch (type_) { case Type::HC: @@ -139,7 +144,7 @@ void Mixing::publish_values() { char topic[30]; char s[3]; // for formatting strings strlcpy(topic, "mixing_data", 30); - strlcat(topic, Helpers::itoa(s, device_id() - 0x20 + 1), 30); // append hc to topic + strlcat(topic, Helpers::itoa(s, get_device_id() - 0x20 + 1), 30); // append hc to topic Mqtt::publish(topic, doc); } @@ -171,7 +176,7 @@ void Mixing::process_MMPLUSStatusMessage_WWC(std::shared_ptr tel // A1 00 FF 00 00 0C 02 04 00 01 1D 00 82 void Mixing::process_IPMStatusMessage(std::shared_ptr telegram) { type_ = Type::HC; - hc_ = device_id() - 0x20 + 1; + hc_ = get_device_id() - 0x20 + 1; uint8_t ismixed = 0; telegram->read_value(ismixed, 0); // check if circuit is active, 0-off, 1-unmixed, 2-mixed if (ismixed == 0) { @@ -198,7 +203,7 @@ void Mixing::process_MMStatusMessage(std::shared_ptr telegram) { // the heating circuit is determine by which device_id it is, 0x20 - 0x23 // 0x21 is position 2. 0x20 is typically reserved for the WM10 switch module // see https://github.com/proddy/EMS-ESP/issues/270 and https://github.com/proddy/EMS-ESP/issues/386#issuecomment-629610918 - hc_ = device_id() - 0x20 + 1; + hc_ = get_device_id() - 0x20 + 1; telegram->read_value(flowTemp_, 1); // is * 10 telegram->read_value(pumpMod_, 3); telegram->read_value(flowSetTemp_, 0); @@ -210,7 +215,7 @@ void Mixing::process_MMStatusMessage(std::shared_ptr telegram) { // Mixing on a MM10 - 0xAA // e.g. Thermostat -> Mixing Module, type 0xAA, telegram: 10 21 AA 00 FF 0C 0A 11 0A 32 xx void Mixing::process_MMConfigMessage(std::shared_ptr telegram) { - hc_ = device_id() - 0x20 + 1; + hc_ = get_device_id() - 0x20 + 1; // pos 0: active FF = on // pos 1: valve runtime 0C = 120 sec in units of 10 sec } @@ -218,7 +223,7 @@ void Mixing::process_MMConfigMessage(std::shared_ptr telegram) { // Mixing on a MM10 - 0xAC // e.g. Thermostat -> Mixing Module, type 0xAC, telegram: 10 21 AC 00 1E 64 01 AB void Mixing::process_MMSetMessage(std::shared_ptr telegram) { - hc_ = device_id() - 0x20 + 1; + hc_ = get_device_id() - 0x20 + 1; // pos 0: flowtemp setpoint 1E = 30°C // pos 1: position in % } diff --git a/src/devices/solar.cpp b/src/devices/solar.cpp index 8ea96e0e7..c6527e485 100644 --- a/src/devices/solar.cpp +++ b/src/devices/solar.cpp @@ -18,40 +18,35 @@ #include "solar.h" -MAKE_PSTR(kwh, "kWh") -MAKE_PSTR(wh, "Wh") - namespace emsesp { REGISTER_FACTORY(Solar, EMSdevice::DeviceType::SOLAR); -MAKE_PSTR(logger_name, "solar") -uuid::log::Logger Solar::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger Solar::logger_{F_(solar), uuid::log::Facility::CONSOLE}; Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - LOG_DEBUG(F("Registering new Solar module with device ID 0x%02X"), device_id); + LOG_DEBUG(F("Adding new Solar module with device ID 0x%02X"), device_id); // telegram handlers if (flags == EMSdevice::EMS_DEVICE_FLAG_SM10) { - register_telegram_type(0x0097, F("SM10Monitor"), true, std::bind(&Solar::process_SM10Monitor, this, _1)); + register_telegram_type(0x0097, F("SM10Monitor"), true, [&](std::shared_ptr t) { process_SM10Monitor(t); }); } + if (flags == EMSdevice::EMS_DEVICE_FLAG_SM100) { - register_telegram_type(0x0362, F("SM100Monitor"), true, std::bind(&Solar::process_SM100Monitor, this, _1)); - register_telegram_type(0x0363, F("SM100Monitor2"), true, std::bind(&Solar::process_SM100Monitor2, this, _1)); - register_telegram_type(0x0366, F("SM100Config"), true, std::bind(&Solar::process_SM100Config, this, _1)); + register_telegram_type(0x0362, F("SM100Monitor"), true, [&](std::shared_ptr t) { process_SM100Monitor(t); }); + register_telegram_type(0x0363, F("SM100Monitor2"), true, [&](std::shared_ptr t) { process_SM100Monitor2(t); }); + register_telegram_type(0x0366, F("SM100Config"), true, [&](std::shared_ptr t) { process_SM100Config(t); }); - register_telegram_type(0x0364, F("SM100Status"), false, std::bind(&Solar::process_SM100Status, this, _1)); - register_telegram_type(0x036A, F("SM100Status2"), false, std::bind(&Solar::process_SM100Status2, this, _1)); - register_telegram_type(0x038E, F("SM100Energy"), true, std::bind(&Solar::process_SM100Energy, this, _1)); + register_telegram_type(0x0364, F("SM100Status"), false, [&](std::shared_ptr t) { process_SM100Status(t); }); + register_telegram_type(0x036A, F("SM100Status2"), false, [&](std::shared_ptr t) { process_SM100Status2(t); }); + register_telegram_type(0x038E, F("SM100Energy"), true, [&](std::shared_ptr t) { process_SM100Energy(t); }); } + if (flags == EMSdevice::EMS_DEVICE_FLAG_ISM) { - register_telegram_type(0x0103, F("ISM1StatusMessage"), true, std::bind(&Solar::process_ISM1StatusMessage, this, _1)); - register_telegram_type(0x0101, F("ISM1Set"), false, std::bind(&Solar::process_ISM1Set, this, _1)); + register_telegram_type(0x0103, F("ISM1StatusMessage"), true, [&](std::shared_ptr t) { process_ISM1StatusMessage(t); }); + register_telegram_type(0x0101, F("ISM1Set"), false, [&](std::shared_ptr t) { process_ISM1Set(t); }); } - - // MQTT callbacks - // register_mqtt_topic("topic", std::bind(&Solar::cmd, this, _1)); } // context submenu @@ -113,7 +108,7 @@ void Solar::show_values(uuid::console::Shell & shell) { // publish values via MQTT void Solar::publish_values() { - DynamicJsonDocument doc(EMSESP_MAX_JSON_SIZE_MEDIUM); + StaticJsonDocument doc; char s[10]; // for formatting strings @@ -141,11 +136,11 @@ void Solar::publish_values() { doc["cylinderPumpModulation"] = cylinderPumpModulation_; } - if (Helpers::hasValue(solarPump_, VALUE_BOOL)) { + if (Helpers::hasValue(solarPump_, EMS_VALUE_BOOL)) { doc["solarPump"] = Helpers::render_value(s, solarPump_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(valveStatus_, VALUE_BOOL)) { + if (Helpers::hasValue(valveStatus_, EMS_VALUE_BOOL)) { doc["valveStatus"] = Helpers::render_value(s, valveStatus_, EMS_VALUE_BOOL); } @@ -153,11 +148,11 @@ void Solar::publish_values() { doc["pumpWorkMin"] = (float)pumpWorkMin_; } - if (Helpers::hasValue(tankHeated_, VALUE_BOOL)) { + if (Helpers::hasValue(tankHeated_, EMS_VALUE_BOOL)) { doc["tankHeated"] = Helpers::render_value(s, tankHeated_, EMS_VALUE_BOOL); } - if (Helpers::hasValue(collectorShutdown_, VALUE_BOOL)) { + if (Helpers::hasValue(collectorShutdown_, EMS_VALUE_BOOL)) { doc["collectorShutdown"] = Helpers::render_value(s, collectorShutdown_, EMS_VALUE_BOOL); } @@ -187,8 +182,8 @@ void Solar::console_commands() { // SM10Monitor - type 0x97 void Solar::process_SM10Monitor(std::shared_ptr telegram) { - telegram->read_value(collectorTemp_, 2); // collector temp from SM10, is *10 - telegram->read_value(tankBottomTemp_, 5); // bottom temp from SM10, is *10 + telegram->read_value(collectorTemp_, 2); // collector temp from SM10, is *10 + telegram->read_value(tankBottomTemp_, 5); // bottom temp from SM10, is *10 telegram->read_value(solarPumpModulation_, 4); // modulation solar pump telegram->read_bitvalue(solarPump_, 7, 1); telegram->read_value(pumpWorkMin_, 8); @@ -196,7 +191,6 @@ void Solar::process_SM10Monitor(std::shared_ptr telegram) { /* * SM100Monitor - type 0x0362 EMS+ - for MS/SM100 and MS/SM200 - * e.g. B0 0B FF 00 02 62 00 44 02 7A 80 00 80 00 80 00 80 00 80 00 80 00 00 7C 80 00 80 00 80 00 80 * e.g. B0 0B FF 00 02 62 00 77 01 D4 80 00 80 00 80 00 80 00 80 00 80 00 80 00 80 00 00 F9 80 00 80 9E - for heat exchanger temp * e.g, 30 00 FF 00 02 62 01 AC * 30 00 FF 18 02 62 80 00 @@ -237,21 +231,21 @@ void Solar::process_SM100Config(std::shared_ptr telegram) { - PS1: Solar circuit pump for collector array 1 - PS5: Cylinder primary pump when using an external heat exchanger * e.g. 30 00 FF 09 02 64 64 = 100% - * 30 00 FF 09 02 64 1E = 30% */ void Solar::process_SM100Status(std::shared_ptr telegram) { - uint8_t solarpumpmod = solarPumpModulation_; + uint8_t solarpumpmod = solarPumpModulation_; uint8_t cylinderpumpmod = cylinderPumpModulation_; telegram->read_value(cylinderPumpModulation_, 8); telegram->read_value(solarPumpModulation_, 9); + if (solarpumpmod == 0 && solarPumpModulation_ == 100) { // mask out boosts solarPumpModulation_ = 15; // set to minimum } + if (cylinderpumpmod == 0 && cylinderPumpModulation_ == 100) { // mask out boosts cylinderPumpModulation_ = 15; // set to minimum } - - telegram->read_bitvalue(tankHeated_, 3, 1); // issue #422 + telegram->read_bitvalue(tankHeated_, 3, 1); // issue #422 telegram->read_bitvalue(collectorShutdown_, 3, 0); // collector shutdown } @@ -281,22 +275,23 @@ void Solar::process_SM100Energy(std::shared_ptr telegram) { * e.g. B0 00 FF 00 00 03 32 00 00 00 00 13 00 D6 00 00 00 FB D0 F0 */ void Solar::process_ISM1StatusMessage(std::shared_ptr telegram) { - telegram->read_value(collectorTemp_, 4); // Collector Temperature - telegram->read_value(tankBottomTemp_, 6); // Temperature Bottom of Solar Boiler + telegram->read_value(collectorTemp_, 4); // Collector Temperature + telegram->read_value(tankBottomTemp_, 6); // Temperature Bottom of Solar Boiler uint16_t Wh = 0xFFFF; telegram->read_value(Wh, 2); // Solar Energy produced in last hour only ushort, is not * 10 + if (Wh != 0xFFFF) { energyLastHour_ = Wh * 10; // set to *10 } - telegram->read_bitvalue(solarPump_, 8, 0); // PS1 Solar pump on (1) or off (0) - telegram->read_value(pumpWorkMin_, 10, 3); // force to 3 bytes - telegram->read_bitvalue(collectorShutdown_, 9, 0); // collector shutdown on/off - telegram->read_bitvalue(tankHeated_, 9, 2); // tank full + + telegram->read_bitvalue(solarPump_, 8, 0); // PS1 Solar pump on (1) or off (0) + telegram->read_value(pumpWorkMin_, 10, 3); // force to 3 bytes + telegram->read_bitvalue(collectorShutdown_, 9, 0); // collector shutdown on/off + telegram->read_bitvalue(tankHeated_, 9, 2); // tank full } /* * Junkers ISM1 Solar Module - type 0x0101 EMS+ for setting values - * e.g. 90 30 FF 06 00 01 50 */ void Solar::process_ISM1Set(std::shared_ptr telegram) { telegram->read_value(setpoint_maxBottomTemp_, 6); diff --git a/src/devices/switch.cpp b/src/devices/switch.cpp index c7a160260..95d1f4454 100644 --- a/src/devices/switch.cpp +++ b/src/devices/switch.cpp @@ -18,22 +18,14 @@ #include "switch.h" -// MAKE_PSTR_WORD(switch) - namespace emsesp { REGISTER_FACTORY(Switch, EMSdevice::DeviceType::SWITCH); -MAKE_PSTR(logger_name, "switch") -uuid::log::Logger Switch::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger Switch::logger_{F_(switch), uuid::log::Facility::CONSOLE}; Switch::Switch(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - // telegram handlers - // register_telegram_type(EMS_TYPE_XX, "XX", false, std::bind(&Controller::process_XX, this, _1)); - - // MQTT callbacks - // register_mqtt_topic("topic", std::bind(&Switch::cmd, this, _1)); } void Switch::add_context_menu() { @@ -44,7 +36,7 @@ void Switch::device_info(JsonArray & root) { // display all values into the shell console void Switch::show_values(uuid::console::Shell & shell) { - EMSdevice::show_values(shell); // always call this to show header + // EMSdevice::show_values(shell); // always call this to show header } // publish values via MQTT diff --git a/src/devices/thermostat.cpp b/src/devices/thermostat.cpp index 3468abe06..c5783afd2 100644 --- a/src/devices/thermostat.cpp +++ b/src/devices/thermostat.cpp @@ -18,36 +18,28 @@ #include "thermostat.h" -MAKE_PSTR_WORD(thermostat) -MAKE_PSTR_WORD(master) -MAKE_PSTR_WORD(temp) -MAKE_PSTR_WORD(mode) -MAKE_PSTR_WORD(wwmode) - -MAKE_PSTR(hc_optional, "[heating circuit]") -MAKE_PSTR(mode_mandatory, "") -MAKE_PSTR(mode_optional, "[mode]") -MAKE_PSTR(master_thermostat_fmt, "Master Thermostat device ID = %s") - namespace emsesp { REGISTER_FACTORY(Thermostat, EMSdevice::DeviceType::THERMOSTAT); -MAKE_PSTR(logger_name, "thermostat") -uuid::log::Logger Thermostat::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; + +uuid::log::Logger Thermostat::logger_{F_(thermostat), uuid::log::Facility::CONSOLE}; Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { - // common telegram handlers - register_telegram_type(EMS_TYPE_RCOutdoorTemp, F("RCOutdoorTemp"), false, std::bind(&Thermostat::process_RCOutdoorTemp, this, _1)); - register_telegram_type(EMS_TYPE_RCTime, F("RCTime"), true, std::bind(&Thermostat::process_RCTime, this, _1)); // 0x06 + if (EMSESP::actual_master_thermostat() == 0) { + this->reserve_mem(25); // reserve some space for the telegram registries, to avoid memory fragmentation + // common telegram handlers + register_telegram_type(EMS_TYPE_RCOutdoorTemp, F("RCOutdoorTemp"), false, [&](std::shared_ptr t) { process_RCOutdoorTemp(t); }); + register_telegram_type(EMS_TYPE_RCTime, F("RCTime"), false, [&](std::shared_ptr t) { process_RCTime(t); }); + } // RC10 if (flags == EMSdevice::EMS_DEVICE_FLAG_RC10) { monitor_typeids = {0xB1}; set_typeids = {0xB0}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC10Monitor"), false, std::bind(&Thermostat::process_RC10Monitor, this, _1)); - register_telegram_type(set_typeids[i], F("RC10Set"), false, std::bind(&Thermostat::process_RC10Set, this, _1)); + register_telegram_type(monitor_typeids[i], F("RC10Monitor"), false, [&](std::shared_ptr t) { process_RC10Monitor(t); }); + register_telegram_type(set_typeids[i], F("RC10Set"), false, [&](std::shared_ptr t) { process_RC10Set(t); }); } // RC35 @@ -56,73 +48,77 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i set_typeids = {0x3D, 0x47, 0x51, 0x5B}; timer_typeids = {0x3F, 0x49, 0x53, 0x5D}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC35Monitor"), false, std::bind(&Thermostat::process_RC35Monitor, this, _1)); - register_telegram_type(set_typeids[i], F("RC35Set"), false, std::bind(&Thermostat::process_RC35Set, this, _1)); + register_telegram_type(monitor_typeids[i], F("RC35Monitor"), false, [&](std::shared_ptr t) { process_RC35Monitor(t); }); + register_telegram_type(set_typeids[i], F("RC35Set"), false, [&](std::shared_ptr t) { process_RC35Set(t); }); } - register_telegram_type(EMS_TYPE_IBASettings, F("IBASettings"), true, std::bind(&Thermostat::process_IBASettings, this, _1)); - register_telegram_type(EMS_TYPE_wwSettings, F("WWSettings"), true, std::bind(&Thermostat::process_RC35wwSettings, this, _1)); + register_telegram_type(EMS_TYPE_IBASettings, F("IBASettings"), true, [&](std::shared_ptr t) { process_IBASettings(t); }); + register_telegram_type(EMS_TYPE_wwSettings, F("WWSettings"), true, [&](std::shared_ptr t) { process_RC35wwSettings(t); }); // RC20 } else if (flags == EMSdevice::EMS_DEVICE_FLAG_RC20) { monitor_typeids = {0x91}; set_typeids = {0xA8}; - for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC20Monitor"), false, std::bind(&Thermostat::process_RC20Monitor, this, _1)); - register_telegram_type(set_typeids[i], F("RC20Set"), false, std::bind(&Thermostat::process_RC20Set, this, _1)); + if (EMSESP::actual_master_thermostat() == 0) { + for (uint8_t i = 0; i < monitor_typeids.size(); i++) { + register_telegram_type(monitor_typeids[i], F("RC20Monitor"), false, [&](std::shared_ptr t) { process_RC20Monitor(t); }); + register_telegram_type(set_typeids[i], F("RC20Set"), false, [&](std::shared_ptr t) { process_RC20Set(t); }); + } + } else { + register_telegram_type(0xAF, F("RC20Remote"), false, [&](std::shared_ptr t) { process_RC20Remote(t); }); } - register_telegram_type(0xAF, F("RC20Remote"), false, std::bind(&Thermostat::process_RC20Remote, this, _1)); - // RC20 newer } else if (flags == EMSdevice::EMS_DEVICE_FLAG_RC20_2) { monitor_typeids = {0xAE}; set_typeids = {0xAD}; - for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC20Monitor"), false, std::bind(&Thermostat::process_RC20Monitor_2, this, _1)); - register_telegram_type(set_typeids[i], F("RC20Set"), false, std::bind(&Thermostat::process_RC20Set_2, this, _1)); + if (EMSESP::actual_master_thermostat() == 0) { + for (uint8_t i = 0; i < monitor_typeids.size(); i++) { + register_telegram_type(monitor_typeids[i], F("RC20Monitor"), false, [&](std::shared_ptr t) { process_RC20Monitor_2(t); }); + register_telegram_type(set_typeids[i], F("RC20Set"), false, [&](std::shared_ptr t) { process_RC20Set_2(t); }); + } + } else { + register_telegram_type(0xAF, F("RC20Remote"), false, [&](std::shared_ptr t) { process_RC20Remote(t); }); } - register_telegram_type(0xAF, F("RC20Remote"), false, std::bind(&Thermostat::process_RC20Remote, this, _1)); - // RC30 } else if (flags == EMSdevice::EMS_DEVICE_FLAG_RC30) { monitor_typeids = {0x41}; set_typeids = {0xA7}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC30Monitor"), false, std::bind(&Thermostat::process_RC30Monitor, this, _1)); - register_telegram_type(set_typeids[i], F("RC30Set"), false, std::bind(&Thermostat::process_RC30Set, this, _1)); + register_telegram_type(monitor_typeids[i], F("RC30Monitor"), false, [&](std::shared_ptr t) { process_RC30Monitor(t); }); + register_telegram_type(set_typeids[i], F("RC30Set"), false, [&](std::shared_ptr t) { process_RC30Set(t); }); } // EASY } else if (flags == EMSdevice::EMS_DEVICE_FLAG_EASY) { monitor_typeids = {0x0A}; set_typeids = {}; - register_telegram_type(monitor_typeids[0], F("EasyMonitor"), false, std::bind(&Thermostat::process_EasyMonitor, this, _1)); + register_telegram_type(monitor_typeids[0], F("EasyMonitor"), false, [&](std::shared_ptr t) { process_EasyMonitor(t); }); // RC300/RC100 } else if ((flags == EMSdevice::EMS_DEVICE_FLAG_RC300) || (flags == EMSdevice::EMS_DEVICE_FLAG_RC100)) { monitor_typeids = {0x02A5, 0x02A6, 0x02A7, 0x02A8}; set_typeids = {0x02B9, 0x02BA, 0x02BB, 0x02BC}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC300Monitor"), false, std::bind(&Thermostat::process_RC300Monitor, this, _1)); - register_telegram_type(set_typeids[i], F("RC300Set"), false, std::bind(&Thermostat::process_RC300Set, this, _1)); + register_telegram_type(monitor_typeids[i], F("RC300Monitor"), false, [&](std::shared_ptr t) { process_RC300Monitor(t); }); + register_telegram_type(set_typeids[i], F("RC300Set"), false, [&](std::shared_ptr t) { process_RC300Set(t); }); } - register_telegram_type(0x31D, F("RC300WWmode"), false, std::bind(&Thermostat::process_RC300WWmode, this, _1)); - register_telegram_type(0x31E, F("RC300WWmode"), false, std::bind(&Thermostat::process_RC300WWmode, this, _1)); + register_telegram_type(0x31D, F("RC300WWmode"), false, [&](std::shared_ptr t) { process_RC300WWmode(t); }); + register_telegram_type(0x31E, F("RC300WWmode"), false, [&](std::shared_ptr t) { process_RC300WWmode(t); }); // JUNKERS/HT3 } else if (flags == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) { monitor_typeids = {0x016F, 0x0170, 0x0171, 0x0172}; set_typeids = {0x0165, 0x0166, 0x0167, 0x0168}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("JunkersMonitor"), false, std::bind(&Thermostat::process_JunkersMonitor, this, _1)); - register_telegram_type(set_typeids[i], F("JunkersSet"), false, std::bind(&Thermostat::process_JunkersSet, this, _1)); + register_telegram_type(monitor_typeids[i], F("JunkersMonitor"), false, [&](std::shared_ptr t) { process_JunkersMonitor(t); }); + register_telegram_type(set_typeids[i], F("JunkersSet"), false, [&](std::shared_ptr t) { process_JunkersSet(t); }); } } else if (flags == (EMSdevice::EMS_DEVICE_FLAG_JUNKERS | EMSdevice::EMS_DEVICE_FLAG_JUNKERS_2)) { monitor_typeids = {0x016F, 0x0170, 0x0171, 0x0172}; set_typeids = {0x0179, 0x017A, 0x017B, 0x017C}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("JunkersMonitor"), false, std::bind(&Thermostat::process_JunkersMonitor, this, _1)); - register_telegram_type(set_typeids[i], F("JunkersSet"), false, std::bind(&Thermostat::process_JunkersSet, this, _1)); + register_telegram_type(monitor_typeids[i], F("JunkersMonitor"), false, [&](std::shared_ptr t) { process_JunkersMonitor(t); }); + register_telegram_type(set_typeids[i], F("JunkersSet"), false, [&](std::shared_ptr t) { process_JunkersSet2(t); }); } } @@ -138,34 +134,30 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i uint8_t actual_master_thermostat = EMSESP::actual_master_thermostat(); // what we're actually using uint8_t num_devices = EMSESP::count_devices(EMSdevice::DeviceType::THERMOSTAT) + 1; // including this thermostat - // if we're on auto mode, register this thermostat if it has a device id of 0x10 or 0x17 + // if we're on auto mode, register this thermostat if it has a device id of 0x10, 0x17 or 0x18 // or if its the master thermostat we defined // see https://github.com/proddy/EMS-ESP/issues/362#issuecomment-629628161 if (((num_devices == 1) && (actual_master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT)) || (master_thermostat == device_id)) { EMSESP::actual_master_thermostat(device_id); - LOG_DEBUG(F("Registering new thermostat with device ID 0x%02X (as master)"), device_id); - init_mqtt(); + LOG_DEBUG(F("Adding new thermostat with device ID 0x%02X (as master)"), device_id); + add_commands(); } else { - LOG_DEBUG(F("Registering new thermostat with device ID 0x%02X"), device_id); + LOG_DEBUG(F("Adding new thermostat with device ID 0x%02X"), device_id); + return; // don't fetch data if more than 1 thermostat } + // reserve some memory for the heating circuits (max 4 to start with) + heating_circuits_.reserve(4); - // for the thermostat, go a query all the heating circuits. This is only done once. The automatic fetch will from now on - // only update the active heating circuits - for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - EMSESP::send_read_request(set_typeids[i], device_id); - } + // only for for the master-thermostat, go a query all the heating circuits. This is only done once. + // The automatic fetch will from now on only update the active heating circuits for (uint8_t i = 0; i < monitor_typeids.size(); i++) { EMSESP::send_read_request(monitor_typeids[i], device_id); } -} -// for the master thermostat initialize the MQTT subscribes -// these will be prefixed with hostname -void Thermostat::init_mqtt() { - register_mqtt_topic("thermostat_cmd", std::bind(&Thermostat::thermostat_cmd, this, _1)); // generic commands - register_mqtt_topic("thermostat_cmd_temp", std::bind(&Thermostat::thermostat_cmd_temp, this, _1)); - register_mqtt_topic("thermostat_cmd_mode", std::bind(&Thermostat::thermostat_cmd_mode, this, _1)); + for (uint8_t i = 0; i < set_typeids.size(); i++) { + EMSESP::send_read_request(set_typeids[i], device_id); + } } // prepare data for Web UI @@ -205,14 +197,18 @@ void Thermostat::device_info(JsonArray & root) { dataElement = root.createNestedObject(); std::string mode_str(15, '\0'); snprintf_P(&mode_str[0], mode_str.capacity() + 1, PSTR("%sMode"), hc_str.c_str()); - dataElement["name"] = mode_str; + dataElement["name"] = mode_str; std::string modetype_str(20, '\0'); if (Helpers::hasValue(hc->summer_mode) && hc->summer_mode) { snprintf_P(&modetype_str[0], modetype_str.capacity() + 1, PSTR("%s - summer"), mode_tostring(hc->get_mode(flags)).c_str()); } else if (Helpers::hasValue(hc->holiday_mode) && hc->holiday_mode) { snprintf_P(&modetype_str[0], modetype_str.capacity() + 1, PSTR("%s - holiday"), mode_tostring(hc->get_mode(flags)).c_str()); } else if (Helpers::hasValue(hc->mode_type)) { - snprintf_P(&modetype_str[0], modetype_str.capacity() + 1, PSTR("%s - %s"), mode_tostring(hc->get_mode(flags)).c_str(), mode_tostring(hc->get_mode_type(flags)).c_str()); + snprintf_P(&modetype_str[0], + modetype_str.capacity() + 1, + PSTR("%s - %s"), + mode_tostring(hc->get_mode(flags)).c_str(), + mode_tostring(hc->get_mode_type(flags)).c_str()); } else { snprintf_P(&modetype_str[0], modetype_str.capacity() + 1, mode_tostring(hc->get_mode(flags)).c_str()); } @@ -221,9 +217,10 @@ void Thermostat::device_info(JsonArray & root) { } } -// only add the menu for the master thermostat +// context menu "thermostat" void Thermostat::add_context_menu() { - if (device_id() != EMSESP::actual_master_thermostat()) { + // only add it once, to prevent conflicts when there are multiple thermostats + if (this->get_device_id() != EMSESP::actual_master_thermostat()) { return; } @@ -232,323 +229,15 @@ void Thermostat::add_context_menu() { flash_string_vector{F_(thermostat)}, [&](Shell & shell, const std::vector & arguments __attribute__((unused))) { Thermostat::console_commands(shell, ShellContext::THERMOSTAT); + add_context_commands(ShellContext::THERMOSTAT); }); } -// general MQTT command for controlling thermostat -// e.g. { "hc": 1, "cmd":"daytemp", "data": 20 } -// or { "hc": 1, "daytemp": 20 } or { "hc2": { "daytemp":20 }} -void Thermostat::thermostat_cmd(const char * message) { - StaticJsonDocument doc; - DeserializationError error = deserializeJson(doc, message); - if (error) { - LOG_DEBUG(F("MQTT error: payload %s, error %s"), message, error.c_str()); - return; - } - - // check for nested commands like {"hc2":{"temp":21}} - for (const auto & hc : heating_circuits_) { - char hc_name[6], s[3]; // hc{1-4} - strlcpy(hc_name, "hc", 6); - uint8_t hc_num = hc->hc_num(); - strlcat(hc_name, Helpers::itoa(s, hc_num), 6); - if (nullptr != doc[hc_name]["mode"]) { - std::string mode = doc[hc_name]["mode"]; - set_mode(mode, hc_num); - } - if (float f = doc[hc_name]["temp"]) { - set_temperature(f, HeatingCircuit::Mode::AUTO, hc_num); - } - if (float f = doc[hc_name]["nighttemp"]) { - set_temperature(f, HeatingCircuit::Mode::NIGHT, hc_num); - } - if (float f = doc[hc_name]["daytemp"]) { - set_temperature(f, HeatingCircuit::Mode::DAY, hc_num); - } - if (float f = doc[hc_name]["nofrosttemp"]) { - set_temperature(f, HeatingCircuit::Mode::NOFROST, hc_num); - } - if (float f = doc[hc_name]["ecotemp"]) { - set_temperature(f, HeatingCircuit::Mode::ECO, hc_num); - } - if (float f = doc[hc_name]["heattemp"]) { - set_temperature(f, HeatingCircuit::Mode::HEAT, hc_num); - } - if (float f = doc[hc_name]["summertemp"]) { - set_temperature(f, HeatingCircuit::Mode::SUMMER, hc_num); - } - if (float f = doc[hc_name]["designtemp"]) { - set_temperature(f, HeatingCircuit::Mode::DESIGN, hc_num); - } - if (float f = doc[hc_name]["offsettemp"]) { - set_temperature(f, HeatingCircuit::Mode::OFFSET, hc_num); - } - if (float f = doc[hc_name]["holidaytemp"]) { // - set_temperature(f, HeatingCircuit::Mode::HOLIDAY, hc_num); - } - if (float f = doc[hc_name]["remotetemp"]) { - if (f > 100 || f < 0) { - Roomctrl::set_remotetemp(hc_num - 1, EMS_VALUE_SHORT_NOTSET); - } else { - Roomctrl::set_remotetemp(hc_num - 1, (int16_t)(f * 10)); - } - } - if (nullptr != doc[hc_name]["control"]) { - uint8_t ctrl = doc[hc_name]["control"]; - set_control(ctrl, hc_num); - } - if (nullptr != doc[hc_name]["pause"]) { - uint8_t p = doc[hc_name]["pause"]; - set_pause(p, hc_num); - } - if (nullptr != doc[hc_name]["party"]) { - uint8_t p = doc[hc_name]["party"]; - set_party(p, hc_num); - } - if (nullptr != doc[hc_name]["holiday"]) { - std::string holiday = doc[hc_name]["holiday"]; - set_holiday(holiday.c_str(), hc_num); - } - } - // commands without heatingcircuit - if (nullptr != doc["wwmode"]) { - std::string mode = doc["wwmode"]; - set_ww_mode(mode); - } - if (float ct = doc["calinttemp"]) { - set_settings_calinttemp((int8_t)(ct * 10)); - } - if (nullptr != doc["minexttemp"]) { - int8_t mt = doc["minexttemp"]; - set_settings_minexttemp(mt); - } - if (nullptr != doc["building"]) { - std::string bds = doc["building"]; - uint8_t bd = doc["building"]; - if (strcmp(bds.c_str(), "light") == 0) { - bd = 0; - } else if (strcmp(bds.c_str(), "medium") == 0) { - bd = 1; - } else if (strcmp(bds.c_str(), "heavy") == 0) { - bd = 2; - } - set_settings_building(bd); - } - if (nullptr != doc["language"]) { - uint8_t lg = doc["language"]; - set_settings_language(lg); - } - if (nullptr != doc["display"]) { - uint8_t dp = doc["display"]; - set_settings_display(dp); - } - if (nullptr != doc["clockoffset"]) { - int8_t co = doc["clockoffset"]; - set_settings_clockoffset(co); - } - - // get heating circuit if it exists - uint8_t hc_num = doc["hc"] | AUTO_HEATING_CIRCUIT; - - // check for unnested commands like {"temp":21} or {"hc":2,"temp":21,"mode":"auto"} - if (nullptr != doc["mode"]) { - std::string mode = doc["mode"]; - set_mode(mode, hc_num); - } - if (float f = doc["temp"]) { - set_temperature(f, HeatingCircuit::Mode::AUTO, hc_num); - } - if (float f = doc["nighttemp"]) { - set_temperature(f, HeatingCircuit::Mode::NIGHT, hc_num); - } - if (float f = doc["daytemp"]) { - set_temperature(f, HeatingCircuit::Mode::DAY, hc_num); - } - if (float f = doc["nofrosttemp"]) { - set_temperature(f, HeatingCircuit::Mode::NOFROST, hc_num); - } - if (float f = doc["ecotemp"]) { - set_temperature(f, HeatingCircuit::Mode::ECO, hc_num); - } - if (float f = doc["heattemp"]) { - set_temperature(f, HeatingCircuit::Mode::HEAT, hc_num); - } - if (float f = doc["summertemp"]) { - set_temperature(f, HeatingCircuit::Mode::SUMMER, hc_num); - } - if (float f = doc["designtemp"]) { - set_temperature(f, HeatingCircuit::Mode::DESIGN, hc_num); - } - if (float f = doc["offsettemp"]) { - set_temperature(f, HeatingCircuit::Mode::OFFSET, hc_num); - } - if (float f = doc["holidaytemp"]) { // - set_temperature(f, HeatingCircuit::Mode::HOLIDAY, hc_num); - } - if (float f = doc["remotetemp"]) { - if (f > 100 || f < 0) { - Roomctrl::set_remotetemp(hc_num - 1, EMS_VALUE_SHORT_NOTSET); - } else { - Roomctrl::set_remotetemp(hc_num - 1, (int16_t)(f * 10)); - } - } - if (nullptr != doc["control"]) { - uint8_t ctrl = doc["control"]; - set_control(ctrl, hc_num); - } - if (nullptr != doc["pause"]) { - uint8_t p = doc["pause"]; - set_pause(p, hc_num); - } - if (nullptr != doc["party"]) { - uint8_t p = doc["party"]; - set_party(p, hc_num); - } - if (nullptr != doc["holiday"]) { - std::string holiday = doc["holiday"]; - set_holiday(holiday.c_str(), hc_num); - } - if (nullptr != doc["date"]) { - std::string date = doc["date"]; - set_datetime(date.c_str()); - } - - // check for commands like {"hc":2,"cmd":"temp","data":21} - const char * command = doc["cmd"]; - if (command == nullptr || doc["data"] == nullptr) { - return; - } - // ok, we have command and data - if (strcmp(command, "temp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::AUTO, hc_num); - } - return; - } - if (strcmp(command, "mode") == 0) { - std::string mode = doc["data"]; - if (mode.empty()) { - return; - } - set_mode(mode, hc_num); - return; - } - if (strcmp(command, "nighttemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::NIGHT, hc_num); - } - return; - } - if (strcmp(command, "daytemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::DAY, hc_num); - } - return; - } - if (strcmp(command, "holidaytemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::HOLIDAY, hc_num); - } - return; - } - if (strcmp(command, "ecotemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::ECO, hc_num); - } - return; - } - if (strcmp(command, "heattemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::HEAT, hc_num); - } - return; - } - if (strcmp(command, "nofrosttemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::NOFROST, hc_num); - } - return; - } - if (strcmp(command, "summertemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::SUMMER, hc_num); - } - return; - } - if (strcmp(command, "designtemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::DESIGN, hc_num); - } - return; - } - if (strcmp(command, "offsettemp") == 0) { - float f = doc["data"]; - if (f) { - set_temperature(f, HeatingCircuit::Mode::OFFSET, hc_num); - } - return; - } - if (strcmp(command, "remotetemp") == 0) { - float f = doc["data"]; - if (f > 100 || f < 0) { - Roomctrl::set_remotetemp(hc_num - 1, EMS_VALUE_SHORT_NOTSET); - } else { - Roomctrl::set_remotetemp(hc_num - 1, (int16_t)(f * 10)); - } - return; - } - if (strcmp(command, "control") == 0) { - uint8_t ctrl = doc["data"]; - set_control(ctrl, hc_num); - return; - } - if (strcmp(command, "pause") == 0) { - uint8_t p = doc["data"]; - set_pause(p, hc_num); - return; - } - if (strcmp(command, "party") == 0) { - uint8_t p = doc["data"]; - set_party(p, hc_num); - return; - } - if (strcmp(command, "holiday") == 0) { - std::string holiday = doc["data"]; - set_holiday(holiday.c_str(), hc_num); - return; - } - if (strcmp(command, "date") == 0) { - std::string date = doc["data"]; - set_datetime(date.c_str()); - return; - } -} - -void Thermostat::thermostat_cmd_temp(const char * message) { - float f = strtof((char *)message, 0); - set_temperature(f, HeatingCircuit::Mode::AUTO, AUTO_HEATING_CIRCUIT); -} - -// message payload holds the text name of the mode e.g. "auto" -void Thermostat::thermostat_cmd_mode(const char * message) { - std::string s(message); - set_mode(s, AUTO_HEATING_CIRCUIT); -} - // this function is called post the telegram handler function has been executed // we check if any of the thermostat values have changed and then republish if necessary bool Thermostat::updated_values() { // only publish on the master thermostat - if (EMSESP::actual_master_thermostat() != device_id()) { + if (EMSESP::actual_master_thermostat() != this->get_device_id()) { return false; } @@ -574,12 +263,10 @@ bool Thermostat::updated_values() { // publish values via MQTT void Thermostat::publish_values() { // only publish on the master thermostat - if (EMSESP::actual_master_thermostat() != device_id()) { + if (EMSESP::actual_master_thermostat() != this->get_device_id()) { return; } - LOG_DEBUG(F("Performing a thermostat publish (device ID 0x%02X)"), device_id()); - uint8_t flags = (this->flags() & 0x0F); // specific thermostat characteristics, stripping the option bits bool has_data = false; @@ -676,15 +363,27 @@ void Thermostat::publish_values() { } if (Helpers::hasValue(hc->daytemp)) { - dataThermostat["daytemp"] = (float)hc->daytemp / 2; + if (flags == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) { + dataThermostat["heattemp"] = (float)hc->daytemp / 2; + } else { + dataThermostat["daytemp"] = (float)hc->daytemp / 2; + } } if (Helpers::hasValue(hc->nighttemp)) { - dataThermostat["nighttemp"] = (float)hc->nighttemp / 2; + if (flags == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) { + dataThermostat["ecotemp"] = (float)hc->nighttemp / 2; + } else { + dataThermostat["nighttemp"] = (float)hc->nighttemp / 2; + } } if (Helpers::hasValue(hc->holidaytemp)) { dataThermostat["holidaytemp"] = (float)hc->holidaytemp / 2; } + if (Helpers::hasValue(hc->nofrosttemp)) { + dataThermostat["nofrosttemp"] = (float)hc->nofrosttemp / 2; + } + if (Helpers::hasValue(hc->heatingtype)) { dataThermostat["heatingtype"] = hc->heatingtype; } @@ -761,12 +460,14 @@ void Thermostat::publish_values() { // returns the heating circuit object based on the hc number // of nullptr if it doesn't exist yet std::shared_ptr Thermostat::heating_circuit(const uint8_t hc_num) { + // if hc_num is 0 then return the first existing hc in the list if (hc_num == 0) { - // return first existing hc for (const auto & heating_circuit : heating_circuits_) { return heating_circuit; } } + + // otherwise find a match for (const auto & heating_circuit : heating_circuits_) { if (heating_circuit->hc_num() == hc_num) { return heating_circuit; @@ -821,7 +522,8 @@ std::shared_ptr Thermostat::heating_circuit(std::sha } // create a new heating circuit object - heating_circuits_.emplace_back(new HeatingCircuit(hc_num, monitor_typeids[hc_num - 1], set_typeids[hc_num - 1])); + auto new_hc = std::make_shared(hc_num, monitor_typeids[hc_num - 1], set_typeids[hc_num - 1]); + heating_circuits_.push_back(new_hc); std::sort(heating_circuits_.begin(), heating_circuits_.end()); // sort based on hc number @@ -888,9 +590,9 @@ void Thermostat::register_mqtt_ha_config(uint8_t hc_num) { // subscribe to the temp and mode commands snprintf_P(&topic[0], topic.capacity() + 1, PSTR("homeassistant/climate/ems-esp/hc%d/cmd_temp"), hc_num); - register_mqtt_topic(topic, std::bind(&Thermostat::thermostat_cmd_temp, this, _1)); + register_mqtt_topic(topic, [&](const char * m) { thermostat_cmd_temp(m); }); snprintf_P(&topic[0], topic.capacity() + 1, PSTR("homeassistant/climate/ems-esp/hc%d/cmd_mode"), hc_num); - register_mqtt_topic(topic, std::bind(&Thermostat::thermostat_cmd_mode, this, _1)); + register_mqtt_topic(topic, [&](const char * m) { thermostat_cmd_mode(m); }); } // decodes the thermostat mode for the heating circuit based on the thermostat type @@ -971,7 +673,7 @@ uint8_t Thermostat::HeatingCircuit::get_mode_type(uint8_t flags) const { // decodes the thermostat mode based on the thermostat type // works with both modes and mode_types -std::string Thermostat::mode_tostring(uint8_t mode) const { +std::string Thermostat::mode_tostring(uint8_t mode) { switch (mode) { case HeatingCircuit::Mode::OFF: return read_flash_string(F("off")); @@ -1140,10 +842,21 @@ void Thermostat::show_values(uuid::console::Shell & shell) { } if (Helpers::hasValue(hc->daytemp)) { - print_value(shell, 4, F("Day temperature"), hc->daytemp, F_(degrees), 2); + if (flags == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) { + print_value(shell, 4, F("Heat temperature"), hc->daytemp, F_(degrees), 2); + } else { + print_value(shell, 4, F("Day temperature"), hc->daytemp, F_(degrees), 2); + } } if (Helpers::hasValue(hc->nighttemp)) { - print_value(shell, 4, F("Night temperature"), hc->nighttemp, F_(degrees), 2); + if (flags == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) { + print_value(shell, 4, F("Eco temperature"), hc->nighttemp, F_(degrees), 2); + } else { + print_value(shell, 4, F("Night temperature"), hc->nighttemp, F_(degrees), 2); + } + } + if (Helpers::hasValue(hc->nofrosttemp)) { + print_value(shell, 4, F("Nofrost temperature"), hc->nofrosttemp, F_(degrees), 2); } if (Helpers::hasValue(hc->holidaytemp)) { print_value(shell, 4, F("Holiday temperature"), hc->holidaytemp, F_(degrees), 2); @@ -1161,6 +874,8 @@ void Thermostat::show_values(uuid::console::Shell & shell) { print_value(shell, 4, F("Target flow temperature"), hc->targetflowtemp, F_(degrees)); } } + + shell.println(); } // 0xA8 - for reading the mode from the RC20 thermostat (0x17) @@ -1208,14 +923,23 @@ void Thermostat::process_RC10Monitor(std::shared_ptr telegram) { void Thermostat::process_RC10Set(std::shared_ptr telegram) { // mode not implemented yet } - -// not sure about this one yet -// data comes in but i don't think we need to process it as its covered in the Monitor type_id? -void Thermostat::process_JunkersSet(std::shared_ptr telegram) { -} - #pragma GCC diagnostic pop +// type 0x0165, ff +void Thermostat::process_JunkersSet(std::shared_ptr telegram) { + std::shared_ptr hc = heating_circuit(telegram); + telegram->read_value(hc->daytemp, 17); // is * 2 + telegram->read_value(hc->nighttemp, 16); // is * 2 + telegram->read_value(hc->nofrosttemp, 15); // is * 2 +} +// type 0x0179, ff +void Thermostat::process_JunkersSet2(std::shared_ptr telegram) { + std::shared_ptr hc = heating_circuit(telegram); + telegram->read_value(hc->daytemp, 7); // is * 2 + telegram->read_value(hc->nighttemp, 6); // is * 2 + telegram->read_value(hc->nofrosttemp, 5); // is * 2 +} + // type 0xA3 - for external temp settings from the the RC* thermostats (e.g. RC35) void Thermostat::process_RCOutdoorTemp(std::shared_ptr telegram) { telegram->read_value(dampedoutdoortemp_, 0); @@ -1360,8 +1084,7 @@ void Thermostat::process_RC35Monitor(std::shared_ptr telegram) { // type 0x3D (HC1), 0x47 (HC2), 0x51 (HC3), 0x5B (HC4) - Working Mode Heating - for reading the mode from the RC35 thermostat (0x10) void Thermostat::process_RC35Set(std::shared_ptr telegram) { - // check to see we have a valid type - // heating: 1 radiator, 2 convectors, 3 floors, 4 room supply + // check to see we have a valid type. heating: 1 radiator, 2 convectors, 3 floors, 4 room supply if (telegram->message_data[0] == 0x00) { return; } @@ -1382,14 +1105,14 @@ void Thermostat::process_RC35Set(std::shared_ptr telegram) { // process_RCTime - type 0x06 - date and time from a thermostat - 14 bytes long void Thermostat::process_RCTime(std::shared_ptr telegram) { - if (flags() == EMS_DEVICE_FLAG_EASY) { + if (this->flags() == EMS_DEVICE_FLAG_EASY) { return; // not supported } if (telegram->message_length < 7) { return; } if (telegram->message_data[7] & 0x0C) { // date and time not valid - set_datetime("NTP"); // set from NTP + set_datetime("ntp", -1); // set from NTP return; } if (datetime_.empty()) { @@ -1415,93 +1138,211 @@ void Thermostat::process_RCTime(std::shared_ptr telegram) { ); } +// add console commands +void Thermostat::console_commands(Shell & shell, unsigned int context) { + EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, + CommandFlags::ADMIN, + flash_string_vector{F_(set), F_(master)}, + flash_string_vector{F_(deviceid_optional)}, + [](Shell & shell, const std::vector & arguments) { + uint8_t value; + if (arguments.empty()) { + value = EMSESP_DEFAULT_MASTER_THERMOSTAT; + } else { + value = Helpers::hextoint(arguments.front().c_str()); + } + + EMSESP::emsespSettingsService.update( + [&](EMSESPSettings & settings) { + settings.master_thermostat = value; + EMSESP::actual_master_thermostat(value); // set the internal value too + char buffer[5]; + shell.printfln(F_(master_thermostat_fmt), + !value ? uuid::read_flash_string(F_(auto)).c_str() : Helpers::hextoa(buffer, value)); + return StateUpdateResult::CHANGED; + }, + "local"); + }); + + EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, + CommandFlags::ADMIN, + flash_string_vector{F_(read)}, + flash_string_vector{F_(typeid_mandatory)}, + [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { + uint16_t type_id = Helpers::hextoint(arguments.front().c_str()); + EMSESP::set_read_id(type_id); + EMSESP::send_read_request(type_id, this->get_device_id()); + }); + + EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, + CommandFlags::USER, + flash_string_vector{F_(show)}, + [&](Shell & shell, const std::vector & arguments __attribute__((unused))) { show_values(shell); }); + + EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, + CommandFlags::USER, + flash_string_vector{F_(set)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { + EMSESP::emsespSettingsService.read([&](EMSESPSettings & settings) { + char buffer[4]; + shell.printfln(F_(master_thermostat_fmt), + settings.master_thermostat == 0 ? uuid::read_flash_string(F_(auto)).c_str() + : Helpers::hextoa(buffer, settings.master_thermostat)); + shell.println(); + }); + }); + + // enter the context + Console::enter_custom_context(shell, context); +} + // 0xA5 - Set minimum external temperature -void Thermostat::set_settings_minexttemp(const int8_t mt) { - if (((flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) || ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC35)) { - LOG_INFO(F("Setting min external temperature to %d"), mt); - write_command(EMS_TYPE_IBASettings, 5, mt); +void Thermostat::set_minexttemp(const char * value, const int8_t id) { + int mt = 0; + if (!Helpers::value2number(value, mt)) { + return; } + LOG_INFO(F("Setting min external temperature to %d"), mt); + write_command(EMS_TYPE_IBASettings, 5, mt); } // 0xA5 - Clock offset -void Thermostat::set_settings_clockoffset(const int8_t co) { - if ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) { - LOG_INFO(F("Setting clock offset to %d"), co); - write_command(EMS_TYPE_IBASettings, 12, co); +void Thermostat::set_clockoffset(const char * value, const int8_t id) { + int co = 0; + if (!Helpers::value2number(value, co)) { + return; } + LOG_INFO(F("Setting clock offset to %d"), co); + write_command(EMS_TYPE_IBASettings, 12, co); } + // 0xA5 - Calibrate internal temperature -void Thermostat::set_settings_calinttemp(const int8_t ct) { - if (((flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) || ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC35)) { - LOG_INFO(F("Calibrating internal temperature to %d.%d"), ct / 10, ct < 0 ? -ct % 10 : ct % 10); - write_command(EMS_TYPE_IBASettings, 2, ct); +void Thermostat::set_calinttemp(const char * value, const int8_t id) { + int ct = 0; + if (!Helpers::value2number(value, ct)) { + return; } + // does this value need to be multiple by 10? + LOG_INFO(F("Calibrating internal temperature to %d.%d"), ct / 10, ct < 0 ? -ct % 10 : ct % 10); + write_command(EMS_TYPE_IBASettings, 2, ct); } // 0xA5 - Set the display settings -void Thermostat::set_settings_display(const uint8_t ds) { - if ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) { - LOG_INFO(F("Setting display to %d"), ds); - write_command(EMS_TYPE_IBASettings, 0, ds); +void Thermostat::set_display(const char * value, const int8_t id) { + int ds = 0; + if (!Helpers::value2number(value, ds)) { + return; + } + LOG_INFO(F("Setting display to %d"), ds); + write_command(EMS_TYPE_IBASettings, 0, ds); +} + +void Thermostat::set_remotetemp(const char * value, const int8_t id) { + float f = 0; + if (!Helpers::value2float(value, f)) { + return; + } + + uint8_t hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id; + + if (f > 100 || f < 0) { + Roomctrl::set_remotetemp(hc_num - 1, EMS_VALUE_SHORT_NOTSET); + } else { + Roomctrl::set_remotetemp(hc_num - 1, (int16_t)(f * 10)); } } // 0xA5 - Set the building settings -void Thermostat::set_settings_building(const uint8_t bg) { - if (((flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) || ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC35)) { - LOG_INFO(F("Setting building to %d"), bg); - write_command(EMS_TYPE_IBASettings, 6, bg); +void Thermostat::set_building(const char * value, const int8_t id) { + std::string bd(20, '\0'); + if (!Helpers::value2string(value, bd)) { + return; } + + uint8_t bg = 0; + if (bd == "light") { + bg = 0; + } else if (bd == "medium") { + bg = 1; + } else if (bd == "heavy") { + bg = 2; + } else { + return; // invalid + } + + LOG_INFO(F("Setting building to %d"), bg); + write_command(EMS_TYPE_wwSettings, 6, bg); } // 0xA5 Set the language settings -void Thermostat::set_settings_language(const uint8_t lg) { - if ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) { - LOG_INFO(F("Setting language to %d"), lg); - write_command(EMS_TYPE_IBASettings, 1, lg); +void Thermostat::set_language(const char * value, const int8_t id) { + int lg = 0; + if (!Helpers::value2number(value, lg)) { + return; } + LOG_INFO(F("Setting language to %d"), lg); + write_command(EMS_TYPE_wwSettings, 1, lg); } // Set the control-mode for hc 0-off, 1-RC20, 2-RC3x -void Thermostat::set_control(const uint8_t ctrl, const uint8_t hc_num) { +void Thermostat::set_control(const char * value, const int8_t id) { + int ctrl = 0; + if (!Helpers::value2number(value, ctrl)) { + return; + } + + uint8_t hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id; + std::shared_ptr hc = heating_circuit(hc_num); if (hc == nullptr) { LOG_WARNING(F("Set control: Heating Circuit %d not found or activated"), hc_num); return; } + if (ctrl > 2) { LOG_WARNING(F("Set control: Invalid control mode: %d"), ctrl); return; } - if ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC35 || (flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) { - LOG_INFO(F("Setting circuit-control for hc%d to %d"), hc_num, ctrl); - write_command(set_typeids[hc->hc_num() - 1], 26, ctrl); - } else { - LOG_INFO(F("Set circuit-control not supported")); - } + + LOG_INFO(F("Setting circuit-control for hc%d to %d"), hc_num, ctrl); + write_command(set_typeids[hc->hc_num() - 1], 26, ctrl); } // sets the thermostat ww working mode, where mode is a string -void Thermostat::set_ww_mode(const std::string & mode) { - if (strcasecmp("off", mode.c_str()) == 0) { - LOG_INFO(F("Setting thermostat warm water mode to %s"), mode.c_str()); - write_command(EMS_TYPE_wwSettings, 2, 0); - } else if (strcasecmp("on", mode.c_str()) == 0) { - LOG_INFO(F("Setting thermostat warm water mode to %s"), mode.c_str()); - write_command(EMS_TYPE_wwSettings, 2, 1); - } else if (strcasecmp("auto", mode.c_str()) == 0) { - LOG_INFO(F("Setting thermostat warm water mode to %s"), mode.c_str()); - write_command(EMS_TYPE_wwSettings, 2, 2); +void Thermostat::set_wwmode(const char * value, const int8_t id) { + std::string v(10, '\0'); + if (!Helpers::value2string(value, v)) { + return; + } + + uint8_t set = 0xFF; // some dummy value + if (v == "off") { + set = 0; + } else if (v == "on") { + set = 1; + } else if (v == "auto") { + set = 2; + } + + if (set != 0xFF) { + LOG_INFO(F("Setting thermostat warm water mode to %s"), v.c_str()); + write_command(EMS_TYPE_wwSettings, 2, set); } else { - LOG_WARNING(F("Set thermostat warm water mode: Invalid mode: %s"), mode.c_str()); + LOG_WARNING(F("Set thermostat warm water mode: Invalid mode: %s"), v.c_str()); } } // set the holiday as string dd.mm.yyyy-dd.mm.yyyy -void Thermostat::set_holiday(const char * hd, const uint8_t hc_num) { +void Thermostat::set_holiday(const char * value, const int8_t id) { + std::string hd(30, '\0'); + if (!Helpers::value2string(value, hd)) { + return; + } + uint8_t hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id; + std::shared_ptr hc = heating_circuit(hc_num); if (hc == nullptr) { - LOG_WARNING(F("Set holiday: Heating Circuit %d not found or activated for device ID 0x%02X"), hc_num, device_id()); + LOG_WARNING(F("Set holiday: Heating Circuit %d not found or activated for device ID 0x%02X"), hc_num, this->get_device_id()); return; } uint8_t data[6]; @@ -1511,51 +1352,58 @@ void Thermostat::set_holiday(const char * hd, const uint8_t hc_num) { data[3] = (hd[11] - '0') * 10 + (hd[11] - '0'); data[4] = (hd[14] - '0') * 10 + (hd[15] - '0'); data[5] = (hd[18] - '0') * 100 + (hd[19] - '0') * 10 + (hd[20] - '0'); - if ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC35 || (flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) { - LOG_INFO(F("Setting holiday for hc %d"), hc->hc_num()); - write_command(timer_typeids[hc->hc_num() - 1], 87, data, 6, 0); - } else { - LOG_INFO(F("Set holiday not supported")); - } + + LOG_INFO(F("Setting holiday for hc %d"), hc->hc_num()); + write_command(timer_typeids[hc->hc_num() - 1], 87, data, 6, 0); } // set pause in hours -void Thermostat::set_pause(const uint8_t hrs, const uint8_t hc_num) { - std::shared_ptr hc = heating_circuit(hc_num); - if (hc == nullptr) { - LOG_WARNING(F("Set pause: Heating Circuit %d not found or activated for device ID 0x%02X"), hc_num, device_id()); +void Thermostat::set_pause(const char * value, const int8_t id) { + int hrs = 0; + if (!Helpers::value2number(value, hrs)) { return; } - if ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC35 || (flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) { - LOG_INFO(F("Setting pause: %d hours, hc: %d"), hrs, hc->hc_num()); - write_command(timer_typeids[hc->hc_num() - 1], 85, hrs); - } else { - LOG_INFO(F("Set pause not supported")); + uint8_t hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id; + + std::shared_ptr hc = heating_circuit(hc_num); + if (hc == nullptr) { + LOG_WARNING(F("Set pause: Heating Circuit %d not found or activated for device ID 0x%02X"), hc_num, this->get_device_id()); + return; } + LOG_INFO(F("Setting pause: %d hours, hc: %d"), hrs, hc->hc_num()); + write_command(timer_typeids[hc->hc_num() - 1], 85, hrs); } // set partymode in hours -void Thermostat::set_party(const uint8_t hrs, const uint8_t hc_num) { - std::shared_ptr hc = heating_circuit(hc_num); - if (hc == nullptr) { - LOG_WARNING(F("Set party: Heating Circuit %d not found or activated for device ID 0x%02X"), hc_num, device_id()); +void Thermostat::set_party(const char * value, const int8_t id) { + int hrs = 0; + if (!Helpers::value2number(value, hrs)) { return; } - if ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC35 || (flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) { - LOG_INFO(F("Setting party: %d hours, hc: %d"), hrs, hc->hc_num()); - write_command(timer_typeids[hc->hc_num() - 1], 86, hrs); - } else { - LOG_INFO(F("Set party not supported")); + uint8_t hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id; + + std::shared_ptr hc = heating_circuit(hc_num); + if (hc == nullptr) { + LOG_WARNING(F("Set party: Heating Circuit %d not found or activated for device ID 0x%02X"), hc_num, this->get_device_id()); + return; } + LOG_INFO(F("Setting party: %d hours, hc: %d"), hrs, hc->hc_num()); + write_command(timer_typeids[hc->hc_num() - 1], 86, hrs); } // set date&time as string hh:mm:ss-dd.mm.yyyy-dw-dst or "NTP" for setting to internet-time // dw - day of week (0..6), dst- summertime (0/1) -void Thermostat::set_datetime(const char * dt) { +// id is ignored +void Thermostat::set_datetime(const char * value, const int8_t id) { + std::string dt(30, '\0'); + if (!Helpers::value2string(value, dt)) { + return; + } + uint8_t data[9]; - if (strcmp(dt,"NTP") == 0) { - time_t now = time(nullptr); - tm * tm_ = localtime(&now); + if (dt == "ntp") { + time_t now = time(nullptr); + tm * tm_ = localtime(&now); if (tm_->tm_year < 110) { // no NTP time LOG_WARNING(F("No NTP time. Cannot set RCtime")); return; @@ -1581,48 +1429,48 @@ void Thermostat::set_datetime(const char * dt) { data[6] = (dt[20] - '0'); // day of week data[7] = (dt[22] - '0') + 2; // DST and flag } - if ((flags() & 0x0F) == EMS_DEVICE_FLAG_RC35 || (flags() & 0x0F) == EMS_DEVICE_FLAG_RC30_1) { - LOG_INFO(F("Setting date and time")); - write_command(6, 0, data, 8, 0); - } else { - LOG_INFO(F("Set date not supported")); - } + LOG_INFO(F("Setting date and time")); + write_command(EMS_TYPE_time, 0, data, 8, 0); } // sets the thermostat working mode, where mode is a string -void Thermostat::set_mode(const std::string & mode, const uint8_t hc_num) { +// converts string mode to HeatingCircuit::Mode +void Thermostat::set_mode(const char * value, const int8_t id) { + std::string mode(10, '\0'); + if (!Helpers::value2string(value, mode)) { + return; + } + + uint8_t hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id; + if (mode_tostring(HeatingCircuit::Mode::OFF) == mode) { - set_mode(HeatingCircuit::Mode::OFF, hc_num); + set_mode_n(HeatingCircuit::Mode::OFF, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::MANUAL) == mode) { - set_mode(HeatingCircuit::Mode::MANUAL, hc_num); + set_mode_n(HeatingCircuit::Mode::MANUAL, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::AUTO) == mode) { - set_mode(HeatingCircuit::Mode::AUTO, hc_num); + set_mode_n(HeatingCircuit::Mode::AUTO, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::DAY) == mode) { - set_mode(HeatingCircuit::Mode::DAY, hc_num); + set_mode_n(HeatingCircuit::Mode::DAY, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::NIGHT) == mode) { - set_mode(HeatingCircuit::Mode::NIGHT, hc_num); + set_mode_n(HeatingCircuit::Mode::NIGHT, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::HEAT) == mode) { - set_mode(HeatingCircuit::Mode::HEAT, hc_num); + set_mode_n(HeatingCircuit::Mode::HEAT, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::NOFROST) == mode) { - set_mode(HeatingCircuit::Mode::NOFROST, hc_num); + set_mode_n(HeatingCircuit::Mode::NOFROST, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::ECO) == mode) { - set_mode(HeatingCircuit::Mode::ECO, hc_num); + set_mode_n(HeatingCircuit::Mode::ECO, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::HOLIDAY) == mode) { - set_mode(HeatingCircuit::Mode::HOLIDAY, hc_num); + set_mode_n(HeatingCircuit::Mode::HOLIDAY, hc_num); } else if (mode_tostring(HeatingCircuit::Mode::COMFORT) == mode) { - set_mode(HeatingCircuit::Mode::COMFORT, hc_num); + set_mode_n(HeatingCircuit::Mode::COMFORT, hc_num); } else { LOG_WARNING(F("Invalid mode %s. Cannot set"), mode.c_str()); } } // Set the thermostat working mode -void Thermostat::set_mode(const uint8_t mode, const uint8_t hc_num) { - if (can_write()) { - LOG_WARNING(F("Write not supported for this model Thermostat")); - return; - } - +// mode is HeatingCircuit::Mode +void Thermostat::set_mode_n(const uint8_t mode, const uint8_t hc_num) { // get hc based on number std::shared_ptr hc = heating_circuit(hc_num); if (hc == nullptr) { @@ -1655,7 +1503,7 @@ void Thermostat::set_mode(const uint8_t mode, const uint8_t hc_num) { break; } - switch (flags() & 0x0F) { + switch (this->flags() & 0x0F) { case EMSdevice::EMS_DEVICE_FLAG_RC20: offset = EMS_OFFSET_RC20Set_mode; validate_typeid = set_typeids[hc_p]; @@ -1684,7 +1532,7 @@ void Thermostat::set_mode(const uint8_t mode, const uint8_t hc_num) { } break; case EMSdevice::EMS_DEVICE_FLAG_JUNKERS: - if ((flags() & EMS_DEVICE_FLAG_JUNKERS_2) == EMS_DEVICE_FLAG_JUNKERS_2) { + if ((this->flags() & EMS_DEVICE_FLAG_JUNKERS_2) == EMS_DEVICE_FLAG_JUNKERS_2) { offset = EMS_OFFSET_JunkersSetMessage2_set_mode; } else { offset = EMS_OFFSET_JunkersSetMessage_set_mode; @@ -1709,6 +1557,7 @@ void Thermostat::set_mode(const uint8_t mode, const uint8_t hc_num) { // add the write command to the Tx queue // post validate is the corresponding monitor or set type IDs as they can differ per model + // write_command(set_typeids[hc->hc_num() - 1], offset, set_mode_value, validate_typeid); write_command(set_typeids[hc->hc_num() - 1], offset, set_mode_value, validate_typeid); } @@ -1742,20 +1591,16 @@ void Thermostat::set_temperature(const float temperature, const std::string & mo } // Set the temperature of the thermostat +// the id passed into this function is the heating circuit number void Thermostat::set_temperature(const float temperature, const uint8_t mode, const uint8_t hc_num) { - if (can_write()) { - LOG_WARNING(F("Write not supported for this model Thermostat")); - return; - } - // get hc based on number std::shared_ptr hc = heating_circuit(hc_num); if (hc == nullptr) { - LOG_WARNING(F("Set temperature: Heating Circuit %d not found or activated for device ID 0x%02X"), hc_num, device_id()); + LOG_WARNING(F("Set temperature: Heating Circuit %d not found or activated for device ID 0x%02X"), hc_num, this->get_device_id()); return; } - uint8_t model = flags() & 0x0F; + uint8_t model = this->flags() & 0x0F; int8_t offset = -1; // we use -1 to check if there is a value uint8_t factor = 2; // some temperatures only use 1 uint16_t validate_typeid = monitor_typeids[hc->hc_num() - 1]; @@ -1819,7 +1664,7 @@ void Thermostat::set_temperature(const float temperature, const uint8_t mode, co default: case HeatingCircuit::Mode::AUTO: // automatic selection, if no type is defined, we use the standard code if (model == EMS_DEVICE_FLAG_RC35) { - uint8_t mode_ = hc->get_mode(flags()); + uint8_t mode_ = hc->get_mode(this->flags()); if (mode_ == HeatingCircuit::Mode::NIGHT) { offset = EMS_OFFSET_RC35Set_temp_night; } else if (mode_ == HeatingCircuit::Mode::DAY) { @@ -1828,7 +1673,7 @@ void Thermostat::set_temperature(const float temperature, const uint8_t mode, co offset = EMS_OFFSET_RC35Set_seltemp; // https://github.com/proddy/EMS-ESP/issues/310 } } else { - uint8_t mode_type = hc->get_mode_type(flags()); + uint8_t mode_type = hc->get_mode_type(this->flags()); offset = (mode_type == HeatingCircuit::Mode::NIGHT) ? EMS_OFFSET_RC35Set_temp_night : EMS_OFFSET_RC35Set_temp_day; } break; @@ -1837,7 +1682,7 @@ void Thermostat::set_temperature(const float temperature, const uint8_t mode, co } else if (model == EMS_DEVICE_FLAG_JUNKERS) { // figure out if we have older or new thermostats, Heating Circuits on 0x65 or 0x79 // see https://github.com/proddy/EMS-ESP/issues/335#issuecomment-593324716) - bool old_junkers = ((flags() & EMS_DEVICE_FLAG_JUNKERS_2) == EMS_DEVICE_FLAG_JUNKERS_2); + bool old_junkers = ((this->flags() & EMS_DEVICE_FLAG_JUNKERS_2) == EMS_DEVICE_FLAG_JUNKERS_2); if (!old_junkers) { switch (mode) { case HeatingCircuit::Mode::NOFROST: @@ -1853,7 +1698,7 @@ void Thermostat::set_temperature(const float temperature, const uint8_t mode, co break; default: case HeatingCircuit::Mode::AUTO: // automatic selection, if no type is defined, we use the standard code - uint8_t mode_type = hc->get_mode_type(flags()); + uint8_t mode_type = hc->get_mode_type(this->flags()); offset = (mode_type == HeatingCircuit::Mode::NIGHT || mode_type == HeatingCircuit::Mode::ECO) ? EMS_OFFSET_JunkersSetMessage_night_temp : EMS_OFFSET_JunkersSetMessage_day_temp; break; @@ -1886,116 +1731,121 @@ void Thermostat::set_temperature(const float temperature, const uint8_t mode, co hc->hc_num(), mode_tostring(mode).c_str()); - // add the write command to the Tx queue - // value is *2 + // add the write command to the Tx queue. value is *2 // post validate is the corresponding monitor or set type IDs as they can differ per model write_command(set_typeids[hc->hc_num() - 1], offset, (uint8_t)((float)temperature * (float)factor), validate_typeid); } } -// add console commands -void Thermostat::console_commands(Shell & shell, unsigned int context) { - EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, - CommandFlags::ADMIN, - flash_string_vector{F_(set), F_(master)}, - flash_string_vector{F_(deviceid_optional)}, - [](Shell & shell, const std::vector & arguments) { - uint8_t value; - if (arguments.empty()) { - value = EMSESP_DEFAULT_MASTER_THERMOSTAT; - } else { - value = Helpers::hextoint(arguments.front().c_str()); - } - - EMSESP::emsespSettingsService.update( - [&](EMSESPSettings & settings) { - settings.master_thermostat = value; - EMSESP::actual_master_thermostat(value); // set the internal value too - char buffer[5]; - shell.printfln(F_(master_thermostat_fmt), - !value ? uuid::read_flash_string(F_(auto)).c_str() : Helpers::hextoa(buffer, value)); - return StateUpdateResult::CHANGED; - }, - "local"); - }); - - EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, - CommandFlags::ADMIN, - flash_string_vector{F_(read)}, - flash_string_vector{F_(typeid_mandatory)}, - [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { - uint16_t type_id = Helpers::hextoint(arguments.front().c_str()); - EMSESP::send_read_request(type_id, device_id()); - }); - - EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, - CommandFlags::ADMIN, - flash_string_vector{F_(temp)}, - flash_string_vector{F_(degrees_mandatory), F_(hc_optional), F_(mode_optional)}, - [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { - uint8_t hc = (arguments.size() >= 2) ? arguments[1].at(0) - '0' : AUTO_HEATING_CIRCUIT; - if ((arguments.size() == 3)) { - set_temperature(atof(arguments.front().c_str()), arguments.back().c_str(), hc); - } else if (arguments[1].at(0) >= 'A') { - set_temperature(atof(arguments.front().c_str()), arguments.back().c_str(), AUTO_HEATING_CIRCUIT); - } else { - set_temperature(atof(arguments.front().c_str()), HeatingCircuit::Mode::AUTO, hc); - } - }); - - EMSESPShell::commands->add_command( - ShellContext::THERMOSTAT, - CommandFlags::ADMIN, - flash_string_vector{F_(mode)}, - flash_string_vector{F_(mode_mandatory), F_(hc_optional)}, - [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { - uint8_t hc = (arguments.size() == 2) ? arguments[1].at(0) - '0' : AUTO_HEATING_CIRCUIT; - set_mode(arguments.front(), hc); - }, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> const std::vector { - return std::vector{read_flash_string(F("off")), - read_flash_string(F("manual")), - read_flash_string(F("day")), - read_flash_string(F("night")), - read_flash_string(F("eco")), - read_flash_string(F("comfort")), - read_flash_string(F("heat")), - read_flash_string(F("nofrost")), - read_flash_string(F("auto")) - - }; - }); - - EMSESPShell::commands->add_command( - ShellContext::THERMOSTAT, - CommandFlags::ADMIN, - flash_string_vector{F_(wwmode)}, - flash_string_vector{F_(mode_mandatory)}, - [=](Shell & shell __attribute__((unused)), const std::vector & arguments) { set_ww_mode(arguments.front()); }, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> const std::vector { - return std::vector{read_flash_string(F("off")), read_flash_string(F("on")), read_flash_string(F("auto"))}; - }); - - EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, - CommandFlags::USER, - flash_string_vector{F_(show)}, - [&](Shell & shell, const std::vector & arguments __attribute__((unused))) { show_values(shell); }); - - EMSESPShell::commands->add_command(ShellContext::THERMOSTAT, - CommandFlags::USER, - flash_string_vector{F_(set)}, - [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - EMSESP::emsespSettingsService.read([&](EMSESPSettings & settings) { - char buffer[4]; - shell.printfln(F_(master_thermostat_fmt), - settings.master_thermostat == 0 ? uuid::read_flash_string(F_(auto)).c_str() - : Helpers::hextoa(buffer, settings.master_thermostat)); - shell.println(); - }); - }); - - // enter the context - Console::enter_custom_context(shell, context); +// for HA specifically when receiving over MQTT +void Thermostat::thermostat_cmd_temp(const char * message) { + float f = strtof((char *)message, 0); + set_temperature(f, HeatingCircuit::Mode::AUTO, AUTO_HEATING_CIRCUIT); } +// for HA specifically when receiving over MQTT +// message payload holds the text name of the mode e.g. "auto" +void Thermostat::thermostat_cmd_mode(const char * message) { + set_mode(message, AUTO_HEATING_CIRCUIT); +} + +void Thermostat::set_temperature_value(const char * value, const int8_t id, const uint8_t mode) { + float f = 0; + uint8_t hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id; + if (Helpers::value2float(value, f)) { + set_temperature(f, mode, hc_num); + } +} + +void Thermostat::set_temp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::AUTO); +} + +void Thermostat::set_nighttemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::NIGHT); +} + +void Thermostat::set_daytemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::DAY); +} + +void Thermostat::set_nofrosttemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::NOFROST); +} + +void Thermostat::set_ecotemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::ECO); +} + +void Thermostat::set_heattemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::HEAT); +} + +void Thermostat::set_summertemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::SUMMER); +} + +void Thermostat::set_designtemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::DESIGN); +} + +void Thermostat::set_offsettemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::OFFSET); +} + +void Thermostat::set_holidaytemp(const char * value, const int8_t id) { + set_temperature_value(value, id, HeatingCircuit::Mode::HOLIDAY); +} + +// commands for MQTT and Console +void Thermostat::add_commands() { + // if this thermostat doesn't support write, don't add the commands + if ((this->flags() & EMSdevice::EMS_DEVICE_FLAG_NO_WRITE) == EMSdevice::EMS_DEVICE_FLAG_NO_WRITE) { + return; + } + + // common to all thermostats + register_mqtt_cmd(F("wwmode"), [&](const char * value, const int8_t id) { set_wwmode(value, id); }); + register_mqtt_cmd(F("temp"), [&](const char * value, const int8_t id) { set_temp(value, id); }); + register_mqtt_cmd(F("mode"), [&](const char * value, const int8_t id) { set_mode(value, id); }); + + uint8_t model = this->flags() & 0x0F; + switch (model) { + case EMS_DEVICE_FLAG_RC20_2: + register_mqtt_cmd(F("nighttemp"), [&](const char * value, const int8_t id) { set_nighttemp(value, id); }); + register_mqtt_cmd(F("daytemp"), [&](const char * value, const int8_t id) { set_daytemp(value, id); }); + break; + case EMS_DEVICE_FLAG_RC30_1: // only RC30_1 + register_mqtt_cmd(F("clockoffset"), [&](const char * value, const int8_t id) { set_clockoffset(value, id); }); + register_mqtt_cmd(F("language"), [&](const char * value, const int8_t id) { set_language(value, id); }); + register_mqtt_cmd(F("display"), [&](const char * value, const int8_t id) { set_display(value, id); }); + case EMS_DEVICE_FLAG_RC35: // RC30 and RC35 + register_mqtt_cmd(F("nighttemp"), [&](const char * value, const int8_t id) { set_nighttemp(value, id); }); + register_mqtt_cmd(F("daytemp"), [&](const char * value, const int8_t id) { set_daytemp(value, id); }); + register_mqtt_cmd(F("nofrosttemp"), [&](const char * value, const int8_t id) { set_nofrosttemp(value, id); }); + register_mqtt_cmd(F("remotetemp"), [&](const char * value, const int8_t id) { set_remotetemp(value, id); }); + register_mqtt_cmd(F("datetime"), [&](const char * value, const int8_t id) { set_datetime(value, id); }); + register_mqtt_cmd(F("minexttemp"), [&](const char * value, const int8_t id) { set_minexttemp(value, id); }); + register_mqtt_cmd(F("calinttemp"), [&](const char * value, const int8_t id) { set_calinttemp(value, id); }); + register_mqtt_cmd(F("building"), [&](const char * value, const int8_t id) { set_building(value, id); }); + register_mqtt_cmd(F("control"), [&](const char * value, const int8_t id) { set_control(value, id); }); + register_mqtt_cmd(F("pause"), [&](const char * value, const int8_t id) { set_pause(value, id); }); + register_mqtt_cmd(F("party"), [&](const char * value, const int8_t id) { set_party(value, id); }); + register_mqtt_cmd(F("holiday"), [&](const char * value, const int8_t id) { set_holiday(value, id); }); + register_mqtt_cmd(F("summertemp"), [&](const char * value, const int8_t id) { set_summertemp(value, id); }); + register_mqtt_cmd(F("designtemp"), [&](const char * value, const int8_t id) { set_designtemp(value, id); }); + register_mqtt_cmd(F("offsettemp"), [&](const char * value, const int8_t id) { set_offsettemp(value, id); }); + register_mqtt_cmd(F("holidaytemp"), [&](const char * value, const int8_t id) { set_holidaytemp(value, id); }); + break; + case EMS_DEVICE_FLAG_JUNKERS: + register_mqtt_cmd(F("nofrosttemp"), [&](const char * value, const int8_t id) { set_nofrosttemp(value, id); }); + register_mqtt_cmd(F("ecotemp"), [&](const char * value, const int8_t id) { set_ecotemp(value, id); }); + register_mqtt_cmd(F("heattemp"), [&](const char * value, const int8_t id) { set_heattemp(value, id); }); + break; + default: + break; + } +} + + } // namespace emsesp \ No newline at end of file diff --git a/src/devices/thermostat.h b/src/devices/thermostat.h index e0db67f99..d230be079 100644 --- a/src/devices/thermostat.h +++ b/src/devices/thermostat.h @@ -91,7 +91,7 @@ class Thermostat : public EMSdevice { uint16_t set_typeid_; }; - std::string mode_tostring(uint8_t mode) const; + static std::string mode_tostring(uint8_t mode); virtual void show_values(uuid::console::Shell & shell); virtual void publish_values(); @@ -99,21 +99,17 @@ class Thermostat : public EMSdevice { virtual bool updated_values(); virtual void add_context_menu(); - bool can_write() const { - return ((flags() & EMSdevice::EMS_DEVICE_FLAG_NO_WRITE) == EMSdevice::EMS_DEVICE_FLAG_NO_WRITE); - } + private: + static uuid::log::Logger logger_; + + void console_commands(Shell & shell, unsigned int context); + void add_commands(); // each thermostat has a list of heating controller type IDs for reading and writing std::vector monitor_typeids; std::vector set_typeids; std::vector timer_typeids; - private: - static uuid::log::Logger logger_; - - void console_commands(Shell & shell, unsigned int context); - void init_mqtt(); - std::string datetime_; // date and time stamp uint8_t mqtt_format_; // single, nested or ha @@ -210,6 +206,7 @@ class Thermostat : public EMSdevice { // Installation settings static constexpr uint8_t EMS_TYPE_IBASettings = 0xA5; // installation settings static constexpr uint8_t EMS_TYPE_wwSettings = 0x37; // ww settings + static constexpr uint8_t EMS_TYPE_time = 0x06; // time std::shared_ptr heating_circuit(std::shared_ptr telegram); std::shared_ptr heating_circuit(const uint8_t hc_num); @@ -220,55 +217,65 @@ class Thermostat : public EMSdevice { void process_IBASettings(std::shared_ptr telegram); void process_RCTime(std::shared_ptr telegram); void process_RC35wwSettings(std::shared_ptr telegram); - void process_RC35Monitor(std::shared_ptr telegram); void process_RC35Set(std::shared_ptr telegram); - void process_RC30Monitor(std::shared_ptr telegram); void process_RC30Set(std::shared_ptr telegram); - void process_RC20Monitor(std::shared_ptr telegram); void process_RC20Set(std::shared_ptr telegram); void process_RC20Remote(std::shared_ptr telegram); - void process_RC20Monitor_2(std::shared_ptr telegram); void process_RC20Set_2(std::shared_ptr telegram); - void process_RC10Monitor(std::shared_ptr telegram); void process_RC10Set(std::shared_ptr telegram); - void process_RC300Monitor(std::shared_ptr telegram); void process_RC300Set(std::shared_ptr telegram); - void process_JunkersMonitor(std::shared_ptr telegram); void process_JunkersSet(std::shared_ptr telegram); - + void process_JunkersSet2(std::shared_ptr telegram); void process_EasyMonitor(std::shared_ptr telegram); - void process_RC300WWmode(std::shared_ptr telegram); - // set functions - void set_settings_minexttemp(const int8_t mt); - void set_settings_calinttemp(const int8_t ct); - void set_settings_clockoffset(const int8_t co); - void set_settings_display(const uint8_t ds); - void set_settings_building(const uint8_t bg); - void set_settings_language(const uint8_t lg); - void set_control(const uint8_t ctrl, const uint8_t hc_num); - void set_ww_mode(const std::string & mode); - void set_holiday(const char * hd, const uint8_t hc_num); - void set_datetime(const char * dt); - void set_pause(const uint8_t hrs, const uint8_t hc_num); - void set_party(const uint8_t hrs, const uint8_t hc_num); - void set_mode(const uint8_t mode, const uint8_t hc_num); - void set_mode(const std::string & mode, const uint8_t hc_num); + // internal helper functions + void set_mode_n(const uint8_t mode, const uint8_t hc_num); + + void set_temperature_value(const char * value, const int8_t id, const uint8_t mode); void set_temperature(const float temperature, const std::string & mode, const uint8_t hc_num); void set_temperature(const float temperature, const uint8_t mode, const uint8_t hc_num); - // MQTT functions - void thermostat_cmd(const char * message); + // for HA specifically. MQTT functions. void thermostat_cmd_temp(const char * message); void thermostat_cmd_mode(const char * message); + + // set functions - these use the id/hc + void set_mode(const char * value, const int8_t id); + void set_control(const char * value, const int8_t id); + void set_holiday(const char * value, const int8_t id); + void set_pause(const char * value, const int8_t id); + void set_party(const char * value, const int8_t id); + + void set_temp(const char * value, const int8_t id); + void set_nighttemp(const char * value, const int8_t id); + void set_daytemp(const char * value, const int8_t id); + void set_nofrosttemp(const char * value, const int8_t id); + void set_ecotemp(const char * value, const int8_t id); + void set_heattemp(const char * value, const int8_t id); + void set_summertemp(const char * value, const int8_t id); + void set_designtemp(const char * value, const int8_t id); + void set_offsettemp(const char * value, const int8_t id); + void set_holidaytemp(const char * value, const int8_t id); + + void set_remotetemp(const char * value, const int8_t id); + + // set functions - these don't use the id/hc, the parameters are ignored + void set_wwmode(const char * value, const int8_t id); + void set_datetime(const char * value, const int8_t id); + void set_minexttemp(const char * value, const int8_t id); + void set_clockoffset(const char * value, const int8_t id); + void set_calinttemp(const char * value, const int8_t id); + void set_display(const char * value, const int8_t id); + void set_building(const char * value, const int8_t id); + void set_language(const char * value, const int8_t id); }; } // namespace emsesp diff --git a/src/emsdevice.cpp b/src/emsdevice.cpp index 2185b17df..b223e33ba 100644 --- a/src/emsdevice.cpp +++ b/src/emsdevice.cpp @@ -20,11 +20,9 @@ #include "emsesp.h" #include "mqtt.h" // for the mqtt_function_p -MAKE_PSTR(logger_name, "emsdevice") - namespace emsesp { -uuid::log::Logger EMSdevice::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger EMSdevice::logger_{F_(emsesp), uuid::log::Facility::CONSOLE}; std::string EMSdevice::brand_to_string() const { switch (brand_) { @@ -55,6 +53,39 @@ std::string EMSdevice::brand_to_string() const { return std::string{}; } +// returns the name of the MQTT topic to use for a specific device +std::string EMSdevice::device_type_topic_name(const uint8_t device_type) { + switch (device_type) { + case DeviceType::SERVICEKEY: + return read_flash_string(F("system_cmd")); + break; + + case DeviceType::BOILER: + return read_flash_string(F("boiler_cmd")); + break; + + case DeviceType::THERMOSTAT: + return read_flash_string(F("thermostat_cmd")); + break; + + case DeviceType::HEATPUMP: + return read_flash_string(F("heatpump_cmd")); + break; + + case DeviceType::SOLAR: + return read_flash_string(F("solar_cmd")); + break; + + case DeviceType::MIXING: + return read_flash_string(F("mixing_cmd")); + break; + + default: + return std::string{}; + break; + } +} + std::string EMSdevice::device_type_name() const { switch (device_type_) { case DeviceType::BOILER: @@ -171,7 +202,7 @@ void EMSdevice::show_values(uuid::console::Shell & shell) { // for each telegram that has the fetch value set (true) do a read request void EMSdevice::fetch_values() { - LOG_DEBUG(F("Fetching values for device ID 0x%02X"), device_id()); + LOG_DEBUG(F("Fetching values for device ID 0x%02X"), get_device_id()); for (const auto & tf : telegram_functions_) { if (tf.fetch_) { @@ -182,7 +213,7 @@ void EMSdevice::fetch_values() { // toggle on/off automatic fetch for a telegram id void EMSdevice::toggle_fetch(uint16_t telegram_id, bool toggle) { - LOG_DEBUG(F("Toggling fetch for device ID 0x%02X, telegram ID 0x%02X to %d"), device_id(), telegram_id, toggle); + LOG_DEBUG(F("Toggling fetch for device ID 0x%02X, telegram ID 0x%02X to %d"), get_device_id(), telegram_id, toggle); for (auto & tf : telegram_functions_) { if (tf.telegram_type_id_ == telegram_id) { @@ -206,22 +237,16 @@ void EMSdevice::show_telegram_handlers(uuid::console::Shell & shell) { // list all the mqtt handlers for this device void EMSdevice::show_mqtt_handlers(uuid::console::Shell & shell) { - Mqtt::show_topic_handlers(shell, this->device_id_); + Mqtt::show_topic_handlers(shell, this->device_type_); } void EMSdevice::register_mqtt_topic(const std::string & topic, mqtt_subfunction_p f) { - LOG_DEBUG(F("Registering MQTT topic %s for device ID %02X"), topic.c_str(), this->device_id_); - Mqtt::subscribe(this->device_id_, topic, f); + LOG_DEBUG(F("Registering MQTT topic %s for device ID %02X and type %s"), topic.c_str(), this->device_id_, this->device_type_name().c_str()); + Mqtt::subscribe(this->device_type_, topic, f); } -EMSdevice::TelegramFunction::TelegramFunction(uint16_t telegram_type_id, - const __FlashStringHelper * telegram_type_name, - bool fetch, - process_function_p process_function) - : telegram_type_id_(telegram_type_id) - , telegram_type_name_(telegram_type_name) - , fetch_(fetch) - , process_function_(process_function) { +void EMSdevice::register_mqtt_cmd(const __FlashStringHelper * cmd, mqtt_cmdfunction_p f) { + Mqtt::add_command(this->device_type_, this->device_id_, cmd, f); } // register a call back function for a specific telegram type @@ -239,7 +264,7 @@ std::string EMSdevice::telegram_type_name(std::shared_ptr telegr } for (const auto & tf : telegram_functions_) { - if ((tf.telegram_type_id_ == telegram->type_id) && ((telegram->type_id & 0x0F0) != 0xF0)) { + if ((tf.telegram_type_id_ == telegram->type_id) && ((telegram->type_id & 0xF0) != 0xF0)) { return uuid::read_flash_string(tf.telegram_type_name_); } } @@ -270,24 +295,22 @@ bool EMSdevice::handle_telegram(std::shared_ptr telegram) { // send Tx write with a data block void EMSdevice::write_command(const uint16_t type_id, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validate_typeid) { - EMSESP::send_write_request(type_id, device_id(), offset, message_data, message_length, validate_typeid); + EMSESP::send_write_request(type_id, this->get_device_id(), offset, message_data, message_length, validate_typeid); } // send Tx write with a single value void EMSdevice::write_command(const uint16_t type_id, const uint8_t offset, const uint8_t value, const uint16_t validate_typeid) { - uint8_t message_data[1]; - message_data[0] = value; - EMSESP::send_write_request(type_id, device_id(), offset, message_data, 1, validate_typeid); + EMSESP::send_write_request(type_id, this->get_device_id(), offset, value, validate_typeid); } // send Tx write with a single value, with no post validation void EMSdevice::write_command(const uint16_t type_id, const uint8_t offset, const uint8_t value) { - write_command(type_id, offset, value, 0); + EMSESP::send_write_request(type_id, this->get_device_id(), offset, value, 0); } // send Tx read command to the device void EMSdevice::read_command(const uint16_t type_id) { - EMSESP::send_read_request(type_id, device_id()); + EMSESP::send_read_request(type_id, get_device_id()); } // prints a string value to the console @@ -295,6 +318,7 @@ void EMSdevice::print_value(uuid::console::Shell & shell, uint8_t padding, const print_value(shell, padding, name, uuid::read_flash_string(value).c_str()); } +// print string value, value is not in flash void EMSdevice::print_value(uuid::console::Shell & shell, uint8_t padding, const __FlashStringHelper * name, const char * value) { uint8_t i = padding; while (i-- > 0) { @@ -304,4 +328,60 @@ void EMSdevice::print_value(uuid::console::Shell & shell, uint8_t padding, const shell.printfln(PSTR("%s: %s"), uuid::read_flash_string(name).c_str(), value); } +// given a context, automatically add the commands taken them from the MQTT registry for "_cmd" topics +void EMSdevice::add_context_commands(unsigned int context) { + // if we're adding commands for a thermostat or mixing, then include an additional optional paramter called heating circuit + flash_string_vector params; + if ((context == ShellContext::THERMOSTAT) || (context == ShellContext::MIXING)) { + params = flash_string_vector{F_(cmd_optional), F_(data_optional), F_(hc_optional)}; + } else { + params = flash_string_vector{F_(cmd_optional), F_(data_optional)}; + } + + EMSESPShell::commands->add_command( + context, + CommandFlags::ADMIN, + flash_string_vector{F_(call)}, + params, + [&](Shell & shell, const std::vector & arguments) { + uint8_t device_type_ = device_type(); + if (arguments.empty()) { + // list options + shell.print("Available commands:"); + for (const auto & cf : Mqtt::commands()) { + if (cf.device_type_ == device_type_) { + shell.printf(" %s", uuid::read_flash_string(cf.cmd_).c_str()); + } + } + shell.println(); + return; + } + + const char * cmd = arguments[0].c_str(); + if (arguments.size() == 1) { + // no value specified + Mqtt::call_command(device_type_, cmd, nullptr, -1); + } else if (arguments.size() == 2) { + // has a value but no id + Mqtt::call_command(device_type_, cmd, arguments.back().c_str(), -1); + } else { + // use value, which could be an id or hc + Mqtt::call_command(device_type_, cmd, arguments[1].c_str(), atoi(arguments[2].c_str())); + } + }, + [&](Shell & shell __attribute__((unused)), const std::vector & arguments) -> std::vector { + if (arguments.size() > 0) { + return {}; + } + std::vector commands; + for (const auto & cf : Mqtt::commands()) { + if (cf.device_type_ == device_type()) { + commands.emplace_back(uuid::read_flash_string(cf.cmd_)); + } + } + return commands; + }); +} + + } // namespace emsesp diff --git a/src/emsdevice.h b/src/emsdevice.h index 2abc3bc42..6e5025d51 100644 --- a/src/emsdevice.h +++ b/src/emsdevice.h @@ -30,10 +30,10 @@ namespace emsesp { -using namespace std::placeholders; // for `_1` - class EMSdevice { public: + static constexpr uint8_t EMS_DEVICES_MAX_TELEGRAMS = 20; + // device_type defines which derived class to use, e.g. BOILER, THERMOSTAT etc.. EMSdevice(uint8_t device_type, uint8_t device_id, uint8_t product_id, const std::string & version, const std::string & name, uint8_t flags, uint8_t brand) : device_type_(device_type) @@ -47,11 +47,12 @@ class EMSdevice { virtual ~EMSdevice() = default; // destructor of base class must always be virtual because it's a polymorphic class - inline uint8_t device_id() const { + inline uint8_t get_device_id() const { return device_id_; } - std::string device_type_name() const; + std::string device_type_name() const; + static std::string device_type_topic_name(const uint8_t device_type); inline uint8_t product_id() const { return product_id_; @@ -129,7 +130,10 @@ class EMSdevice { void read_command(const uint16_t type_id); + void add_context_commands(unsigned int context); + void register_mqtt_topic(const std::string & topic, mqtt_subfunction_p f); + void register_mqtt_cmd(const __FlashStringHelper * cmd, mqtt_cmdfunction_p f); // virtual functions overrules by derived classes virtual void show_values(uuid::console::Shell & shell) = 0; @@ -143,6 +147,10 @@ class EMSdevice { void fetch_values(); void toggle_fetch(uint16_t telegram_id, bool toggle); + void reserve_mem(size_t n) { + telegram_functions_.reserve(n); + } + // prints a ems device value to the console, handling the correct rendering of the type // padding is # white space // name is the name of the parameter @@ -221,8 +229,7 @@ class EMSdevice { }; enum DeviceType : uint8_t { - UNKNOWN = 0, - SERVICEKEY, + SERVICEKEY = 0, // this is us BOILER, THERMOSTAT, MIXING, @@ -272,25 +279,29 @@ class EMSdevice { private: uint8_t unique_id_; - uint8_t device_type_ = DeviceType::UNKNOWN; + uint8_t device_type_ = DeviceType::SERVICEKEY; uint8_t device_id_ = 0; uint8_t product_id_ = 0; std::string version_; - std::string name_; // the long name of the EMS model + std::string name_; // the long name for the EMS model uint8_t flags_ = 0; uint8_t brand_ = Brand::NO_BRAND; static uuid::log::Logger logger_; - class TelegramFunction { - public: - TelegramFunction(uint16_t telegram_type_id, const __FlashStringHelper * telegram_type_name, bool fetch, process_function_p process_function); - ~TelegramFunction() = default; - + struct TelegramFunction { uint16_t telegram_type_id_; // it's type_id const __FlashStringHelper * telegram_type_name_; // e.g. RC20Message bool fetch_; // if this type_id be queried automatically - process_function_p process_function_; + + process_function_p process_function_; + + TelegramFunction(uint16_t telegram_type_id, const __FlashStringHelper * telegram_type_name, bool fetch, process_function_p process_function) + : telegram_type_id_(telegram_type_id) + , telegram_type_name_(telegram_type_name) + , fetch_(fetch) + , process_function_(process_function) { + } }; std::vector telegram_functions_; // each EMS device has its own set of registered telegram types }; diff --git a/src/emsesp.cpp b/src/emsesp.cpp index e26fb9e26..c2fb2cfb2 100644 --- a/src/emsesp.cpp +++ b/src/emsesp.cpp @@ -18,13 +18,8 @@ #include "emsesp.h" -MAKE_PSTR(logger_name, "emsesp") - namespace emsesp { -using DeviceFlags = emsesp::EMSdevice; -using DeviceType = emsesp::EMSdevice::DeviceType; - AsyncWebServer webServer(80); #if defined(ESP32) @@ -42,10 +37,12 @@ EMSESPSettingsService EMSESP::emsespSettingsService = EMSESPSettingsService(&web EMSESPStatusService EMSESP::emsespStatusService = EMSESPStatusService(&webServer, EMSESP::esp8266React.getSecurityManager()); EMSESPDevicesService EMSESP::emsespDevicesService = EMSESPDevicesService(&webServer, EMSESP::esp8266React.getSecurityManager()); +using DeviceFlags = emsesp::EMSdevice; +using DeviceType = emsesp::EMSdevice::DeviceType; std::vector> EMSESP::emsdevices; // array of all the detected EMS devices std::vector EMSESP::device_library_; // libary of all our known EMS devices so far -uuid::log::Logger EMSESP::logger_{FPSTR(__pstr__logger_name), uuid::log::Facility::KERN}; +uuid::log::Logger EMSESP::logger_{F_(emsesp), uuid::log::Facility::KERN}; // The services RxService EMSESP::rxservice_; // incoming Telegram Rx handler @@ -60,7 +57,8 @@ Shower EMSESP::shower_; // Shower logic uint8_t EMSESP::actual_master_thermostat_ = EMSESP_DEFAULT_MASTER_THERMOSTAT; // which thermostat leads when multiple found uint16_t EMSESP::watch_id_ = WATCH_ID_NONE; // for when log is TRACE. 0 means no trace set uint8_t EMSESP::watch_ = 0; // trace off -bool EMSESP::tap_water_active_ = false; // for when Boiler states we having running warm water. used in Shower() +uint16_t EMSESP::read_id_ = WATCH_ID_NONE; +bool EMSESP::tap_water_active_ = false; // for when Boiler states we having running warm water. used in Shower() uint32_t EMSESP::last_fetch_ = 0; uint8_t EMSESP::unique_id_count_ = 0; @@ -79,6 +77,11 @@ void EMSESP::fetch_device_values(const uint8_t device_id) { } } +// clears list of recognized devices +void EMSESP::clear_all_devices() { + emsdevices.clear(); // or use empty to release memory too +} + // return number of devices of a known type uint8_t EMSESP::count_devices(const uint8_t device_type) { uint8_t count = 0; @@ -90,6 +93,33 @@ uint8_t EMSESP::count_devices(const uint8_t device_type) { return count; } +// scans for new devices +void EMSESP::scan_devices() { + EMSESP::clear_all_devices(); + EMSESP::send_read_request(EMSdevice::EMS_TYPE_UBADevices, EMSdevice::EMS_DEVICE_ID_BOILER); +} + +/** +* if thermostat master is 0x18 it handles only ww and hc1, hc2..hc4 handled by devices 0x19..0x1B +* we send to right device and match all reads to 0x18 +*/ +uint8_t EMSESP::check_master_device(const uint8_t device_id, const uint16_t type_id, const bool read) { + uint16_t mon_id[4] = {0x02A5, 0x02A6, 0x02A7, 0x02A8}; + uint16_t set_id[4] = {0x02B9, 0x02BA, 0x02BB, 0x02BC}; + if (actual_master_thermostat_ == 0x18) { + for (uint8_t i = 0; i < 4; i++) { + if (type_id == mon_id[i] || type_id == set_id[i]) { + if (read) { + return 0x18; + } else { + return 0x18 + i; + } + } + } + } + return device_id; +} + void EMSESP::actual_master_thermostat(const uint8_t device_id) { actual_master_thermostat_ = device_id; } @@ -110,6 +140,7 @@ void EMSESP::watch_id(uint16_t watch_id) { // change the tx_mode // resets all counters and bumps the UART +// this is called when the tx_mode is persisted in the FS either via Web UI or the console void EMSESP::reset_tx() { // get the tx_mode uint8_t tx_mode; @@ -182,25 +213,12 @@ void EMSESP::show_ems(uuid::console::Shell & shell) { shell.printfln(F(" #telegrams received: %d"), rxservice_.telegram_count()); shell.printfln(F(" #read requests sent: %d"), txservice_.telegram_read_count()); shell.printfln(F(" #write requests sent: %d"), txservice_.telegram_write_count()); - shell.printfln(F(" #corrupted telegrams: %d (%d%%)"), rxservice_.telegram_error_count(), success_rate); + shell.printfln(F(" #incomplete telegrams: %d (%d%%)"), rxservice_.telegram_error_count(), success_rate); shell.printfln(F(" #tx fails (after %d retries): %d"), TxService::MAXIMUM_TX_RETRIES, txservice_.telegram_fail_count()); } shell.println(); - // Rx queue - auto rx_telegrams = rxservice_.queue(); - if (rx_telegrams.empty()) { - shell.printfln(F("Rx Queue is empty")); - } else { - shell.printfln(F("Rx Queue (%ld telegram%s):"), rx_telegrams.size(), rx_telegrams.size() == 1 ? "" : "s"); - for (const auto & it : rx_telegrams) { - shell.printfln(F(" [%02d] %s"), it.id_, pretty_telegram(it.telegram_).c_str()); - } - } - - shell.println(); - // Tx queue auto tx_telegrams = txservice_.queue(); if (tx_telegrams.empty()) { @@ -208,7 +226,7 @@ void EMSESP::show_ems(uuid::console::Shell & shell) { } else { shell.printfln(F("Tx Queue (%ld telegram%s):"), tx_telegrams.size(), tx_telegrams.size() == 1 ? "" : "s"); - std::string op; + std::string op(10, '\0'); for (const auto & it : tx_telegrams) { if ((it.telegram_->operation) == Telegram::Operation::TX_RAW) { op = read_flash_string(F("RAW ")); @@ -217,12 +235,7 @@ void EMSESP::show_ems(uuid::console::Shell & shell) { } else if ((it.telegram_->operation) == Telegram::Operation::TX_WRITE) { op = read_flash_string(F("WRITE")); } - shell.printfln(F(" [%02d%c] %s %s (offset %d)"), - it.id_, - ((it.retry_) ? '*' : ' '), - op.c_str(), - pretty_telegram(it.telegram_).c_str(), - it.telegram_->offset); + shell.printfln(F(" [%02d%c] %s %s"), it.id_, ((it.retry_) ? '*' : ' '), op.c_str(), pretty_telegram(it.telegram_).c_str()); } } @@ -242,7 +255,6 @@ void EMSESP::show_device_values(uuid::console::Shell & shell) { for (const auto & emsdevice : emsdevices) { if ((emsdevice) && (emsdevice->device_type() == device_class.first)) { emsdevice->show_values(shell); - shell.println(); } } } @@ -291,16 +303,16 @@ std::string EMSESP::device_tostring(const uint8_t device_id) { } // created a pretty print telegram as a text string -// e.g. Boiler(0x08) -> Me(0x0B), Version(0x02), data: 7B 06 01 00 00 00 00 00 00 04 (#data=10) +// e.g. Boiler(0x08) -> Me(0x0B), Version(0x02), data: 7B 06 01 00 00 00 00 00 00 04 (offset 1) std::string EMSESP::pretty_telegram(std::shared_ptr telegram) { uint8_t src = telegram->src & 0x7F; uint8_t dest = telegram->dest & 0x7F; uint8_t offset = telegram->offset; // find name for src and dest by looking up known devices - std::string src_name; - std::string dest_name; - std::string type_name; + std::string src_name(20, '\0'); + std::string dest_name(20, '\0'); + std::string type_name(20, '\0'); for (const auto & emsdevice : emsdevices) { if (emsdevice) { // get src & dest @@ -340,14 +352,14 @@ std::string EMSESP::pretty_telegram(std::shared_ptr telegram) { if (offset) { snprintf_P(&str[0], str.capacity() + 1, - PSTR("%s(0x%02X) -> %s(0x%02X), %s(0x%02X), data: %s @offset %d"), + PSTR("%s(0x%02X) -> %s(0x%02X), %s(0x%02X), data: %s (offset %d)"), src_name.c_str(), src, dest_name.c_str(), dest, type_name.c_str(), telegram->type_id, - telegram->to_string().c_str(), + telegram->to_string_message().c_str(), offset); } else { snprintf_P(&str[0], @@ -359,7 +371,7 @@ std::string EMSESP::pretty_telegram(std::shared_ptr telegram) { dest, type_name.c_str(), telegram->type_id, - telegram->to_string().c_str()); + telegram->to_string_message().c_str()); } return str; @@ -444,7 +456,10 @@ void EMSESP::process_version(std::shared_ptr telegram) { // returns false if there are none found bool EMSESP::process_telegram(std::shared_ptr telegram) { // if watching... - if (watch() == WATCH_ON) { + if (telegram->type_id == read_id_) { + LOG_NOTICE(pretty_telegram(telegram).c_str()); + read_id_ = WATCH_ID_NONE; + } else if (watch() == WATCH_ON) { if ((watch_id_ == WATCH_ID_NONE) || (telegram->src == watch_id_) || (telegram->dest == watch_id_) || (telegram->type_id == watch_id_)) { LOG_NOTICE(pretty_telegram(telegram).c_str()); } @@ -544,16 +559,13 @@ void EMSESP::show_devices(uuid::console::Shell & shell) { // shell.printf(F("[factory ID: %d] "), device_class.first); for (const auto & emsdevice : emsdevices) { if ((emsdevice) && (emsdevice->device_type() == device_class.first)) { -#if defined(EMSESP_DEBUG) - shell.printf(F("[id=%d] "), emsdevice->unique_id()); -#endif shell.printf(F("%s: %s"), emsdevice->device_type_name().c_str(), emsdevice->to_string().c_str()); - if ((emsdevice->device_type() == EMSdevice::DeviceType::THERMOSTAT) && (emsdevice->device_id() == actual_master_thermostat())) { + if ((emsdevice->device_type() == EMSdevice::DeviceType::THERMOSTAT) && (emsdevice->get_device_id() == actual_master_thermostat())) { shell.printf(F(" ** master device **")); } shell.println(); emsdevice->show_telegram_handlers(shell); - emsdevice->show_mqtt_handlers(shell); + // emsdevice->show_mqtt_handlers(shell); shell.println(); } } @@ -568,11 +580,12 @@ bool EMSESP::add_device(const uint8_t device_id, const uint8_t product_id, std:: return false; } + // first check to see if we already have it, if so update the record for (const auto & emsdevice : emsdevices) { if (emsdevice) { if (emsdevice->is_device_id(device_id)) { - LOG_DEBUG(F("Updating details to already existing device ID 0x%02X"), device_id); + LOG_DEBUG(F("Updating details on already existing device ID 0x%02X"), device_id); emsdevice->product_id(product_id); emsdevice->version(version); // only set brand if it doesn't already exist @@ -592,6 +605,7 @@ bool EMSESP::add_device(const uint8_t device_id, const uint8_t product_id, std:: } } + // look up the rest of the details using the product_id and create the new device object Device_record * device_p = nullptr; for (auto & device : device_library_) { @@ -616,12 +630,11 @@ bool EMSESP::add_device(const uint8_t device_id, const uint8_t product_id, std:: LOG_NOTICE(F("Unrecognized EMS device with device ID 0x%02X with product ID %d. Please report on GitHub."), device_id, product_id); return false; // not found } else { - emsdevices.push_back( - EMSFactory::add(device_p->device_type, device_id, device_p->product_id, version, uuid::read_flash_string(device_p->name), device_p->flags, brand)); + std::string name = uuid::read_flash_string(device_p->name); + emsdevices.push_back(EMSFactory::add(device_p->device_type, device_id, device_p->product_id, version, name, device_p->flags, brand)); emsdevices.back()->unique_id(++unique_id_count_); LOG_DEBUG(F("Adding new device with device ID 0x%02X with product ID %d and version %s"), device_id, product_id, version.c_str()); - // go and fetch its data, - fetch_device_values(device_id); + fetch_device_values(device_id); // go and fetch its data, } return true; @@ -644,6 +657,17 @@ void EMSESP::send_write_request(const uint16_t type_id, txservice_.set_post_send_query(validate_typeid); // store which type_id to send Tx read after a write } +void EMSESP::send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, const uint8_t value) { + send_write_request(type_id, dest, offset, value, 0); +} + +// send Tx write with a single value +void EMSESP::send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, const uint8_t value, const uint16_t validate_typeid) { + uint8_t message_data[1]; + message_data[0] = value; + EMSESP::send_write_request(type_id, dest, offset, message_data, 1, validate_typeid); +} + // this is main entry point when data is received on the Rx line, via emsuart library // we check if its a complete telegram or just a single byte (which could be a poll or a return status) // the CRC check is not done here, only when it's added to the Rx queue with add() @@ -743,9 +767,11 @@ void EMSESP::send_raw_telegram(const char * data) { txservice_.send_raw(data); } -// kick off the party, start all the services +// start all the core services +// the services must be loaded in the correct order void EMSESP::start() { - // Load our library of known devices + // Load our library of known devices. Names are stored in Flash mem. + device_library_.reserve(100); device_library_ = { #include "device_library.h" }; @@ -758,17 +784,22 @@ void EMSESP::start() { esp8266React.begin(); // loads system settings (wifi, mqtt, etc) emsespSettingsService.begin(); // load EMS-ESP specific settings - // system_.check_upgrade(); // see if we need to migrate from previous versions - console_.start(); // telnet and serial console - system_.start(); // starts syslog, uart, sets version, initializes LED. Requires pre-loaded settings. mqtt_.start(); // mqtt init + system_.start(); // starts syslog, uart, sets version, initializes LED. Requires pre-loaded settings. shower_.start(); // initialize shower timer and shower alert txservice_.start(); // sets bus ID, sends out request for EMS devices sensors_.start(); // dallas external sensors + webServer.begin(); // start web server - webServer.begin(); // start web server + emsdevices.reserve(5); // reserve space for initially 5 devices to avoid mem + + LOG_INFO("EMS Device library loaded with %d records", device_library_.size()); + +#if defined(EMSESP_STANDALONE) + mqtt_.on_connect(); // simulate an MQTT connection +#endif } // main loop calling all services @@ -777,18 +808,19 @@ void EMSESP::loop() { // if we're doing an OTA upload, skip MQTT and EMS if (system_.upload_status()) { + /* #if defined(ESP32) delay(10); // slow down OTA update to avoid getting killed by task watchdog (task_wdt) #endif +*/ return; } - system_.loop(); // does LED and checks system health, and syslog service - rxservice_.loop(); // process what ever is in the rx queue - shower_.loop(); // check for shower on/off - sensors_.loop(); // this will also send out via MQTT - mqtt_.loop(); // sends out anything in the queue via MQTT - console_.loop(); // telnet/serial console + system_.loop(); // does LED and checks system health, and syslog service + shower_.loop(); // check for shower on/off + sensors_.loop(); // this will also send out via MQTT + mqtt_.loop(); // sends out anything in the queue via MQTT + console_.loop(); // telnet/serial console // force a query on the EMS devices to fetch latest data at a set interval (1 min) if ((uuid::get_uptime() - last_fetch_ > EMS_FETCH_FREQUENCY)) { @@ -796,7 +828,9 @@ void EMSESP::loop() { fetch_device_values(); } +#if defined(ESP8266) delay(1); +#endif } } // namespace emsesp diff --git a/src/emsesp.h b/src/emsesp.h index e22633f88..18bda872f 100644 --- a/src/emsesp.h +++ b/src/emsesp.h @@ -78,6 +78,9 @@ class EMSESP { uint8_t * message_data, const uint8_t message_length, const uint16_t validate_typeid); + static void send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, const uint8_t value); + static void send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, const uint8_t value, const uint16_t validate_typeid); + static void send_raw_telegram(const char * data); static bool device_exists(const uint8_t device_id); @@ -87,6 +90,7 @@ class EMSESP { static uint8_t actual_master_thermostat(); static void actual_master_thermostat(const uint8_t device_id); + static uint8_t check_master_device(const uint8_t device_id, const uint16_t type_id, const bool read); static void show_device_values(uuid::console::Shell & shell); static void show_sensor_values(uuid::console::Shell & shell); @@ -119,6 +123,9 @@ class EMSESP { static uint8_t watch() { return watch_; } + static void set_read_id(uint16_t id) { + read_id_ = id; + } enum Bus_status : uint8_t { BUS_STATUS_CONNECTED = 0, BUS_STATUS_TX_ERRORS, BUS_STATUS_OFFLINE }; static uint8_t bus_status(); @@ -134,6 +141,8 @@ class EMSESP { static void fetch_device_values(const uint8_t device_id = 0); static bool add_device(const uint8_t device_id, const uint8_t product_id, std::string & version, const uint8_t brand); + static void scan_devices(); + static void clear_all_devices(); static std::vector> emsdevices; @@ -181,6 +190,7 @@ class EMSESP { static uint8_t actual_master_thermostat_; static uint16_t watch_id_; static uint8_t watch_; + static uint16_t read_id_; static bool tap_water_active_; static uint8_t unique_id_count_; diff --git a/src/emsfactory.h b/src/emsfactory.h index 50b2d0afe..ecc2b2556 100644 --- a/src/emsfactory.h +++ b/src/emsfactory.h @@ -55,12 +55,12 @@ class EMSFactory { } // Construct derived class returning an unique ptr - static auto add(const uint8_t device_type, uint8_t device_id, uint8_t product_id, std::string version, std::string name, uint8_t flags, uint8_t brand) + static auto add(const uint8_t device_type, uint8_t device_id, uint8_t product_id, std::string &version, std::string &name, uint8_t flags, uint8_t brand) -> std::unique_ptr { return std::unique_ptr(EMSFactory::makeRaw(device_type, device_id, product_id, version, name, flags, brand)); } - virtual auto construct(uint8_t device_type, uint8_t device_id, uint8_t product_id, std::string version, std::string name, uint8_t flags, uint8_t brand) const + virtual auto construct(uint8_t device_type, uint8_t device_id, uint8_t product_id, std::string &version, std::string &name, uint8_t flags, uint8_t brand) const -> EMSdevice * = 0; private: @@ -72,7 +72,7 @@ class EMSFactory { // Construct derived class returning a raw pointer // find which EMS device it is and use that class - static auto makeRaw(const uint8_t device_type, uint8_t device_id, uint8_t product_id, std::string version, std::string name, uint8_t flags, uint8_t brand) + static auto makeRaw(const uint8_t device_type, uint8_t device_id, uint8_t product_id, std::string &version, std::string &name, uint8_t flags, uint8_t brand) -> EMSdevice * { auto it = EMSFactory::getRegister().find(device_type); if (it != EMSFactory::getRegister().end()) { @@ -90,7 +90,7 @@ class ConcreteEMSFactory : EMSFactory { EMSFactory::registerFactory(device_type, this); } - auto construct(uint8_t device_type, uint8_t device_id, uint8_t product_id, std::string version, std::string name, uint8_t flags, uint8_t brand) const + auto construct(uint8_t device_type, uint8_t device_id, uint8_t product_id, std::string &version, std::string &name, uint8_t flags, uint8_t brand) const -> EMSdevice * { return new DerivedClass(device_type, device_id, product_id, version, name, flags, brand); } diff --git a/src/helpers.cpp b/src/helpers.cpp index 5cdde4c60..4ca778590 100644 --- a/src/helpers.cpp +++ b/src/helpers.cpp @@ -17,7 +17,6 @@ */ #include "helpers.h" -#include "telegram.h" // for EMS_VALUE_* settings namespace emsesp { @@ -187,7 +186,7 @@ char * Helpers::render_value(char * result, const int16_t value, const uint8_t f return nullptr; } - // just print it if mo conversion required (format = 0) + // just print it if no conversion required (format = 0) if (!format) { itoa(result, value, 10); return result; @@ -329,9 +328,9 @@ bool Helpers::check_abs(const int32_t i) { return ((i < 0 ? -i : i) != 0xFFFFFF); } -// for booleans, use isBool true (VALUE_BOOL) -bool Helpers::hasValue(const uint8_t v, bool isBool) { - if (isBool) { +// for booleans, use isBool true (EMS_VALUE_BOOL) +bool Helpers::hasValue(const uint8_t v, const uint8_t isBool) { + if (isBool == EMS_VALUE_BOOL) { return (v != EMS_VALUE_BOOL_NOTSET); } return (v != EMS_VALUE_UINT_NOTSET); @@ -354,4 +353,63 @@ bool Helpers::hasValue(const uint32_t v) { return (v != EMS_VALUE_ULONG_NOTSET); } +// checks if we can convert a char string to an int value +bool Helpers::value2number(const char * v, int & value) { + if ((v == nullptr) || (strlen(v) == 0)) { + value = 0; + return false; + } + value = atoi((char *)v); + return true; +} + +// checks if we can convert a char string to a float value +bool Helpers::value2float(const char * v, float & value) { + if ((v == nullptr) || (strlen(v) == 0)) { + value = 0; + return false; + } + value = atof((char *)v); + return true; +} + +// https://stackoverflow.com/questions/313970/how-to-convert-stdstring-to-lower-case +std::string Helpers::toLower(std::string const & s) { + std::string lc = s; + std::transform(lc.begin(), lc.end(), lc.begin(), [](unsigned char c) { return std::tolower(c); }); + return lc; +} + +// checks if we can convert a chat string to an int value +bool Helpers::value2string(const char * v, std::string & value) { + if ((v == nullptr) || (strlen(v) == 0)) { + value = {}; + return false; + } + value = toLower(v); + return true; +} + +// checks to see if a string (usually a command or payload cmd) looks like a boolean +// on, off, true, false, 1, 0 +bool Helpers::value2bool(const char * v, bool & value) { + if ((v == nullptr) || (strlen(v) == 0)) { + return false; + } + + std::string bool_str = toLower(v); // convert to lower case + + if ((bool_str == "on") || (bool_str == "1") or (bool_str == "true")) { + value = true; + return true; // is a bool + } + + if ((bool_str == "off") || (bool_str == "0") or (bool_str == "false")) { + value = false; + return true; // is a bool + } + + return false; // not a bool +} + } // namespace emsesp diff --git a/src/helpers.h b/src/helpers.h index 33fcc13a5..963c2735f 100644 --- a/src/helpers.h +++ b/src/helpers.h @@ -22,6 +22,8 @@ #include #include +#include "telegram.h" // for EMS_VALUE_* settings + namespace emsesp { class Helpers { @@ -48,11 +50,18 @@ class Helpers { static char * ultostr(char * ptr, uint32_t value, const uint8_t base); #endif - static bool hasValue(const uint8_t v, bool isBool = false); // use isBool=true for bool's + static bool hasValue(const uint8_t v, const uint8_t isBool = 0); static bool hasValue(const int8_t v); static bool hasValue(const int16_t v); static bool hasValue(const uint16_t v); static bool hasValue(const uint32_t v); + + static std::string toLower(std::string const & s); + + static bool value2number(const char * v, int & value); + static bool value2float(const char * v, float & value); + static bool value2bool(const char * v, bool & value); + static bool value2string(const char * v, std::string & value); }; } // namespace emsesp diff --git a/src/locale_EN.h b/src/locale_EN.h new file mode 100644 index 000000000..57f74f86c --- /dev/null +++ b/src/locale_EN.h @@ -0,0 +1,120 @@ +/* + * EMS-ESP - https://github.com/proddy/EMS-ESP + * Copyright 2019 Paul Derbyshire + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +// common words +MAKE_PSTR_WORD(exit) +MAKE_PSTR_WORD(help) +MAKE_PSTR_WORD(settings) +MAKE_PSTR_WORD(log) +MAKE_PSTR_WORD(logout) +MAKE_PSTR_WORD(enabled) +MAKE_PSTR_WORD(disabled) +MAKE_PSTR_WORD(set) +MAKE_PSTR_WORD(show) +MAKE_PSTR_WORD(on) +MAKE_PSTR_WORD(off) +MAKE_PSTR_WORD(su) +MAKE_PSTR_WORD(name) +MAKE_PSTR_WORD(auto) +MAKE_PSTR_WORD(scan) +MAKE_PSTR_WORD(password) +MAKE_PSTR_WORD(read) +MAKE_PSTR_WORD(version) +MAKE_PSTR_WORD(values) +MAKE_PSTR_WORD(system) +MAKE_PSTR_WORD(fetch) +MAKE_PSTR_WORD(restart) +MAKE_PSTR_WORD(format) +MAKE_PSTR_WORD(raw) +MAKE_PSTR_WORD(watch) +MAKE_PSTR_WORD(send) +MAKE_PSTR_WORD(telegram) +MAKE_PSTR_WORD(bus_id) +MAKE_PSTR_WORD(tx_mode) +MAKE_PSTR_WORD(ems) +MAKE_PSTR_WORD(devices) +MAKE_PSTR_WORD(shower) +MAKE_PSTR_WORD(mqtt) +MAKE_PSTR_WORD(emsesp) +MAKE_PSTR_WORD(connected) +MAKE_PSTR_WORD(disconnected) +MAKE_PSTR_WORD(passwd) +MAKE_PSTR_WORD(hostname) +MAKE_PSTR_WORD(wifi) +MAKE_PSTR_WORD(reconnect) +MAKE_PSTR_WORD(ssid) +MAKE_PSTR_WORD(heartbeat) +MAKE_PSTR_WORD(users) +MAKE_PSTR_WORD(master) +MAKE_PSTR_WORD(test) +MAKE_PSTR_WORD(pin) + +// for commands +MAKE_PSTR_WORD(call) + +// devices +MAKE_PSTR_WORD(boiler) +MAKE_PSTR_WORD(thermostat) +MAKE_PSTR_WORD(switch) +MAKE_PSTR_WORD(solar) +MAKE_PSTR_WORD(mixing) +MAKE_PSTR_WORD(gateway) +MAKE_PSTR_WORD(controller) +MAKE_PSTR_WORD(connect) +MAKE_PSTR_WORD(heatpump) + +// dallas sensors +MAKE_PSTR_WORD(sensors) + +MAKE_PSTR(kwh, "kWh") +MAKE_PSTR(wh, "Wh") +MAKE_PSTR(hc_optional, "[heating circuit]") +MAKE_PSTR(master_thermostat_fmt, "Master Thermostat Device ID = %s") +MAKE_PSTR(host_fmt, "Host = %s") +MAKE_PSTR(hostname_fmt, "WiFi Hostname = %s") +MAKE_PSTR(mark_interval_fmt, "Mark interval = %lus") +MAKE_PSTR(wifi_ssid_fmt, "WiFi SSID = %s") +MAKE_PSTR(wifi_password_fmt, "WiFi Password = %S") +MAKE_PSTR(system_heartbeat_fmt, "MQTT Heartbeat is %s") +MAKE_PSTR(cmd_optional, "[cmd]") +MAKE_PSTR(deep_optional, "[deep]") +MAKE_PSTR(tx_mode_fmt, "Tx mode = %d") +MAKE_PSTR(bus_id_fmt, "Bus ID = %02X") +MAKE_PSTR(watchid_optional, "[ID]") +MAKE_PSTR(watch_format_optional, "[off | on | raw]") +MAKE_PSTR(invalid_watch, "Invalid watch type") +MAKE_PSTR(data_mandatory, "<\"XX XX ...\">") +MAKE_PSTR(percent, "%") +MAKE_PSTR(degrees, "°C") +MAKE_PSTR(asterisks, "********") +MAKE_PSTR(n_mandatory, "") +MAKE_PSTR(n_optional, "[n]") +MAKE_PSTR(gpio_mandatory, "") +MAKE_PSTR(data_optional, "[data]") +MAKE_PSTR(typeid_mandatory, "") +MAKE_PSTR(deviceid_mandatory, "") +MAKE_PSTR(deviceid_optional, "[device ID]") +MAKE_PSTR(invalid_log_level, "Invalid log level") +MAKE_PSTR(log_level_fmt, "Log level = %s") +MAKE_PSTR(log_level_optional, "[level]") +MAKE_PSTR(name_mandatory, "") +MAKE_PSTR(name_optional, "[name]") +MAKE_PSTR(new_password_prompt1, "Enter new password: ") +MAKE_PSTR(new_password_prompt2, "Retype new password: ") +MAKE_PSTR(password_prompt, "Password: ") +MAKE_PSTR(unset, "") diff --git a/src/mqtt.cpp b/src/mqtt.cpp index a38bc4ec5..3cc0f4df9 100644 --- a/src/mqtt.cpp +++ b/src/mqtt.cpp @@ -20,12 +20,6 @@ #include "emsesp.h" #include "version.h" -MAKE_PSTR_WORD(connected) -MAKE_PSTR_WORD(disconnected) -MAKE_PSTR(system_heartbeat_fmt, "Heartbeat is %s") - -MAKE_PSTR(logger_name, "mqtt") - namespace emsesp { AsyncMqttClient * Mqtt::mqttClient_; @@ -34,58 +28,59 @@ AsyncMqttClient * Mqtt::mqttClient_; std::string Mqtt::hostname_; uint8_t Mqtt::mqtt_qos_; uint16_t Mqtt::publish_time_; +uint8_t Mqtt::bus_id_; -std::vector Mqtt::mqtt_subfunctions_; -uint16_t Mqtt::mqtt_publish_fails_ = 0; -size_t Mqtt::maximum_mqtt_messages_ = Mqtt::MAX_MQTT_MESSAGES; -uint16_t Mqtt::mqtt_message_id_ = 0; -std::deque Mqtt::mqtt_messages_; -char will_topic_[Mqtt::MQTT_TOPIC_MAX_SIZE]; // because MQTT library keeps only char pointer +std::vector Mqtt::mqtt_subfunctions_; +std::vector Mqtt::mqtt_cmdfunctions_; -uuid::log::Logger Mqtt::logger_{F_(logger_name), uuid::log::Facility::DAEMON}; +uint16_t Mqtt::mqtt_publish_fails_ = 0; +size_t Mqtt::maximum_mqtt_messages_ = Mqtt::MAX_MQTT_MESSAGES; +uint16_t Mqtt::mqtt_message_id_ = 0; +std::list Mqtt::mqtt_messages_; +char will_topic_[Mqtt::MQTT_TOPIC_MAX_SIZE]; // because MQTT library keeps only char pointer -Mqtt::QueuedMqttMessage::QueuedMqttMessage(uint16_t id, std::shared_ptr && content) - : id_(id) - , content_(std::move(content)) { - retry_count_ = 0; - packet_id_ = 0; -} - -MqttMessage::MqttMessage(const uint8_t operation, const std::string & topic, const std::string & payload, bool retain) - : operation(operation) - , topic(topic) - , payload(payload) - , retain(retain) { -} - -Mqtt::MQTTSubFunction::MQTTSubFunction(const uint8_t device_id, const std::string && topic, mqtt_subfunction_p mqtt_subfunction) - : device_id_(device_id) - , topic_(topic) - , mqtt_subfunction_(mqtt_subfunction) { -} +uuid::log::Logger Mqtt::logger_{F_(mqtt), uuid::log::Facility::DAEMON}; // subscribe to an MQTT topic, and store the associated callback function -void Mqtt::subscribe(const uint8_t device_id, const std::string & topic, mqtt_subfunction_p cb) { - auto message = queue_subscribe_message(topic); // add subscription to queue. The hostname will automatically be appended - - if (message == nullptr) { - return; - } - - // the message will contain the full topic, with the hostname prefixed +// only if it already hasn't been added +void Mqtt::subscribe(const uint8_t device_type, const std::string & topic, mqtt_subfunction_p cb) { // check if we already have the topic subscribed, if so don't add it again - bool exists = false; if (!mqtt_subfunctions_.empty()) { for (const auto & mqtt_subfunction : mqtt_subfunctions_) { - if ((mqtt_subfunction.device_id_ == device_id) && (strcmp(mqtt_subfunction.topic_.c_str(), message->topic.c_str()) == 0)) { - exists = true; + if ((mqtt_subfunction.device_type_ == device_type) && (strcmp(mqtt_subfunction.topic_.c_str(), topic.c_str()) == 0)) { + return; // it exists, exit } } } - if (!exists) { - mqtt_subfunctions_.emplace_back(device_id, std::move(message->topic), cb); // register a call back function for a specific telegram type + // add to MQTT queue as a subscribe operation + auto message = queue_subscribe_message(topic); + + // register in our libary with the callback function. + // We store both the original topic and the fully-qualified + mqtt_subfunctions_.emplace_back(device_type, std::move(topic), std::move(message->topic), std::move(cb)); +} + +// adds a command and callback function for a specific device +void Mqtt::add_command(const uint8_t device_type, const uint8_t device_id, const __FlashStringHelper * cmd, mqtt_cmdfunction_p cb) { + // subscribe to the command topic if it doesn't exist yet + std::string cmd_topic = EMSdevice::device_type_topic_name(device_type); // cmd topic for a device like "_cmd" e.g. "boiler_cmd" + + bool exists = false; + if (!mqtt_subfunctions_.empty()) { + for (const auto & mqtt_subfunction : mqtt_subfunctions_) { + if ((mqtt_subfunction.device_type_ == device_type) && (strcmp(mqtt_subfunction.topic_.c_str(), cmd_topic.c_str()) == 0)) { + exists = true; + } + } } + if (!exists) { + Mqtt::subscribe(device_type, cmd_topic, nullptr); // use an empty function handler to signal this is a command function + } + + LOG_DEBUG(F("Registering MQTT cmd %s with topic %s"), uuid::read_flash_string(cmd).c_str(), EMSdevice::device_type_topic_name(device_type).c_str()); + + mqtt_cmdfunctions_.emplace_back(device_type, device_id, cmd, cb); } // subscribe to an MQTT topic, and store the associated callback function. For generic functions not tied to a specific device @@ -100,7 +95,7 @@ void Mqtt::resubscribe() { } for (const auto & mqtt_subfunction : mqtt_subfunctions_) { - queue_message(Operation::SUBSCRIBE, mqtt_subfunction.topic_, "", false, true); // no payload, no topic prefixing + queue_subscribe_message(mqtt_subfunction.topic_); } } @@ -142,7 +137,19 @@ void Mqtt::show_mqtt(uuid::console::Shell & shell) { // show subscriptions shell.printfln(F("MQTT subscriptions:")); for (const auto & mqtt_subfunction : mqtt_subfunctions_) { - shell.printfln(F(" %s"), mqtt_subfunction.topic_.c_str()); + // don't show commands if its homeassistant + if ((strncmp(mqtt_subfunction.full_topic_.c_str(), "homeassistant/", 13) == 0)) { + shell.printf(F(" topic: %s"), mqtt_subfunction.full_topic_.c_str()); + } else { + // show the commands associated with this subscription + shell.printf(F(" topic: %s, [cmd]:"), mqtt_subfunction.full_topic_.c_str()); + for (const auto & mqtt_cmdfunction : mqtt_cmdfunctions_) { + if (EMSdevice::device_type_topic_name(mqtt_cmdfunction.device_type_) == mqtt_subfunction.topic_) { + shell.printf(F(" %s"), uuid::read_flash_string(mqtt_cmdfunction.cmd_).c_str()); + } + } + } + shell.println(); } shell.println(); @@ -183,15 +190,42 @@ void Mqtt::show_mqtt(uuid::console::Shell & shell) { } } shell.println(); -} +} // namespace emsesp +#if defined(EMSESP_DEBUG) // simulate receiving a MQTT message, used only for testing -void Mqtt::incoming(char * topic, char * payload) { +void Mqtt::incoming(const char * topic, const char * payload) { on_message(topic, payload, strlen(payload)); } +#endif + +// calls a command, context is the device_type +// id may be used to represent a heating circuit for example +bool Mqtt::call_command(const uint8_t device_type, const char * cmd, const char * value, const int8_t id) { +#ifdef EMSESP_DEBUG + if (id == -1) { + LOG_DEBUG(F("[DEBUG] Calling command %s, value %s, id is default"), cmd, value); + } else { + LOG_DEBUG(F("[DEBUG] Calling command %s, value %s, id is %d"), cmd, value, id); + } +#endif + + if (!mqtt_cmdfunctions_.empty()) { + for (const auto & cf : mqtt_cmdfunctions_) { + if (cf.device_type_ == device_type) { + const char * cf_cmd = uuid::read_flash_string(cf.cmd_).c_str(); + if (strcmp(cf_cmd, cmd) == 0) { + (cf.mqtt_cmdfunction_)(value, id); // call function, data needs to be a string and can be null + return true; + } + } + } + } + return false; +} // received an MQTT message that we subscribed too -void Mqtt::on_message(char * topic, char * payload, size_t len) { +void Mqtt::on_message(const char * topic, const char * payload, size_t len) { if (len == 0) { return; } @@ -199,33 +233,76 @@ void Mqtt::on_message(char * topic, char * payload, size_t len) { // convert payload to a null-terminated char string char message[len + 2]; strlcpy(message, payload, len + 1); + +#ifdef EMSESP_DEBUG LOG_DEBUG(F("[DEBUG] Received %s => %s (length %d)"), topic, message, len); +#endif // see if we have this topic in our subscription list, then call its callback handler - // note: this will pick the first topic that matches, so for multiple devices of the same type it's gonna fail. Not sure if this is going to be an issue? for (const auto & mf : mqtt_subfunctions_) { - if (strcmp(topic, mf.topic_.c_str()) == 0) { - (mf.mqtt_subfunction_)(message); - return; + if (strcmp(topic, mf.full_topic_.c_str()) == 0) { + if (mf.mqtt_subfunction_) { + (mf.mqtt_subfunction_)(message); // matching function, call it + return; + } else { + // empty function. It's a command then. Find the command from the json and call it directly. + StaticJsonDocument doc; + DeserializationError error = deserializeJson(doc, message); + if (error) { + LOG_ERROR(F("MQTT error: payload %s, error %s"), message, error.c_str()); + return; + } + + const char * command = doc["cmd"]; + if (command == nullptr) { + LOG_ERROR(F("MQTT error: invalid payload cmd format. message=%s"), message); + return; + } + + // check for hc and id, and convert to int + int8_t n = -1; // no value + if (doc.containsKey("hc")) { + n = doc["hc"]; + } else if (doc.containsKey("id")) { + n = doc["id"]; + } + + bool cmd_known = false; + JsonVariant data = doc["data"]; + if (data.is()) { + cmd_known = call_command(mf.device_type_, command, data.as(), n); + } else if (data.is()) { + char data_str[10]; + cmd_known = call_command(mf.device_type_, command, Helpers::itoa(data_str, (int16_t)data.as()), n); + } else if (data.is()) { + char data_str[10]; + cmd_known = call_command(mf.device_type_, command, Helpers::render_value(data_str, (float)data.as(), 2), n); + } + + if (!cmd_known) { + LOG_ERROR(F("MQTT: no matching cmd or invalid data: %s"), command); + } + + return; + } } } - // if we got here we didn't find a topic match - LOG_DEBUG(F("No responding handler found for topic %s"), topic); + LOG_ERROR(F("No MQTT handler found for topic %s and payload %s"), topic, message); } -// print all the topics related to a specific device_id -void Mqtt::show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_id) { +// print all the topics related to a specific device type +void Mqtt::show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_type) { if (std::count_if(mqtt_subfunctions_.cbegin(), mqtt_subfunctions_.cend(), - [=](MQTTSubFunction const & mqtt_subfunction) { return device_id == mqtt_subfunction.device_id_; }) + [=](MQTTSubFunction const & mqtt_subfunction) { return device_type == mqtt_subfunction.device_type_; }) == 0) { return; } shell.print(F(" Subscribed MQTT topics: ")); for (const auto & mqtt_subfunction : mqtt_subfunctions_) { - if (mqtt_subfunction.device_id_ == device_id) { + if (mqtt_subfunction.device_type_ == device_type) { shell.printf(F("%s "), mqtt_subfunction.topic_.c_str()); } } @@ -269,6 +346,8 @@ void Mqtt::start() { mqtt_qos_ = mqttSettings.mqtt_qos; }); + EMSESP::emsespSettingsService.read([&](EMSESPSettings & settings) { bus_id_ = settings.ems_bus_id; }); + mqttClient_->onConnect([this](bool sessionPresent) { on_connect(); }); mqttClient_->onDisconnect([this](AsyncMqttClientDisconnectReason reason) { @@ -297,9 +376,18 @@ void Mqtt::start() { mqttClient_->setWill(will_topic, 1, true, "offline"); // with qos 1, retain true mqttClient_->onMessage([this](char * topic, char * payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total) { + // receiving mqtt on_message(topic, payload, len); - mqttClient_->onPublish([this](uint16_t packetId) { on_publish(packetId); }); }); + + mqttClient_->onPublish([this](uint16_t packetId) { + // publish + on_publish(packetId); + }); + + // create space for command buffer, to avoid heap memory fragmentation + mqtt_cmdfunctions_.reserve(40); // current count with boiler+thermostat is 37 + mqtt_subfunctions_.reserve(10); } void Mqtt::set_publish_time(uint16_t publish_time) { @@ -327,31 +415,31 @@ void Mqtt::on_connect() { resubscribe(); // in case this is a reconnect, re-subscribe again to all MQTT topics - // add the system MQTT subscriptions, only if its a fresh start with no previous subscriptions - if (mqtt_subfunctions_.empty()) { - Mqtt::subscribe("cmd", System::mqtt_commands); - } + // these commands respond to the topic "system_cmd" and take a payload like {cmd:"", data:"", id:""} + add_command(EMSdevice::DeviceType::SERVICEKEY, bus_id_, F("pin"), System::mqtt_command_pin); + add_command(EMSdevice::DeviceType::SERVICEKEY, bus_id_, F("send"), System::mqtt_command_send); LOG_INFO(F("MQTT connected")); } -// add sub or pub task to the queue. When the message is created, the topic will have -// automatically the hostname prefixed. -std::shared_ptr -Mqtt::queue_message(const uint8_t operation, const std::string & topic, const std::string & payload, const bool retain, bool no_prefix) { +// add sub or pub task to the queue. +// a fully-qualified topic is created by prefixing the hostname, unless it's HA +// returns a pointer to the message created +std::shared_ptr Mqtt::queue_message(const uint8_t operation, const std::string & topic, const std::string & payload, const bool retain) { if (topic.empty()) { return nullptr; } // take the topic and prefix the hostname, unless its for HA std::shared_ptr message; - if ((strncmp(topic.c_str(), "homeassistant/", 13) == 0) || no_prefix) { + if ((strncmp(topic.c_str(), "homeassistant/", 13) == 0)) { // leave topic as it is - message = std::make_shared(operation, topic, payload, retain); + message = std::make_shared(operation, topic, std::move(payload), retain); } else { // prefix the hostname - std::string full_topic = Mqtt::hostname_ + "/" + topic; - message = std::make_shared(operation, full_topic, payload, retain); + std::string full_topic(50, '\0'); + snprintf_P(&full_topic[0], full_topic.capacity() + 1, PSTR("%s/%s"), Mqtt::hostname_.c_str(), topic.c_str()); + message = std::make_shared(operation, full_topic, std::move(payload), retain); } // if the queue is full, make room but removing the last one diff --git a/src/mqtt.h b/src/mqtt.h index b0ec6b3e8..a5afbe3c0 100644 --- a/src/mqtt.h +++ b/src/mqtt.h @@ -24,7 +24,7 @@ #include #include -#include +#include #include #include @@ -37,23 +37,29 @@ using uuid::console::Shell; -#define EMSESP_MAX_JSON_SIZE_SMALL 200 // for smaller json docs -#define EMSESP_MAX_JSON_SIZE_MEDIUM 800 // for smaller json docs from ems devices -#define EMSESP_MAX_JSON_SIZE_LARGE 1500 // for large json docs from ems devices, like boiler or thermostat data +#define EMSESP_MAX_JSON_SIZE_SMALL 200 // for smaller json docs when using StaticJsonDocument +#define EMSESP_MAX_JSON_SIZE_MEDIUM 800 // for smaller json docs from ems devices, when using StaticJsonDocument +#define EMSESP_MAX_JSON_SIZE_LARGE 1500 // for large json docs from ems devices, like boiler or thermostat data. Using DynamicJsonDocument namespace emsesp { using mqtt_subfunction_p = std::function; -using namespace std::placeholders; // for `_1` +using mqtt_cmdfunction_p = std::function; struct MqttMessage { - MqttMessage(const uint8_t operation, const std::string & topic, const std::string & payload, bool retain); ~MqttMessage() = default; const uint8_t operation; const std::string topic; const std::string payload; const bool retain; + + MqttMessage(const uint8_t operation, const std::string & topic, const std::string && payload, bool retain) + : operation(operation) + , topic(topic) + , payload(std::move(payload)) + , retain(retain) { + } }; class Mqtt { @@ -68,25 +74,31 @@ class Mqtt { static constexpr uint8_t MQTT_TOPIC_MAX_SIZE = 100; - static void subscribe(const uint8_t device_id, const std::string & topic, mqtt_subfunction_p cb); + static void subscribe(const uint8_t device_type, const std::string & topic, mqtt_subfunction_p cb); static void subscribe(const std::string & topic, mqtt_subfunction_p cb); static void resubscribe(); + static void add_command(const uint8_t device_type, const uint8_t device_id, const __FlashStringHelper * cmd, mqtt_cmdfunction_p cb); + static void publish(const std::string & topic, const std::string & payload, bool retain = false); static void publish(const std::string & topic, const JsonDocument & payload, bool retain = false); static void publish(const std::string & topic, const bool value); static void publish(const std::string & topic); - static void show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_id); + static void show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_type); static void show_mqtt(uuid::console::Shell & shell); static void on_connect(); + static bool call_command(const uint8_t device_type, const char * cmd, const char * value, const int8_t id); + void disconnect() { mqttClient_->disconnect(); } - void incoming(char * topic, char * payload); // for testing +#if defined(EMSESP_DEBUG) + void incoming(const char * topic, const char * payload); // for testing only +#endif static bool connected() { return mqttClient_->connected(); @@ -100,22 +112,43 @@ class Mqtt { mqtt_publish_fails_ = 0; } - static std::string hostname_; + struct MQTTCmdFunction { + uint8_t device_type_; + uint8_t device_id_; + const __FlashStringHelper * cmd_; + mqtt_cmdfunction_p mqtt_cmdfunction_; + + MQTTCmdFunction(uint8_t device_type, uint8_t device_id, const __FlashStringHelper * cmd, mqtt_cmdfunction_p mqtt_cmdfunction) + : device_type_(device_type) + , device_id_(device_id) + , cmd_(cmd) + , mqtt_cmdfunction_(mqtt_cmdfunction) { + } + }; + + static std::vector commands() { + return mqtt_cmdfunctions_; + } private: static uuid::log::Logger logger_; class QueuedMqttMessage { public: - QueuedMqttMessage(uint16_t id, std::shared_ptr && content); - ~QueuedMqttMessage() = default; - const uint16_t id_; const std::shared_ptr content_; uint8_t retry_count_; uint16_t packet_id_; + + ~QueuedMqttMessage() = default; + QueuedMqttMessage(uint16_t id, std::shared_ptr && content) + : id_(id) + , content_(std::move(content)) { + retry_count_ = 0; + packet_id_ = 0; + } }; - static std::deque mqtt_messages_; + static std::list mqtt_messages_; static AsyncMqttClient * mqttClient_; @@ -123,40 +156,47 @@ class Mqtt { static uint16_t mqtt_message_id_; static bool mqtt_retain_; - static constexpr size_t MAX_MQTT_MESSAGES = 30; // size of queue + static constexpr size_t MAX_MQTT_MESSAGES = 20; // size of queue static constexpr uint32_t MQTT_PUBLISH_WAIT = 200; // delay between sending publishes, to account for large payloads static constexpr uint8_t MQTT_PUBLISH_MAX_RETRY = 3; // max retries for giving up on publishing - static std::shared_ptr queue_message(const uint8_t operation, const std::string & topic, const std::string & payload, const bool retain, bool no_prefix = false); + static std::shared_ptr queue_message(const uint8_t operation, const std::string & topic, const std::string & payload, const bool retain); static std::shared_ptr queue_publish_message(const std::string & topic, const std::string & payload, const bool retain); static std::shared_ptr queue_subscribe_message(const std::string & topic); - void on_publish(uint16_t packetId); - void on_message(char * topic, char * payload, size_t len); - void process_queue(); - void process_all_queue(); + void on_publish(uint16_t packetId); + void on_message(const char * topic, const char * payload, size_t len); + void process_queue(); + void process_all_queue(); static uint16_t mqtt_publish_fails_; // function handlers for MQTT subscriptions - class MQTTSubFunction { - public: - MQTTSubFunction(const uint8_t device_id, const std::string && topic, mqtt_subfunction_p mqtt_subfunction); - ~MQTTSubFunction() = default; + struct MQTTSubFunction { + uint8_t device_type_; // which device type, from DeviceType:: + const std::string topic_; // short topic name + const std::string full_topic_; // the fully qualified topic name, usually with the hostname prefixed + mqtt_subfunction_p mqtt_subfunction_; // can be empty - const uint8_t device_id_; // which device ID owns this - const std::string topic_; - mqtt_subfunction_p mqtt_subfunction_; + MQTTSubFunction(uint8_t device_type, const std::string && topic, const std::string && full_topic, mqtt_subfunction_p mqtt_subfunction) + : device_type_(device_type) + , topic_(topic) + , full_topic_(full_topic) + , mqtt_subfunction_(mqtt_subfunction) { + } }; static std::vector mqtt_subfunctions_; // list of mqtt subscribe callbacks for all devices + static std::vector mqtt_cmdfunctions_; // list of commands uint32_t last_mqtt_poll_ = 0; uint32_t last_publish_ = 0; // settings, copied over - static uint8_t mqtt_qos_; - static uint16_t publish_time_; + static std::string hostname_; + static uint8_t mqtt_qos_; + static uint16_t publish_time_; + static uint8_t bus_id_; }; } // namespace emsesp diff --git a/src/sensors.cpp b/src/sensors.cpp index 26a0a1223..9973d0aca 100644 --- a/src/sensors.cpp +++ b/src/sensors.cpp @@ -16,13 +16,11 @@ * along with this program. If not, see . */ -// code written by nomis - https://github.com/nomis +// code originally written by nomis - https://github.com/nomis #include "sensors.h" #include "emsesp.h" -MAKE_PSTR(logger_name, "sensors") - #ifdef ESP32 #define YIELD #else @@ -31,7 +29,7 @@ MAKE_PSTR(logger_name, "sensors") namespace emsesp { -uuid::log::Logger Sensors::logger_{F_(logger_name), uuid::log::Facility::DAEMON}; +uuid::log::Logger Sensors::logger_{F_(sensors), uuid::log::Facility::DAEMON}; void Sensors::start() { // copy over values from MQTT so we don't keep on quering the filesystem @@ -206,7 +204,7 @@ float Sensors::get_temperature_c(const uint8_t addr[]) { break; } - uint32_t raw = (raw_value *625) / 100; // round to 0.01 + uint32_t raw = (raw_value * 625) / 100; // round to 0.01 return (float)raw / 100; #else return NAN; @@ -257,7 +255,7 @@ void Sensors::publish_values() { if (mqtt_format_ == MQTT_format::SINGLE) { StaticJsonDocument<100> doc; for (const auto & device : devices_) { - char s[5]; + char s[7]; // sensorrange -55.00 to 125.00 doc["temp"] = Helpers::render_value(s, device.temperature_c, 2); char topic[60]; // sensors{1-n} strlcpy(topic, "sensor_", 50); // create topic, e.g. home/ems-esp/sensor_28-EA41-9497-0E03-5F @@ -283,12 +281,12 @@ void Sensors::publish_values() { uint8_t i = 1; for (const auto & device : devices_) { if (mqtt_format_ == MQTT_format::CUSTOM) { - char s[5]; + char s[7]; doc[device.to_string()] = Helpers::render_value(s, device.temperature_c, 2); } else { char sensorID[10]; // sensor{1-n} strlcpy(sensorID, "sensor", 10); - char s[5]; + char s[7]; strlcat(sensorID, Helpers::itoa(s, i++), 10); JsonObject dataSensor = doc.createNestedObject(sensorID); dataSensor["id"] = device.to_string(); @@ -303,4 +301,4 @@ void Sensors::publish_values() { } } -} // namespace emsesp +} // namespace emsesp \ No newline at end of file diff --git a/src/sensors.h b/src/sensors.h index 7ec37d6d3..f98797cd5 100644 --- a/src/sensors.h +++ b/src/sensors.h @@ -16,7 +16,7 @@ * along with this program. If not, see . */ -// code written by nomis - https://github.com/nomis +// code originally written by nomis - https://github.com/nomis #ifndef EMSESP_SENSORS_H #define EMSESP_SENSORS_H @@ -87,10 +87,10 @@ class Sensors { static constexpr uint8_t TYPE_DS1822 = 0x22; static constexpr uint8_t TYPE_DS1825 = 0x3B; - static constexpr uint32_t READ_INTERVAL_MS = 5000; // 5 seconds - static constexpr uint32_t CONVERSION_MS = 1000; // 1 seconds - static constexpr uint32_t READ_TIMEOUT_MS = 2000; // 2 seconds - static constexpr uint32_t SCAN_TIMEOUT_MS = 3000; // 3 seconds + static constexpr uint32_t READ_INTERVAL_MS = 5000; // 5 seconds + static constexpr uint32_t CONVERSION_MS = 1000; // 1 seconds + static constexpr uint32_t READ_TIMEOUT_MS = 2000; // 2 seconds + static constexpr uint32_t SCAN_TIMEOUT_MS = 3000; // 3 seconds static constexpr uint8_t CMD_CONVERT_TEMP = 0x44; static constexpr uint8_t CMD_READ_SCRATCHPAD = 0xBE; @@ -112,9 +112,8 @@ class Sensors { uint8_t mqtt_format_; uint8_t retrycnt_ = 0; - }; } // namespace emsesp -#endif +#endif \ No newline at end of file diff --git a/src/shower.cpp b/src/shower.cpp index 6ca21de5d..2d8e33ef2 100644 --- a/src/shower.cpp +++ b/src/shower.cpp @@ -18,11 +18,9 @@ #include "shower.h" -MAKE_PSTR(logger_name, "shower") - namespace emsesp { -uuid::log::Logger Shower::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger Shower::logger_{F_(shower), uuid::log::Facility::CONSOLE}; void Shower::start() { EMSESP::emsespSettingsService.read([&](EMSESPSettings & settings) { diff --git a/src/system.cpp b/src/system.cpp index 9bac30722..e0d22706c 100644 --- a/src/system.cpp +++ b/src/system.cpp @@ -21,25 +21,9 @@ #include "version.h" // firmware version of EMS-ESP -MAKE_PSTR_WORD(passwd) -MAKE_PSTR_WORD(hostname) -MAKE_PSTR_WORD(wifi) -MAKE_PSTR_WORD(reconnect) -MAKE_PSTR_WORD(ssid) -MAKE_PSTR_WORD(heartbeat) -MAKE_PSTR_WORD(users) - -MAKE_PSTR(host_fmt, "Host = %s") -MAKE_PSTR(hostname_fmt, "WiFi Hostname = %s") -MAKE_PSTR(mark_interval_fmt, "Mark interval = %lus"); -MAKE_PSTR(wifi_ssid_fmt, "WiFi SSID = %s"); -MAKE_PSTR(wifi_password_fmt, "WiFi Password = %S") - -MAKE_PSTR(logger_name, "system") - namespace emsesp { -uuid::log::Logger System::logger_{F_(logger_name), uuid::log::Facility::KERN}; +uuid::log::Logger System::logger_{F_(system), uuid::log::Facility::KERN}; #ifndef EMSESP_STANDALONE uuid::syslog::SyslogService System::syslog_; @@ -50,94 +34,20 @@ uint32_t System::heap_start_ = 0; int System::reset_counter_ = 0; bool System::upload_status_ = false; -// handle generic system related MQTT commands -void System::mqtt_commands(const char * message) { - StaticJsonDocument doc; - DeserializationError error = deserializeJson(doc, message); - if (error) { - LOG_DEBUG(F("MQTT error: payload %s, error %s"), message, error.c_str()); - return; +// send on/off to a gpio pin +// value: true = HIGH, false = LOW +void System::mqtt_command_pin(const char * value, const int8_t id) { + bool v = false; + if (Helpers::value2bool(value, v)) { + pinMode(id, OUTPUT); + digitalWrite(id, v); + LOG_INFO(F("GPIO %d set to %s"), id, v ? "HIGH" : "LOW"); } +} - if (doc["send"] != nullptr) { - const char * data = doc["send"]; - EMSESP::send_raw_telegram(data); - LOG_INFO(F("Sending raw: %s"), data); - } - -#if defined(ESP8266) - const uint8_t d0_ = 16; - const uint8_t d1_ = 5; - const uint8_t d2_ = 4; - const uint8_t d3_ = 0; -#elif defined(ESP32) - const uint8_t d0_ = 26; - const uint8_t d1_ = 22; - const uint8_t d2_ = 21; - const uint8_t d3_ = 17; -#endif - -#ifndef EMSESP_STANDALONE - if (doc["D0"] != nullptr) { - const int8_t set = doc["D0"]; - pinMode(d0_, OUTPUT); - if (set == 1) { - digitalWrite(d0_, HIGH); - } else if (set == 0) { - digitalWrite(d0_, LOW); - } - LOG_INFO(F("Port D0 set to %d"), set); - } - - if (doc["D1"] != nullptr) { - const int8_t set = doc["D1"]; - pinMode(d1_, OUTPUT); - if (set == 1) { - digitalWrite(d1_, HIGH); - } else if (set == 0) { - digitalWrite(d1_, LOW); - } - LOG_INFO(F("Port D1 set to %d"), set); - } - - if (doc["D2"] != nullptr) { - const int8_t set = doc["D2"]; - pinMode(d2_, OUTPUT); - if (set == 1) { - digitalWrite(d2_, HIGH); - } else if (set == 0) { - digitalWrite(d2_, LOW); - } - LOG_INFO(F("Port D2 set to %d"), set); - } - - if (doc["D3"] != nullptr) { - const int8_t set = doc["D3"]; - pinMode(d3_, OUTPUT); - if (set == 1) { - digitalWrite(d3_, HIGH); - } else if (set == 0) { - digitalWrite(d3_, LOW); - } - LOG_INFO(F("Port D3 set to %d"), set); - } -#endif - - const char * command = doc["cmd"]; - if (command == nullptr) { - return; - } - - // send raw command - if (strcmp(command, "send") == 0) { - const char * data = doc["data"]; - if (data == nullptr) { - return; - } - EMSESP::send_raw_telegram(data); - LOG_INFO(F("Sending raw: %s"), data); - return; - } +// send raw +void System::mqtt_command_send(const char * value, const int8_t id) { + EMSESP::send_raw_telegram(value); // ignore id } // restart EMS-ESP @@ -280,6 +190,24 @@ void System::loop() { send_heartbeat(); } } + +#if defined(ESP8266) +#if defined(EMSESP_DEBUG) + static uint32_t last_memcheck_ = 0; + if (currentMillis - last_memcheck_ > 10000) { // 10 seconds + last_memcheck_ = currentMillis; + show_mem("core"); + } +#endif +#endif +} + +void System::show_mem(const char * note) { +#if defined(ESP8266) +#if defined(EMSESP_DEBUG) + LOG_INFO(F("(%s) Free heap: %d%% (%lu), frag:%u%%"), note, free_mem(), (unsigned long)ESP.getFreeHeap(), ESP.getHeapFragmentation()); +#endif +#endif } // send periodic MQTT message with system information @@ -297,6 +225,7 @@ void System::send_heartbeat() { doc["freemem"] = free_mem(); doc["mqttpublishfails"] = Mqtt::publish_fails(); doc["txfails"] = EMSESP::txservice_.telegram_fail_count(); + doc["rxfails"] = EMSESP::rxservice_.telegram_error_count(); Mqtt::publish("heartbeat", doc, false); // send to MQTT with retain off. This will add to MQTT queue. } @@ -398,6 +327,7 @@ void System::show_users(uuid::console::Shell & shell) { void System::show_system(uuid::console::Shell & shell) { shell.printfln(F("Uptime: %s"), uuid::log::format_timestamp_ms(uuid::get_uptime_ms(), 3).c_str()); +#ifndef EMSESP_STANDALONE #if defined(ESP8266) shell.printfln(F("Chip ID: 0x%08x"), ESP.getChipId()); shell.printfln(F("SDK version: %s"), ESP.getSdkVersion()); @@ -407,26 +337,22 @@ void System::show_system(uuid::console::Shell & shell) { shell.printfln(F("Boot mode: %u"), ESP.getBootMode()); shell.printfln(F("CPU frequency: %u MHz"), ESP.getCpuFreqMHz()); shell.printfln(F("Flash chip: 0x%08X (%u bytes)"), ESP.getFlashChipId(), ESP.getFlashChipRealSize()); - shell.printfln(F("Sketch size: %u bytes (%u bytes free)"), ESP.getSketchSize(), ESP.getFreeSketchSpace()); shell.printfln(F("Reset reason: %s"), ESP.getResetReason().c_str()); shell.printfln(F("Reset info: %s"), ESP.getResetInfo().c_str()); - shell.println(); shell.printfln(F("Free heap: %lu bytes"), (unsigned long)ESP.getFreeHeap()); - shell.printfln(F("Free mem: %d %%"), free_mem()); + shell.printfln(F("Free mem: %d %%"), free_mem()); shell.printfln(F("Maximum free block size: %lu bytes"), (unsigned long)ESP.getMaxFreeBlockSize()); - shell.printfln(F("Heap fragmentation: %u%"), ESP.getHeapFragmentation()); + shell.printfln(F("Heap fragmentation: %u %%"), ESP.getHeapFragmentation()); shell.printfln(F("Free continuations stack: %lu bytes"), (unsigned long)ESP.getFreeContStack()); #elif defined(ESP32) shell.printfln(F("SDK version: %s"), ESP.getSdkVersion()); shell.printfln(F("CPU frequency: %u MHz"), ESP.getCpuFreqMHz()); +#endif shell.printfln(F("Sketch size: %u bytes (%u bytes free)"), ESP.getSketchSize(), ESP.getFreeSketchSpace()); shell.printfln(F("Free heap: %lu bytes"), (unsigned long)ESP.getFreeHeap()); shell.printfln(F("Free mem: %d %%"), free_mem()); -#endif - shell.println(); -#ifndef EMSESP_STANDALONE switch (WiFi.status()) { case WL_IDLE_STATUS: shell.printfln(F("WiFi: Idle")); @@ -446,6 +372,7 @@ void System::show_system(uuid::console::Shell & shell) { shell.printfln(F("BSSID: %s"), WiFi.BSSIDstr().c_str()); shell.printfln(F("RSSI: %d dBm (%d %%)"), WiFi.RSSI(), wifi_quality()); shell.printfln(F("MAC address: %s"), WiFi.macAddress().c_str()); + #if defined(ESP8266) shell.printfln(F("Hostname: %s"), WiFi.hostname().c_str()); #elif defined(ESP32) @@ -480,7 +407,7 @@ void System::show_system(uuid::console::Shell & shell) { shell.print(" "); shell.printfln(F_(host_fmt), !settings.syslog_host.isEmpty() ? settings.syslog_host.c_str() : uuid::read_flash_string(F_(unset)).c_str()); shell.print(" "); - shell.printfln(F_(log_level_fmt), uuid::log::format_level_uppercase(static_cast(settings.syslog_level))); + shell.printfln(F_(log_level_fmt), uuid::log::format_level_lowercase(static_cast(settings.syslog_level))); shell.print(" "); shell.printfln(F_(mark_interval_fmt), settings.syslog_mark_interval); }); @@ -628,17 +555,31 @@ void System::console_commands(Shell & shell, unsigned int context) { shell.printfln(F_(wifi_password_fmt), wifiSettings.ssid.isEmpty() ? F_(unset) : F_(asterisks)); }); }); - +/* EMSESPShell::commands->add_command(ShellContext::SYSTEM, CommandFlags::USER, flash_string_vector{F_(show), F_(mqtt)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { Mqtt::show_mqtt(shell); }); - +*/ EMSESPShell::commands->add_command(ShellContext::SYSTEM, CommandFlags::ADMIN, flash_string_vector{F_(show), F_(users)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { System::show_users(shell); }); + EMSESPShell::commands->add_command(ShellContext::SYSTEM, + CommandFlags::ADMIN, + flash_string_vector{F_(pin)}, + flash_string_vector{F_(gpio_mandatory), F_(data_optional)}, + [](Shell & shell, const std::vector & arguments) { + if (arguments.size() == 1) { + shell.printfln(F("use on/off, 1/0 or true/false")); + return; + } + int pin = 0; + if (Helpers::value2number(arguments[0].c_str(), pin)) { + System::mqtt_command_pin(arguments[1].c_str(), pin); + } + }); // enter the context Console::enter_custom_context(shell, context); @@ -646,9 +587,10 @@ void System::console_commands(Shell & shell, unsigned int context) { // upgrade from previous versions of EMS-ESP void System::check_upgrade() { + /* // check for v1.9. It uses SPIFFS and only on the ESP8266 #if defined(ESP8266) - Serial.begin(115200); // TODO remove, just for debugging + Serial.begin(115200); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" @@ -771,6 +713,7 @@ void System::check_upgrade() { }, "local"); #endif +*/ } } // namespace emsesp diff --git a/src/system.h b/src/system.h index e46965017..9cb62f9ab 100644 --- a/src/system.h +++ b/src/system.h @@ -47,7 +47,9 @@ class System { static void format(uuid::console::Shell & shell); static void console_commands(Shell & shell, unsigned int context); - static void mqtt_commands(const char * message); + + static void mqtt_command_pin(const char * value, const int8_t id); + static void mqtt_command_send(const char * value, const int8_t id); static uint8_t free_mem(); static void upload_status(bool in_progress); @@ -59,6 +61,8 @@ class System { void set_heartbeat(bool system_heartbeat); void send_heartbeat(); + static void show_mem(const char * note); + void check_upgrade(); private: @@ -68,7 +72,7 @@ class System { static uuid::syslog::SyslogService syslog_; #endif - static constexpr uint32_t SYSTEM_CHECK_FREQUENCY = 10000; // check every 10 seconds + static constexpr uint32_t SYSTEM_CHECK_FREQUENCY = 5000; // check every 5 seconds static constexpr uint32_t LED_WARNING_BLINK = 1000; // pulse to show no connection, 1 sec static constexpr uint32_t LED_WARNING_BLINK_FAST = 100; // flash quickly for boot up sequence static constexpr uint32_t SYSTEM_HEARTBEAT_INTERVAL = 60000; // in milliseconds, how often the MQTT heartbeat is sent (1 min) diff --git a/src/telegram.cpp b/src/telegram.cpp index 97e2a41ce..02c119a63 100644 --- a/src/telegram.cpp +++ b/src/telegram.cpp @@ -19,8 +19,6 @@ #include "telegram.h" #include "emsesp.h" -MAKE_PSTR(logger_name, "telegram") - namespace emsesp { // CRC lookup table with poly 12 for faster checking @@ -45,7 +43,7 @@ uint8_t EMSbus::ems_bus_id_ = EMSESP_DEFAULT_EMS_BUS_ID; uint8_t EMSbus::tx_mode_ = EMSESP_DEFAULT_TX_MODE; uint8_t EMSbus::tx_state_ = Telegram::Operation::NONE; -uuid::log::Logger EMSbus::logger_{F_(logger_name), uuid::log::Facility::CONSOLE}; +uuid::log::Logger EMSbus::logger_{F_(telegram), uuid::log::Facility::CONSOLE}; // Calculates CRC checksum using lookup table for speed // length excludes the last byte (which mainly is the CRC) @@ -80,12 +78,8 @@ Telegram::Telegram(const uint8_t operation, } } -// returns telegram's message data bytes in hex +// returns telegram as data bytes in hex (excluding CRC) std::string Telegram::to_string() const { - if (this->message_length == 0) { - return read_flash_string(F("")); - } - uint8_t data[EMS_MAX_TELEGRAM_LENGTH]; uint8_t length = 0; data[0] = this->src ^ RxService::ems_mask(); @@ -124,34 +118,13 @@ std::string Telegram::to_string() const { return Helpers::data_to_hex(data, length); } -// returns telegram's full telegram message in hex -std::string Telegram::to_string(const uint8_t * telegram, uint8_t length) const { - return Helpers::data_to_hex(telegram, length); -} - -RxService::QueuedRxTelegram::QueuedRxTelegram(uint16_t id, std::shared_ptr && telegram) - : id_(id) - , telegram_(std::move(telegram)) { -} - -// empty queue, don't process them -void RxService::flush_rx_queue() { - rx_telegrams_.clear(); - rx_telegram_id_ = 0; -} - -// Rx loop, run as many times as you can -// processes all telegrams on the queue. Assumes there are valid (i.e. CRC checked) -void RxService::loop() { - while (!rx_telegrams_.empty()) { - auto telegram = rx_telegrams_.front().telegram_; - - (void)EMSESP::process_telegram(telegram); // further process the telegram - - increment_telegram_count(); // increase count - - rx_telegrams_.pop_front(); // remove it from the queue +// returns telegram's message body only, in hex +std::string Telegram::to_string_message() const { + if (this->message_length == 0) { + return read_flash_string(F("")); } + + return Helpers::data_to_hex(this->message_data, this->message_length); } // add a new rx telegram object @@ -163,13 +136,11 @@ void RxService::add(uint8_t * data, uint8_t length) { return; } - // validate the CRC + // validate the CRC. if it fails then increment the number of corrupt/incomplete telegrams and only report to console/syslog uint8_t crc = calculate_crc(data, length - 1); if (data[length - 1] != crc) { increment_telegram_error_count(); - if (EMSESP::watch() != EMSESP::Watch::WATCH_OFF) { - LOG_ERROR(F("Rx: %s %s(CRC %02X != %02X)%s"), Helpers::data_to_hex(data, length).c_str(), COLOR_RED, data[length - 1], crc, COLOR_RESET); - } + LOG_ERROR(F("Rx: %s (CRC %02X != %02X)"), Helpers::data_to_hex(data, length).c_str(), data[length - 1], crc); return; } @@ -220,35 +191,30 @@ void RxService::add(uint8_t * data, uint8_t length) { } #ifdef EMSESP_DEBUG - LOG_DEBUG(F("[DEBUG] New Rx [#%d] telegram, message length %d"), rx_telegram_id_, message_length); + LOG_DEBUG(F("[DEBUG] New Rx telegram, message length %d"), message_length); #endif - // if we don't have a type_id or empty data block, exit - if ((type_id == 0) || (message_length == 0)) { + // if we don't have a type_id exit, + // do not exit on empty message, it is checked for toggle fetch + if (type_id == 0) { return; } + // if we receive a hc2.. telegram from 0x19.. match it to master_thermostat if master is 0x18 + src = EMSESP::check_master_device(src, type_id, true); + // create the telegram - auto telegram = std::make_shared(Telegram::Operation::RX, src, dest, type_id, offset, message_data, message_length); + rx_telegram = std::make_shared(Telegram::Operation::RX, src, dest, type_id, offset, message_data, message_length); - // check if queue is full, if so remove top item to make space - if (rx_telegrams_.size() >= MAX_RX_TELEGRAMS) { - rx_telegrams_.pop_front(); - } - - rx_telegrams_.emplace_back(rx_telegram_id_++, std::move(telegram)); // add to queue + // process it immediately + EMSESP::process_telegram(rx_telegram); // further process the telegram + increment_telegram_count(); // increase count } // // Tx CODE starts here... // -TxService::QueuedTxTelegram::QueuedTxTelegram(uint16_t id, std::shared_ptr && telegram, bool retry) - : id_(id) - , telegram_(std::move(telegram)) - , retry_(retry) { -} - // empty queue, don't process void TxService::flush_tx_queue() { tx_telegrams_.clear(); @@ -290,23 +256,18 @@ void TxService::send() { } // if there's nothing in the queue to transmit, send back a poll and quit - // unless tx_mode is 0 if (tx_telegrams_.empty()) { send_poll(); return; } // if we're in read-only mode (tx_mode 0) forget the Tx call - if (tx_mode() == 0) { - tx_telegrams_.pop_front(); - return; + if (tx_mode() != 0) { + send_telegram(tx_telegrams_.front()); } - // send next telegram in the queue (which is actually a list!) - send_telegram(tx_telegrams_.front()); - // remove the telegram from the queue - tx_telegrams_.pop_front(); + tx_telegrams_.pop_front(); // remove the telegram from the queue } // process a Tx telegram @@ -326,6 +287,10 @@ void TxService::send_telegram(const QueuedTxTelegram & tx_telegram) { // dest - for READ the MSB must be set // fix the READ or WRITE depending on the operation uint8_t dest = telegram->dest; + + // check if we have to manipulate the id for thermostats > 0x18 + dest = EMSESP::check_master_device(dest, telegram->type_id, false); + if (telegram->operation == Telegram::Operation::TX_READ) { dest |= 0x80; // read has 8th bit set for the destination } @@ -382,7 +347,7 @@ void TxService::send_telegram(const QueuedTxTelegram & tx_telegram) { LOG_DEBUG(F("Sending %s Tx [#%d], telegram: %s"), (telegram->operation == Telegram::Operation::TX_WRITE) ? F("write") : F("read"), tx_telegram.id_, - telegram->to_string(telegram_raw, length).c_str()); + Helpers::data_to_hex(telegram_raw, length).c_str()); // send the telegram to the UART Tx uint16_t status = EMSuart::transmit(telegram_raw, length); @@ -572,11 +537,13 @@ void TxService::retry_tx(const uint8_t operation, const uint8_t * data, const ui return; } +#ifdef EMSESP_DEBUG LOG_DEBUG(F("[DEBUG] Last Tx %s operation failed. Retry #%d. sent message: %s, received: %s"), (operation == Telegram::Operation::TX_WRITE) ? F("Write") : F("Read"), retry_count_, telegram_last_->to_string().c_str(), Helpers::data_to_hex(data, length).c_str()); +#endif // add to the top of the queue if (tx_telegrams_.size() >= MAX_TX_TELEGRAMS) { diff --git a/src/telegram.h b/src/telegram.h index 14f762a12..02a6e29b8 100644 --- a/src/telegram.h +++ b/src/telegram.h @@ -20,9 +20,7 @@ #define EMSESP_TELEGRAM_H #include -#include -#include // for unique ptrs -#include +#include // UART drivers #if defined(ESP8266) @@ -38,9 +36,9 @@ #include "helpers.h" // default values for null values -static constexpr uint8_t VALUE_BOOL = true; // is a boolean -static constexpr uint8_t EMS_VALUE_BOOL = 0xFF; // is a boolean -static constexpr uint8_t EMS_VALUE_BOOL_OFF = 0x00; // boolean false. True can be 0x01 or 0xFF sometimes. +static constexpr uint8_t EMS_VALUE_BOOL = 0xFF; // used to mark that something is a boolean +static constexpr uint8_t EMS_VALUE_BOOL_OFF = 0x00; // boolean false +static constexpr uint8_t EMS_VALUE_BOOL_ON = 0x01; // boolean true. True can be 0x01 or 0xFF sometimes static constexpr uint8_t EMS_VALUE_BOOL_NOTSET = 0xFE; // random number for booleans, that's not 0, 1 or FF static constexpr uint8_t EMS_VALUE_UINT_NOTSET = 0xFF; // for 8-bit unsigned ints/bytes @@ -83,8 +81,8 @@ class Telegram { TX_WRITE, }; + std::string to_string_message() const; std::string to_string() const; - std::string to_string(const uint8_t * telegram, uint8_t length) const; // reads a bit value from a given telegram position void read_bitvalue(uint8_t & value, const uint8_t index, const uint8_t bit) const { @@ -112,8 +110,7 @@ class Telegram { value = 0; for (uint8_t i = 0; i < size; i++) { - // shift - value = (value << 8) + message_data[abs_index + i]; + value = (value << 8) + message_data[abs_index + i]; // shift } } @@ -198,63 +195,39 @@ class EMSbus { class RxService : public EMSbus { public: - static constexpr size_t MAX_RX_TELEGRAMS = 20; - RxService() = default; ~RxService() = default; - void loop(); - void add(uint8_t * data, uint8_t length); - void flush_rx_queue(); - uint16_t telegram_count() const { return telegram_count_; } - uint16_t telegram_error_count() const { - return telegram_error_count_; - } - void increment_telegram_count() { telegram_count_++; } + uint16_t telegram_error_count() const { + return telegram_error_count_; + } + void increment_telegram_error_count() { telegram_error_count_++; } - class QueuedRxTelegram { - public: - QueuedRxTelegram(uint16_t id, std::shared_ptr && telegram); - ~QueuedRxTelegram() = default; - - uint16_t id_; // sequential identifier - const std::shared_ptr telegram_; - }; - - const std::deque queue() const { - return rx_telegrams_; - } - private: - uint32_t last_rx_check_ = 0; - - uint8_t rx_telegram_id_ = 0; // queue counter - - uint16_t telegram_count_ = 0; // # Rx received - uint16_t telegram_error_count_ = 0; // # Rx CRC errors - - std::deque rx_telegrams_; + uint16_t telegram_count_ = 0; // # Rx received + uint16_t telegram_error_count_ = 0; // # Rx CRC errors + std::shared_ptr rx_telegram; // the incoming Rx telegram }; class TxService : public EMSbus { public: - static constexpr size_t MAX_TX_TELEGRAMS = 30; // size of Tx queue + static constexpr size_t MAX_TX_TELEGRAMS = 20; // size of Tx queue - static constexpr uint8_t TX_WRITE_FAIL = 4; - static constexpr uint8_t TX_WRITE_SUCCESS = 1; + static constexpr uint8_t TX_WRITE_FAIL = 4; // EMS return code for fail + static constexpr uint8_t TX_WRITE_SUCCESS = 1; // EMS return code for success TxService() = default; ~TxService() = default; @@ -337,26 +310,30 @@ class TxService : public EMSbus { class QueuedTxTelegram { public: - QueuedTxTelegram(uint16_t id, std::shared_ptr && telegram, bool retry); - ~QueuedTxTelegram() = default; - - uint16_t id_; // sequential identifier + const uint16_t id_; const std::shared_ptr telegram_; - bool retry_; // is a retry + const bool retry_; // is a retry + + ~QueuedTxTelegram() = default; + QueuedTxTelegram(uint16_t id, std::shared_ptr && telegram, bool retry) + : id_(id) + , telegram_(std::move(telegram)) + , retry_(retry) { + } }; - const std::deque queue() const { + const std::list queue() const { return tx_telegrams_; } +#if defined(EMSESP_DEBUG) + static constexpr uint8_t MAXIMUM_TX_RETRIES = 0; // when compiled with EMSESP_DEBUG don't retry +#else static constexpr uint8_t MAXIMUM_TX_RETRIES = 3; +#endif private: - uint8_t tx_telegram_id_ = 0; // queue counter - - uint32_t last_tx_check_ = 0; - - std::deque tx_telegrams_; + std::list tx_telegrams_; // the Tx queue uint16_t telegram_read_count_ = 0; // # Tx successful reads uint16_t telegram_write_count_ = 0; // # Tx successful writes @@ -364,7 +341,9 @@ class TxService : public EMSbus { std::shared_ptr telegram_last_; uint16_t telegram_last_post_send_query_; // which type ID to query after a successful send, to read back the values just written - uint8_t retry_count_ = 0; // count for # Tx retries + uint8_t retry_count_ = 0; // count for # Tx retries + + uint8_t tx_telegram_id_ = 0; // queue counter void send_telegram(const QueuedTxTelegram & tx_telegram); void send_telegram(const uint8_t * data, const uint8_t length); diff --git a/src/test/test.cpp b/src/test/test.cpp index 440245cad..524027744 100644 --- a/src/test/test.cpp +++ b/src/test/test.cpp @@ -17,7 +17,8 @@ * along with this program. If not, see . */ -#if defined(EMSESP_STANDALONE) + +#if defined(EMSESP_DEBUG) #include "test.h" @@ -26,6 +27,14 @@ namespace emsesp { // create some fake test data // used with the 'test' command, under su/admin void Test::run_test(uuid::console::Shell & shell, const std::string & command) { + if (command == "default") { + run_test(shell, "mqtt"); // add the default test case here + } + + if (command.empty()) { + run_test(shell, "default"); + } + if (command == "render") { uint8_t test1 = 12; int8_t test2 = -12; @@ -129,7 +138,7 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { rx_telegram({0x08, 0x00, 0x07, 0x00, 0x0B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}); } - if (command == "boiler2") { + if (command == "boiler") { // question: do we need to set the mask? std::string version("1.2.3"); EMSESP::add_device(0x08, 123, version, EMSdevice::Brand::BUDERUS); // Nefit Trendline @@ -142,11 +151,9 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { // add boiler EMSESP::add_device(0x08, 84, version, EMSdevice::Brand::BUDERUS); - EMSESP::rxservice_.loop(); // add Controller - BC10 GB142 - but using the same device_id to see what happens EMSESP::add_device(0x09, 84, version, EMSdevice::Brand::BUDERUS); - EMSESP::rxservice_.loop(); // simulate getting version information back from an unknown device // note there is no brand (byte 9) @@ -172,25 +179,64 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { // add thermostat - Thermostat: RC300/RC310/Moduline 3000/CW400/Sense II (DeviceID:0x10, ProductID:158, Version:03.03) ** master device ** std::string version("01.03"); EMSESP::add_device(0x10, 158, version, EMSdevice::Brand::BUDERUS); - EMSESP::rxservice_.loop(); // simulate incoming telegram // Thermostat(0x10) -> 48(0x48), ?(0x26B), data: 6B 08 4F 00 00 00 02 00 00 00 02 00 03 00 03 00 03 rx_telegram({0x10, 0x48, 0xFF, 00, 01, 0x6B, 00, 0x6B, 0x08, 0x4F, 00, 00, 00, 02, 00, 00, 00, 02, 00, 03, 00, 03, 00, 03}); } - if (command == "thermostat") { - shell.printfln(F("Testing adding devices on the EMS bus...")); + if (command == "general") { + shell.printfln(F("Testing adding a boiler & thermostat...")); - // create some fake devices std::string version("1.2.3"); + EMSESP::add_device(0x08, 123, version, EMSdevice::Brand::BUDERUS); // Nefit Trendline + EMSESP::add_device(0x18, 157, version, EMSdevice::Brand::BOSCH); // Bosch CR100 - https://github.com/proddy/EMS-ESP/issues/355 + + // add some data + // Boiler -> Me, UBAMonitorFast(0x18), telegram: 08 00 18 00 00 02 5A 73 3D 0A 10 65 40 02 1A 80 00 01 E1 01 76 0E 3D 48 00 C9 44 02 00 (#data=25) + uart_telegram({0x08, 0x00, 0x18, 0x00, 0x00, 0x02, 0x5A, 0x73, 0x3D, 0x0A, 0x10, 0x65, 0x40, 0x02, 0x1A, + 0x80, 0x00, 0x01, 0xE1, 0x01, 0x76, 0x0E, 0x3D, 0x48, 0x00, 0xC9, 0x44, 0x02, 0x00}); + + // Boiler -> Thermostat, UBAParameterWW(0x33), telegram: 08 97 33 00 23 24 (#data=2) + uart_telegram({0x08, 0x98, 0x33, 0x00, 0x23, 0x24}); + + // Boiler -> Me, UBAParameterWW(0x33), telegram: 08 0B 33 00 08 FF 34 FB 00 28 00 00 46 00 FF FF 00 (#data=13) + uart_telegram({0x08, 0x0B, 0x33, 0x00, 0x08, 0xFF, 0x34, 0xFB, 0x00, 0x28, 0x00, 0x00, 0x46, 0x00, 0xFF, 0xFF, 0x00}); + + // Thermostat RCPLUSStatusMessage_HC1(0x01A5) + uart_telegram({0x98, 0x00, 0xFF, 0x00, 0x01, 0xA5, 0x00, 0xCF, 0x21, 0x2E, 0x00, 0x00, 0x2E, 0x24, + 0x03, 0x25, 0x03, 0x03, 0x01, 0x03, 0x25, 0x00, 0xC8, 0x00, 0x00, 0x11, 0x01, 0x03}); + + shell.invoke_command("show"); + // shell.invoke_command("system"); + // shell.invoke_command("show mqtt"); + + // shell.loop_all(); + } + + if (command == "thermostat") { + shell.printfln(F("Testing adding a thermostat to the EMS bus...")); // add_device(0x10, 165, version, EMSdevice::Brand::BUDERUS); // add_device(0x17, 125, version, EMSdevice::Brand::BUDERUS); // test unknown class test // add_device(0x17, 93, version, EMSdevice::Brand::BUDERUS); // add_device(0x17, 254, version, EMSdevice::Brand::BUDERUS); // test unknown product_id + // EMSESP::add_device(0x18, 157, version, EMSdevice::Brand::BOSCH); // Bosch CR100 - https://github.com/proddy/EMS-ESP/issues/355 + + std::string version("1.2.3"); + + // add a boiler + // EMSESP::add_device(0x08, 123, version, EMSdevice::Brand::BUDERUS); // Nefit Trendline + + // add a thermostat EMSESP::add_device(0x18, 157, version, EMSdevice::Brand::BOSCH); // Bosch CR100 - https://github.com/proddy/EMS-ESP/issues/355 + + // RCPLUSStatusMessage_HC1(0x01A5) + uart_telegram({0x98, 0x00, 0xFF, 0x00, 0x01, 0xA5, 0x00, 0xCF, 0x21, 0x2E, 0x00, 0x00, 0x2E, 0x24, + 0x03, 0x25, 0x03, 0x03, 0x01, 0x03, 0x25, 0x00, 0xC8, 0x00, 0x00, 0x11, 0x01, 0x03}); + + shell.loop_all(); } if (command == "solar") { @@ -201,8 +247,6 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { std::string version("1.2.3"); EMSESP::add_device(0x30, 163, version, EMSdevice::Brand::BUDERUS); // SM100 - EMSESP::rxservice_.loop(); - // SM100Monitor - type 0x0362 EMS+ - for SM100 and SM200 // B0 0B FF 00 02 62 00 44 02 7A 80 00 80 00 80 00 80 00 80 00 80 00 00 7C 80 00 80 00 80 00 80 rx_telegram({0xB0, 0x0B, 0xFF, 00, 0x02, 0x62, 00, 0x44, 0x02, 0x7A, 0x80, 00, 0x80, 0x00, 0x80, 00, @@ -221,12 +265,10 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { uart_telegram("30 00 FF 0A 02 6A 04"); // SM100 pump on 1 uart_telegram("30 00 FF 00 02 64 00 00 00 04 00 00 FF 00 00 1E 0B 09 64 00 00 00 00"); // SM100 modulation - EMSESP::rxservice_.loop(); EMSESP::show_device_values(shell); uart_telegram("30 00 FF 0A 02 6A 03"); // SM100 pump off 0 - EMSESP::rxservice_.loop(); EMSESP::show_device_values(shell); } @@ -240,12 +282,10 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { std::string version("1.2.3"); EMSESP::add_device(0x10, 158, version, EMSdevice::Brand::BUDERUS); // RC300 EMSESP::add_device(0x48, 189, version, EMSdevice::Brand::BUDERUS); // KM200 - EMSESP::rxservice_.loop(); // see https://github.com/proddy/EMS-ESP/issues/390 /* - uart_telegram_withCRC("90 48 FF 04 01 A6 5C"); uart_telegram_withCRC("90 48 FF 00 01 A6 4C"); uart_telegram_withCRC("90 48 FF 08 01 A7 6D"); @@ -283,7 +323,6 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { uart_telegram_withCRC("C8 90 FF 00 02 01 A6 D0"); // uart_telegram_withCRC("10 00 FF 00 01 A5 00 D7 21 00 00 00 00 30 01 84 01 01 03 01 84 01 F1 00 00 11 01 00 08 63 00"); - */ uart_telegram_withCRC("C8 90 F7 02 01 FF 01 A6 BA"); @@ -295,7 +334,6 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { uart_telegram_withCRC("90 00 FF 19 01 A5 01 04 00 00 00 00 FF 64 2A 00 3C 01 FF 92"); EMSESP::show_ems(shell); - EMSESP::rxservice_.loop(); EMSESP::show_device_values(shell); } @@ -308,7 +346,6 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { std::string version("1.2.3"); EMSESP::add_device(0x18, 157, version, EMSdevice::Brand::BOSCH); // Bosch CR100 - https://github.com/proddy/EMS-ESP/issues/355 - EMSESP::rxservice_.loop(); // RCPLUSStatusMessage_HC1(0x01A5) // 98 00 FF 00 01 A5 00 CF 21 2E 00 00 2E 24 03 25 03 03 01 03 25 00 C8 00 00 11 01 03 (no CRC) @@ -318,8 +355,6 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { uart_telegram("98 00 FF 00 01 A5 00 CF 21 2E 00 00 2E 24 03 25 03 03 01 03 25 00 C8 00 00 11 01 03"); // without CRC uart_telegram_withCRC("98 00 FF 00 01 A5 00 CF 21 2E 00 00 2E 24 03 25 03 03 01 03 25 00 C8 00 00 11 01 03 13"); // with CRC - shell.loop_all(); - EMSESP::rxservice_.loop(); EMSESP::txservice_.flush_tx_queue(); shell.loop_all(); EMSESP::show_device_values(shell); @@ -337,6 +372,13 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { EMSESP::txservice_.send(); // send it to UART } + if (command == "rx2") { + shell.printfln(F("Testing Rx2...")); + for (uint8_t i = 0; i < 30; i++) { + uart_telegram({0x08, 0x0B, 0x33, 0x00, 0x08, 0xFF, 0x34, 0xFB, 0x00, 0x28, 0x00, 0x00, 0x46, 0x00, 0xFF, 0xFF, 0x00}); + } + } + if (command == "rx") { shell.printfln(F("Testing Rx...")); @@ -473,49 +515,89 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { EMSESP::txservice_.flush_tx_queue(); } - if (command == "mqtt1") { + if (command == "pin") { + shell.printfln(F("Testing pin...")); + + EMSESP::add_context_menus(); // need to add this as it happens later in the code + shell.invoke_command("su"); + shell.invoke_command("system"); + shell.invoke_command("help"); + shell.invoke_command("pin"); + shell.invoke_command("pin 1 true"); + + shell.loop_all(); + } + + if (command == "mqtt") { shell.printfln(F("Testing MQTT...")); - // MQTT test + // add a boiler + // question: do we need to set the mask? + std::string version("1.2.3"); + EMSESP::add_device(0x08, 123, version, EMSdevice::Brand::BUDERUS); // Nefit Trendline + + // add a thermostat + EMSESP::add_device(0x18, 157, version, EMSdevice::Brand::BOSCH); // Bosch CR100 - https://github.com/proddy/EMS-ESP/issues/355 + + // RCPLUSStatusMessage_HC1(0x01A5) + uart_telegram({0x98, 0x00, 0xFF, 0x00, 0x01, 0xA5, 0x00, 0xCF, 0x21, 0x2E, 0x00, 0x00, 0x2E, 0x24, + 0x03, 0x25, 0x03, 0x03, 0x01, 0x03, 0x25, 0x00, 0xC8, 0x00, 0x00, 0x11, 0x01, 0x03}); + uart_telegram("98 00 FF 00 01 A5 00 CF 21 2E 00 00 2E 24 03 25 03 03 01 03 25 00 C8 00 00 11 01 03"); // without CRC + uart_telegram_withCRC("98 00 FF 00 01 A5 00 CF 21 2E 00 00 2E 24 03 25 03 03 01 03 25 00 C8 00 00 11 01 03 13"); // with CRC + + shell.loop_all(); + + char boiler_topic[Mqtt::MQTT_TOPIC_MAX_SIZE]; + char thermostat_topic[Mqtt::MQTT_TOPIC_MAX_SIZE]; + char system_topic[Mqtt::MQTT_TOPIC_MAX_SIZE]; + + // test publish and adding to queue EMSESP::txservice_.flush_tx_queue(); EMSESP::EMSESP::mqtt_.publish("boiler_cmd", "test me"); - // EMSESP::mqtt_.show_queue(); - // simulate an incoming mqtt msg - char topic[Mqtt::MQTT_TOPIC_MAX_SIZE]; - char payload[100]; + Mqtt::show_mqtt(shell); // show queue - strcpy(topic, "boiler_cmd"); - strcpy(payload, "12345"); - EMSESP::mqtt_.incoming(topic, payload); - EMSESP::mqtt_.incoming(payload, payload); // should report error + strcpy(boiler_topic, "ems-esp/boiler_cmd"); + strcpy(thermostat_topic, "ems-esp/thermostat_cmd"); + strcpy(system_topic, "ems-esp/saystem_cmd"); - strcpy(topic, "thermostat_cmd_mode"); - strcpy(payload, "auto"); - EMSESP::mqtt_.incoming(topic, payload); + EMSESP::mqtt_.incoming(boiler_topic, "12345"); // invalid format + EMSESP::mqtt_.incoming("bad_topic", "12345"); // no matching topic + EMSESP::mqtt_.incoming(boiler_topic, "{\"cmd\":\"garbage\",\"data\":22.52}"); // should report error + EMSESP::mqtt_.incoming(boiler_topic, "{\"cmd\":\"comfort\",\"data\":\"eco\"}"); + EMSESP::mqtt_.incoming(boiler_topic, "{\"cmd\":\"wwactivated\",\"data\":\"1\"}"); + EMSESP::mqtt_.incoming(boiler_topic, "{\"cmd\":\"wwactivated\",\"data\":1}"); + EMSESP::mqtt_.incoming(boiler_topic, "{\"cmd\":\"flowtemp\",\"data\":55}"); - strcpy(topic, "thermostat_cmd_temp"); - strcpy(payload, "20"); - EMSESP::mqtt_.incoming(topic, payload); + EMSESP::mqtt_.incoming(system_topic, "{\"cmd\":\"send\",\"data\":\"01 02 03 04 05\"}"); + EMSESP::mqtt_.incoming(system_topic, "{\"cmd\":\"pin\",\"id\":12,\"data\":\"1\"}"); - strcpy(topic, "thermostat_cmd"); - strcpy(payload, "{\"cmd\":\"temp\",\"data\":22.52}"); - EMSESP::mqtt_.incoming(topic, payload); - - strcpy(topic, "boiler_cmd_wwtemp"); - strcpy(payload, "66"); - EMSESP::mqtt_.incoming(topic, payload); - - strcpy(topic, "thermostat_cmd"); - strcpy(payload, "{\"cmd\":\"temp\",\"hc\":2,\"data\":22}"); - EMSESP::mqtt_.incoming(topic, payload); - - strcpy(topic, "home/ems-esp/cmd"); - strcpy(payload, "restart"); - EMSESP::mqtt_.incoming(topic, payload); + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"wwmode\",\"data\":\"auto\"}"); + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"control\",\"data\":\"1\"}"); + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"control\",\"data\":1}"); + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"mode\",\"data\":\"auto\",\"id\":2}"); + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"mode\",\"data\":\"auto\",\"hc\":2}"); // hc as number + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"mode\",\"data\":\"auto\",\"hc\":\"2\"}"); // hc as string + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"temp\",\"data\":22.56}"); + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"temp\",\"data\":22}"); + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"temp\",\"data\":\"22.56\"}"); + EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"temp\",\"id\":2,\"data\":22}"); // EMSESP::txservice_.show_tx_queue(); + // EMSESP::publish_all_values(); - EMSESP::publish_all_values(); + EMSESP::add_context_menus(); // need to add this as it happens later in the code + shell.invoke_command("su"); + shell.invoke_command("thermostat"); + shell.invoke_command("help"); + shell.invoke_command("call"); + shell.invoke_command("call wwmode"); + shell.invoke_command("call mode auto 2"); + shell.invoke_command("call temp 22.56"); + + Mqtt::resubscribe(); + Mqtt::show_mqtt(shell); // show queue + + shell.loop_all(); } if (command == "poll2") { @@ -526,8 +608,6 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { uint8_t poll[1] = {0x8B}; EMSESP::incoming_telegram(poll, 1); - EMSESP::rxservice_.loop(); - EMSESP::show_ems(shell); EMSESP::txservice_.flush_tx_queue(); } @@ -542,12 +622,6 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { uart_telegram({0x21, 0x0B, 0xFF, 0x00}); } - if (command == "mqtt2") { - for (uint8_t i = 0; i < 30; i++) { - Mqtt::subscribe("topic", dummy_mqtt_commands); - } - } - // testing the UART tx command, without a queue if (command == "tx2") { uint8_t t[] = {0x0B, 0x88, 0x18, 0x00, 0x20, 0xD4}; // including CRC @@ -571,8 +645,6 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { EMSESP::add_device(0x20, 160, version, EMSdevice::Brand::BOSCH); // MM100 - EMSESP::rxservice_.loop(); - // WWC1 on 0x29 rx_telegram({0xA9, 0x00, 0xFF, 0x00, 0x02, 0x32, 0x02, 0x6C, 0x00, 0x3C, 0x00, 0x3C, 0x3C, 0x46, 0x02, 0x03, 0x03, 0x00, 0x3C}); @@ -591,20 +663,26 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & command) { void Test::rx_telegram(const std::vector & rx_data) { uint8_t len = rx_data.size(); uint8_t data[50]; - std::copy(rx_data.begin(), rx_data.end(), data); - data[len] = EMSESP::rxservice_.calculate_crc(rx_data.data(), len); + uint8_t i = 0; + while (len--) { + data[i] = rx_data[i]; + i++; + } + data[i] = EMSESP::rxservice_.calculate_crc(data, i); EMSESP::rxservice_.add(data, len + 1); - EMSESP::rxservice_.loop(); } // simulates a telegram straight from UART, but without the CRC which is added automatically void Test::uart_telegram(const std::vector & rx_data) { uint8_t len = rx_data.size(); uint8_t data[50]; - std::copy(rx_data.begin(), rx_data.end(), data); - data[len] = EMSESP::rxservice_.calculate_crc(rx_data.data(), len); - EMSESP::incoming_telegram(data, len + 1); - EMSESP::rxservice_.loop(); + uint8_t i = 0; + while (len--) { + data[i] = rx_data[i]; + i++; + } + data[i] = EMSESP::rxservice_.calculate_crc(data, i); + EMSESP::incoming_telegram(data, i + 1); } // takes raw string, assuming it contains the CRC. This is what is output from 'watch raw' @@ -686,9 +764,6 @@ void Test::uart_telegram(const char * rx_data) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" -void Test::dummy_mqtt_commands(const char * message) { - // -} #pragma GCC diagnostic pop diff --git a/src/test/test.h b/src/test/test.h index c45fe42d4..7d94eac9d 100644 --- a/src/test/test.h +++ b/src/test/test.h @@ -16,7 +16,7 @@ * along with this program. If not, see . */ -#if defined(EMSESP_STANDALONE) +#if defined(EMSESP_DEBUG) #ifndef EMSESP_TEST_H #define EMSESP_TEST_H @@ -36,8 +36,6 @@ #include "mqtt.h" #include "emsesp.h" -MAKE_PSTR_WORD(test) - namespace emsesp { class Test { diff --git a/src/version.h b/src/version.h index 0d74e7d44..2d648f16b 100644 --- a/src/version.h +++ b/src/version.h @@ -1 +1 @@ -#define EMSESP_APP_VERSION "2.0.0b11" +#define EMSESP_APP_VERSION "2.0.0b12"