Merge branch 'v2_cmd' into v2

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
 
 <img src="media/web_settings.PNG" width=70% height=70%>
 <img src="media/web_status.PNG" width=70% height=70%>
 <img src="media/web_devices.PNG" width=70% height=70%>
 <img src="media/web_mqtt.PNG" width=70% height=70%>
 
-- 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:
+- 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
+    * `help` lists the commands and keywords. This works in each context.
-    * 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.
+    * `exit` will exit the console or exit the current context. CTRL-D does the same.
-    * To change a setting use the `set` command. Typing `set` shows the current settings.
+    * `CTRL-U` for Undo
-    * `show` shows the data specific to the which context you're in.
+    * `TAB` for auto-complete
-    * `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 `#`.
+    * 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.
-    * `log` sets the logging level. `log off` disables logging. Use `log debug` for debugging commands and actions.
+    * `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 `#`.
-    * `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.
+    * Some settings can be changed in the console. The `set` command will list them.
-    * CTRL-D to exit, CTRL-U to remove line, TAB to auto-complete 
+    * `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 <COM PORT> -b 115200 write_flash 0x00000 <firmware.bin>`
+  For ESP8266: `esptool.py -p <COM PORT> -b 921600 write_flash 0x00000 <firmware.bin>`
+  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  <firmware.bin>`
 - Uploading over WiFi: `espota.py --debug --progress --port 8266 --auth ems-esp-neo -i <IP address> -f <firmware.bin>`
 
 ## **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.
+ - 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
- - 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 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).
- - 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.
 
-## **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
+  system (enters a context)
-	fetch
+  boiler (enters a context)
-	system (enters a context)
+  thermostat (enters a context)
-	boiler (enters a context)
+  set
-	thermostat (enters a context)
+  fetch
-	scan devices [deep]
+  scan devices [deep] *
-	send telegram <"XX XX ...">
+  send telegram <"XX XX ..."> *
-	set bus_id <device ID>
+  set bus_id <device ID> *
-	set tx_mode <n>
+  set tx_mode <n> *
-	show
+  show
-	show devices
+  show devices
-	show ems
+  show ems
-	show values
+  show values
+  show mqtt
 
 system
-	set
+  set
-	show
+  show
-	show mqtt
+  format *
-  show users
+  show users *
-	passwd
+  passwd *
-	restart
+  restart *
-	set wifi hostname <name>
+  set wifi hostname <name> *
-	set wifi password
+  set wifi password *
-	set wifi ssid <name>
+  set wifi ssid <name> *
-  wifi reconnect
+  wifi reconnect *
+  pin <gpio> [data] *
 
 boiler
-	comfort <hot |eco | intelligent>
+  read <type ID> *
-	flowtemp <degrees>
+  call [cmd] [data] *
-	wwactive <on | off>
-	wwcirculation <on | off>
-	wwonetime <on | off>
-	wwtemp <degrees>
-	read <type ID>
-  maxpower <%>
-  minpower <%>
 
 thermostat
-	set
+  set
-	set master [device ID]
+  set master [device ID] *
-	mode <mode> [heating circuit]
+  read <type ID> *
-	temp <degrees> [heating circuit]
+  call [cmd] [data] [heating circuit] *
-	read <type ID>
+
 ```
   
 ----------
-### **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":<cmd> ,"data":<data>, "id":<n>}`. 
+
+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 <hot, eco, intelligent>
@@ -159,35 +154,19 @@ In direct commands it's possible to combine commands, i.e. `{"hc1":{"daytemp":21
   holiday <dd.mm.yyyy-dd.mm.yyyy>
   date <NTP | hh:mm:ss-dd.mm.yyyy-dw-dst>
 
-*cmd*
+*system_cmd*
   send <"0B XX XX ..">
-  D0 <0 | 1>
+  pin <gpio> <on|off|1|0|true|false>
-  D1 <0 | 1>
-  D2 <0 | 1>
-  D3 <0 | 1>
 
 ```
 
-### **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**
+## **Customizing the Web UI**
-
-- 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**
 
 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
 
 

interface/src/project/EMSESPDevicesForm.tsx

@@ -173,7 +173,7 @@ class EMSESPDevicesForm extends Component<EMSESPDevicesFormProps, EMSESPDevicesF
           (
             <Box color="warning.main" p={0} mt={0} mb={0}>
               <Typography variant="body1">
-                No external temperature sensors detected.
+                <i>No external temperature sensors detected.</i>
               </Typography>
             </Box>
           )

interface/src/project/EMSESPSettingsController.tsx

@@ -63,6 +63,19 @@ function EMSESPSettingsControllerForm(props: EMSESPSettingsControllerFormProps)
                 onChange={handleValueChange('tx_mode')}
                 margin="normal"
             />
+            <SelectValidator name="ems_bus_id"
+                label="Bus ID"
+                value={data.ems_bus_id}
+                fullWidth
+                variant="outlined"
+                onChange={handleValueChange('ems_bus_id')}
+                margin="normal">
+                <MenuItem value={0x0B}>Service Key (0x0B)</MenuItem>
+                <MenuItem value={0x0D}>Modem (0x0D)</MenuItem>
+                <MenuItem value={0x0A}>Terminal (0x0A)</MenuItem>
+                <MenuItem value={0x0F}>Time Module (0x0F)</MenuItem>
+                <MenuItem value={0x12}>Alarm Module (0x12)</MenuItem>
+            </SelectValidator>
             <BlockFormControlLabel
                 control={
                     <Checkbox

interface/src/project/ProjectMenu.tsx

@@ -6,26 +6,31 @@ import { List, ListItem, ListItemIcon, ListItemText } from "@material-ui/core";
 import SettingsIcon from '@material-ui/icons/Settings';
 import SettingsRemoteIcon from "@material-ui/icons/SettingsRemote";
 
-class ProjectMenu extends Component<RouteComponentProps> {
+import { withAuthenticatedContext, AuthenticatedContextProps } from '../authentication';
+
+type ProjectProps = AuthenticatedContextProps & RouteComponentProps;
+
+class ProjectMenu extends Component<ProjectProps> {
   render() {
+    const { authenticatedContext } = this.props;
     const path = this.props.match.url;
     return (
       <List>
-        <ListItem to='/ems-esp/status/' selected={path.startsWith('/ems-esp/status/')} button component={Link}>
+        <ListItem to='/ems-esp/' selected={path.startsWith('/ems-esp/status') || path.startsWith('/ems-esp/devices') || path.startsWith('/ems-esp/help')} button component={Link}>
           <ListItemIcon>
             <SettingsRemoteIcon />
           </ListItemIcon>
           <ListItemText primary="Dashboard" />
         </ListItem>
-        <ListItem to='/ems-esp/settings/' selected={path.startsWith('/ems-esp/settings/')} button component={Link}>
+        <ListItem to='/ems-esp/settings' selected={path.startsWith('/ems-esp/settings')} button component={Link} disabled={!authenticatedContext.me.admin}>
           <ListItemIcon>
             <SettingsIcon />
           </ListItemIcon>
-          <ListItemText primary="Settings" />
+          <ListItemText primary="Settings" /> 
         </ListItem>
       </List>
     );
   }
 }
 
-export default withRouter(ProjectMenu);
+export default withRouter(withAuthenticatedContext(ProjectMenu));

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.
           */
         }
-        <Redirect to={`/ems-esp/status/`} />
+        <Redirect to={`/ems-esp/status`} />
       </Switch>
     )
   }

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 *>([](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 *>([](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;
+}
+

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 <Arduino.h>
+#ifdef ESP32
+#include <AsyncTCP.h>
+#define SSE_MAX_QUEUED_MESSAGES 32
+#else
+#include <ESPAsyncTCP.h>
+#define SSE_MAX_QUEUED_MESSAGES 8
+#endif
+#include <ESPAsyncWebServer.h>
+
+#include "AsyncWebSynchronization.h"
+
+#ifdef ESP8266
+#include <Hash.h>
+#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<void(AsyncEventSourceClient *client)> 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<AsyncEventSourceMessage *> _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<AsyncEventSourceClient *> _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_ */

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<JsonObject>();
+    // ...
+  });
+  server.addHandler(handler);
+  
+*/
+#ifndef ASYNC_JSON_H_
+#define ASYNC_JSON_H_
+#include <ArduinoJson.h>
+#include <ESPAsyncWebServer.h>
+#include <Print.h>
+
+#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<void(AsyncWebServerRequest *request, JsonVariant &json)> 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<JsonVariant>();
+#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

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 <Arduino.h>
+#ifdef ESP32
+#include <AsyncTCP.h>
+#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 <ESPAsyncTCP.h>
+#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 <ESPAsyncWebServer.h>
+
+// 0 = disable
+#ifndef WS_MAX_QUEUED_MESSAGES_MIN_HEAP
+#define WS_MAX_QUEUED_MESSAGES_MIN_HEAP 0
+#endif
+
+#include "AsyncWebSynchronization.h"
+
+#ifdef ESP8266
+#include <Hash.h>
+#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<AsyncWebSocketMessageBuffer *> {
+public:
+  using T = AsyncWebSocketMessageBuffer *;
+  using LT = LinkedList<T>;
+
+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<AsyncWebSocketControl *> _controlQueue;
+    LinkedList<AsyncWebSocketMessage *> _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<void(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len)> AwsEventHandler;
+
+//WebServer Handler implementation that plays the role of a socket server
+class AsyncWebSocket: public AsyncWebHandler {
+  public:
+    typedef LinkedList<AsyncWebSocketClient *> 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_ */

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 <ESPAsyncWebServer.h>
+
+#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_

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 <functional>
+#include "FS.h"
+
+#include "StringArray.h"
+
+#ifdef ESP32
+#include <WiFi.h>
+#include <AsyncTCP.h>
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#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<void(void)> 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<size_t(uint8_t*, size_t, size_t)> AwsResponseFiller;
+typedef std::function<String(const String&)> 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<AsyncWebHeader *> _headers;
+    LinkedList<AsyncWebParameter *> _params;
+    LinkedList<String *> _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<bool(AsyncWebServerRequest *request)> 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<AsyncWebHeader *> _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<void(AsyncWebServerRequest *request)> ArRequestHandlerFunction;
+typedef std::function<void(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final)> ArUploadHandlerFunction;
+typedef std::function<void(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total)> ArBodyHandlerFunction;
+
+class AsyncWebServer {
+  protected:
+    AsyncServer _server;
+    LinkedList<AsyncWebRewrite*> _rewrites;
+    LinkedList<AsyncWebHandler*> _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<AsyncWebHeader *>;
+  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_ */

lib/ESPAsyncWebServer/SPIFFSEditor.cpp

@@ -0,0 +1,544 @@
+#include "SPIFFSEditor.h"
+#include <FS.h>
+
+//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();
+    }
+  }
+}

lib/ESPAsyncWebServer/SPIFFSEditor.h

@@ -0,0 +1,24 @@
+#ifndef SPIFFSEditor_H_
+#define SPIFFSEditor_H_
+#include <ESPAsyncWebServer.h>
+
+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

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 <typename T>
+class LinkedListNode {
+    T _value;
+  public:
+    LinkedListNode<T>* next;
+    LinkedListNode(const T val): _value(val), next(nullptr) {}
+    ~LinkedListNode(){}
+    const T& value() const { return _value; };
+    T& value(){ return _value; }
+};
+
+template <typename T, template<typename> class Item = LinkedListNode>
+class LinkedList {
+  public:
+    typedef Item<T> ItemType;
+    typedef std::function<void(const T&)> OnRemove;
+    typedef std::function<bool(const T&)> 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<String> {
+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_ */

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 <libb64/cencode.h>
+#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;
+}

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

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 <string>
+#ifdef ASYNCWEBSERVER_REGEX
+#include <regex>
+#endif
+
+#include "stddef.h"
+#include <time.h>
+
+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_ */

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);
+  }
+}

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 *>([](AsyncWebHeader *h){ delete h; }))
+  , _params(LinkedList<AsyncWebParameter *>([](AsyncWebParameter *p){ delete p; }))
+  , _pathParams(LinkedList<String *>([](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<len; i++){
+          _parseMultipartPostByte(((uint8_t*)buf)[i], i == len - 1);
+          _parsedLength++;
+        }
+      } else
+          _parsedLength += len;
+    } else {
+      if(_parsedLength == 0){
+        if(_contentType.startsWith(F("application/x-www-form-urlencoded"))){
+          _isPlainPost = true;
+        } else if(_contentType == F("text/plain") && __is_param_char(((char*)buf)[0])){
+          size_t i = 0;
+          while (i<len && __is_param_char(((char*)buf)[i++]));
+          if(i < len && ((char*)buf)[i-1] == '='){
+            _isPlainPost = true;
+          }
+        }
+      }
+      if(!_isPlainPost) {
+        //check if authenticated before calling the body
+        if(_handler) _handler->handleBody(this, (uint8_t*)buf, len, _parsedLength, _contentLength);
+        _parsedLength += len;
+      } else if(needParse) {
+        size_t i;
+        for(i=0; i<len; i++){
+          _parsedLength++;
+          _parsePlainPostChar(((uint8_t*)buf)[i]);
+        }
+      } else {
+        _parsedLength += len;
+      }
+    }
+    if(_parsedLength == _contentLength){
+      _parseState = PARSE_REQ_END;
+      //check if authenticated before calling handleRequest and request auth instead
+      if(_handler) _handler->handleRequest(this);
+      else send(501);
+    }
+  }
+  break;
+  }
+}
+
+void AsyncWebServerRequest::_removeNotInterestingHeaders(){
+  if (_interestingHeaders.containsIgnoreCase(F("ANY"))) return; // nothing to do
+  for(const auto& header: _headers){
+      if(!_interestingHeaders.containsIgnoreCase(header->name().c_str())){
+        _headers.remove(header);
+      }
+  }
+}
+
+void AsyncWebServerRequest::_onPoll(){
+  //os_printf("p\n");
+  if(_response != NULL && _client != NULL && _client->canSend() && !_response->_finished()){
+    _response->_ack(this, 0, 0);
+  }
+}
+
+void AsyncWebServerRequest::_onAck(size_t len, uint32_t time){
+  //os_printf("a:%u:%u\n", len, time);
+  if(_response != NULL){
+    if(!_response->_finished()){
+      _response->_ack(this, len, time);
+    } else {
+      AsyncWebServerResponse* r = _response;
+      _response = NULL;
+      delete r;
+    }
+  }
+}
+
+void AsyncWebServerRequest::_onError(int8_t error){
+  (void)error;
+}
+
+void AsyncWebServerRequest::_onTimeout(uint32_t time){
+  (void)time;
+  //os_printf("TIMEOUT: %u, state: %s\n", time, _client->stateToString());
+  _client->close();
+}
+
+void AsyncWebServerRequest::onDisconnect (ArDisconnectHandler fn){
+    _onDisconnectfn=fn;
+}
+
+void AsyncWebServerRequest::_onDisconnect(){
+  //os_printf("d\n");
+  if(_onDisconnectfn) {
+      _onDisconnectfn();
+    }
+  _server->_handleDisconnect(this);
+}
+
+void AsyncWebServerRequest::_addParam(AsyncWebParameter *p){
+  _params.add(p);
+}
+
+void AsyncWebServerRequest::_addPathParam(const char *p){
+  _pathParams.add(new String(p));
+}
+
+void AsyncWebServerRequest::_addGetParams(const String& params){
+  size_t start = 0;
+  while (start < params.length()){
+    int end = params.indexOf('&', start);
+    if (end < 0) end = params.length();
+    int equal = params.indexOf('=', start);
+    if (equal < 0 || equal > 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;
+}

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 <vector>
+// 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<uint8_t> _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_ */

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<unsigned char*>(ptr);
+  while(count--)
+    if(*p++ == static_cast<unsigned char>(ch))
+      return --p;
+  return nullptr;
+}
+
+
+/*
+ * Abstract Response
+ * */
+const char* AsyncWebServerResponse::_responseCodeToString(int code) {
+  return reinterpret_cast<const char *>(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 *>([](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<char*>(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<char*>(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<unsigned int>(&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;i<outLen;i++)
+    data[i] = _content->read();
+  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);
+}

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*>([](AsyncWebRewrite* r){ delete r; }))
+  , _handlers(LinkedList<AsyncWebHandler*>([](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);
+  }
+}
+

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

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
+#ifdef ARDUINO_ARCH_ESP32
-   void IRAM_ATTR write_bit(uint8_t v);
+    void IRAM_ATTR write_bit(uint8_t v);
- #else
+#else
-   void write_bit(uint8_t v);
+    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

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)

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<JsonObject>();
@@ -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");

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 )

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<int8_t>(code));
       return DeserializationError::Ok;
     }

platformio.ini

@@ -1,8 +1,8 @@
 ; PlatformIO Project Configuration File for EMS-ESP
 
 [platformio]
-; default_envs = esp8266
+default_envs = esp8266
-default_envs = esp32
+; 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 = espressif32
-platform = https://github.com/platformio/platform-espressif32.git
+; 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}

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<JsonObject>()) {
-        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();

src/EMSESPDevicesService.h

@@ -24,8 +24,7 @@
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>
 
-// #define MAX_EMSESP_STATUS_SIZE 1024
+#define MAX_EMSESP_DEVICE_SIZE 1536
-#define MAX_EMSESP_DEVICE_SIZE 1280
 
 #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);

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();
 }
 

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<std::string> & 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<std::string> & 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<std::string> & 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<uint8_t> 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<std::string> & 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<std::string> 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<std::string> & arguments __attribute__((unused))) -> std::vector<std::string> {
             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<std::string> & 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<std::string> & 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

src/console.h

@@ -50,69 +50,8 @@ using uuid::log::Level;
 #define F_(string_name) FPSTR(__pstr__##string_name)
 // clang-format on
 
-// common words
+// localizations
-MAKE_PSTR_WORD(exit)
+#include "locale_EN.h"
-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, "<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(degrees_mandatory, "<degrees>")
-MAKE_PSTR(asterisks, "********")
-MAKE_PSTR(n_mandatory, "<n>")
-MAKE_PSTR(n_optional, "[n]")
-MAKE_PSTR(bool_mandatory, "<on | off>")
-MAKE_PSTR(typeid_mandatory, "<type ID>")
-MAKE_PSTR(deviceid_mandatory, "<device ID>")
-MAKE_PSTR(deviceid_optional, "[device ID]")
-MAKE_PSTR(invalid_log_level, "Invalid log level")
-MAKE_PSTR(port_mandatory, "<port>")
-MAKE_PSTR(log_level_fmt, "Log level = %s")
-MAKE_PSTR(log_level_optional, "[level]")
-MAKE_PSTR(name_mandatory, "<name>")
-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, "<unset>")
 
 #ifdef LOCAL
 #undef LOCAL

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
+// Gateways - 0x48
-{ 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}
-{189, DeviceType::GATEWAY, F("KM200/MB LAN 2"), DeviceFlags::EMS_DEVICE_FLAG_NONE} // 0x48
-
 
 // clang-format on

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, "<hot | eco | intelligent>")
-
-// 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(0x10, F("UBAErrorMessage1"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAErrorMessage(t); });
-    register_telegram_type(0x11, F("UBAErrorMessage2"), false, std::bind(&Boiler::process_UBAErrorMessage, this, _1));
+    register_telegram_type(0x11, F("UBAErrorMessage2"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAErrorMessage(t); });
-    register_telegram_type(0x18, F("UBAMonitorFast"), false, std::bind(&Boiler::process_UBAMonitorFast, this, _1));
+    register_telegram_type(0x18, F("UBAMonitorFast"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAMonitorFast(t); });
-    register_telegram_type(0x19, F("UBAMonitorSlow"), true, std::bind(&Boiler::process_UBAMonitorSlow, this, _1));
+    register_telegram_type(0x19, F("UBAMonitorSlow"), true, [&](std::shared_ptr<const Telegram> t) { process_UBAMonitorSlow(t); });
-    register_telegram_type(0x34, F("UBAMonitorWW"), false, std::bind(&Boiler::process_UBAMonitorWW, this, _1));
+    register_telegram_type(0x34, F("UBAMonitorWW"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAMonitorWW(t); });
-    register_telegram_type(0x1C, F("UBAMaintenanceStatus"), false, std::bind(&Boiler::process_UBAMaintenanceStatus, this, _1));
+    register_telegram_type(0x1C, F("UBAMaintenanceStatus"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAMaintenanceStatus(t); });
-    register_telegram_type(0x2A, F("MC10Status"), false, std::bind(&Boiler::process_MC10Status, this, _1));
+    register_telegram_type(0x2A, F("MC10Status"), false, [&](std::shared_ptr<const Telegram> t) { process_MC10Status(t); });
-    register_telegram_type(0x33, F("UBAParameterWW"), true, std::bind(&Boiler::process_UBAParameterWW, this, _1));
+    register_telegram_type(0x33, F("UBAParameterWW"), true, [&](std::shared_ptr<const Telegram> t) { process_UBAParameterWW(t); });
-    register_telegram_type(0x14, F("UBATotalUptime"), false, std::bind(&Boiler::process_UBATotalUptime, this, _1));
+    register_telegram_type(0x14, F("UBATotalUptime"), false, [&](std::shared_ptr<const Telegram> t) { process_UBATotalUptime(t); });
-    register_telegram_type(0x35, F("UBAFlags"), false, std::bind(&Boiler::process_UBAFlags, this, _1));
+    register_telegram_type(0x35, F("UBAFlags"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAFlags(t); });
-    register_telegram_type(0x15, F("UBAMaintenanceData"), false, std::bind(&Boiler::process_UBAMaintenanceData, this, _1));
+    register_telegram_type(0x15, F("UBAMaintenanceData"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAMaintenanceData(t); });
-    register_telegram_type(0x16, F("UBAParameters"), true, std::bind(&Boiler::process_UBAParameters, this, _1));
+    register_telegram_type(0x16, F("UBAParameters"), true, [&](std::shared_ptr<const Telegram> t) { process_UBAParameters(t); });
-    register_telegram_type(0x1A, F("UBASetPoints"), false, std::bind(&Boiler::process_UBASetPoints, this, _1));
+    register_telegram_type(0x1A, F("UBASetPoints"), false, [&](std::shared_ptr<const Telegram> t) { process_UBASetPoints(t); });
-    register_telegram_type(0xD1, F("UBAOutdoorTemp"), false, std::bind(&Boiler::process_UBAOutdoorTemp, this, _1));
+    register_telegram_type(0xD1, F("UBAOutdoorTemp"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAOutdoorTemp(t); });
-    register_telegram_type(0xE3, F("UBAMonitorSlowPlus"), false, std::bind(&Boiler::process_UBAMonitorSlowPlus2, this, _1));
+    register_telegram_type(0xE3, F("UBAMonitorSlowPlus"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAMonitorSlowPlus2(t); });
-    register_telegram_type(0xE4, F("UBAMonitorFastPlus"), false, std::bind(&Boiler::process_UBAMonitorFastPlus, this, _1));
+    register_telegram_type(0xE4, F("UBAMonitorFastPlus"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAMonitorFastPlus(t); });
-    register_telegram_type(0xE5, F("UBAMonitorSlowPlus"), false, std::bind(&Boiler::process_UBAMonitorSlowPlus, this, _1));
+    register_telegram_type(0xE5, F("UBAMonitorSlowPlus"), false, [&](std::shared_ptr<const Telegram> t) { process_UBAMonitorSlowPlus(t); });
+    register_telegram_type(0xE9, F("UBADHWStatus"), false, [&](std::shared_ptr<const Telegram> t) { process_UBADHWStatus(t); });
 
-    register_telegram_type(0xE9, F("UBADHWStatus"), false, std::bind(&Boiler::process_UBADHWStatus, 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); });
-    // MQTT callbacks
+    register_mqtt_cmd(F("wwactivated"), [&](const char * value, const int8_t id) { set_warmwater_activated(value, id); });
-    register_mqtt_topic("boiler_cmd", std::bind(&Boiler::boiler_cmd, this, _1));
+    register_mqtt_cmd(F("wwtapactivated"), [&](const char * value, const int8_t id) { set_tapwarmwater_activated(value, id); });
-    register_mqtt_topic("boiler_cmd_wwactivated", std::bind(&Boiler::boiler_cmd_wwactivated, this, _1));
+    register_mqtt_cmd(F("wwonetime"), [&](const char * value, const int8_t id) { set_warmwater_onetime(value, id); });
-    register_mqtt_topic("boiler_cmd_wwonetime", std::bind(&Boiler::boiler_cmd_wwonetime, this, _1));
+    register_mqtt_cmd(F("wwcirculation"), [&](const char * value, const int8_t id) { set_warmwater_circulation(value, id); });
-    register_mqtt_topic("boiler_cmd_wwcirculation", std::bind(&Boiler::boiler_cmd_wwcirculation, this, _1));
+    register_mqtt_cmd(F("flowtemp"), [&](const char * value, const int8_t id) { set_flow_temp(value, id); });
-    register_mqtt_topic("boiler_cmd_wwtemp", std::bind(&Boiler::boiler_cmd_wwtemp, this, _1));
+    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<std::string> & 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<EMSESP_MAX_JSON_SIZE_SMALL> 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();
+    if (Helpers::hasValue(tap_water_active_, EMS_VALUE_BOOL)) {
-    dataElement["name"]  = F("Hot tap water");
+        dataElement          = root.createNestedObject();
-    dataElement["value"] = tap_water_active_ ? F("running") : F("off");
+        dataElement["name"]  = F("Hot tap water");
+        dataElement["value"] = tap_water_active_ ? F("running") : F("off");
+    }
 
-    dataElement          = root.createNestedObject();
+    if (Helpers::hasValue(heating_active_, EMS_VALUE_BOOL)) {
-    dataElement["name"]  = F("Central heating");
+        dataElement          = root.createNestedObject();
-    dataElement["value"] = heating_active_ ? F("active") : F("off");
+        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/
+    // const size_t        capacity = JSON_OBJECT_SIZE(56); // must recalculate if more objects addded https://arduinojson.org/v6/assistant/
-    DynamicJsonDocument doc(capacity);
+    // DynamicJsonDocument doc(capacity);
+    StaticJsonDocument<EMSESP_MAX_JSON_SIZE_LARGE> 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<const Telegram> telegram) {
  */
 void Boiler::process_UBAParameters(std::shared_ptr<const Telegram> telegram) {
     telegram->read_value(heating_temp_, 1);
-    telegram->read_value(burnPowermax_,2);
+    telegram->read_value(burnPowermax_, 2);
-    telegram->read_value(burnPowermin_,3);
+    telegram->read_value(burnPowermin_, 3);
-    telegram->read_value(boilTemp_off_,4);
+    telegram->read_value(boilTemp_off_, 4);
-    telegram->read_value(boilTemp_on_,5);
+    telegram->read_value(boilTemp_on_, 5);
-    telegram->read_value(burnPeriod_,6);
+    telegram->read_value(burnPeriod_, 6);
-    telegram->read_value(pumpDelay_,8);
+    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<const Telegram> telegr
 // 0x10, 0x11, 0x12
 // not yet implemented
 void Boiler::process_UBAErrorMessage(std::shared_ptr<const Telegram> 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<const Telegram> telegram
     }
 }
 
+/*
+ * Commands
+ */
+
+
 // Set the warm water temperature 0x33
-void Boiler::set_warmwater_temp(const uint8_t temperature) {
+void Boiler::set_warmwater_temp(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler warm water temperature to %d C"), temperature);
+    int v = 0;
-    write_command(EMS_TYPE_UBAParameterWW, 2, temperature);
+    if (!Helpers::value2number(value, v)) {
-    write_command(EMS_TYPE_UBAFlags, 3, temperature); // for i9000, see #397
+        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) {
+void Boiler::set_flow_temp(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler flow temperature to %d C"), temperature);
+    int v = 0;
-    write_command(EMS_TYPE_UBASetPoints, 0, temperature);
+    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) {
+void Boiler::set_min_power(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler min power to "), power);
+    int v = 0;
-    write_command(EMS_TYPE_UBAParameters, 3, power);
+    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) {
+void Boiler::set_max_power(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler max power to %d C"), power);
+    int v = 0;
-    write_command(EMS_TYPE_UBAParameters, 2, power);
+    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) {
+void Boiler::set_hyst_on(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler hysteresis on to %d C"), temp);
+    int v = 0;
-    write_command(EMS_TYPE_UBAParameters, 5, temp);
+    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) {
+void Boiler::set_hyst_off(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler hysteresis off to %d C"), temp);
+    int v = 0;
-    write_command(EMS_TYPE_UBAParameters, 4, temp);
+    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) {
+void Boiler::set_burn_period(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting burner min. period to %d min"), t);
+    int v = 0;
-    write_command(EMS_TYPE_UBAParameters, 6, t);
+    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) {
+void Boiler::set_pump_delay(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler pump delay to %d min"), t);
+    int v = 0;
-    write_command(EMS_TYPE_UBAParameters, 8, t);
+    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)
+// 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 uint8_t comfort) {
+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) {
+void Boiler::set_warmwater_activated(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler warm water %s"), activated ? "on" : "off");
+    bool v = false;
-    uint8_t value;
+    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) {
+void Boiler::set_tapwarmwater_activated(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler warm tap water %s"), activated ? "on" : "off");
+    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) {
+void Boiler::set_warmwater_onetime(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler warm water OneTime loading %s"), activated ? "on" : "off");
+    bool v = false;
-    write_command(EMS_TYPE_UBAFlags, 0, (activated ? 0x22 : 0x02));
+    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) {
+void Boiler::set_warmwater_circulation(const char * value, const int8_t id) {
-    LOG_INFO(F("Setting boiler warm water circulation %s"), activated ? "on" : "off");
+    bool v = false;
-    write_command(EMS_TYPE_UBAFlags, 1, (activated ? 0x22 : 0x02));
+    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<std::string> & 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<std::string> & 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<std::string> & 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<std::string> & 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<std::string> & 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<std::string> & 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<std::string> & arguments __attribute__((unused))) -> const std::vector<std::string> {
-            return std::vector<std::string>{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<std::string> & 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<std::string> & arguments __attribute__((unused))) -> const std::vector<std::string> {
-            return std::vector<std::string>{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<std::string> & 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<std::string> & arguments __attribute__((unused))) -> const std::vector<std::string> {
-            return std::vector<std::string>{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<std::string> & 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<std::string> & arguments __attribute__((unused))) -> const std::vector<std::string> {
-            return std::vector<std::string>{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)},

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);
+    // commands - none of these use the additional id parameter
-    void set_flow_temp(const uint8_t temperature);
+    void set_warmwater_mode(const char * value, const int8_t id);
-    void set_warmwater_mode(const uint8_t comfort);
+    void set_warmwater_activated(const char * value, const int8_t id);
-    void set_warmwater_activated(const bool activated);
+    void set_tapwarmwater_activated(const char * value, const int8_t id);
-    void set_tapwarmwater_activated(const bool activated);
+    void set_warmwater_onetime(const char * value, const int8_t id);
-    void set_warmwater_onetime(const bool activated);
+    void set_warmwater_circulation(const char * value, const int8_t id);
-    void set_warmwater_circulation(const bool activated);
+    void set_warmwater_temp(const char * value, const int8_t id);
-    void set_min_power(const uint8_t power);
+    void set_flow_temp(const char * value, const int8_t id);
-    void set_max_power(const uint8_t power);
+    void set_min_power(const char * value, const int8_t id);
-    void set_hyst_on(const uint8_t temp);
+    void set_max_power(const char * value, const int8_t id);
-    void set_hyst_off(const uint8_t temp);
+    void set_hyst_on(const char * value, const int8_t id);
-    void set_burn_period(const uint8_t t);
+    void set_hyst_off(const char * value, const int8_t id);
-    void set_pump_delay(const uint8_t t);
+    void set_burn_period(const char * value, const int8_t id);
-
+    void set_pump_delay(const char * value, const int8_t id);
-
-    // 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);
 };
 
 } // namespace emsesp

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_(connect), uuid::log::Facility::CONSOLE};
-uuid::log::Logger Connect::logger_{F_(logger_name), 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

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_(controller), uuid::log::Facility::CONSOLE};
-uuid::log::Logger Controller::logger_{F_(logger_name), 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

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_(gateway), uuid::log::Facility::CONSOLE};
-uuid::log::Logger Gateway::logger_{F_(logger_name), 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() {

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_(heatpump), uuid::log::Facility::CONSOLE};
-uuid::log::Logger Heatpump::logger_{F_(logger_name), 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(0x047B, F("HP1"), true, [&](std::shared_ptr<const Telegram> t) { process_HPMonitor1(t); });
-    register_telegram_type(0x042B, F("HP2"), true, std::bind(&Heatpump::process_HPMonitor2, this, _1));
+    register_telegram_type(0x042B, F("HP2"), true, [&](std::shared_ptr<const Telegram> t) { process_HPMonitor2(t); });
-
-    // MQTT callbacks
-    // register_mqtt_topic("topic", std::bind(&Heatpump::cmd, this, _1));
 }
 
 // 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

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_(mixing), uuid::log::Facility::CONSOLE};
-uuid::log::Logger Mixing::logger_{F_(logger_name), 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<const Telegram> 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<const Telegram> 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(0x00AA, F("MMConfigMessage"), false, [&](std::shared_ptr<const Telegram> t) { process_MMConfigMessage(t); });
-        register_telegram_type(0x00AB, F("MMStatusMessage"), true, std::bind(&Mixing::process_MMStatusMessage, this, _1));
+        register_telegram_type(0x00AB, F("MMStatusMessage"), true, [&](std::shared_ptr<const Telegram> t) { process_MMStatusMessage(t); });
-        register_telegram_type(0x00AC, F("MMSetMessage"), false, std::bind(&Mixing::process_MMSetMessage, this, _1));
+        register_telegram_type(0x00AC, F("MMSetMessage"), false, [&](std::shared_ptr<const Telegram> t) { process_MMSetMessage(t); });
-    }
-    // HT3
-    if (flags == EMSdevice::EMS_DEVICE_FLAG_IPM) {
-        register_telegram_type(0x010C, F("IPMSetMessage"), false, std::bind(&Mixing::process_IPMStatusMessage, this, _1));
     }
 
-    // MQTT callbacks
+    // HT3
-    // register_mqtt_topic("topic", std::bind(&Mixing::cmd, this, _1));
+    if (flags == EMSdevice::EMS_DEVICE_FLAG_IPM) {
+        register_telegram_type(0x010C, F("IPMSetMessage"), false, [&](std::shared_ptr<const Telegram> 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<EMSESP_MAX_JSON_SIZE_SMALL> 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<const Telegram> tel
 //       A1 00 FF 00 00 0C 02 04 00 01 1D 00 82
 void Mixing::process_IPMStatusMessage(std::shared_ptr<const Telegram> 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<const Telegram> 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<const Telegram> 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<const Telegram> 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<const Telegram> 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<const Telegram> telegram) {
-    hc_ = device_id() - 0x20 + 1;
+    hc_ = get_device_id() - 0x20 + 1;
     // pos 0: flowtemp setpoint 1E = 30°C
     // pos 1: position in %
 }

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_(solar), uuid::log::Facility::CONSOLE};
-uuid::log::Logger Solar::logger_{F_(logger_name), 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<const Telegram> 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(0x0362, F("SM100Monitor"), true, [&](std::shared_ptr<const Telegram> t) { process_SM100Monitor(t); });
-        register_telegram_type(0x0363, F("SM100Monitor2"), true, std::bind(&Solar::process_SM100Monitor2, this, _1));
+        register_telegram_type(0x0363, F("SM100Monitor2"), true, [&](std::shared_ptr<const Telegram> t) { process_SM100Monitor2(t); });
-        register_telegram_type(0x0366, F("SM100Config"), true, std::bind(&Solar::process_SM100Config, this, _1));
+        register_telegram_type(0x0366, F("SM100Config"), true, [&](std::shared_ptr<const Telegram> t) { process_SM100Config(t); });
 
-        register_telegram_type(0x0364, F("SM100Status"), false, std::bind(&Solar::process_SM100Status, this, _1));
+        register_telegram_type(0x0364, F("SM100Status"), false, [&](std::shared_ptr<const Telegram> t) { process_SM100Status(t); });
-        register_telegram_type(0x036A, F("SM100Status2"), false, std::bind(&Solar::process_SM100Status2, this, _1));
+        register_telegram_type(0x036A, F("SM100Status2"), false, [&](std::shared_ptr<const Telegram> t) { process_SM100Status2(t); });
-        register_telegram_type(0x038E, F("SM100Energy"), true, std::bind(&Solar::process_SM100Energy, this, _1));
+        register_telegram_type(0x038E, F("SM100Energy"), true, [&](std::shared_ptr<const Telegram> 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(0x0103, F("ISM1StatusMessage"), true, [&](std::shared_ptr<const Telegram> t) { process_ISM1StatusMessage(t); });
-        register_telegram_type(0x0101, F("ISM1Set"), false, std::bind(&Solar::process_ISM1Set, this, _1));
+        register_telegram_type(0x0101, F("ISM1Set"), false, [&](std::shared_ptr<const Telegram> 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<EMSESP_MAX_JSON_SIZE_MEDIUM> 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<const Telegram> telegram) {
-    telegram->read_value(collectorTemp_, 2);  // collector 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(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<const Telegram> 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<const Telegram> 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<const Telegram> 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<const Telegram> 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<const Telegram> telegram) {
-    telegram->read_value(collectorTemp_, 4);     // Collector Temperature
+    telegram->read_value(collectorTemp_, 4);  // Collector Temperature
-    telegram->read_value(tankBottomTemp_, 6);    // Temperature Bottom of Solar Boiler
+    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(solarPump_, 8, 0);         // PS1 Solar pump on (1) or off (0)
-    telegram->read_bitvalue(collectorShutdown_, 9, 0);   // collector shutdown on/off
+    telegram->read_value(pumpWorkMin_, 10, 3);         // force to 3 bytes
-    telegram->read_bitvalue(tankHeated_, 9, 2);          // tank full
+    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<const Telegram> telegram) {
     telegram->read_value(setpoint_maxBottomTemp_, 6);

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_(switch), uuid::log::Facility::CONSOLE};
-uuid::log::Logger Switch::logger_{F_(logger_name), 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

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 {
+  private:
-        return ((flags() & EMSdevice::EMS_DEVICE_FLAG_NO_WRITE) == EMSdevice::EMS_DEVICE_FLAG_NO_WRITE);
+    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<uint16_t> monitor_typeids;
     std::vector<uint16_t> set_typeids;
     std::vector<uint16_t> 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<Thermostat::HeatingCircuit> heating_circuit(std::shared_ptr<const Telegram> telegram);
     std::shared_ptr<Thermostat::HeatingCircuit> heating_circuit(const uint8_t hc_num);
@@ -220,55 +217,65 @@ class Thermostat : public EMSdevice {
     void process_IBASettings(std::shared_ptr<const Telegram> telegram);
     void process_RCTime(std::shared_ptr<const Telegram> telegram);
     void process_RC35wwSettings(std::shared_ptr<const Telegram> telegram);
-
     void process_RC35Monitor(std::shared_ptr<const Telegram> telegram);
     void process_RC35Set(std::shared_ptr<const Telegram> telegram);
-
     void process_RC30Monitor(std::shared_ptr<const Telegram> telegram);
     void process_RC30Set(std::shared_ptr<const Telegram> telegram);
-
     void process_RC20Monitor(std::shared_ptr<const Telegram> telegram);
     void process_RC20Set(std::shared_ptr<const Telegram> telegram);
     void process_RC20Remote(std::shared_ptr<const Telegram> telegram);
-
     void process_RC20Monitor_2(std::shared_ptr<const Telegram> telegram);
     void process_RC20Set_2(std::shared_ptr<const Telegram> telegram);
-
     void process_RC10Monitor(std::shared_ptr<const Telegram> telegram);
     void process_RC10Set(std::shared_ptr<const Telegram> telegram);
-
     void process_RC300Monitor(std::shared_ptr<const Telegram> telegram);
     void process_RC300Set(std::shared_ptr<const Telegram> telegram);
-
     void process_JunkersMonitor(std::shared_ptr<const Telegram> telegram);
     void process_JunkersSet(std::shared_ptr<const Telegram> telegram);
-
+    void process_JunkersSet2(std::shared_ptr<const Telegram> telegram);
     void process_EasyMonitor(std::shared_ptr<const Telegram> telegram);
-
     void process_RC300WWmode(std::shared_ptr<const Telegram> telegram);
 
-    // set functions
+    // internal helper functions
-    void set_settings_minexttemp(const int8_t mt);
+    void set_mode_n(const uint8_t mode, const uint8_t hc_num);
-    void set_settings_calinttemp(const int8_t ct);
+
-    void set_settings_clockoffset(const int8_t co);
+    void set_temperature_value(const char * value, const int8_t id, const uint8_t mode);
-    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);
     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
+    // for HA specifically. MQTT functions.
-    void thermostat_cmd(const char * message);
     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

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_);
+    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_id_, topic, f);
+    Mqtt::subscribe(this->device_type_, topic, f);
 }
 
-EMSdevice::TelegramFunction::TelegramFunction(uint16_t                    telegram_type_id,
+void EMSdevice::register_mqtt_cmd(const __FlashStringHelper * cmd, mqtt_cmdfunction_p f) {
-                                              const __FlashStringHelper * telegram_type_name,
+    Mqtt::add_command(this->device_type_, this->device_id_, cmd, f);
-                                              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) {
 }
 
 // register a call back function for a specific telegram type
@@ -239,7 +264,7 @@ std::string EMSdevice::telegram_type_name(std::shared_ptr<const Telegram> 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<const Telegram> 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];
+    EMSESP::send_write_request(type_id, this->get_device_id(), offset, value, validate_typeid);
-    message_data[0] = value;
-    EMSESP::send_write_request(type_id, device_id(), offset, message_data, 1, 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 "<device_type>_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<std::string> & 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<std::string> & arguments) -> std::vector<std::string> {
+            if (arguments.size() > 0) {
+                return {};
+            }
+            std::vector<std::string> 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

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 = 0, // this is us
-        SERVICEKEY,
         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 {
+    struct TelegramFunction {
-      public:
-        TelegramFunction(uint16_t telegram_type_id, const __FlashStringHelper * telegram_type_name, bool fetch, process_function_p process_function);
-        ~TelegramFunction() = default;
-
         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<TelegramFunction> telegram_functions_; // each EMS device has its own set of registered telegram types
 };

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<std::unique_ptr<EMSdevice>>    EMSESP::emsdevices;      // array of all the detected EMS devices
 std::vector<emsesp::EMSESP::Device_record> 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)"),
+            shell.printfln(F(" [%02d%c] %s %s"), it.id_, ((it.retry_) ? '*' : ' '), op.c_str(), pretty_telegram(it.telegram_).c_str());
-                           it.id_,
-                           ((it.retry_) ? '*' : ' '),
-                           op.c_str(),
-                           pretty_telegram(it.telegram_).c_str(),
-                           it.telegram_->offset);
         }
     }
 
@@ -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<const Telegram> 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 src_name(20, '\0');
-    std::string dest_name;
+    std::string dest_name(20, '\0');
-    std::string type_name;
+    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<const Telegram> 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<const Telegram> 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<const Telegram> telegram) {
 // returns false if there are none found
 bool EMSESP::process_telegram(std::shared_ptr<const Telegram> 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(
+        std::string name = uuid::read_flash_string(device_p->name);
-            EMSFactory::add(device_p->device_type, device_id, device_p->product_id, version, uuid::read_flash_string(device_p->name), device_p->flags, brand));
+        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); // go and fetch its data,
-        fetch_device_values(device_id);
     }
 
     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
+    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
-    shower_.loop();    // check for shower on/off
+    sensors_.loop(); // this will also send out via MQTT
-    sensors_.loop();   // this will also send out via MQTT
+    mqtt_.loop();    // sends out anything in the queue via MQTT
-    mqtt_.loop();      // sends out anything in the queue via MQTT
+    console_.loop(); // telnet/serial console
-    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

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<std::unique_ptr<EMSdevice>> 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_;

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<EMSdevice> {
         return std::unique_ptr<EMSdevice>(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);
     }

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)
+// for booleans, use isBool true (EMS_VALUE_BOOL)
-bool Helpers::hasValue(const uint8_t v, bool isBool) {
+bool Helpers::hasValue(const uint8_t v, const uint8_t isBool) {
-    if (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

src/helpers.h

@@ -22,6 +22,8 @@
 #include <Arduino.h>
 #include <uuid/common.h>
 
+#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

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 <http://www.gnu.org/licenses/>.
+ */
+
+// 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, "<n>")
+MAKE_PSTR(n_optional, "[n]")
+MAKE_PSTR(gpio_mandatory, "<gpio>")
+MAKE_PSTR(data_optional, "[data]")
+MAKE_PSTR(typeid_mandatory, "<type ID>")
+MAKE_PSTR(deviceid_mandatory, "<device ID>")
+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, "<name>")
+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, "<unset>")

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::MQTTSubFunction>  Mqtt::mqtt_subfunctions_;
+std::vector<Mqtt::MQTTSubFunction> Mqtt::mqtt_subfunctions_;
-uint16_t                            Mqtt::mqtt_publish_fails_    = 0;
+std::vector<Mqtt::MQTTCmdFunction> Mqtt::mqtt_cmdfunctions_;
-size_t                              Mqtt::maximum_mqtt_messages_ = Mqtt::MAX_MQTT_MESSAGES;
-uint16_t                            Mqtt::mqtt_message_id_       = 0;
-std::deque<Mqtt::QueuedMqttMessage> Mqtt::mqtt_messages_;
-char                                will_topic_[Mqtt::MQTT_TOPIC_MAX_SIZE]; // because MQTT library keeps only char pointer
 
-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::QueuedMqttMessage> 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<MqttMessage> && content)
+uuid::log::Logger Mqtt::logger_{F_(mqtt), uuid::log::Facility::DAEMON};
-    : 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) {
-}
 
 // 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) {
+// only if it already hasn't been added
-    auto message = queue_subscribe_message(topic); // add subscription to queue. The hostname will automatically be appended
+void Mqtt::subscribe(const uint8_t device_type, const std::string & topic, mqtt_subfunction_p cb) {
-
-    if (message == nullptr) {
-        return;
-    }
-
-    // the message will contain the full topic, with the hostname prefixed
     // 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)) {
+            if ((mqtt_subfunction.device_type_ == device_type) && (strcmp(mqtt_subfunction.topic_.c_str(), topic.c_str()) == 0)) {
-                exists = true;
+                return; // it exists, exit
             }
         }
     }
 
-    if (!exists) {
+    // add to MQTT queue as a subscribe operation
-        mqtt_subfunctions_.emplace_back(device_id, std::move(message->topic), cb); // register a call back function for a specific telegram type
+    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 "<device_type>_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) {
+        if (strcmp(topic, mf.full_topic_.c_str()) == 0) {
-            (mf.mqtt_subfunction_)(message);
+            if (mf.mqtt_subfunction_) {
-            return;
+                (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<EMSESP_MAX_JSON_SIZE_SMALL> 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<char *>()) {
+                    cmd_known = call_command(mf.device_type_, command, data.as<char *>(), n);
+                } else if (data.is<int>()) {
+                    char data_str[10];
+                    cmd_known = call_command(mf.device_type_, command, Helpers::itoa(data_str, (int16_t)data.as<int>()), n);
+                } else if (data.is<float>()) {
+                    char data_str[10];
+                    cmd_known = call_command(mf.device_type_, command, Helpers::render_value(data_str, (float)data.as<float>(), 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
+// print all the topics related to a specific device type
-void Mqtt::show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_id) {
+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
+    // these commands respond to the topic "system_cmd" and take a payload like {cmd:"", data:"", id:""}
-    if (mqtt_subfunctions_.empty()) {
+    add_command(EMSdevice::DeviceType::SERVICEKEY, bus_id_, F("pin"), System::mqtt_command_pin);
-        Mqtt::subscribe("cmd", System::mqtt_commands);
+    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
+// add sub or pub task to the queue.
-// automatically the hostname prefixed.
+// a fully-qualified topic is created by prefixing the hostname, unless it's HA
-std::shared_ptr<const MqttMessage>
+// returns a pointer to the message created
-Mqtt::queue_message(const uint8_t operation, const std::string & topic, const std::string & payload, const bool retain, bool no_prefix) {
+std::shared_ptr<const MqttMessage> 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<MqttMessage> 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<MqttMessage>(operation, topic, payload, retain);
+        message = std::make_shared<MqttMessage>(operation, topic, std::move(payload), retain);
     } else {
         // prefix the hostname
-        std::string full_topic = Mqtt::hostname_ + "/" + topic;
+        std::string full_topic(50, '\0');
-        message                = std::make_shared<MqttMessage>(operation, full_topic, payload, retain);
+        snprintf_P(&full_topic[0], full_topic.capacity() + 1, PSTR("%s/%s"), Mqtt::hostname_.c_str(), topic.c_str());
+        message = std::make_shared<MqttMessage>(operation, full_topic, std::move(payload), retain);
     }
 
     // if the queue is full, make room but removing the last one

src/mqtt.h

@@ -24,7 +24,7 @@
 
 #include <string>
 #include <vector>
-#include <deque>
+#include <list>
 #include <functional>
 
 #include <AsyncMqttClient.h>
@@ -37,23 +37,29 @@
 
 using uuid::console::Shell;
 
-#define EMSESP_MAX_JSON_SIZE_SMALL 200  // for smaller json docs
+#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
+#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
+#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<void(const char * message)>;
-using namespace std::placeholders; // for `_1`
+using mqtt_cmdfunction_p = std::function<void(const char * data, const int8_t id)>;
 
 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<MQTTCmdFunction> commands() {
+        return mqtt_cmdfunctions_;
+    }
 
   private:
     static uuid::log::Logger logger_;
 
     class QueuedMqttMessage {
       public:
-        QueuedMqttMessage(uint16_t id, std::shared_ptr<MqttMessage> && content);
-        ~QueuedMqttMessage() = default;
-
         const uint16_t                           id_;
         const std::shared_ptr<const MqttMessage> content_;
         uint8_t                                  retry_count_;
         uint16_t                                 packet_id_;
+
+        ~QueuedMqttMessage() = default;
+        QueuedMqttMessage(uint16_t id, std::shared_ptr<MqttMessage> && content)
+            : id_(id)
+            , content_(std::move(content)) {
+            retry_count_ = 0;
+            packet_id_   = 0;
+        }
     };
-    static std::deque<QueuedMqttMessage> mqtt_messages_;
+    static std::list<QueuedMqttMessage> 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<const MqttMessage> 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<const MqttMessage> queue_message(const uint8_t operation, const std::string & topic, const std::string & payload, const bool retain);
     static std::shared_ptr<const MqttMessage> queue_publish_message(const std::string & topic, const std::string & payload, const bool retain);
     static std::shared_ptr<const MqttMessage> queue_subscribe_message(const std::string & topic);
 
-    void          on_publish(uint16_t packetId);
+    void on_publish(uint16_t packetId);
-    void          on_message(char * topic, char * payload, size_t len);
+    void on_message(const char * topic, const char * payload, size_t len);
-    void          process_queue();
+    void process_queue();
-    void          process_all_queue();
+    void process_all_queue();
 
     static uint16_t mqtt_publish_fails_;
 
     // function handlers for MQTT subscriptions
-    class MQTTSubFunction {
+    struct MQTTSubFunction {
-      public:
+        uint8_t            device_type_;      // which device type, from DeviceType::
-        MQTTSubFunction(const uint8_t device_id, const std::string && topic, mqtt_subfunction_p mqtt_subfunction);
+        const std::string  topic_;            // short topic name
-        ~MQTTSubFunction() = default;
+        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
+        MQTTSubFunction(uint8_t device_type, const std::string && topic, const std::string && full_topic, mqtt_subfunction_p mqtt_subfunction)
-        const std::string  topic_;
+            : device_type_(device_type)
-        mqtt_subfunction_p mqtt_subfunction_;
+            , topic_(topic)
+            , full_topic_(full_topic)
+            , mqtt_subfunction_(mqtt_subfunction) {
+        }
     };
 
     static std::vector<MQTTSubFunction> mqtt_subfunctions_; // list of mqtt subscribe callbacks for all devices
+    static std::vector<MQTTCmdFunction> 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 std::string hostname_;
-    static uint16_t publish_time_;
+    static uint8_t     mqtt_qos_;
+    static uint16_t    publish_time_;
+    static uint8_t     bus_id_;
 };
 
 } // namespace emsesp

src/sensors.cpp

@@ -16,13 +16,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-// 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

src/sensors.h

@@ -16,7 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-// 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 READ_INTERVAL_MS = 5000; // 5 seconds
-    static constexpr uint32_t CONVERSION_MS    = 1000;  // 1 seconds
+    static constexpr uint32_t CONVERSION_MS    = 1000; // 1 seconds
-    static constexpr uint32_t READ_TIMEOUT_MS  = 2000;  // 2 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 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

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) {

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
+// send on/off to a gpio pin
-void System::mqtt_commands(const char * message) {
+// value: true = HIGH, false = LOW
-    StaticJsonDocument<EMSESP_MAX_JSON_SIZE_SMALL> doc;
+void System::mqtt_command_pin(const char * value, const int8_t id) {
-    DeserializationError                           error = deserializeJson(doc, message);
+    bool v = false;
-    if (error) {
+    if (Helpers::value2bool(value, v)) {
-        LOG_DEBUG(F("MQTT error: payload %s, error %s"), message, error.c_str());
+        pinMode(id, OUTPUT);
-        return;
+        digitalWrite(id, v);
+        LOG_INFO(F("GPIO %d set to %s"), id, v ? "HIGH" : "LOW");
     }
+}
 
-    if (doc["send"] != nullptr) {
+// send raw
-        const char * data = doc["send"];
+void System::mqtt_command_send(const char * value, const int8_t id) {
-        EMSESP::send_raw_telegram(data);
+    EMSESP::send_raw_telegram(value); // ignore id
-        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;
-    }
 }
 
 // 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<uuid::log::Level>(settings.syslog_level)));
+        shell.printfln(F_(log_level_fmt), uuid::log::format_level_lowercase(static_cast<uuid::log::Level>(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<std::string> & 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<std::string> & 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<std::string> & 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

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)

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("<empty>"));
-    }
-
     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
+// returns telegram's message body only, in hex
-std::string Telegram::to_string(const uint8_t * telegram, uint8_t length) const {
+std::string Telegram::to_string_message() const {
-    return Helpers::data_to_hex(telegram, length);
+    if (this->message_length == 0) {
-}
+        return read_flash_string(F("<empty>"));
-
-RxService::QueuedRxTelegram::QueuedRxTelegram(uint16_t id, std::shared_ptr<Telegram> && 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
     }
+
+    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 (CRC %02X != %02X)"), Helpers::data_to_hex(data, length).c_str(), data[length - 1], crc);
-            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);
-        }
         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 we don't have a type_id exit,
-    if ((type_id == 0) || (message_length == 0)) {
+    // 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>(Telegram::Operation::RX, src, dest, type_id, offset, message_data, message_length);
+    rx_telegram = std::make_shared<Telegram>(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
+    // process it immediately
-    if (rx_telegrams_.size() >= MAX_RX_TELEGRAMS) {
+    EMSESP::process_telegram(rx_telegram); // further process the telegram
-        rx_telegrams_.pop_front();
+    increment_telegram_count();            // increase count
-    }
-
-    rx_telegrams_.emplace_back(rx_telegram_id_++, std::move(telegram)); // add to queue
 }
 
 //
 // Tx CODE starts here...
 //
 
-TxService::QueuedTxTelegram::QueuedTxTelegram(uint16_t id, std::shared_ptr<Telegram> && 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) {
+    if (tx_mode() != 0) {
-        tx_telegrams_.pop_front();
+        send_telegram(tx_telegrams_.front());
-        return;
     }
 
-    // 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(); // remove the telegram from the queue
-    tx_telegrams_.pop_front();
 }
 
 // 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) {

src/telegram.h

@@ -20,9 +20,7 @@
 #define EMSESP_TELEGRAM_H
 
 #include <string>
-#include <deque>
+#include <list>
-#include <memory> // for unique ptrs
-#include <vector>
 
 // 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; // used to mark that something 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
-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_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]; // shift
-            value = (value << 8) + message_data[abs_index + i];
         }
     }
 
@@ -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> && telegram);
-        ~QueuedRxTelegram() = default;
-
-        uint16_t                              id_; // sequential identifier
-        const std::shared_ptr<const Telegram> telegram_;
-    };
-
-    const std::deque<QueuedRxTelegram> queue() const {
-        return rx_telegrams_;
-    }
-
   private:
-    uint32_t last_rx_check_ = 0;
+    uint16_t                        telegram_count_       = 0; // # Rx received
-
+    uint16_t                        telegram_error_count_ = 0; // # Rx CRC errors
-    uint8_t rx_telegram_id_ = 0; // queue counter
+    std::shared_ptr<const Telegram> rx_telegram;               // the incoming Rx telegram
-
-    uint16_t telegram_count_       = 0; // # Rx received
-    uint16_t telegram_error_count_ = 0; // # Rx CRC errors
-
-    std::deque<QueuedRxTelegram> rx_telegrams_;
 };
 
 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_FAIL    = 4; // EMS return code for fail
-    static constexpr uint8_t TX_WRITE_SUCCESS = 1;
+    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> && telegram, bool retry);
+        const uint16_t                        id_;
-        ~QueuedTxTelegram() = default;
-
-        uint16_t                              id_; // sequential identifier
         const std::shared_ptr<const Telegram> telegram_;
-        bool                                  retry_; // is a retry
+        const bool                            retry_; // is a retry
+
+        ~QueuedTxTelegram() = default;
+        QueuedTxTelegram(uint16_t id, std::shared_ptr<Telegram> && telegram, bool retry)
+            : id_(id)
+            , telegram_(std::move(telegram))
+            , retry_(retry) {
+        }
     };
 
-    const std::deque<QueuedTxTelegram> queue() const {
+    const std::list<QueuedTxTelegram> 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
+    std::list<QueuedTxTelegram> tx_telegrams_; // the Tx queue
-
-    uint32_t last_tx_check_ = 0;
-
-    std::deque<QueuedTxTelegram> tx_telegrams_;
 
     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> 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);

src/test/test.cpp

@@ -17,7 +17,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#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") {
+    if (command == "general") {
-        shell.printfln(F("Testing adding devices on the EMS bus..."));
+        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();
+        Mqtt::show_mqtt(shell); // show queue
-        // simulate an incoming mqtt msg
-        char topic[Mqtt::MQTT_TOPIC_MAX_SIZE];
-        char payload[100];
 
-        strcpy(topic, "boiler_cmd");
+        strcpy(boiler_topic, "ems-esp/boiler_cmd");
-        strcpy(payload, "12345");
+        strcpy(thermostat_topic, "ems-esp/thermostat_cmd");
-        EMSESP::mqtt_.incoming(topic, payload);
+        strcpy(system_topic, "ems-esp/saystem_cmd");
-        EMSESP::mqtt_.incoming(payload, payload); // should report error
 
-        strcpy(topic, "thermostat_cmd_mode");
+        EMSESP::mqtt_.incoming(boiler_topic, "12345");                                // invalid format
-        strcpy(payload, "auto");
+        EMSESP::mqtt_.incoming("bad_topic", "12345");                                 // no matching topic
-        EMSESP::mqtt_.incoming(topic, payload);
+        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");
+        EMSESP::mqtt_.incoming(system_topic, "{\"cmd\":\"send\",\"data\":\"01 02 03 04 05\"}");
-        strcpy(payload, "20");
+        EMSESP::mqtt_.incoming(system_topic, "{\"cmd\":\"pin\",\"id\":12,\"data\":\"1\"}");
-        EMSESP::mqtt_.incoming(topic, payload);
 
-        strcpy(topic, "thermostat_cmd");
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"wwmode\",\"data\":\"auto\"}");
-        strcpy(payload, "{\"cmd\":\"temp\",\"data\":22.52}");
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"control\",\"data\":\"1\"}");
-        EMSESP::mqtt_.incoming(topic, payload);
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"control\",\"data\":1}");
-
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"mode\",\"data\":\"auto\",\"id\":2}");
-        strcpy(topic, "boiler_cmd_wwtemp");
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"mode\",\"data\":\"auto\",\"hc\":2}");     // hc as number
-        strcpy(payload, "66");
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"mode\",\"data\":\"auto\",\"hc\":\"2\"}"); // hc as string
-        EMSESP::mqtt_.incoming(topic, payload);
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"temp\",\"data\":22.56}");
-
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"temp\",\"data\":22}");
-        strcpy(topic, "thermostat_cmd");
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"temp\",\"data\":\"22.56\"}");
-        strcpy(payload, "{\"cmd\":\"temp\",\"hc\":2,\"data\":22}");
+        EMSESP::mqtt_.incoming(thermostat_topic, "{\"cmd\":\"temp\",\"id\":2,\"data\":22}");
-        EMSESP::mqtt_.incoming(topic, payload);
-
-        strcpy(topic, "home/ems-esp/cmd");
-        strcpy(payload, "restart");
-        EMSESP::mqtt_.incoming(topic, payload);
 
         // 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<uint8_t> & rx_data) {
     uint8_t len = rx_data.size();
     uint8_t data[50];
-    std::copy(rx_data.begin(), rx_data.end(), data);
+    uint8_t i = 0;
-    data[len] = EMSESP::rxservice_.calculate_crc(rx_data.data(), len);
+    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<uint8_t> & rx_data) {
     uint8_t len = rx_data.size();
     uint8_t data[50];
-    std::copy(rx_data.begin(), rx_data.end(), data);
+    uint8_t i = 0;
-    data[len] = EMSESP::rxservice_.calculate_crc(rx_data.data(), len);
+    while (len--) {
-    EMSESP::incoming_telegram(data, len + 1);
+        data[i] = rx_data[i];
-    EMSESP::rxservice_.loop();
+        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
 

src/test/test.h

@@ -16,7 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#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 {

src/version.h

@@ -1 +1 @@
-#define EMSESP_APP_VERSION "2.0.0b11"
+#define EMSESP_APP_VERSION "2.0.0b12"