Merge remote-tracking branch 'origin/ft_https' into dev

.clang-format

@@ -2,7 +2,7 @@ Language: Cpp
 BasedOnStyle: LLVM
 UseTab: Never
 IndentWidth: 4
-ColumnLimit: 220
+ColumnLimit: 160
 TabWidth: 4
 #BreakBeforeBraces: Custom
 BraceWrapping:

CHANGELOG_LATEST.md

@@ -5,5 +5,6 @@
 ## Fixed
 
 ## Changed
+- new API. Using secure access tokens and OpenAPI standard. See `doc/EMS-ESP32 API.md` and [#50](https://github.com/emsesp/EMS-ESP32/issues/50)
 
 ## Removed

doc/EMS-ESP32 API.md

@@ -0,0 +1,80 @@
+# EMS-ESP REST API
+
+OpenAPI is an open standard specification for describing REST APIs. From the [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification):
+
+> The OpenAPI Specification (OAS) defines a standard, programming language-agnostic interface description for HTTP APIs, which allows both humans and computers to discover and understand the capabilities of a service without requiring access to source code, additional documentation, or inspection of network traffic. When properly defined via OpenAPI, a consumer can understand and interact with the remote service with a minimal amount of implementation logic. Similar to what interface descriptions have done for lower-level programming, the OpenAPI Specification removes guesswork in calling a service.
+
+## Specification
+
+- All data is sent and received as JSON.
+- The URL is `http://<hostname>/api` with the default `<hostname>` being `ems-esp`. Note that it may also be ems-esp.local on some environments depending on your domain and dns setup.
+- Only HTTP for now. HTTPS will be supported soon, with self-signed certificates or user's own.
+- The EMS-ESP REST API will eventually be fully described in an OpenAPI 3.0 compliant document, available via [postman](https://www.postman.com/collections/479af3935991ac030130).
+- Read instructions to fetch data use HTTP `GET` and operations that change data use HTTP `POST`, `PUT` or `PATCH`.
+- To keep backwards compatibility with earlier versions, parameters can also be provided as HTML query parameters (name-value pairs) as opposed to URI path parameters. For example `POST http://ems-esp/api/boiler/wwtemp` with a JSON body of `{value: 50}` is the same as the URL `http://ems-esp/api?device=boiler?cmd=wwtemp?data=50`.
+- Unless explicitly bypassed in the WebUI some operations required admin privileges in the form of an Access Token which can be generated from the Web UI's Security tab. An Access Token is a string 152 characters long. Token's do not expire. The token needs to be either embedded into the HTTP Header as `"Authorization: Bearer {ACCESS_TOKEN}"` or as query parameter `?access_token={ACCESS_TOKEN}`. To test you can use a command line instruction like
+
+  ```bash
+    curl -i -H "Authorization: Bearer {ACCESS_TOKEN}" -X GET http://ems-esp/api/system/settings
+    curl -i -H "Authorization: Bearer {ACCESS_TOKEN}" -H "Content-Type: application/json" -d '{ "name": "wwtemp", "value":60}' http://ems-esp/api/boiler
+  ```
+
+## Error handling
+
+- Requests that require authentication will return `403 Forbidden`
+- Authenticating with invalid credentials will return `401 Unauthorized`
+
+    ```html
+    HTTP/1.1 401 Unauthorized
+    {"message": "Bad credentials"}
+    ```
+
+- Sending invalid JSON will result in a `400 Bad Request` response.
+
+    ```html
+    HTTP/1.1 400 Bad Request
+    {"message":"Problems parsing JSON"}
+    ```
+
+- Sending invalid fields will result in a `422 Unprocessable Entity` response.
+
+    ```html
+    HTTP/1.1 422 Unprocessable Entity
+    {"message":"Invalid command"}
+    ```
+
+## Endpoints
+
+### types
+
+- `<string>` is a character string
+- `<integer>` is a positive integer value
+- `<number>` is an integer or floating point number
+- `<boolean>` is either 1, 0, "1", "0", "on", "off", "true" or "false"
+  
+### descriptions
+
+- `{device}` is boiler, thermostat, mixer, solar, heatpump, dallassensor
+- `{name}` is the short name of the parameter, e.g. **curflowtemp**
+- `{hc}` is the heating circuit number as a string, like **hc1**, **hc2** etc
+- `{value}` is either a `<string>`, `<integer>`, `<number>` or `<boolean>`
+
+## Device Endpoints
+
+| Method | Endpoint | Description | Access Token required | JSON body data |
+| - | - | - | - | - |
+| GET | `/{device}` | return all device details and values | | |
+| GET | `/{device}/{name}` | return a specific parameter and all its properties (name, fullname, value, type, min, max, unit, writeable) | | |
+| GET | `/device={device}?cmd={name}?data={value}[?hc=<number>` | Using HTTP query parameters. This is to keep compatibility with v2. Unless bypassed in the EMS-ESP settings make sure you include `access_token={ACCESS_TOKEN}` | x |
+| POST/PUT | `/{device}[/{hc}][/{name}]` | sets a specific value to a parameter name. If no hc is selected and one is required for the device, the default will be used |  x | `{ ["name" : <string>] , ["hc": <number>], "value": <value> }` |
+
+## System Endpoints
+
+| Method | Endpoint | Description | Access Token required | JSON body data |
+| - | - | - | - | - |
+| GET | `/system/info` | list system information | | | |
+| GET | `/system/settings` | list all settings, except passwords | |
+| POST/PUT | `/system/pin` | switch a GPIO state to HIGH or LOW | x | `{ "id":<gpio>, "value":<boolean> }` |
+| POST/PUT | `/system/send` | send a telegram to the EMS bus | x | `{ "value" : <string> }` |
+| POST/PUT | `/system/publish` | force an MQTT publish | x | `{ "value" : <device> \| "ha" }` |
+| POST/PUT | `/system/fetch` | fetch all EMS data from all devices | x | `{ "value" : <device> \| "all" }` |

interface/src/project/EMSESPHelp.tsx

@@ -52,7 +52,7 @@ class EMSESPHelp extends Component {
                             <ImportExportIcon />
                         </ListItemAvatar>
                         <ListItemText>
-                            To list your system settings <Link target="_blank" href={WebAPISystemSettings} color="primary">{'click here'}</Link>
+                            To export your system settings <Link target="_blank" href={WebAPISystemSettings} color="primary">{'click here'}</Link>
                         </ListItemText>
                     </ListItem>
 
@@ -62,7 +62,7 @@ class EMSESPHelp extends Component {
                             <BugReportIcon />
                         </ListItemAvatar>
                         <ListItemText>
-                            To create a report of the current EMS-ESP status <Link target="_blank" href={WebAPISystemInfo} color="primary">{'click here'}</Link>
+                            To export the current status of EMS-ESP <Link target="_blank" href={WebAPISystemInfo} color="primary">{'click here'}</Link>
                         </ListItemText>
                     </ListItem>
 

interface/src/project/EMSESPSettingsForm.tsx

@@ -396,12 +396,12 @@ class EMSESPSettingsForm extends React.Component<EMSESPSettingsFormProps> {
         <BlockFormControlLabel
           control={
             <Checkbox
-              checked={data.api_enabled}
+              checked={data.notoken_api}
-              onChange={handleValueChange("api_enabled")}
+              onChange={handleValueChange("notoken_api")}
-              value="api_enabled"
+              value="notoken_api"
             />
           }
-          label="Enable API write commands"
+          label="Bypass Access Token authorization on API calls"
         />
         <BlockFormControlLabel
           control={

interface/src/project/EMSESPtypes.ts

@@ -16,7 +16,7 @@ export interface EMSESPSettings {
   dallas_parasite: boolean;
   led_gpio: number;
   hide_led: boolean;
-  api_enabled: boolean;
+  notoken_api: boolean;
   analog_enabled: boolean;
   pbutton_gpio: number;
   trace_raw: boolean;

lib/framework/APStatus.h

@@ -5,7 +5,6 @@
 #include <AsyncTCP.h>
 
 #include <ArduinoJson.h>
-#include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 #include <IPAddress.h>
 #include <SecurityManager.h>

lib/framework/AuthenticationService.cpp

@@ -14,7 +14,7 @@ AuthenticationService::AuthenticationService(AsyncWebServer * server, SecurityMa
 }
 
 /**
- * Verifys that the request supplied a valid JWT.
+ * Verifies that the request supplied a valid JWT.
  */
 void AuthenticationService::verifyAuthorization(AsyncWebServerRequest * request) {
     Authentication authentication = _securityManager->authenticateRequest(request);

lib/framework/AuthenticationService.h

@@ -2,7 +2,6 @@
 #define AuthenticationService_H_
 
 #include <Features.h>
-#include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>
 

lib/framework/ESP8266React.cpp

@@ -40,6 +40,11 @@ ESP8266React::ESP8266React(AsyncWebServer * server, FS * fs)
             });
         }
     });
+
+    // only added for local testing (CORS)
+    // DefaultHeaders::Instance().addHeader("Access-Control-Allow-Headers", "Accept, Content-Type, Authorization");
+    // DefaultHeaders::Instance().addHeader("Access-Control-Allow-Credentials", "true");
+    // DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", "*");
 }
 
 void ESP8266React::begin() {

lib/framework/FactoryResetService.h

@@ -2,7 +2,6 @@
 #define FactoryResetService_h
 
 #include <WiFi.h>
-#include <AsyncTCP.h>
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>
 #include <RestartService.h>

lib/framework/FeaturesService.h

@@ -4,7 +4,6 @@
 #include <Features.h>
 
 #include <WiFi.h>
-#include <AsyncTCP.h>
 #include <ArduinoJson.h>
 #include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>

lib/framework/HttpEndpoint.h

@@ -3,7 +3,6 @@
 
 #include <functional>
 
-#include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 
 #include <SecurityManager.h>

lib/framework/MqttStatus.h

@@ -2,10 +2,8 @@
 #define MqttStatus_h
 
 #include <WiFi.h>
-#include <AsyncTCP.h>
 #include <MqttSettingsService.h>
 #include <ArduinoJson.h>
-#include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>
 

lib/framework/NTPStatus.h

@@ -4,16 +4,13 @@
 #include <time.h>
 
 #include <WiFi.h>
-#include <AsyncTCP.h>
 #include <lwip/apps/sntp.h>
 
 #include <ArduinoJson.h>
-#include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>
 #include <uuid/common.h>
 
-
 #define MAX_NTP_STATUS_SIZE 1024
 #define NTP_STATUS_SERVICE_PATH "/rest/ntpStatus"
 

lib/framework/NetworkStatus.h

@@ -7,7 +7,6 @@
 #include <ETH.h>
 
 #include <ArduinoJson.h>
-#include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 #include <IPAddress.h>
 #include <IPUtils.h>

lib/framework/SystemStatus.h

@@ -7,7 +7,6 @@
 #include <LITTLEFS.h>
 
 #include <ArduinoJson.h>
-#include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>
 

lib/framework/UploadFirmwareService.h

@@ -5,7 +5,6 @@
 
 #include <Update.h>
 #include <WiFi.h>
-#include <AsyncTCP.h>
 
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>

lib/framework/WiFiScanner.h

@@ -5,7 +5,6 @@
 #include <AsyncTCP.h>
 
 #include <ArduinoJson.h>
-#include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>
 

lib_standalone/AsyncJson.h

@@ -40,6 +40,53 @@ class ChunkPrint : public Print {
     }
 };
 
+class PrettyAsyncJsonResponse {
+  protected:
+    DynamicJsonDocument _jsonBuffer;
+
+    JsonVariant _root;
+    bool        _isValid;
+
+  public:
+    PrettyAsyncJsonResponse(bool isArray = false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE)
+        : _jsonBuffer(maxJsonBufferSize)
+        , _isValid{false} {
+        if (isArray)
+            _root = _jsonBuffer.createNestedArray();
+        else
+            _root = _jsonBuffer.createNestedObject();
+    }
+
+    ~PrettyAsyncJsonResponse() {
+    }
+
+    JsonVariant & getRoot() {
+        return _root;
+    }
+
+    bool _sourceValid() const {
+        return _isValid;
+    }
+
+    size_t setLength() {
+        return 0;
+    }
+
+    void setContentType(const char * s) {
+    }
+
+    size_t getSize() {
+        return _jsonBuffer.size();
+    }
+
+    size_t _fillBuffer(uint8_t * data, size_t len) {
+        return len;
+    }
+
+    void setCode(uint16_t) {
+    }
+};
+
 class AsyncJsonResponse {
   protected:
     DynamicJsonDocument _jsonBuffer;
@@ -56,14 +103,18 @@ class AsyncJsonResponse {
         else
             _root = _jsonBuffer.createNestedObject();
     }
+
     ~AsyncJsonResponse() {
     }
+
     JsonVariant & getRoot() {
         return _root;
     }
+
     bool _sourceValid() const {
         return _isValid;
     }
+
     size_t setLength() {
         return 0;
     }
@@ -75,6 +126,9 @@ class AsyncJsonResponse {
     size_t _fillBuffer(uint8_t * data, size_t len) {
         return len;
     }
+
+    void setCode(uint16_t) {
+    }
 };
 
 typedef std::function<void(AsyncWebServerRequest * request, JsonVariant & json)> ArJsonRequestHandlerFunction;

lib_standalone/ESP8266React.h

@@ -25,7 +25,7 @@ class DummySettings {
     bool     shower_timer         = true;
     bool     shower_alert         = false;
     bool     hide_led             = false;
-    bool     api_enabled          = true;
+    bool     notoken_api          = false;
 
     // MQTT
     uint16_t publish_time      = 10; // seconds

lib_standalone/ESPAsyncWebServer.h

@@ -11,6 +11,7 @@ class AsyncWebServer;
 class AsyncWebServerRequest;
 class AsyncWebServerResponse;
 class AsyncJsonResponse;
+class PrettyAsyncJsonResponse;
 
 class AsyncWebParameter {
   private:
@@ -68,11 +69,13 @@ class AsyncWebServerRequest {
     AsyncWebServer *          _server;
     WebRequestMethodComposite _method;
 
+    String _url;
+
   public:
     void * _tempObject;
 
-    AsyncWebServerRequest(AsyncWebServer *, AsyncClient *);
+    AsyncWebServerRequest(AsyncWebServer *, AsyncClient *){};
-    ~AsyncWebServerRequest();
+    ~AsyncWebServerRequest(){};
 
     AsyncClient * client() {
         return _client;
@@ -82,13 +85,30 @@ class AsyncWebServerRequest {
         return _method;
     }
 
+    void method(WebRequestMethodComposite method_s) {
+        _method = method_s;
+    }
+
     void addInterestingHeader(const String & name){};
 
+    size_t args() const {
+        return 0;
+    }
+
     void send(AsyncWebServerResponse * response){};
     void send(AsyncJsonResponse * response){};
+    void send(PrettyAsyncJsonResponse * response){};
     void send(int code, const String & contentType = String(), const String & content = String()){};
     void send(int code, const String & contentType, const __FlashStringHelper *){};
 
+    const String & url() const {
+        return _url;
+    }
+
+    void url(const String & url_s) {
+        _url = url_s;
+    }
+
     bool hasParam(const String & name, bool post, bool file) const {
         return false;
     }

mock-api/server.js

@@ -117,7 +117,7 @@ const emsesp_settings = {
     "tx_mode": 1, "tx_delay": 0, "ems_bus_id": 11, "syslog_enabled": false, "syslog_level": 3,
     "trace_raw": false, "syslog_mark_interval": 0, "syslog_host": "192.168.1.4", "syslog_port": 514,
     "master_thermostat": 0, "shower_timer": true, "shower_alert": false, "rx_gpio": 23, "tx_gpio": 5,
-    "dallas_gpio": 3, "dallas_parasite": false, "led_gpio": 2, "hide_led": false, "api_enabled": true,
+    "dallas_gpio": 3, "dallas_parasite": false, "led_gpio": 2, "hide_led": false, "notoken_api": false,
     "analog_enabled": false, "pbutton_gpio": 0, "board_profile": "S32"
 };
 const emsesp_alldevices = {

src/WebAPIService.cpp

@@ -16,76 +16,308 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+// SUrlParser from https://github.com/Mad-ness/simple-url-parser
+
 #include "emsesp.h"
 
 using namespace std::placeholders; // for `_1` etc
 
 namespace emsesp {
 
-WebAPIService::WebAPIService(AsyncWebServer * server) {
+WebAPIService::WebAPIService(AsyncWebServer * server, SecurityManager * securityManager)
-    server->on(EMSESP_API_SERVICE_PATH, HTTP_GET, std::bind(&WebAPIService::webAPIService, this, _1));
+    : _securityManager(securityManager)
+    , _apiHandler("/api", std::bind(&WebAPIService::webAPIService_post, this, _1, _2), 256) { // for POSTS
+    server->on("/api", HTTP_GET, std::bind(&WebAPIService::webAPIService_get, this, _1));     // for GETS
+    server->addHandler(&_apiHandler);
 }
 
-// e.g. http://ems-esp/api?device=boiler&cmd=wwtemp&data=20&id=1
+// GET /{device}
-void WebAPIService::webAPIService(AsyncWebServerRequest * request) {
+// GET /{device}/{name}
-    // must have device and cmd parameters
+// GET /device={device}?cmd={name}?data={value}[?id={hc}
-    if ((!request->hasParam(F_(device))) || (!request->hasParam(F_(cmd)))) {
+void WebAPIService::webAPIService_get(AsyncWebServerRequest * request) {
-        request->send(400, "text/plain", F("Invalid syntax"));
+    std::string device("");
+    std::string cmd("");
+    int         id = -1;
+    std::string value("");
+
+    parse(request, device, cmd, id, value); // pass it defaults
+}
+
+// For POSTS with an optional JSON body
+// HTTP_POST | HTTP_PUT | HTTP_PATCH
+// POST/PUT /{device}[/{hc}][/{name}]
+void WebAPIService::webAPIService_post(AsyncWebServerRequest * request, JsonVariant & json) {
+    // extra the params from the json body
+    if (not json.is<JsonObject>()) {
+        webAPIService_get(request);
         return;
     }
 
-    // get device
+    // extract values from the json
-    String  device      = request->getParam(F_(device))->value();
+    // these will be used as default values
-    uint8_t device_type = EMSdevice::device_name_2_device_type(device.c_str());
+    auto && body = json.as<JsonObject>();
-    if (device_type == emsesp::EMSdevice::DeviceType::UNKNOWN) {
+
-        request->send(400, "text/plain", F("Invalid device"));
+    std::string device = body["name"].as<std::string>(); // note this was called device in the v2
-        return;
+    std::string cmd    = body["cmd"].as<std::string>();
+    int         id     = -1;
+    if (body.containsKey("id")) {
+        id = body["id"];
+    } else if (body.containsKey("hc")) {
+        id = body["hc"];
+    } else {
+        id = -1;
     }
 
-    // get cmd, we know we have one
+    // make sure we have a value. There must always be a value
-    String cmd = request->getParam(F_(cmd))->value();
+    if (!body.containsKey("value")) {
+        send_message_response(request, 400, "Problems parsing JSON"); // Bad Request
+        return;
+    }
+    std::string value = body["value"].as<std::string>(); // always convert value to string
 
-    String data;
+    // now parse the URL. The URL is always leading and will overwrite anything provided in the json body
+    parse(request, device, cmd, id, value); // pass it defaults
+}
+
+// parse the URL looking for query or path parameters
+// reporting back any errors
+void WebAPIService::parse(AsyncWebServerRequest * request, std::string & device_s, std::string & cmd_s, int id, std::string & value_s) {
+#ifndef EMSESP_STANDALONE
+    // parse URL for the path names
+    SUrlParser p;
+    p.parse(request->url().c_str());
+
+    // remove the /api from the path
+    if (p.paths().front() == "api") {
+        p.paths().erase(p.paths().begin());
+    } else {
+        return; // bad URL
+    }
+
+    uint8_t device_type;
+    int8_t  id_n = -1; // default hc
+
+    // check for query parameters first
+    // /device={device}?cmd={name}?data={value}[?id={hc}
+    if (p.paths().size() == 0) {
+        // get the device
+        if (request->hasParam(F_(device))) {
+            device_s = request->getParam(F_(device))->value().c_str();
+        }
+
+        // get cmd
+        if (request->hasParam(F_(cmd))) {
+            cmd_s = request->getParam(F_(cmd))->value().c_str();
+        }
+
+        // get data, which is optional. This is now replaced with the name 'value' in JSON body
         if (request->hasParam(F_(data))) {
-        data = request->getParam(F_(data))->value();
+            value_s = request->getParam(F_(data))->value().c_str();
+        }
+        if (request->hasParam("value")) {
+            value_s = request->getParam("value")->value().c_str();
         }
 
-    String id;
+        // get id (or hc), which is optional
         if (request->hasParam(F_(id))) {
-        id = request->getParam(F_(id))->value();
+            id_n = Helpers::atoint(request->getParam(F_(id))->value().c_str());
+        }
+        if (request->hasParam("hc")) {
+            id_n = Helpers::atoint(request->getParam("hc")->value().c_str());
+        }
+    } else {
+        // parse paths and json data
+        // /{device}[/{hc}][/{name}]
+        // first param must be a valid device, which includes "system"
+        device_s    = p.paths().front();
+        device_type = EMSdevice::device_name_2_device_type(device_s.c_str());
+
+        // if there are no more paths parameters, default to 'info'
+        auto num_paths = p.paths().size();
+        if (num_paths > 1) {
+            auto path2 = p.paths()[1]; // get next path
+            // if it's a system, the next path must be a command (info, settings,...)
+            if (device_type == EMSdevice::DeviceType::SYSTEM) {
+                cmd_s = path2;
+            } else {
+                // it's an EMS device
+                // path2 could be a hc which is optional or a name. first check if it's a hc
+                if (path2.substr(0, 2) == "hc") {
+                    id_n = (byte)path2[2] - '0'; // bit of a hack
+                    // there must be a name following
+                    if (num_paths > 2) {
+                        cmd_s = p.paths()[2];
+                    }
+                } else {
+                    cmd_s = path2;
+                }
+            }
+        }
     }
 
-    if (id.isEmpty()) {
+    // now go and validate everything
-        id = "-1";
+
+    // device check
+    if (device_s.empty()) {
+        send_message_response(request, 422, "Missing device"); // Unprocessable Entity
+        return;
+    }
+    device_type = EMSdevice::device_name_2_device_type(device_s.c_str());
+    if (device_type == EMSdevice::DeviceType::UNKNOWN) {
+        send_message_response(request, 422, "Invalid device"); // Unprocessable Entity
+        return;
     }
 
-    DynamicJsonDocument doc(EMSESP_JSON_SIZE_XLARGE_DYN);
+    // cmd check
-    JsonObject          json = doc.to<JsonObject>();
+    // if the cmd is empty, default it 'info'
-    bool                ok   = false;
+    if (cmd_s.empty()) {
+        cmd_s = "info";
+    }
+    if (Command::find_command(device_type, cmd_s.c_str()) == nullptr) {
+        send_message_response(request, 422, "Invalid cmd"); // Unprocessable Entity
+        return;
+    }
 
-    // execute the command
+    // check that we have permissions first. We require authenticating on 1 or more of these conditions:
-    if (data.isEmpty()) {
+    //  1. any HTTP POSTs or PUTs
-        ok = Command::call(device_type, cmd.c_str(), nullptr, id.toInt(), json); // command only
+    //  2. a HTTP GET which has a 'data' parameter which is not empty (to keep v2 compatibility)
-    } else {
+    auto method    = request->method();
-        // we only allow commands with parameters if the API is enabled
+    bool have_data = !value_s.empty();
-        bool api_enabled;
+    bool admin_allowed;
-        EMSESP::webSettingsService.read([&](WebSettings & settings) { api_enabled = settings.api_enabled; });
+    EMSESP::webSettingsService.read([&](WebSettings & settings) {
-        if (api_enabled) {
+        Authentication authentication = _securityManager->authenticateRequest(request);
-            ok = Command::call(device_type, cmd.c_str(), data.c_str(), id.toInt(), json); // has cmd, data and id
+        admin_allowed                 = settings.notoken_api | AuthenticationPredicates::IS_ADMIN(authentication);
-        } else {
+    });
-            request->send(401, "text/plain", F("Unauthorized"));
+
+    if ((method != HTTP_GET) || ((method == HTTP_GET) && have_data)) {
+        if (!admin_allowed) {
+            send_message_response(request, 401, "Bad credentials"); // Unauthorized
             return;
         }
     }
-    if (ok && json.size()) {
+
-        // send json output back to web
+    // now we have all the parameters go and execute the command
-        doc.shrinkToFit();
+    PrettyAsyncJsonResponse * response = new PrettyAsyncJsonResponse(false, EMSESP_JSON_SIZE_XLARGE_DYN);
-        std::string buffer;
+    JsonObject                json     = response->getRoot();
-        serializeJsonPretty(doc, buffer);
+
-        request->send(200, "text/plain;charset=utf-8", buffer.c_str());
+    // EMSESP::logger().notice("Calling device=%s, cmd=%s, data=%s, id/hc=%d", device_s.c_str(), cmd_s.c_str(), value_s.c_str(), id_n);
+    bool ok = Command::call(device_type, cmd_s.c_str(), (have_data ? value_s.c_str() : nullptr), id_n, json);
+
+    // check for errors
+    if (!ok) {
+        send_message_response(request, 400, "Problems parsing elements"); // Bad Request
         return;
     }
-    request->send(200, "text/plain", ok ? F("OK") : F("Invalid"));
+
+    if (!json.size()) {
+        send_message_response(request, 200, "OK"); // OK
+        return;
+    }
+
+    // send the json that came back from the command call
+    response->setLength();
+    request->send(response); // send json response
+
+#endif
+}
+
+// send a HTTP error back, with optional JSON body data
+void WebAPIService::send_message_response(AsyncWebServerRequest * request, uint16_t error_code, const char * error_message) {
+    if (error_message == nullptr) {
+        AsyncWebServerResponse * response = request->beginResponse(error_code); // just send the code
+        request->send(response);
+    } else {
+        // build a return message and send it
+        PrettyAsyncJsonResponse * response = new PrettyAsyncJsonResponse(false, EMSESP_JSON_SIZE_SMALL);
+        JsonObject                json     = response->getRoot();
+        json["message"]                    = error_message;
+        response->setCode(error_code);
+        response->setLength();
+        response->setContentType("application/json");
+        request->send(response);
+    }
+}
+
+/**
+ * Extract only the path component from the passed URI 
+ * and normalized it.
+ * Ex. //one/two////three///
+ * becomes
+ *  /one/two/three
+ */
+std::string SUrlParser::path() {
+    std::string s = "/"; // set up the beginning slash
+    for (std::string & f : m_folders) {
+        s += f;
+        s += "/";
+    }
+    s.pop_back(); // deleting last letter, that is slash '/'
+    return std::string(s);
+}
+
+SUrlParser::SUrlParser(const char * uri) {
+    parse(uri);
+}
+
+bool SUrlParser::parse(const char * uri) {
+    m_folders.clear();
+    m_keysvalues.clear();
+    enum Type { begin, folder, param, value };
+    std::string s;
+
+    const char * c = uri;
+    enum Type    t = Type::begin;
+    std::string  last_param;
+
+    if (c != NULL || *c != '\0') {
+        do {
+            if (*c == '/') {
+                if (s.length() > 0) {
+                    m_folders.push_back(s);
+                    s.clear();
+                }
+                t = Type::folder;
+            } else if (*c == '?' && (t == Type::folder || t == Type::begin)) {
+                if (s.length() > 0) {
+                    m_folders.push_back(s);
+                    s.clear();
+                }
+                t = Type::param;
+            } else if (*c == '=' && (t == Type::param || t == Type::begin)) {
+                m_keysvalues[s] = "";
+                last_param      = s;
+                s.clear();
+                t = Type::value;
+            } else if (*c == '&' && (t == Type::value || t == Type::param || t == Type::begin)) {
+                if (t == Type::value) {
+                    m_keysvalues[last_param] = s;
+                } else if ((t == Type::param || t == Type::begin) && (s.length() > 0)) {
+                    m_keysvalues[s] = "";
+                    last_param      = s;
+                }
+                t = Type::param;
+                s.clear();
+            } else if (*c == '\0' && s.length() > 0) {
+                if (t == Type::value) {
+                    m_keysvalues[last_param] = s;
+                } else if (t == Type::folder || t == Type::begin) {
+                    m_folders.push_back(s);
+                } else if (t == Type::param) {
+                    m_keysvalues[s] = "";
+                    last_param      = s;
+                }
+                s.clear();
+            } else if (*c == '\0' && s.length() == 0) {
+                if (t == Type::param && last_param.length() > 0) {
+                    m_keysvalues[last_param] = "";
+                }
+                s.clear();
+            } else {
+                s += *c;
+            }
+        } while (*c++ != '\0');
+    }
+    return true;
 }
 
 } // namespace emsesp

src/WebAPIService.h

@@ -23,16 +23,52 @@
 #include <AsyncJson.h>
 #include <ESPAsyncWebServer.h>
 
+#include <string>
+#include <unordered_map>
+#include <vector>
+
 #define EMSESP_API_SERVICE_PATH "/api"
 
 namespace emsesp {
 
+typedef std::unordered_map<std::string, std::string> KeyValueMap_t;
+typedef std::vector<std::string>                     Folder_t;
+
+class SUrlParser {
+  private:
+    KeyValueMap_t m_keysvalues;
+    Folder_t      m_folders;
+
+  public:
+    SUrlParser(){};
+    SUrlParser(const char * url);
+
+    bool parse(const char * url);
+
+    Folder_t & paths() {
+        return m_folders;
+    };
+
+    KeyValueMap_t & params() {
+        return m_keysvalues;
+    };
+
+    std::string path();
+};
+
 class WebAPIService {
   public:
-    WebAPIService(AsyncWebServer * server);
+    WebAPIService(AsyncWebServer * server, SecurityManager * securityManager);
 
   private:
-    void webAPIService(AsyncWebServerRequest * request);
+    SecurityManager *           _securityManager;
+    AsyncCallbackJsonWebHandler _apiHandler; // for POSTs
+
+    void webAPIService_post(AsyncWebServerRequest * request, JsonVariant & json); // for POSTs
+    void webAPIService_get(AsyncWebServerRequest * request);                      // for GETs
+
+    void parse(AsyncWebServerRequest * request, std::string & device, std::string & cmd, int id, std::string & value);
+    void send_message_response(AsyncWebServerRequest * request, uint16_t error_code, const char * error_message = nullptr);
 };
 
 } // namespace emsesp

src/WebDevicesService.cpp

@@ -23,10 +23,16 @@ namespace emsesp {
 using namespace std::placeholders; // for `_1` etc
 
 WebDevicesService::WebDevicesService(AsyncWebServer * server, SecurityManager * securityManager)
-    : _device_dataHandler(DEVICE_DATA_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebDevicesService::device_data, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED))
+    : _device_dataHandler(DEVICE_DATA_SERVICE_PATH,
-    , _writevalue_dataHandler(WRITE_VALUE_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebDevicesService::write_value, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) {
+                          securityManager->wrapCallback(std::bind(&WebDevicesService::device_data, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED))
-    server->on(EMSESP_DEVICES_SERVICE_PATH, HTTP_GET, securityManager->wrapRequest(std::bind(&WebDevicesService::all_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED));
+    , _writevalue_dataHandler(WRITE_VALUE_SERVICE_PATH,
-    server->on(SCAN_DEVICES_SERVICE_PATH, HTTP_GET, securityManager->wrapRequest(std::bind(&WebDevicesService::scan_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED));
+                              securityManager->wrapCallback(std::bind(&WebDevicesService::write_value, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) {
+    server->on(EMSESP_DEVICES_SERVICE_PATH,
+               HTTP_GET,
+               securityManager->wrapRequest(std::bind(&WebDevicesService::all_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED));
+    server->on(SCAN_DEVICES_SERVICE_PATH,
+               HTTP_GET,
+               securityManager->wrapRequest(std::bind(&WebDevicesService::scan_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED));
 
     _device_dataHandler.setMethod(HTTP_POST);
     _device_dataHandler.setMaxContentLength(256);
@@ -104,7 +110,7 @@ void WebDevicesService::device_data(AsyncWebServerRequest * request, JsonVariant
 void WebDevicesService::write_value(AsyncWebServerRequest * request, JsonVariant & json) {
     // only issue commands if the API is enabled
     EMSESP::webSettingsService.read([&](WebSettings & settings) {
-        if (!settings.api_enabled) {
+        if (!settings.notoken_api) {
             request->send(403); // forbidden error
             return;
         }

src/WebSettingsService.cpp

@@ -27,7 +27,8 @@ using namespace std::placeholders; // for `_1` etc
 WebSettingsService::WebSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager)
     : _httpEndpoint(WebSettings::read, WebSettings::update, this, server, EMSESP_SETTINGS_SERVICE_PATH, securityManager)
     , _fsPersistence(WebSettings::read, WebSettings::update, this, fs, EMSESP_SETTINGS_FILE)
-    , _boardProfileHandler(EMSESP_BOARD_PROFILE_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebSettingsService::board_profile, this, _1, _2), AuthenticationPredicates::IS_ADMIN)) {
+    , _boardProfileHandler(EMSESP_BOARD_PROFILE_SERVICE_PATH,
+                           securityManager->wrapCallback(std::bind(&WebSettingsService::board_profile, this, _1, _2), AuthenticationPredicates::IS_ADMIN)) {
     _boardProfileHandler.setMethod(HTTP_POST);
     _boardProfileHandler.setMaxContentLength(256);
     server->addHandler(&_boardProfileHandler);
@@ -54,7 +55,7 @@ void WebSettings::read(WebSettings & settings, JsonObject & root) {
     root["dallas_parasite"]      = settings.dallas_parasite;
     root["led_gpio"]             = settings.led_gpio;
     root["hide_led"]             = settings.hide_led;
-    root["api_enabled"]          = settings.api_enabled;
+    root["notoken_api"]          = settings.notoken_api;
     root["analog_enabled"]       = settings.analog_enabled;
     root["pbutton_gpio"]         = settings.pbutton_gpio;
     root["board_profile"]        = settings.board_profile;
@@ -168,7 +169,7 @@ StateUpdateResult WebSettings::update(JsonObject & root, WebSettings & settings)
     settings.master_thermostat = root["master_thermostat"] | EMSESP_DEFAULT_MASTER_THERMOSTAT;
 
     // doesn't need any follow-up actions
-    settings.api_enabled = root["api_enabled"] | EMSESP_DEFAULT_API_ENABLED;
+    settings.notoken_api = root["notoken_api"] | EMSESP_DEFAULT_NOTOKEN_API;
 
     return StateUpdateResult::CHANGED;
 }

src/WebSettingsService.h

@@ -50,7 +50,7 @@ class WebSettings {
     bool     dallas_parasite;
     uint8_t  led_gpio;
     bool     hide_led;
-    bool     api_enabled;
+    bool     notoken_api;
     bool     analog_enabled;
     uint8_t  pbutton_gpio;
     String   board_profile;

src/WebStatusService.cpp

@@ -24,7 +24,9 @@ namespace emsesp {
 
 WebStatusService::WebStatusService(AsyncWebServer * server, SecurityManager * securityManager) {
     // rest endpoint for web page
-    server->on(EMSESP_STATUS_SERVICE_PATH, HTTP_GET, securityManager->wrapRequest(std::bind(&WebStatusService::webStatusService, this, _1), AuthenticationPredicates::IS_AUTHENTICATED));
+    server->on(EMSESP_STATUS_SERVICE_PATH,
+               HTTP_GET,
+               securityManager->wrapRequest(std::bind(&WebStatusService::webStatusService, this, _1), AuthenticationPredicates::IS_AUTHENTICATED));
     WiFi.onEvent(std::bind(&WebStatusService::WiFiEvent, this, _1, _2));
 }
 

src/command.cpp

@@ -95,6 +95,7 @@ bool Command::call(const uint8_t device_type, const char * cmd, const char * val
     }
 }
 
+// set the id if there are prefixes
 char * Command::check_command(char * out, const char * cmd, int8_t & id) {
     // convert cmd to lowercase
     strlcpy(out, cmd, 20);
@@ -102,7 +103,7 @@ char * Command::check_command(char * out, const char * cmd, int8_t & id) {
         *p = tolower(*p);
     }
 
-    //scan for prefix hc.
+    // scan for prefix hc.
     for (uint8_t i = DeviceValueTAG::TAG_HC1; i <= DeviceValueTAG::TAG_HC4; i++) {
         if ((strncmp(out, EMSdevice::tag_to_string(i).c_str(), 3) == 0) && (strlen(out) > 4)) {
             strcpy(out, &out[4]);
@@ -111,7 +112,7 @@ char * Command::check_command(char * out, const char * cmd, int8_t & id) {
         }
     }
 
-    //scan for prefix wwc.
+    // scan for prefix wwc.
     for (uint8_t i = DeviceValueTAG::TAG_WWC1; i <= DeviceValueTAG::TAG_WWC4; i++) {
         if ((strncmp(out, EMSdevice::tag_to_string(i).c_str(), 4) == 0) && (strlen(out) > 5)) {
             strcpy(out, &out[5]);
@@ -123,7 +124,6 @@ char * Command::check_command(char * out, const char * cmd, int8_t & id) {
     return out;
 }
 
-
 // add a command to the list, which does not return json
 void Command::add(const uint8_t device_type, const __FlashStringHelper * cmd, cmdfunction_p cb, uint8_t flag) {
     // if the command already exists for that device type don't add it

src/console.cpp

@@ -36,7 +36,9 @@ static std::shared_ptr<EMSESPShell> shell;
 std::vector<bool> EMSESPStreamConsole::ptys_;
 
 #ifndef EMSESP_STANDALONE
-uuid::telnet::TelnetService telnet_([](Stream & stream, const IPAddress & addr, uint16_t port) -> std::shared_ptr<uuid::console::Shell> { return std::make_shared<EMSESPStreamConsole>(stream, addr, port); });
+uuid::telnet::TelnetService telnet_([](Stream & stream, const IPAddress & addr, uint16_t port) -> std::shared_ptr<uuid::console::Shell> {
+    return std::make_shared<EMSESPStreamConsole>(stream, addr, port);
+});
 #endif
 
 EMSESPShell::EMSESPShell()
@@ -102,30 +104,42 @@ void EMSESPShell::add_console_commands() {
     // just in case, remove everything
     commands->remove_all_commands();
 
-    commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    commands->add_command(ShellContext::MAIN,
+                          CommandFlags::USER,
+                          flash_string_vector{F_(show)},
+                          [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                               shell.printfln(F("%s%sEMS-ESP version %s%s"), COLOR_BRIGHT_GREEN, COLOR_BOLD_ON, EMSESP_APP_VERSION, COLOR_RESET);
                               shell.println();
                               EMSESP::show_device_values(shell);
                               EMSESP::show_sensor_values(shell);
                           });
 
-    commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show), F_(devices)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    commands->add_command(ShellContext::MAIN,
-        EMSESP::show_devices(shell);
+                          CommandFlags::USER,
-    });
+                          flash_string_vector{F_(show), F_(devices)},
+                          [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) { EMSESP::show_devices(shell); });
 
 
-    commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show), F_(ems)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) { EMSESP::show_ems(shell); });
+    commands->add_command(ShellContext::MAIN,
+                          CommandFlags::USER,
+                          flash_string_vector{F_(show), F_(ems)},
+                          [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) { EMSESP::show_ems(shell); });
 
-    commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show), F_(values)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    commands->add_command(ShellContext::MAIN,
-        EMSESP::show_device_values(shell);
+                          CommandFlags::USER,
-    });
+                          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::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::USER, flash_string_vector{F_(show), F_(commands)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    commands->add_command(ShellContext::MAIN,
-        Command::show_all(shell);
+                          CommandFlags::USER,
-    });
+                          flash_string_vector{F_(show), F_(commands)},
+                          [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) { Command::show_all(shell); });
 
     commands->add_command(
         ShellContext::MAIN,
@@ -157,7 +171,11 @@ void EMSESPShell::add_console_commands() {
             };
         });
 
-    commands->add_command(ShellContext::MAIN, CommandFlags::ADMIN, flash_string_vector{F_(set), F_(tx_mode)}, flash_string_vector{F_(n_mandatory)}, [](Shell & shell, const std::vector<std::string> & arguments) {
+    commands->add_command(ShellContext::MAIN,
+                          CommandFlags::ADMIN,
+                          flash_string_vector{F_(set), F_(tx_mode)},
+                          flash_string_vector{F_(n_mandatory)},
+                          [](Shell & shell, const std::vector<std::string> & arguments) {
                               uint8_t tx_mode = std::strtol(arguments[0].c_str(), nullptr, 10);
                               // save the tx_mode
                               EMSESP::webSettingsService.update(
@@ -169,7 +187,11 @@ void EMSESPShell::add_console_commands() {
                                   "local");
                           });
 
-    commands->add_command(ShellContext::MAIN, CommandFlags::ADMIN, flash_string_vector{F_(scan), F_(devices)}, flash_string_vector{F_(deep_optional)}, [](Shell & shell, const std::vector<std::string> & arguments) {
+    commands->add_command(ShellContext::MAIN,
+                          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::scan_devices();
                               } else {
@@ -204,12 +226,17 @@ void EMSESPShell::add_console_commands() {
                               }
                           });
 
-    commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(set)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    commands->add_command(ShellContext::MAIN,
+                          CommandFlags::USER,
+                          flash_string_vector{F_(set)},
+                          [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                               EMSESP::webSettingsService.read([&](WebSettings & settings) {
                                   shell.printfln(F_(tx_mode_fmt), settings.tx_mode);
                                   shell.printfln(F_(bus_id_fmt), settings.ems_bus_id);
                                   char buffer[4];
-            shell.printfln(F_(master_thermostat_fmt), settings.master_thermostat == 0 ? uuid::read_flash_string(F_(auto)).c_str() : Helpers::hextoa(buffer, settings.master_thermostat));
+                                  shell.printfln(F_(master_thermostat_fmt),
+                                                 settings.master_thermostat == 0 ? uuid::read_flash_string(F_(auto)).c_str()
+                                                                                 : Helpers::hextoa(buffer, settings.master_thermostat));
                                   shell.printfln(F_(board_profile_fmt), settings.board_profile.c_str());
                               });
                           });
@@ -245,14 +272,19 @@ void EMSESPShell::add_console_commands() {
                                       settings.master_thermostat = value;
                                       EMSESP::actual_master_thermostat(value); // set the internal value too
                                       char buffer[5];
-                                      shell.printfln(F_(master_thermostat_fmt), !value ? uuid::read_flash_string(F_(auto)).c_str() : Helpers::hextoa(buffer, value));
+                                      shell.printfln(F_(master_thermostat_fmt),
+                                                     !value ? uuid::read_flash_string(F_(auto)).c_str() : Helpers::hextoa(buffer, value));
                                       return StateUpdateResult::CHANGED;
                                   },
                                   "local");
                           });
 
 #ifndef EMSESP_STANDALONE
-    commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(set), F_(timeout)}, flash_string_vector{F_(n_mandatory)}, [](Shell & shell, const std::vector<std::string> & arguments) {
+    commands->add_command(ShellContext::MAIN,
+                          CommandFlags::USER,
+                          flash_string_vector{F_(set), F_(timeout)},
+                          flash_string_vector{F_(n_mandatory)},
+                          [](Shell & shell, const std::vector<std::string> & arguments) {
                               uint16_t value = Helpers::atoint(arguments.front().c_str());
                               telnet_.initial_idle_timeout(value * 60);
                               shell.printfln(F("Telnet timeout set to %d minutes"), value);
@@ -444,7 +476,11 @@ 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) {
 #if defined(EMSESP_DEBUG)
-    EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F("test")}, flash_string_vector{F_(name_optional)}, [](Shell & shell, const std::vector<std::string> & arguments) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::USER,
+                                       flash_string_vector{F("test")},
+                                       flash_string_vector{F_(name_optional)},
+                                       [](Shell & shell, const std::vector<std::string> & arguments) {
                                            if (arguments.size() == 0) {
                                                Test::run_test(shell, "default");
                                            } else {
@@ -454,11 +490,17 @@ void Console::load_standard_commands(unsigned int context) {
 #endif
 
 #if defined(EMSESP_STANDALONE)
-    EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F("t")}, [](Shell & shell, const std::vector<std::string> & arguments) { Test::run_test(shell, "default"); });
+    EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F("t")}, [](Shell & shell, const std::vector<std::string> & arguments) {
+        Test::run_test(shell, "default");
+    });
 #endif
 
 #if defined(EMSESP_DEBUG)
-    EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(debug)}, flash_string_vector{F_(name_optional)}, [](Shell & shell, const std::vector<std::string> & arguments) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::USER,
+                                       flash_string_vector{F_(debug)},
+                                       flash_string_vector{F_(name_optional)},
+                                       [](Shell & shell, const std::vector<std::string> & arguments) {
                                            if (arguments.size() == 0) {
                                                Test::debug(shell, "default");
                                            } else {
@@ -493,18 +535,29 @@ void Console::load_standard_commands(unsigned int context) {
             }
             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(); });
+        [](Shell & shell __attribute__((unused)), const std::vector<std::string> & arguments __attribute__((unused))) -> std::vector<std::string> {
+            return uuid::log::levels_lowercase();
+        });
 
-    EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(help)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::USER,
+                                       flash_string_vector{F_(help)},
+                                       [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                                            shell.print_all_available_commands();
                                        });
 
-    EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(exit)}, [=](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::USER,
+                                       flash_string_vector{F_(exit)},
+                                       [=](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                                            shell.stop();
                                            // shell.exit_context();
                                        });
 
-    EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(su)}, [=](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::USER,
+                                       flash_string_vector{F_(su)},
+                                       [=](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                                            auto become_admin = [](Shell & shell) {
                                                shell.logger().log(LogLevel::NOTICE, LogFacility::AUTH, F("su session opened on console"));
                                                shell.add_flags(CommandFlags::ADMIN);
@@ -538,14 +591,21 @@ void Console::load_system_commands(unsigned int context) {
     EMSESPShell::commands->add_command(context,
                                        CommandFlags::ADMIN,
                                        flash_string_vector{F_(restart)},
-                                       [](Shell & shell __attribute__((unused)), const std::vector<std::string> & arguments __attribute__((unused))) { EMSESP::system_.restart(); });
+                                       [](Shell & shell __attribute__((unused)), const std::vector<std::string> & arguments __attribute__((unused))) {
+                                           EMSESP::system_.restart();
+                                       });
 
     EMSESPShell::commands->add_command(context,
                                        CommandFlags::ADMIN,
                                        flash_string_vector{F_(wifi), F_(reconnect)},
-                                       [](Shell & shell __attribute__((unused)), const std::vector<std::string> & arguments __attribute__((unused))) { EMSESP::system_.wifi_reconnect(); });
+                                       [](Shell & shell __attribute__((unused)), const std::vector<std::string> & arguments __attribute__((unused))) {
+                                           EMSESP::system_.wifi_reconnect();
+                                       });
 
-    EMSESPShell::commands->add_command(ShellContext::MAIN, CommandFlags::ADMIN, flash_string_vector{F_(format)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    EMSESPShell::commands->add_command(ShellContext::MAIN,
+                                       CommandFlags::ADMIN,
+                                       flash_string_vector{F_(format)},
+                                       [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                                            shell.enter_password(F_(password_prompt), [=](Shell & shell, bool completed, const std::string & password) {
                                                if (completed) {
                                                    EMSESP::esp8266React.getSecuritySettingsService()->read([&](SecuritySettings & securitySettings) {
@@ -559,10 +619,14 @@ void Console::load_system_commands(unsigned int context) {
                                            });
                                        });
 
-    EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, flash_string_vector{F_(passwd)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::ADMIN,
+                                       flash_string_vector{F_(passwd)},
+                                       [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                                            shell.enter_password(F_(new_password_prompt1), [](Shell & shell, bool completed, const std::string & password1) {
                                                if (completed) {
-                shell.enter_password(F_(new_password_prompt2), [password1](Shell & shell, bool completed, const std::string & password2) {
+                                                   shell.enter_password(F_(new_password_prompt2),
+                                                                        [password1](Shell & shell, bool completed, const std::string & password2) {
                                                                             if (completed) {
                                                                                 if (password1 == password2) {
                                                                                     EMSESP::esp8266React.getSecuritySettingsService()->update(
@@ -581,7 +645,10 @@ void Console::load_system_commands(unsigned int context) {
                                            });
                                        });
 
-    EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(show), F_(system)}, [=](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::USER,
+                                       flash_string_vector{F_(show), F_(system)},
+                                       [=](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                                            EMSESP::system_.show_system(shell);
                                            shell.println();
                                        });
@@ -614,13 +681,18 @@ void Console::load_system_commands(unsigned int context) {
                                            shell.println("Use `wifi reconnect` to save and apply the new settings");
                                        });
 
-    EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, flash_string_vector{F_(set), F_(wifi), F_(password)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::ADMIN,
+                                       flash_string_vector{F_(set), F_(wifi), F_(password)},
+                                       [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                                            shell.enter_password(F_(new_password_prompt1), [](Shell & shell, bool completed, const std::string & password1) {
                                                if (completed) {
-                shell.enter_password(F_(new_password_prompt2), [password1](Shell & shell, bool completed, const std::string & password2) {
+                                                   shell.enter_password(F_(new_password_prompt2),
+                                                                        [password1](Shell & shell, bool completed, const std::string & password2) {
                                                                             if (completed) {
                                                                                 if (password1 == password2) {
-                            EMSESP::esp8266React.getNetworkSettingsService()->updateWithoutPropagation([&](NetworkSettings & networkSettings) {
+                                                                                    EMSESP::esp8266React.getNetworkSettingsService()->updateWithoutPropagation(
+                                                                                        [&](NetworkSettings & networkSettings) {
                                                                                             networkSettings.password = password2.c_str();
                                                                                             return StateUpdateResult::CHANGED;
                                                                                         });
@@ -634,7 +706,8 @@ void Console::load_system_commands(unsigned int context) {
                                            });
                                        });
 
-    EMSESPShell::commands->add_command(context,
+    EMSESPShell::commands
+        ->add_command(context,
                       CommandFlags::ADMIN,
                       flash_string_vector{F_(set), F_(board_profile)},
                       flash_string_vector{F_(name_mandatory)},
@@ -659,10 +732,12 @@ void Console::load_system_commands(unsigned int context) {
                           shell.printfln("Loaded board profile %s (%d,%d,%d,%d,%d)", board_profile.c_str(), data[0], data[1], data[2], data[3], data[4]);
                           EMSESP::system_.network_init(true);
                       });
-    EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, flash_string_vector{F_(show), F_(users)}, [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
+    EMSESPShell::commands->add_command(context,
+                                       CommandFlags::ADMIN,
+                                       flash_string_vector{F_(show), F_(users)},
+                                       [](Shell & shell, const std::vector<std::string> & arguments __attribute__((unused))) {
                                            EMSESP::system_.show_users(shell);
                                        });
-
 }
 
 /*

src/dallassensor.cpp

@@ -41,7 +41,9 @@ void DallasSensor::start() {
         bus_.begin(dallas_gpio_);
 #endif
         // API call
-        Command::add_with_json(EMSdevice::DeviceType::DALLASSENSOR, F_(info), [&](const char * value, const int8_t id, JsonObject & json) { return command_info(value, id, json); });
+        Command::add_with_json(EMSdevice::DeviceType::DALLASSENSOR, F_(info), [&](const char * value, const int8_t id, JsonObject & json) {
+            return command_info(value, id, json);
+        });
     }
 }
 
@@ -270,11 +272,13 @@ const std::vector<DallasSensor::Sensor> DallasSensor::sensors() const {
 
 // skip crc from id.
 DallasSensor::Sensor::Sensor(const uint8_t addr[])
-    : id_(((uint64_t)addr[0] << 48) | ((uint64_t)addr[1] << 40) | ((uint64_t)addr[2] << 32) | ((uint64_t)addr[3] << 24) | ((uint64_t)addr[4] << 16) | ((uint64_t)addr[5] << 8) | ((uint64_t)addr[6])) {
+    : id_(((uint64_t)addr[0] << 48) | ((uint64_t)addr[1] << 40) | ((uint64_t)addr[2] << 32) | ((uint64_t)addr[3] << 24) | ((uint64_t)addr[4] << 16)
+          | ((uint64_t)addr[5] << 8) | ((uint64_t)addr[6])) {
 }
 
 uint64_t DallasSensor::get_id(const uint8_t addr[]) {
-    return (((uint64_t)addr[0] << 48) | ((uint64_t)addr[1] << 40) | ((uint64_t)addr[2] << 32) | ((uint64_t)addr[3] << 24) | ((uint64_t)addr[4] << 16) | ((uint64_t)addr[5] << 8) | ((uint64_t)addr[6]));
+    return (((uint64_t)addr[0] << 48) | ((uint64_t)addr[1] << 40) | ((uint64_t)addr[2] << 32) | ((uint64_t)addr[3] << 24) | ((uint64_t)addr[4] << 16)
+            | ((uint64_t)addr[5] << 8) | ((uint64_t)addr[6]));
 }
 
 uint64_t DallasSensor::Sensor::id() const {
@@ -283,7 +287,13 @@ uint64_t DallasSensor::Sensor::id() const {
 
 std::string DallasSensor::Sensor::to_string() const {
     std::string str(20, '\0');
-    snprintf_P(&str[0], str.capacity() + 1, PSTR("%02X-%04X-%04X-%04X"), (unsigned int)(id_ >> 48) & 0xFF, (unsigned int)(id_ >> 32) & 0xFFFF, (unsigned int)(id_ >> 16) & 0xFFFF, (unsigned int)(id_)&0xFFFF);
+    snprintf_P(&str[0],
+               str.capacity() + 1,
+               PSTR("%02X-%04X-%04X-%04X"),
+               (unsigned int)(id_ >> 48) & 0xFF,
+               (unsigned int)(id_ >> 32) & 0xFFFF,
+               (unsigned int)(id_ >> 16) & 0xFFFF,
+               (unsigned int)(id_)&0xFFFF);
     return str;
 }
 

src/default_settings.h

@@ -76,8 +76,8 @@
 #define EMSESP_DEFAULT_DALLAS_PARASITE false
 #endif
 
-#ifndef EMSESP_DEFAULT_API_ENABLED
+#ifndef EMSESP_DEFAULT_NOTOKEN_API
-#define EMSESP_DEFAULT_API_ENABLED false // turn off, because its insecure
+#define EMSESP_DEFAULT_NOTOKEN_API false
 #endif
 
 #ifndef EMSESP_DEFAULT_BOOL_FORMAT

src/devices/boiler.cpp

@@ -85,7 +85,8 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
         register_telegram_type(0x48F, F("HpOutdoor"), false, MAKE_PF_CB(process_HpOutdoor));
     }
     // MQTT commands for boiler topic
-    register_device_value(TAG_BOILER_DATA, &dummybool_, DeviceValueType::BOOL, nullptr, FL_(wwtapactivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_tapwarmwater_activated));
+    register_device_value(
+        TAG_BOILER_DATA, &dummybool_, DeviceValueType::BOOL, nullptr, FL_(wwtapactivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_tapwarmwater_activated));
     register_device_value(TAG_BOILER_DATA, &dummy8u_, DeviceValueType::ENUM, FL_(enum_reset), FL_(reset), DeviceValueUOM::NONE, MAKE_CF_CB(set_reset));
 
     // add values
@@ -113,7 +114,8 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
     register_device_value(TAG_BOILER_DATA, &heatingPump_, DeviceValueType::BOOL, nullptr, FL_(heatingPump), DeviceValueUOM::PUMP);
     register_device_value(TAG_BOILER_DATA, &fanWork_, DeviceValueType::BOOL, nullptr, FL_(fanWork), DeviceValueUOM::NONE);
     register_device_value(TAG_BOILER_DATA, &ignWork_, DeviceValueType::BOOL, nullptr, FL_(ignWork), DeviceValueUOM::NONE);
-    register_device_value(TAG_BOILER_DATA, &heatingActivated_, DeviceValueType::BOOL, nullptr, FL_(heatingActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_heating_activated));
+    register_device_value(
+        TAG_BOILER_DATA, &heatingActivated_, DeviceValueType::BOOL, nullptr, FL_(heatingActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_heating_activated));
     register_device_value(TAG_BOILER_DATA, &heatingTemp_, DeviceValueType::UINT, nullptr, FL_(heatingTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_heating_temp));
     register_device_value(TAG_BOILER_DATA, &pumpModMax_, DeviceValueType::UINT, nullptr, FL_(pumpModMax), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_max_pump));
     register_device_value(TAG_BOILER_DATA, &pumpModMin_, DeviceValueType::UINT, nullptr, FL_(pumpModMin), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_min_pump));
@@ -135,7 +137,13 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
     register_device_value(TAG_BOILER_DATA, &serviceCodeNumber_, DeviceValueType::USHORT, nullptr, FL_(serviceCodeNumber), DeviceValueUOM::NONE);
     register_device_value(TAG_BOILER_DATA, &maintenanceMessage_, DeviceValueType::TEXT, nullptr, FL_(maintenanceMessage), DeviceValueUOM::NONE);
     register_device_value(TAG_BOILER_DATA, &maintenanceDate_, DeviceValueType::TEXT, nullptr, FL_(maintenanceDate), DeviceValueUOM::NONE);
-    register_device_value(TAG_BOILER_DATA, &maintenanceType_, DeviceValueType::ENUM, FL_(enum_off_time_date), FL_(maintenanceType), DeviceValueUOM::NONE, MAKE_CF_CB(set_maintenance));
+    register_device_value(TAG_BOILER_DATA,
+                          &maintenanceType_,
+                          DeviceValueType::ENUM,
+                          FL_(enum_off_time_date),
+                          FL_(maintenanceType),
+                          DeviceValueUOM::NONE,
+                          MAKE_CF_CB(set_maintenance));
     register_device_value(TAG_BOILER_DATA, &maintenanceTime_, DeviceValueType::USHORT, nullptr, FL_(maintenanceTime), DeviceValueUOM::HOURS);
     // heatpump info
     if (model() == EMS_DEVICE_FLAG_HEATPUMP) {
@@ -175,20 +183,37 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
     register_device_value(TAG_DEVICE_DATA_WW, &wWSelTemp_, DeviceValueType::UINT, nullptr, FL_(wWSelTemp), DeviceValueUOM::DEGREES);
     register_device_value(TAG_DEVICE_DATA_WW, &wWSetTemp_, DeviceValueType::UINT, nullptr, FL_(wWSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_warmwater_temp));
     register_device_value(TAG_DEVICE_DATA_WW, &wWType_, DeviceValueType::ENUM, FL_(enum_flow), FL_(wWType), DeviceValueUOM::NONE);
-    register_device_value(TAG_DEVICE_DATA_WW, &wWComfort_, DeviceValueType::ENUM, FL_(enum_comfort), FL_(wWComfort), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_mode));
+    register_device_value(
-    register_device_value(TAG_DEVICE_DATA_WW, &wWFlowTempOffset_, DeviceValueType::UINT, nullptr, FL_(wWFlowTempOffset), DeviceValueUOM::NONE, MAKE_CF_CB(set_wWFlowTempOffset));
+        TAG_DEVICE_DATA_WW, &wWComfort_, DeviceValueType::ENUM, FL_(enum_comfort), FL_(wWComfort), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_mode));
-    register_device_value(TAG_DEVICE_DATA_WW, &wWMaxPower_, DeviceValueType::UINT, nullptr, FL_(wWMaxPower), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_warmwater_maxpower));
+    register_device_value(
-    register_device_value(TAG_DEVICE_DATA_WW, &wWCircPump_, DeviceValueType::BOOL, nullptr, FL_(wWCircPump), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_circulation_pump));
+        TAG_DEVICE_DATA_WW, &wWFlowTempOffset_, DeviceValueType::UINT, nullptr, FL_(wWFlowTempOffset), DeviceValueUOM::NONE, MAKE_CF_CB(set_wWFlowTempOffset));
+    register_device_value(
+        TAG_DEVICE_DATA_WW, &wWMaxPower_, DeviceValueType::UINT, nullptr, FL_(wWMaxPower), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_warmwater_maxpower));
+    register_device_value(
+        TAG_DEVICE_DATA_WW, &wWCircPump_, DeviceValueType::BOOL, nullptr, FL_(wWCircPump), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_circulation_pump));
     register_device_value(TAG_DEVICE_DATA_WW, &wWChargeType_, DeviceValueType::BOOL, FL_(enum_charge), FL_(wWChargeType), DeviceValueUOM::NONE);
-    register_device_value(TAG_DEVICE_DATA_WW, &wWDisinfectionTemp_, DeviceValueType::UINT, nullptr, FL_(wWDisinfectionTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_disinfect_temp));
+    register_device_value(TAG_DEVICE_DATA_WW,
-    register_device_value(TAG_DEVICE_DATA_WW, &wWCircMode_, DeviceValueType::ENUM, FL_(enum_freq), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_circulation_mode));
+                          &wWDisinfectionTemp_,
+                          DeviceValueType::UINT,
+                          nullptr,
+                          FL_(wWDisinfectionTemp),
+                          DeviceValueUOM::DEGREES,
+                          MAKE_CF_CB(set_disinfect_temp));
+    register_device_value(TAG_DEVICE_DATA_WW,
+                          &wWCircMode_,
+                          DeviceValueType::ENUM,
+                          FL_(enum_freq),
+                          FL_(wWCircMode),
+                          DeviceValueUOM::NONE,
+                          MAKE_CF_CB(set_warmwater_circulation_mode));
     register_device_value(TAG_DEVICE_DATA_WW, &wWCirc_, DeviceValueType::BOOL, nullptr, FL_(wWCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_circulation));
     register_device_value(TAG_DEVICE_DATA_WW, &wWCurTemp_, DeviceValueType::USHORT, FL_(div10), FL_(wWCurTemp), DeviceValueUOM::DEGREES);
     register_device_value(TAG_DEVICE_DATA_WW, &wWCurTemp2_, DeviceValueType::USHORT, FL_(div10), FL_(wWCurTemp2), DeviceValueUOM::DEGREES);
     register_device_value(TAG_DEVICE_DATA_WW, &wWCurFlow_, DeviceValueType::UINT, FL_(div10), FL_(wWCurFlow), DeviceValueUOM::LMIN);
     register_device_value(TAG_DEVICE_DATA_WW, &wWStorageTemp1_, DeviceValueType::USHORT, FL_(div10), FL_(wWStorageTemp1), DeviceValueUOM::DEGREES);
     register_device_value(TAG_DEVICE_DATA_WW, &wWStorageTemp2_, DeviceValueType::USHORT, FL_(div10), FL_(wWStorageTemp2), DeviceValueUOM::DEGREES);
-    register_device_value(TAG_DEVICE_DATA_WW, &wWActivated_, DeviceValueType::BOOL, nullptr, FL_(wWActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_activated));
+    register_device_value(
+        TAG_DEVICE_DATA_WW, &wWActivated_, DeviceValueType::BOOL, nullptr, FL_(wWActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_activated));
     register_device_value(TAG_DEVICE_DATA_WW, &wWOneTime_, DeviceValueType::BOOL, nullptr, FL_(wWOneTime), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_onetime));
     register_device_value(TAG_DEVICE_DATA_WW, &wWDisinfecting_, DeviceValueType::BOOL, nullptr, FL_(wWDisinfecting), DeviceValueUOM::NONE);
     register_device_value(TAG_DEVICE_DATA_WW, &wWCharging_, DeviceValueType::BOOL, nullptr, FL_(wWCharging), DeviceValueUOM::NONE);
@@ -204,10 +229,14 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
     register_device_value(TAG_DEVICE_DATA_WW, &wWWorkM_, DeviceValueType::TIME, nullptr, FL_(wWWorkM), DeviceValueUOM::MINUTES);
 
     // fetch some initial data
-    EMSESP::send_read_request(0x10, device_id); // read last errorcode on start (only published on errors)
+    EMSESP::send_read_request(0x10,
-    EMSESP::send_read_request(0x11, device_id); // read last errorcode on start (only published on errors)
+                              device_id); // read last errorcode on start (only published on errors)
-    EMSESP::send_read_request(0x15, device_id); // read maintenace data on start (only published on change)
+    EMSESP::send_read_request(0x11,
-    EMSESP::send_read_request(0x1C, device_id); // read maintenace status on start (only published on change)
+                              device_id); // read last errorcode on start (only published on errors)
+    EMSESP::send_read_request(0x15,
+                              device_id); // read maintenace data on start (only published on change)
+    EMSESP::send_read_request(0x1C,
+                              device_id); // read maintenace status on start (only published on change)
 }
 
 // publish HA config
@@ -231,7 +260,8 @@ bool Boiler::publish_ha_config() {
 
     char topic[Mqtt::MQTT_TOPIC_MAX_SIZE];
     snprintf_P(topic, sizeof(topic), PSTR("sensor/%s/boiler/config"), Mqtt::base().c_str());
-    Mqtt::publish_ha(topic, doc.as<JsonObject>()); // publish the config payload with retain flag
+    Mqtt::publish_ha(topic,
+                     doc.as<JsonObject>()); // publish the config payload with retain flag
 
     return true;
 }
@@ -288,7 +318,8 @@ void Boiler::process_UBAParameterWW(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram->read_value(wWCircPump_, 6));       // 0xFF means on
     has_update(telegram->read_value(wWCircMode_, 7));       // 1=1x3min 6=6x3min 7=continuous
     has_update(telegram->read_value(wWDisinfectionTemp_, 8));
-    has_update(telegram->read_value(wWChargeType_, 10)); // 0 = charge pump, 0xff = 3-way valve
+    has_update(telegram->read_value(wWChargeType_,
+                                    10)); // 0 = charge pump, 0xff = 3-way valve
 
     telegram->read_value(wWComfort_, 9);
     if (wWComfort_ == 0x00) {
@@ -320,7 +351,8 @@ void Boiler::process_UBAMonitorFast(std::shared_ptr<const Telegram> telegram) {
     // warm water storage sensors (if present)
     // wWStorageTemp2 is also used by some brands as the boiler temperature - see https://github.com/emsesp/EMS-ESP/issues/206
     has_update(telegram->read_value(wWStorageTemp1_, 9)); // 0x8300 if not available
-    has_update(telegram->read_value(wWStorageTemp2_, 11)); // 0x8000 if not available - this is boiler temp
+    has_update(telegram->read_value(wWStorageTemp2_,
+                                    11)); // 0x8000 if not available - this is boiler temp
 
     has_update(telegram->read_value(retTemp_, 13));
     has_update(telegram->read_value(flameCurr_, 15));
@@ -456,7 +488,8 @@ void Boiler::process_UBAMonitorSlow(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram->read_value(outdoorTemp_, 0));
     has_update(telegram->read_value(boilTemp_, 2));
     has_update(telegram->read_value(exhaustTemp_, 4));
-    has_update(telegram->read_value(switchTemp_, 25)); // only if there is a mixer module present
+    has_update(telegram->read_value(switchTemp_,
+                                    25)); // only if there is a mixer module present
     has_update(telegram->read_value(heatingPumpMod_, 9));
     has_update(telegram->read_value(burnStarts_, 10, 3));  // force to 3 bytes
     has_update(telegram->read_value(burnWorkMin_, 13, 3)); // force to 3 bytes
@@ -515,7 +548,8 @@ void Boiler::process_UBAParametersPlus(std::shared_ptr<const Telegram> telegram)
 void Boiler::process_UBAParameterWWPlus(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram->read_value(wWActivated_, 5)); // 0x01 means on
     has_update(telegram->read_value(wWCircPump_, 10)); // 0x01 means yes
-    has_update(telegram->read_value(wWCircMode_, 11)); // 1=1x3min... 6=6x3min, 7=continuous
+    has_update(telegram->read_value(wWCircMode_,
+                                    11)); // 1=1x3min... 6=6x3min, 7=continuous
     // has_update(telegram->read_value(wWDisinfectTemp_, 12)); // settings, status in E9
     // has_update(telegram->read_value(wWSelTemp_, 6));        // settings, status in E9
 }
@@ -588,13 +622,12 @@ void Boiler::process_UBAEnergySupplied(std::shared_ptr<const Telegram> telegram)
 }
 
 // Heatpump power - type 0x48D
-void Boiler::process_HpPower(std::shared_ptr<const Telegram> telegram){
+void Boiler::process_HpPower(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram->read_value(hpPower_, 11));
-
 }
 
 // Heatpump outdoor unit - type 0x48F
-void Boiler::process_HpOutdoor(std::shared_ptr<const Telegram> telegram){
+void Boiler::process_HpOutdoor(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram->read_value(hpTc0_, 6));
     has_update(telegram->read_value(hpTc1_, 4));
     has_update(telegram->read_value(hpTc3_, 2));
@@ -625,7 +658,8 @@ void Boiler::process_UBAOutdoorTemp(std::shared_ptr<const Telegram> telegram) {
 
 // UBASetPoint 0x1A
 void Boiler::process_UBASetPoints(std::shared_ptr<const Telegram> telegram) {
-    has_update(telegram->read_value(setFlowTemp_, 0));    // boiler set temp from thermostat
+    has_update(telegram->read_value(setFlowTemp_,
+                                    0));                  // boiler set temp from thermostat
     has_update(telegram->read_value(setBurnPow_, 1));     // max json power in %
     has_update(telegram->read_value(wWSetPumpPower_, 2)); // ww pump speed/power?
 }
@@ -728,7 +762,8 @@ bool Boiler::set_warmwater_temp(const char * value, const int8_t id) {
     } else {
         // some boiler have it in 0x33, some in 0x35
         write_command(EMS_TYPE_UBAFlags, 3, v, 0x34); // for i9000, see #397
-        write_command(EMS_TYPE_UBAParameterWW, 2, v, EMS_TYPE_UBAParameterWW); // read seltemp back
+        write_command(EMS_TYPE_UBAParameterWW, 2, v,
+                      EMS_TYPE_UBAParameterWW); // read seltemp back
     }
 
     return true;
@@ -1088,7 +1123,8 @@ bool Boiler::set_warmwater_onetime(const char * value, const int8_t id) {
 
     LOG_INFO(F("Setting warm water OneTime loading %s"), v ? "on" : "off");
     if (get_toggle_fetch(EMS_TYPE_UBAParameterWWPlus)) {
-        write_command(EMS_TYPE_UBAFlags, 0, (v ? 0x22 : 0x02), 0xE9); // not sure if this is in flags
+        write_command(EMS_TYPE_UBAFlags, 0, (v ? 0x22 : 0x02),
+                      0xE9); // not sure if this is in flags
     } else {
         write_command(EMS_TYPE_UBAFlags, 0, (v ? 0x22 : 0x02), 0x34);
     }
@@ -1107,7 +1143,8 @@ bool Boiler::set_warmwater_circulation(const char * value, const int8_t id) {
 
     LOG_INFO(F("Setting warm water circulation %s"), v ? "on" : "off");
     if (get_toggle_fetch(EMS_TYPE_UBAParameterWWPlus)) {
-        write_command(EMS_TYPE_UBAFlags, 1, (v ? 0x22 : 0x02), 0xE9); // not sure if this is in flags
+        write_command(EMS_TYPE_UBAFlags, 1, (v ? 0x22 : 0x02),
+                      0xE9); // not sure if this is in flags
     } else {
         write_command(EMS_TYPE_UBAFlags, 1, (v ? 0x22 : 0x02), 0x34);
     }

src/devices/solar.cpp

@@ -81,7 +81,8 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s
     register_device_value(TAG_NONE, &tankBottomTemp2_, DeviceValueType::SHORT, FL_(div10), FL_(tank2BottomTemp), DeviceValueUOM::DEGREES);
     register_device_value(TAG_NONE, &heatExchangerTemp_, DeviceValueType::SHORT, FL_(div10), FL_(heatExchangerTemp), DeviceValueUOM::DEGREES);
 
-    register_device_value(TAG_NONE, &tankBottomMaxTemp_, DeviceValueType::UINT, nullptr, FL_(tankMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_SM100TankBottomMaxTemp));
+    register_device_value(
+        TAG_NONE, &tankBottomMaxTemp_, DeviceValueType::UINT, nullptr, FL_(tankMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_SM100TankBottomMaxTemp));
     register_device_value(TAG_NONE, &solarPumpModulation_, DeviceValueType::UINT, nullptr, FL_(solarPumpModulation), DeviceValueUOM::PERCENT);
     register_device_value(TAG_NONE, &cylinderPumpModulation_, DeviceValueType::UINT, nullptr, FL_(cylinderPumpModulation), DeviceValueUOM::PERCENT);
 

src/devices/thermostat.cpp

@@ -38,7 +38,8 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i
     // or if its the master thermostat we defined
     // see https://github.com/emsesp/EMS-ESP/issues/362#issuecomment-629628161
     if ((master_thermostat == device_id)
-        || ((master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT) && (device_id < 0x19) && ((actual_master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT) || (device_id < actual_master_thermostat)))) {
+        || ((master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT) && (device_id < 0x19)
+            && ((actual_master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT) || (device_id < actual_master_thermostat)))) {
         EMSESP::actual_master_thermostat(device_id);
         actual_master_thermostat = device_id;
         reserve_telgram_functions(25); // reserve some space for the telegram registries, to avoid memory fragmentation
@@ -2003,7 +2004,10 @@ bool Thermostat::set_temperature(const float temperature, const uint8_t mode, co
     // if we know what to send and to where, go and do it
     if (offset != -1) {
         char s[10];
-        LOG_INFO(F("Setting thermostat temperature to %s for heating circuit %d, mode %s"), Helpers::render_value(s, temperature, 2), hc->hc_num(), mode_tostring(mode).c_str());
+        LOG_INFO(F("Setting thermostat temperature to %s for heating circuit %d, mode %s"),
+                 Helpers::render_value(s, temperature, 2),
+                 hc->hc_num(),
+                 mode_tostring(mode).c_str());
 
         // add the write command to the Tx queue. value is *2
         // post validate is the corresponding monitor or set type IDs as they can differ per model
@@ -2117,11 +2121,19 @@ void Thermostat::register_device_values() {
         register_device_value(TAG_THERMOSTAT_DATA, &floordrystatus_, DeviceValueType::ENUM, FL_(enum_floordrystatus), FL_(floordrystatus), DeviceValueUOM::NONE);
         register_device_value(TAG_THERMOSTAT_DATA, &dampedoutdoortemp2_, DeviceValueType::SHORT, FL_(div10), FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES);
         register_device_value(TAG_THERMOSTAT_DATA, &floordrytemp_, DeviceValueType::UINT, nullptr, FL_(floordrytemp), DeviceValueUOM::DEGREES);
-        register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType), FL_(ibaBuildingType), DeviceValueUOM::NONE, MAKE_CF_CB(set_building));
+        register_device_value(TAG_THERMOSTAT_DATA,
+                              &ibaBuildingType_,
+                              DeviceValueType::ENUM,
+                              FL_(enum_ibaBuildingType),
+                              FL_(ibaBuildingType),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_building));
         register_device_value(TAG_DEVICE_DATA_WW, &wwSetTemp_, DeviceValueType::UINT, nullptr, FL_(wwSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemp));
         register_device_value(TAG_DEVICE_DATA_WW, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode));
-        register_device_value(TAG_DEVICE_DATA_WW, &wwSetTempLow_, DeviceValueType::UINT, nullptr, FL_(wwSetTempLow), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemplow));
+        register_device_value(
-        register_device_value(TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode));
+            TAG_DEVICE_DATA_WW, &wwSetTempLow_, DeviceValueType::UINT, nullptr, FL_(wwSetTempLow), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemplow));
+        register_device_value(
+            TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode));
         register_device_value(TAG_DEVICE_DATA_WW, &wwExtra1_, DeviceValueType::UINT, nullptr, FL_(wwExtra1), DeviceValueUOM::DEGREES);
         register_device_value(TAG_DEVICE_DATA_WW, &wwExtra2_, DeviceValueType::UINT, nullptr, FL_(wwExtra2), DeviceValueUOM::DEGREES);
         break;
@@ -2133,24 +2145,67 @@ void Thermostat::register_device_values() {
         register_device_value(TAG_THERMOSTAT_DATA, &dateTime_, DeviceValueType::TEXT, nullptr, FL_(dateTime), DeviceValueUOM::NONE); // can't set datetime
         register_device_value(TAG_THERMOSTAT_DATA, &ibaMainDisplay_, DeviceValueType::ENUM, FL_(enum_ibaMainDisplay), FL_(ibaMainDisplay), DeviceValueUOM::NONE);
         register_device_value(TAG_THERMOSTAT_DATA, &ibaLanguage_, DeviceValueType::ENUM, FL_(enum_ibaLanguage), FL_(ibaLanguage), DeviceValueUOM::NONE);
-        register_device_value(TAG_THERMOSTAT_DATA, &ibaClockOffset_, DeviceValueType::UINT, nullptr, FL_(ibaClockOffset), DeviceValueUOM::NONE); // offset (in sec) to clock, 0xff=-1s, 0x02=2s
+        register_device_value(TAG_THERMOSTAT_DATA,
-        register_device_value(TAG_THERMOSTAT_DATA, &ibaCalIntTemperature_, DeviceValueType::INT, FL_(div2), FL_(ibaCalIntTemperature), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_calinttemp));
+                              &ibaClockOffset_,
-        register_device_value(TAG_THERMOSTAT_DATA, &ibaMinExtTemperature_, DeviceValueType::INT, nullptr, FL_(ibaMinExtTemperature), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minexttemp));
+                              DeviceValueType::UINT,
+                              nullptr,
+                              FL_(ibaClockOffset),
+                              DeviceValueUOM::NONE); // offset (in sec) to clock, 0xff=-1s, 0x02=2s
+        register_device_value(TAG_THERMOSTAT_DATA,
+                              &ibaCalIntTemperature_,
+                              DeviceValueType::INT,
+                              FL_(div2),
+                              FL_(ibaCalIntTemperature),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_calinttemp));
+        register_device_value(TAG_THERMOSTAT_DATA,
+                              &ibaMinExtTemperature_,
+                              DeviceValueType::INT,
+                              nullptr,
+                              FL_(ibaMinExtTemperature),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_minexttemp));
         register_device_value(TAG_THERMOSTAT_DATA, &dampedoutdoortemp_, DeviceValueType::INT, nullptr, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES);
-        register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType2), FL_(ibaBuildingType), DeviceValueUOM::NONE, MAKE_CF_CB(set_building));
+        register_device_value(TAG_THERMOSTAT_DATA,
+                              &ibaBuildingType_,
+                              DeviceValueType::ENUM,
+                              FL_(enum_ibaBuildingType2),
+                              FL_(ibaBuildingType),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_building));
         register_device_value(TAG_DEVICE_DATA_WW, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode2), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode));
-        register_device_value(TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode));
+        register_device_value(
+            TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode));
         break;
     case EMS_DEVICE_FLAG_RC35:
         register_device_value(TAG_THERMOSTAT_DATA, &dateTime_, DeviceValueType::TEXT, nullptr, FL_(dateTime), DeviceValueUOM::NONE, MAKE_CF_CB(set_datetime));
-        register_device_value(TAG_THERMOSTAT_DATA, &ibaCalIntTemperature_, DeviceValueType::INT, FL_(div2), FL_(ibaCalIntTemperature), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_calinttemp));
+        register_device_value(TAG_THERMOSTAT_DATA,
-        register_device_value(TAG_THERMOSTAT_DATA, &ibaMinExtTemperature_, DeviceValueType::INT, nullptr, FL_(ibaMinExtTemperature), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minexttemp));
+                              &ibaCalIntTemperature_,
+                              DeviceValueType::INT,
+                              FL_(div2),
+                              FL_(ibaCalIntTemperature),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_calinttemp));
+        register_device_value(TAG_THERMOSTAT_DATA,
+                              &ibaMinExtTemperature_,
+                              DeviceValueType::INT,
+                              nullptr,
+                              FL_(ibaMinExtTemperature),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_minexttemp));
         register_device_value(TAG_THERMOSTAT_DATA, &tempsensor1_, DeviceValueType::USHORT, FL_(div10), FL_(tempsensor1), DeviceValueUOM::DEGREES);
         register_device_value(TAG_THERMOSTAT_DATA, &tempsensor2_, DeviceValueType::USHORT, FL_(div10), FL_(tempsensor2), DeviceValueUOM::DEGREES);
         register_device_value(TAG_THERMOSTAT_DATA, &dampedoutdoortemp_, DeviceValueType::INT, nullptr, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES);
-        register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType2), FL_(ibaBuildingType), DeviceValueUOM::NONE, MAKE_CF_CB(set_building));
+        register_device_value(TAG_THERMOSTAT_DATA,
+                              &ibaBuildingType_,
+                              DeviceValueType::ENUM,
+                              FL_(enum_ibaBuildingType2),
+                              FL_(ibaBuildingType),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_building));
         register_device_value(TAG_DEVICE_DATA_WW, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode2), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode));
-        register_device_value(TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode));
+        register_device_value(
+            TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode));
         break;
     case EMS_DEVICE_FLAG_JUNKERS:
         register_device_value(TAG_THERMOSTAT_DATA, &dateTime_, DeviceValueType::TEXT, nullptr, FL_(dateTime), DeviceValueUOM::NONE, MAKE_CF_CB(set_datetime));
@@ -2161,7 +2216,7 @@ void Thermostat::register_device_values() {
 }
 
 // registers the values for a heating circuit
-void Thermostat::register_device_values_hc(std::shared_ptr<emsesp::Thermostat::HeatingCircuit> hc) {
+void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCircuit> hc) {
     uint8_t model = hc->get_model();
 
     // heating circuit
@@ -2184,8 +2239,17 @@ void Thermostat::register_device_values_hc(std::shared_ptr<emsesp::Thermostat::H
     if (has_flags(EMS_DEVICE_FLAG_NO_WRITE) || device_id() != EMSESP::actual_master_thermostat()) {
         register_device_value(tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(setpoint_roomTemp), DeviceValueUOM::DEGREES);
     } else {
-        register_device_value(tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(setpoint_roomTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_temp), 5, 29);
+        register_device_value(tag,
-        register_device_value(tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(temp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_temp), 5, 29);
+                              &hc->setpoint_roomTemp,
+                              DeviceValueType::SHORT,
+                              setpoint_temp_divider,
+                              FL_(setpoint_roomTemp),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_temp),
+                              5,
+                              29);
+        register_device_value(
+            tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(temp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_temp), 5, 29);
     }
     register_device_value(tag, &hc->curr_roomTemp, DeviceValueType::SHORT, curr_temp_divider, FL_(curr_roomTemp), DeviceValueUOM::DEGREES);
 
@@ -2228,9 +2292,11 @@ void Thermostat::register_device_values_hc(std::shared_ptr<emsesp::Thermostat::H
         register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, nullptr, FL_(nofrosttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nofrosttemp));
         register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT, nullptr, FL_(targetflowtemp), DeviceValueUOM::DEGREES);
         register_device_value(tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE);
-        register_device_value(tag, &hc->summer_setmode, DeviceValueType::ENUM, FL_(enum_summermode), FL_(summermode), DeviceValueUOM::NONE, MAKE_CF_CB(set_summermode));
+        register_device_value(
+            tag, &hc->summer_setmode, DeviceValueType::ENUM, FL_(enum_summermode), FL_(summermode), DeviceValueUOM::NONE, MAKE_CF_CB(set_summermode));
         register_device_value(tag, &hc->summermode, DeviceValueType::BOOL, nullptr, FL_(summermode), DeviceValueUOM::NONE);
-        register_device_value(tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode));
+        register_device_value(
+            tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode));
         register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program));
         register_device_value(tag, &hc->tempautotemp, DeviceValueType::UINT, FL_(div2), FL_(tempautotemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_tempautotemp));
         break;
@@ -2269,7 +2335,8 @@ void Thermostat::register_device_values_hc(std::shared_ptr<emsesp::Thermostat::H
         register_device_value(tag, &hc->flowtempoffset, DeviceValueType::UINT, nullptr, FL_(flowtempoffset), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flowtempoffset));
         register_device_value(tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE);
         register_device_value(tag, &hc->reducemode, DeviceValueType::ENUM, FL_(enum_reducemode), FL_(reducemode), DeviceValueUOM::NONE, MAKE_CF_CB(set_reducemode));
-        register_device_value(tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode2), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode));
+        register_device_value(
+            tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode2), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode));
         register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control), FL_(control), DeviceValueUOM::NONE, MAKE_CF_CB(set_control));
         register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program));
         register_device_value(tag, &hc->pause, DeviceValueType::UINT, nullptr, FL_(pause), DeviceValueUOM::HOURS, MAKE_CF_CB(set_pause));

src/devices/thermostat.h

@@ -255,7 +255,7 @@ class Thermostat : public EMSdevice {
     std::shared_ptr<Thermostat::HeatingCircuit> heating_circuit(const uint8_t hc_num);
 
     void register_mqtt_ha_config_hc(uint8_t hc_num);
-    void register_device_values_hc(std::shared_ptr<emsesp::Thermostat::HeatingCircuit> hc);
+    void register_device_values_hc(std::shared_ptr<Thermostat::HeatingCircuit> hc);
 
     bool thermostat_ha_cmd(const char * message, uint8_t hc_num);
 

src/emsdevice.cpp

@@ -298,7 +298,14 @@ std::string EMSdevice::to_string() const {
     if (brand_ == Brand::NO_BRAND) {
         snprintf_P(&str[0], str.capacity() + 1, PSTR("%s (DeviceID:0x%02X, ProductID:%d, Version:%s)"), name_.c_str(), device_id_, product_id_, version_.c_str());
     } else {
-        snprintf_P(&str[0], str.capacity() + 1, PSTR("%s %s (DeviceID:0x%02X ProductID:%d, Version:%s)"), brand_to_string().c_str(), name_.c_str(), device_id_, product_id_, version_.c_str());
+        snprintf_P(&str[0],
+                   str.capacity() + 1,
+                   PSTR("%s %s (DeviceID:0x%02X ProductID:%d, Version:%s)"),
+                   brand_to_string().c_str(),
+                   name_.c_str(),
+                   device_id_,
+                   product_id_,
+                   version_.c_str());
     }
 
     return str;
@@ -470,7 +477,15 @@ void EMSdevice::register_device_value(uint8_t                             tag,
     devicevalues_.emplace_back(device_type_, tag, value_p, type, options, options_size, short_name, full_name, uom, 0, has_cmd, min, max);
 }
 
-void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, cmdfunction_p f, int32_t min, uint32_t max) {
+void EMSdevice::register_device_value(uint8_t                             tag,
+                                      void *                              value_p,
+                                      uint8_t                             type,
+                                      const __FlashStringHelper * const * options,
+                                      const __FlashStringHelper * const * name,
+                                      uint8_t                             uom,
+                                      cmdfunction_p                       f,
+                                      int32_t                             min,
+                                      uint32_t                            max) {
     register_device_value(tag, value_p, type, options, name[0], name[1], uom, (f != nullptr), min, max);
     if (f != nullptr) {
         if (tag >= TAG_HC1 && tag <= TAG_HC4) {
@@ -481,7 +496,13 @@ void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type,
     }
 }
 
-void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, cmdfunction_p f) {
+void EMSdevice::register_device_value(uint8_t                             tag,
+                                      void *                              value_p,
+                                      uint8_t                             type,
+                                      const __FlashStringHelper * const * options,
+                                      const __FlashStringHelper * const * name,
+                                      uint8_t                             uom,
+                                      cmdfunction_p                       f) {
     register_device_value(tag, value_p, type, options, name, uom, f, 0, 0);
 }
 
@@ -489,7 +510,12 @@ void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type,
 //     register_device_value(tag, value_p, type, options, name, uom, nullptr, min, max);
 // }
 
-void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom) {
+void EMSdevice::register_device_value(uint8_t                             tag,
+                                      void *                              value_p,
+                                      uint8_t                             type,
+                                      const __FlashStringHelper * const * options,
+                                      const __FlashStringHelper * const * name,
+                                      uint8_t                             uom) {
     register_device_value(tag, value_p, type, options, name, uom, nullptr, 0, 0);
 }
 
@@ -658,6 +684,9 @@ bool EMSdevice::get_value_info(JsonObject & root, const char * cmd, const int8_t
             const char * value   = "value";
 
             json["name"] = dv.short_name;
+            if (dv.full_name != nullptr) {
+                json["fullname"] = dv.full_name;
+            }
             if (!tag_to_mqtt(dv.tag).empty()) {
                 json["circuit"] = tag_to_mqtt(dv.tag);
             }
@@ -811,7 +840,8 @@ bool EMSdevice::generate_values_json(JsonObject & root, const uint8_t tag_filter
         // only show if tag is either empty (TAG_NONE) or matches a value
         // and don't show if full_name is empty unless we're outputing for mqtt payloads
         // for nested we use all values, dont show command only (have_cmd and no fulname)
-        if (((nested) || tag_filter == DeviceValueTAG::TAG_NONE || (tag_filter == dv.tag)) && (dv.full_name != nullptr || !console) && !(dv.full_name == nullptr && dv.has_cmd)) {
+        if (((nested) || tag_filter == DeviceValueTAG::TAG_NONE || (tag_filter == dv.tag)) && (dv.full_name != nullptr || !console)
+            && !(dv.full_name == nullptr && dv.has_cmd)) {
             // we have a tag if it matches the filter given, and that the tag name is not empty/""
             bool have_tag = ((dv.tag != tag_filter) && !tag_to_string(dv.tag).empty());
 

src/emsdevice.h

@@ -232,9 +232,28 @@ class EMSdevice {
                                bool                                has_cmd,
                                int32_t                             min,
                                uint32_t                            max);
-    void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, cmdfunction_p f, int32_t min, uint32_t max);
+    void register_device_value(uint8_t                             tag,
-    void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, cmdfunction_p f);
+                               void *                              value_p,
-    void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom);
+                               uint8_t                             type,
+                               const __FlashStringHelper * const * options,
+                               const __FlashStringHelper * const * name,
+                               uint8_t                             uom,
+                               cmdfunction_p                       f,
+                               int32_t                             min,
+                               uint32_t                            max);
+    void register_device_value(uint8_t                             tag,
+                               void *                              value_p,
+                               uint8_t                             type,
+                               const __FlashStringHelper * const * options,
+                               const __FlashStringHelper * const * name,
+                               uint8_t                             uom,
+                               cmdfunction_p                       f);
+    void register_device_value(uint8_t                             tag,
+                               void *                              value_p,
+                               uint8_t                             type,
+                               const __FlashStringHelper * const * options,
+                               const __FlashStringHelper * const * name,
+                               uint8_t                             uom);
     // void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, int32_t min, uint32_t max);
 
     void 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);

src/emsesp.cpp

@@ -39,7 +39,7 @@ WebSettingsService EMSESP::webSettingsService = WebSettingsService(&webServer, &
 
 WebStatusService  EMSESP::webStatusService  = WebStatusService(&webServer, EMSESP::esp8266React.getSecurityManager());
 WebDevicesService EMSESP::webDevicesService = WebDevicesService(&webServer, EMSESP::esp8266React.getSecurityManager());
-WebAPIService     EMSESP::webAPIService     = WebAPIService(&webServer);
+WebAPIService     EMSESP::webAPIService     = WebAPIService(&webServer, EMSESP::esp8266React.getSecurityManager());
 
 using DeviceFlags = EMSdevice;
 using DeviceType  = EMSdevice::DeviceType;
@@ -90,6 +90,15 @@ void EMSESP::fetch_device_values(const uint8_t device_id) {
     }
 }
 
+// for a specific EMS device type go and request data values
+void EMSESP::fetch_device_values_type(const uint8_t device_type) {
+    for (const auto & emsdevice : emsdevices) {
+        if ((emsdevice) && (emsdevice->device_type() == device_type)) {
+            emsdevice->fetch_values();
+        }
+    }
+}
+
 // clears list of recognized devices
 void EMSESP::clear_all_devices() {
     // temporary removed: clearing the list causes a crash, the associated commands and mqtt should also be removed.
@@ -765,7 +774,8 @@ bool EMSESP::process_telegram(std::shared_ptr<const Telegram> telegram) {
         }
         read_next_ = false;
     } else if (watch() == WATCH_ON) {
-        if ((watch_id_ == WATCH_ID_NONE) || (telegram->type_id == watch_id_) || ((watch_id_ < 0x80) && ((telegram->src == watch_id_) || (telegram->dest == watch_id_)))) {
+        if ((watch_id_ == WATCH_ID_NONE) || (telegram->type_id == watch_id_)
+            || ((watch_id_ < 0x80) && ((telegram->src == watch_id_) || (telegram->dest == watch_id_)))) {
             LOG_NOTICE(pretty_telegram(telegram).c_str());
         } else if (!trace_raw_) {
             LOG_TRACE(pretty_telegram(telegram).c_str());
@@ -806,7 +816,8 @@ bool EMSESP::process_telegram(std::shared_ptr<const Telegram> telegram) {
                 found       = emsdevice->handle_telegram(telegram);
                 // if we correctly processes the telegram follow up with sending it via MQTT if needed
                 if (found && Mqtt::connected()) {
-                    if ((mqtt_.get_publish_onchange(emsdevice->device_type()) && emsdevice->has_update()) || (telegram->type_id == publish_id_ && telegram->dest == txservice_.ems_bus_id())) {
+                    if ((mqtt_.get_publish_onchange(emsdevice->device_type()) && emsdevice->has_update())
+                        || (telegram->type_id == publish_id_ && telegram->dest == txservice_.ems_bus_id())) {
                         if (telegram->type_id == publish_id_) {
                             publish_id_ = 0;
                         }
@@ -824,7 +835,8 @@ bool EMSESP::process_telegram(std::shared_ptr<const Telegram> telegram) {
         if (watch() == WATCH_UNKNOWN) {
             LOG_NOTICE(pretty_telegram(telegram).c_str());
         }
-        if (first_scan_done_ && !knowndevice && (telegram->src != EMSbus::ems_bus_id()) && (telegram->src != 0x0B) && (telegram->src != 0x0C) && (telegram->src != 0x0D)) {
+        if (first_scan_done_ && !knowndevice && (telegram->src != EMSbus::ems_bus_id()) && (telegram->src != 0x0B) && (telegram->src != 0x0C)
+            && (telegram->src != 0x0D)) {
             send_read_request(EMSdevice::EMS_TYPE_VERSION, telegram->src);
         }
     }
@@ -920,7 +932,8 @@ bool EMSESP::add_device(const uint8_t device_id, const uint8_t product_id, std::
             // sometimes boilers share the same product id as controllers
             // so only add boilers if the device_id is 0x08, which is fixed for EMS
             if (device.device_type == DeviceType::BOILER) {
-                if (device_id == EMSdevice::EMS_DEVICE_ID_BOILER || (device_id >= EMSdevice::EMS_DEVICE_ID_BOILER_1 && device_id <= EMSdevice::EMS_DEVICE_ID_BOILER_F)) {
+                if (device_id == EMSdevice::EMS_DEVICE_ID_BOILER
+                    || (device_id >= EMSdevice::EMS_DEVICE_ID_BOILER_1 && device_id <= EMSdevice::EMS_DEVICE_ID_BOILER_F)) {
                     device_p = &device;
                     break;
                 }
@@ -936,7 +949,8 @@ bool EMSESP::add_device(const uint8_t device_id, const uint8_t product_id, std::
     if (device_p == nullptr) {
         LOG_NOTICE(F("Unrecognized EMS device (device ID 0x%02X, product ID %d). Please report on GitHub."), device_id, product_id);
         std::string name("unknown");
-        emsdevices.push_back(EMSFactory::add(DeviceType::GENERIC, device_id, product_id, version, name, DeviceFlags::EMS_DEVICE_FLAG_NONE, EMSdevice::Brand::NO_BRAND));
+        emsdevices.push_back(
+            EMSFactory::add(DeviceType::GENERIC, device_id, product_id, version, name, DeviceFlags::EMS_DEVICE_FLAG_NONE, EMSdevice::Brand::NO_BRAND));
         return false; // not found
     }
 
@@ -954,7 +968,9 @@ bool EMSESP::add_device(const uint8_t device_id, const uint8_t product_id, std::
         return true;
     }
 
-    Command::add_with_json(device_type, F_(info), [device_type](const char * value, const int8_t id, JsonObject & json) { return command_info(device_type, json, id); });
+    Command::add_with_json(device_type, F_(info), [device_type](const char * value, const int8_t id, JsonObject & json) {
+        return command_info(device_type, json, id);
+    });
 
     return true;
 }
@@ -973,7 +989,8 @@ bool EMSESP::command_info(uint8_t device_type, JsonObject & json, const int8_t i
     }
 
     for (const auto & emsdevice : emsdevices) {
-        if (emsdevice && (emsdevice->device_type() == device_type) && ((device_type != DeviceType::THERMOSTAT) || (emsdevice->device_id() == EMSESP::actual_master_thermostat()))) {
+        if (emsdevice && (emsdevice->device_type() == device_type)
+            && ((device_type != DeviceType::THERMOSTAT) || (emsdevice->device_id() == EMSESP::actual_master_thermostat()))) {
             has_value |= emsdevice->generate_values_json(json, tag, (id < 1), (id == -1)); // nested for id -1,0 & console for id -1
         }
     }
@@ -987,7 +1004,12 @@ void EMSESP::send_read_request(const uint16_t type_id, const uint8_t dest, const
 }
 
 // sends write request
-void EMSESP::send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validate_typeid) {
+void EMSESP::send_write_request(const uint16_t type_id,
+                                const uint8_t  dest,
+                                const uint8_t  offset,
+                                uint8_t *      message_data,
+                                const uint8_t  message_length,
+                                const uint16_t validate_typeid) {
     txservice_.add(Telegram::Operation::TX_WRITE, dest, type_id, offset, message_data, message_length, validate_typeid, true);
 }
 

src/emsesp.h

@@ -93,7 +93,12 @@ class EMSESP {
     static std::string pretty_telegram(std::shared_ptr<const Telegram> telegram);
 
     static void send_read_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset = 0, const uint8_t length = 0);
-    static void send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, 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,
+                                   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);
 
@@ -173,6 +178,7 @@ class EMSESP {
     }
 
     static void fetch_device_values(const uint8_t device_id = 0);
+    static void fetch_device_values_type(const uint8_t device_type);
 
     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();

src/helpers.cpp

@@ -478,7 +478,8 @@ bool Helpers::value2enum(const char * v, uint8_t & value, const __FlashStringHel
     std::string str = toLower(v);
     for (value = 0; strs[value]; value++) {
         std::string str1 = toLower(uuid::read_flash_string(strs[value]));
-        if ((str1 == uuid::read_flash_string(F_(off)) && str == "false") || (str1 == uuid::read_flash_string(F_(on)) && str == "true") || (str == str1) || (v[0] == ('0' + value) && v[1] == '\0')) {
+        if ((str1 == uuid::read_flash_string(F_(off)) && str == "false") || (str1 == uuid::read_flash_string(F_(on)) && str == "true") || (str == str1)
+            || (v[0] == ('0' + value) && v[1] == '\0')) {
             return true;
         }
     }

src/locale_EN.h

@@ -283,7 +283,16 @@ MAKE_PSTR(functioning_mode, "functioning mode")
 MAKE_PSTR(smoke_temperature, "smoke temperature")
 
 // thermostat lists
-MAKE_PSTR_LIST(enum_ibaMainDisplay, F_(internal_temperature), F_(internal_setpoint), F_(external_temperature), F_(burner_temperature), F_(ww_temperature), F_(functioning_mode), F_(time), F_(date), F_(smoke_temperature))
+MAKE_PSTR_LIST(enum_ibaMainDisplay,
+               F_(internal_temperature),
+               F_(internal_setpoint),
+               F_(external_temperature),
+               F_(burner_temperature),
+               F_(ww_temperature),
+               F_(functioning_mode),
+               F_(time),
+               F_(date),
+               F_(smoke_temperature))
 MAKE_PSTR_LIST(enum_ibaLanguage, F_(german), F_(dutch), F_(french), F_(italian))
 MAKE_PSTR_LIST(enum_floordrystatus, F_(off), F_(start), F_(heat), F_(hold), F_(cool), F_(end))
 MAKE_PSTR_LIST(enum_ibaBuildingType, F_(blank), F_(light), F_(medium), F_(heavy)) // RC300

src/mqtt.cpp

@@ -228,12 +228,27 @@ void Mqtt::show_mqtt(uuid::console::Shell & shell) {
     }
     for (const auto & cf : Command::commands()) {
         if (subscribe_format_ == 2 && cf.flag_ == MqttSubFlag::FLAG_HC) {
-            shell.printfln(F(" %s/%s/hc1/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str());
+            shell.printfln(F(" %s/%s/hc1/%s"),
-            shell.printfln(F(" %s/%s/hc2/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str());
+                           mqtt_base_.c_str(),
-            shell.printfln(F(" %s/%s/hc3/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str());
+                           EMSdevice::device_type_2_device_name(cf.device_type_).c_str(),
-            shell.printfln(F(" %s/%s/hc4/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str());
+                           uuid::read_flash_string(cf.cmd_).c_str());
+            shell.printfln(F(" %s/%s/hc2/%s"),
+                           mqtt_base_.c_str(),
+                           EMSdevice::device_type_2_device_name(cf.device_type_).c_str(),
+                           uuid::read_flash_string(cf.cmd_).c_str());
+            shell.printfln(F(" %s/%s/hc3/%s"),
+                           mqtt_base_.c_str(),
+                           EMSdevice::device_type_2_device_name(cf.device_type_).c_str(),
+                           uuid::read_flash_string(cf.cmd_).c_str());
+            shell.printfln(F(" %s/%s/hc4/%s"),
+                           mqtt_base_.c_str(),
+                           EMSdevice::device_type_2_device_name(cf.device_type_).c_str(),
+                           uuid::read_flash_string(cf.cmd_).c_str());
         } else if (subscribe_format_ && cf.flag_ != MqttSubFlag::FLAG_NOSUB) {
-            shell.printfln(F(" %s/%s/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str());
+            shell.printfln(F(" %s/%s/%s"),
+                           mqtt_base_.c_str(),
+                           EMSdevice::device_type_2_device_name(cf.device_type_).c_str(),
+                           uuid::read_flash_string(cf.cmd_).c_str());
         }
     }
     shell.println();
@@ -265,7 +280,12 @@ void Mqtt::show_mqtt(uuid::console::Shell & shell) {
                     shell.printfln(F(" [%02d] (Pub) topic=%s payload=%s (pid %d)"), message.id_, topic, content->payload.c_str(), message.packet_id_);
                 }
             } else {
-                shell.printfln(F(" [%02d] (Pub) topic=%s payload=%s (pid %d, retry #%d)"), message.id_, topic, content->payload.c_str(), message.packet_id_, message.retry_count_);
+                shell.printfln(F(" [%02d] (Pub) topic=%s payload=%s (pid %d, retry #%d)"),
+                               message.id_,
+                               topic,
+                               content->payload.c_str(),
+                               message.packet_id_,
+                               message.retry_count_);
             }
         } else {
             // Subscribe messages
@@ -400,7 +420,10 @@ void Mqtt::on_message(const char * fulltopic, const char * payload, size_t len)
 
 // print all the topics related to a specific device type
 void Mqtt::show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_type) {
-    if (std::count_if(mqtt_subfunctions_.cbegin(), mqtt_subfunctions_.cend(), [=](MQTTSubFunction const & mqtt_subfunction) { return device_type == mqtt_subfunction.device_type_; }) == 0) {
+    if (std::count_if(mqtt_subfunctions_.cbegin(),
+                      mqtt_subfunctions_.cend(),
+                      [=](MQTTSubFunction const & mqtt_subfunction) { return device_type == mqtt_subfunction.device_type_; })
+        == 0) {
         return;
     }
 
@@ -851,7 +874,13 @@ void Mqtt::process_queue() {
 
     // else try and publish it
     uint16_t packet_id = mqttClient_->publish(topic, mqtt_qos_, message->retain, message->payload.c_str(), message->payload.size(), false, mqtt_message.id_);
-    LOG_DEBUG(F("Publishing topic %s (#%02d, retain=%d, try#%d, size %d, pid %d)"), topic, mqtt_message.id_, message->retain, mqtt_message.retry_count_ + 1, message->payload.size(), packet_id);
+    LOG_DEBUG(F("Publishing topic %s (#%02d, retain=%d, try#%d, size %d, pid %d)"),
+              topic,
+              mqtt_message.id_,
+              message->retain,
+              mqtt_message.retry_count_ + 1,
+              message->payload.size(),
+              packet_id);
 
     if (packet_id == 0) {
         // it failed. if we retried n times, give up. remove from queue

src/mqtt.h

@@ -106,7 +106,12 @@ class Mqtt {
     static void publish_ha(const std::string & topic, const JsonObject & payload);
     static void publish_ha(const __FlashStringHelper * topic, const JsonObject & payload);
 
-    static void publish_mqtt_ha_sensor(uint8_t type, uint8_t tag, const __FlashStringHelper * name, const uint8_t device_type, const __FlashStringHelper * entity, const uint8_t uom = 0);
+    static void publish_mqtt_ha_sensor(uint8_t                     type,
+                                       uint8_t                     tag,
+                                       const __FlashStringHelper * name,
+                                       const uint8_t               device_type,
+                                       const __FlashStringHelper * entity,
+                                       const uint8_t               uom = 0);
     static void register_command(const uint8_t device_type, const __FlashStringHelper * cmd, cmdfunction_p cb, uint8_t tag = 0);
 
     static void show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_type);

src/system.cpp

@@ -63,35 +63,55 @@ bool System::command_send(const char * value, const int8_t id) {
 
 // fetch device values
 bool System::command_fetch(const char * value, const int8_t id) {
+    std::string value_s(14, '\0');
+    if (Helpers::value2string(value, value_s)) {
+        if (value_s == "all") {
             LOG_INFO(F("Requesting data from EMS devices"));
             EMSESP::fetch_device_values();
             return true;
+        } else if (value_s == "boiler") {
+            EMSESP::fetch_device_values_type(EMSdevice::DeviceType::BOILER);
+            return true;
+        } else if (value_s == "thermostat") {
+            EMSESP::fetch_device_values_type(EMSdevice::DeviceType::THERMOSTAT);
+            return true;
+        } else if (value_s == "solar") {
+            EMSESP::fetch_device_values_type(EMSdevice::DeviceType::SOLAR);
+            return true;
+        } else if (value_s == "mixer") {
+            EMSESP::fetch_device_values_type(EMSdevice::DeviceType::MIXER);
+            return true;
+        }
+    }
+
+    EMSESP::fetch_device_values(); // default if no name or id is given
+    return true;
 }
 
 // mqtt publish
 bool System::command_publish(const char * value, const int8_t id) {
-    std::string ha(14, '\0');
+    std::string value_s(14, '\0');
-    if (Helpers::value2string(value, ha)) {
+    if (Helpers::value2string(value, value_s)) {
-        if (ha == "ha") {
+        if (value_s == "ha") {
             EMSESP::publish_all(true); // includes HA
             LOG_INFO(F("Publishing all data to MQTT, including HA configs"));
             return true;
-        } else if (ha == "boiler") {
+        } else if (value_s == "boiler") {
             EMSESP::publish_device_values(EMSdevice::DeviceType::BOILER);
             return true;
-        } else if (ha == "thermostat") {
+        } else if (value_s == "thermostat") {
             EMSESP::publish_device_values(EMSdevice::DeviceType::THERMOSTAT);
             return true;
-        } else if (ha == "solar") {
+        } else if (value_s == "solar") {
             EMSESP::publish_device_values(EMSdevice::DeviceType::SOLAR);
             return true;
-        } else if (ha == "mixer") {
+        } else if (value_s == "mixer") {
             EMSESP::publish_device_values(EMSdevice::DeviceType::MIXER);
             return true;
-        } else if (ha == "other") {
+        } else if (value_s == "other") {
             EMSESP::publish_other_values();
             return true;
-        } else if (ha == "dallassensor") {
+        } else if (value_s == "dallassensor") {
             EMSESP::publish_sensor_values(true);
             return true;
         }
@@ -848,7 +868,7 @@ bool System::command_settings(const char * value, const int8_t id, JsonObject &
         node["dallas_parasite"]      = settings.dallas_parasite;
         node["led_gpio"]             = settings.led_gpio;
         node["hide_led"]             = settings.hide_led;
-        node["api_enabled"]          = settings.api_enabled;
+        node["notoken_api"]          = settings.notoken_api;
         node["analog_enabled"]       = settings.analog_enabled;
         node["pbutton_gpio"]         = settings.pbutton_gpio;
         node["board_profile"]        = settings.board_profile;
@@ -860,7 +880,6 @@ bool System::command_settings(const char * value, const int8_t id, JsonObject &
 // export status information including some basic settings
 // e.g. http://ems-esp/api?device=system&cmd=info
 bool System::command_info(const char * value, const int8_t id, JsonObject & json) {
-
     if (id == 0) {
         return EMSESP::system_.heartbeat_json(json);
     }

src/telegram.cpp

@@ -22,15 +22,19 @@
 namespace emsesp {
 
 // CRC lookup table with poly 12 for faster checking
-const uint8_t ems_crc_table[] = {0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2A, 0x2C, 0x2E, 0x30, 0x32, 0x34, 0x36, 0x38,
+const uint8_t ems_crc_table[] = {0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24, 0x26,
-                                 0x3A, 0x3C, 0x3E, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4A, 0x4C, 0x4E, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5A, 0x5C, 0x5E, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6A, 0x6C, 0x6E, 0x70, 0x72,
+                                 0x28, 0x2A, 0x2C, 0x2E, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, 0x3E, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4A, 0x4C, 0x4E,
-                                 0x74, 0x76, 0x78, 0x7A, 0x7C, 0x7E, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8A, 0x8C, 0x8E, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E, 0xA0, 0xA2, 0xA4, 0xA6, 0xA8, 0xAA, 0xAC,
+                                 0x50, 0x52, 0x54, 0x56, 0x58, 0x5A, 0x5C, 0x5E, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6A, 0x6C, 0x6E, 0x70, 0x72, 0x74, 0x76,
-                                 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC, 0xBE, 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE, 0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE, 0xE0, 0xE2, 0xE4, 0xE6,
+                                 0x78, 0x7A, 0x7C, 0x7E, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8A, 0x8C, 0x8E, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E,
-                                 0xE8, 0xEA, 0xEC, 0xEE, 0xF0, 0xF2, 0xF4, 0xF6, 0xF8, 0xFA, 0xFC, 0xFE, 0x19, 0x1B, 0x1D, 0x1F, 0x11, 0x13, 0x15, 0x17, 0x09, 0x0B, 0x0D, 0x0F, 0x01, 0x03, 0x05, 0x07, 0x39,
+                                 0xA0, 0xA2, 0xA4, 0xA6, 0xA8, 0xAA, 0xAC, 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC, 0xBE, 0xC0, 0xC2, 0xC4, 0xC6,
-                                 0x3B, 0x3D, 0x3F, 0x31, 0x33, 0x35, 0x37, 0x29, 0x2B, 0x2D, 0x2F, 0x21, 0x23, 0x25, 0x27, 0x59, 0x5B, 0x5D, 0x5F, 0x51, 0x53, 0x55, 0x57, 0x49, 0x4B, 0x4D, 0x4F, 0x41, 0x43,
+                                 0xC8, 0xCA, 0xCC, 0xCE, 0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE, 0xE0, 0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE,
-                                 0x45, 0x47, 0x79, 0x7B, 0x7D, 0x7F, 0x71, 0x73, 0x75, 0x77, 0x69, 0x6B, 0x6D, 0x6F, 0x61, 0x63, 0x65, 0x67, 0x99, 0x9B, 0x9D, 0x9F, 0x91, 0x93, 0x95, 0x97, 0x89, 0x8B, 0x8D,
+                                 0xF0, 0xF2, 0xF4, 0xF6, 0xF8, 0xFA, 0xFC, 0xFE, 0x19, 0x1B, 0x1D, 0x1F, 0x11, 0x13, 0x15, 0x17, 0x09, 0x0B, 0x0D, 0x0F,
-                                 0x8F, 0x81, 0x83, 0x85, 0x87, 0xB9, 0xBB, 0xBD, 0xBF, 0xB1, 0xB3, 0xB5, 0xB7, 0xA9, 0xAB, 0xAD, 0xAF, 0xA1, 0xA3, 0xA5, 0xA7, 0xD9, 0xDB, 0xDD, 0xDF, 0xD1, 0xD3, 0xD5, 0xD7,
+                                 0x01, 0x03, 0x05, 0x07, 0x39, 0x3B, 0x3D, 0x3F, 0x31, 0x33, 0x35, 0x37, 0x29, 0x2B, 0x2D, 0x2F, 0x21, 0x23, 0x25, 0x27,
-                                 0xC9, 0xCB, 0xCD, 0xCF, 0xC1, 0xC3, 0xC5, 0xC7, 0xF9, 0xFB, 0xFD, 0xFF, 0xF1, 0xF3, 0xF5, 0xF7, 0xE9, 0xEB, 0xED, 0xEF, 0xE1, 0xE3, 0xE5, 0xE7};
+                                 0x59, 0x5B, 0x5D, 0x5F, 0x51, 0x53, 0x55, 0x57, 0x49, 0x4B, 0x4D, 0x4F, 0x41, 0x43, 0x45, 0x47, 0x79, 0x7B, 0x7D, 0x7F,
+                                 0x71, 0x73, 0x75, 0x77, 0x69, 0x6B, 0x6D, 0x6F, 0x61, 0x63, 0x65, 0x67, 0x99, 0x9B, 0x9D, 0x9F, 0x91, 0x93, 0x95, 0x97,
+                                 0x89, 0x8B, 0x8D, 0x8F, 0x81, 0x83, 0x85, 0x87, 0xB9, 0xBB, 0xBD, 0xBF, 0xB1, 0xB3, 0xB5, 0xB7, 0xA9, 0xAB, 0xAD, 0xAF,
+                                 0xA1, 0xA3, 0xA5, 0xA7, 0xD9, 0xDB, 0xDD, 0xDF, 0xD1, 0xD3, 0xD5, 0xD7, 0xC9, 0xCB, 0xCD, 0xCF, 0xC1, 0xC3, 0xC5, 0xC7,
+                                 0xF9, 0xFB, 0xFD, 0xFF, 0xF1, 0xF3, 0xF5, 0xF7, 0xE9, 0xEB, 0xED, 0xEF, 0xE1, 0xE3, 0xE5, 0xE7};
 
 uint32_t EMSbus::last_bus_activity_ = 0;              // timestamp of last time a valid Rx came in
 bool     EMSbus::bus_connected_     = false;          // start assuming the bus hasn't been connected
@@ -55,7 +59,13 @@ uint8_t EMSbus::calculate_crc(const uint8_t * data, const uint8_t length) {
 
 // creates a telegram object
 // stores header in separate member objects and the rest in the message_data block
-Telegram::Telegram(const uint8_t operation, const uint8_t src, const uint8_t dest, const uint16_t type_id, const uint8_t offset, const uint8_t * data, const uint8_t message_length)
+Telegram::Telegram(const uint8_t   operation,
+                   const uint8_t   src,
+                   const uint8_t   dest,
+                   const uint16_t  type_id,
+                   const uint8_t   offset,
+                   const uint8_t * data,
+                   const uint8_t   message_length)
     : operation(operation)
     , src(src)
     , dest(dest)
@@ -192,7 +202,8 @@ void RxService::add(uint8_t * data, uint8_t length) {
     // if we're watching and "raw" print out actual telegram as bytes to the console
     if (EMSESP::watch() == EMSESP::Watch::WATCH_RAW) {
         uint16_t trace_watch_id = EMSESP::watch_id();
-        if ((trace_watch_id == WATCH_ID_NONE) || (type_id == trace_watch_id) || ((trace_watch_id < 0x80) && ((src == trace_watch_id) || (dest == trace_watch_id)))) {
+        if ((trace_watch_id == WATCH_ID_NONE) || (type_id == trace_watch_id)
+            || ((trace_watch_id < 0x80) && ((src == trace_watch_id) || (dest == trace_watch_id)))) {
             LOG_NOTICE(F("Rx: %s"), Helpers::data_to_hex(data, length).c_str());
         } else if (EMSESP::trace_raw()) {
             LOG_TRACE(F("Rx: %s"), Helpers::data_to_hex(data, length).c_str());
@@ -349,7 +360,10 @@ void TxService::send_telegram(const QueuedTxTelegram & tx_telegram) {
 
     length++; // add one since we want to now include the CRC
 
-    LOG_DEBUG(F("Sending %s Tx [#%d], telegram: %s"), (telegram->operation == Telegram::Operation::TX_WRITE) ? F("write") : F("read"), tx_telegram.id_, Helpers::data_to_hex(telegram_raw, length).c_str());
+    LOG_DEBUG(F("Sending %s Tx [#%d], telegram: %s"),
+              (telegram->operation == Telegram::Operation::TX_WRITE) ? F("write") : F("read"),
+              tx_telegram.id_,
+              Helpers::data_to_hex(telegram_raw, length).c_str());
 
     set_post_send_query(tx_telegram.validateid_);
     // send the telegram to the UART Tx
@@ -389,7 +403,14 @@ void TxService::send_telegram(const uint8_t * data, const uint8_t length) {
 }
 */
 
-void TxService::add(const uint8_t operation, const uint8_t dest, const uint16_t type_id, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validateid, const bool front) {
+void TxService::add(const uint8_t  operation,
+                    const uint8_t  dest,
+                    const uint16_t type_id,
+                    const uint8_t  offset,
+                    uint8_t *      message_data,
+                    const uint8_t  message_length,
+                    const uint16_t validateid,
+                    const bool     front) {
     auto telegram = std::make_shared<Telegram>(operation, ems_bus_id(), dest, type_id, offset, message_data, message_length);
 
 #ifdef EMSESP_DEBUG
@@ -546,7 +567,10 @@ void TxService::retry_tx(const uint8_t operation, const uint8_t * data, const ui
         reset_retry_count();             // give up
         increment_telegram_fail_count(); // another Tx fail
 
-        LOG_ERROR(F("Last Tx %s operation failed after %d retries. Ignoring request: %s"), (operation == Telegram::Operation::TX_WRITE) ? F("Write") : F("Read"), MAXIMUM_TX_RETRIES), telegram_last_->to_string().c_str();
+        LOG_ERROR(F("Last Tx %s operation failed after %d retries. Ignoring request: %s"),
+                  (operation == Telegram::Operation::TX_WRITE) ? F("Write") : F("Read"),
+                  MAXIMUM_TX_RETRIES),
+            telegram_last_->to_string().c_str();
         return;
     }
 

src/telegram.h

@@ -55,7 +55,13 @@ namespace emsesp {
 
 class Telegram {
   public:
-    Telegram(const uint8_t operation, const uint8_t src, const uint8_t dest, const uint16_t type_id, const uint8_t offset, const uint8_t * message_data, const uint8_t message_length);
+    Telegram(const uint8_t   operation,
+             const uint8_t   src,
+             const uint8_t   dest,
+             const uint16_t  type_id,
+             const uint8_t   offset,
+             const uint8_t * message_data,
+             const uint8_t   message_length);
     ~Telegram() = default;
 
     const uint8_t  operation; // is Operation mode
@@ -262,7 +268,14 @@ class TxService : public EMSbus {
 
     void     start();
     void     send();
-    void     add(const uint8_t operation, const uint8_t dest, const uint16_t type_id, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validateid, const bool front = false);
+    void     add(const uint8_t  operation,
+                 const uint8_t  dest,
+                 const uint16_t type_id,
+                 const uint8_t  offset,
+                 uint8_t *      message_data,
+                 const uint8_t  message_length,
+                 const uint16_t validateid,
+                 const bool     front = false);
     void     add(const uint8_t operation, const uint8_t * data, const uint8_t length, const uint16_t validateid, const bool front = false);
     void     read_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset = 0, const uint8_t length = 0);
     void     send_raw(const char * telegram_data);

src/test/test.cpp

@@ -37,7 +37,8 @@ bool Test::run_test(const char * command, int8_t id) {
 
         // 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});
+        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});
@@ -46,7 +47,8 @@ bool Test::run_test(const char * command, int8_t id) {
         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});
+        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});
 
         return true;
     }
@@ -59,7 +61,8 @@ bool Test::run_test(const char * command, int8_t id) {
 
         // 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});
+        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, 0x90, 0x33, 0x00, 0x23, 0x24});
@@ -68,7 +71,8 @@ bool Test::run_test(const char * command, int8_t id) {
         uart_telegram({0x08, 0x0B, 0x33, 0x00, 0x08, 0xFF, 0x34, 0xFB, 0x00, 0x28, 0x00, 0x00, 0x46, 0x00, 0xFF, 0xFF, 0x00});
 
         // Thermostat 0x2A5 for HC1
-        uart_telegram({0x10, 00, 0xFF, 00, 01, 0xA5, 0x80, 00, 01, 0x30, 0x28, 00, 0x30, 0x28, 01, 0x54, 03, 03, 01, 01, 0x54, 02, 0xA8, 00, 00, 0x11, 01, 03, 0xFF, 0xFF, 00});
+        uart_telegram({0x10, 00, 0xFF, 00, 01,   0xA5, 0x80, 00, 01, 0x30, 0x28, 00, 0x30, 0x28, 01, 0x54,
+                       03,   03, 01,   01, 0x54, 02,   0xA8, 00, 00, 0x11, 01,   03, 0xFF, 0xFF, 00});
 
         return true;
     }
@@ -123,7 +127,8 @@ bool Test::run_test(const char * command, int8_t id) {
         uart_telegram({0x08, 0x0B, 0x14, 00, 0x3C, 0x1F, 0xAC, 0x70});
 
         // 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});
+        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 -> 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});
@@ -150,9 +155,11 @@ bool Test::run_test(const char * command, int8_t id) {
         add_device(0x30, 163); // SM100
 
         // SM100Monitor - type 0x0362 EMS+ - for SM100 and SM200
-        uart_telegram({0xB0, 0x0B, 0xFF, 00, 0x02, 0x62, 00, 0x44, 0x02, 0x7A, 0x80, 00, 0x80, 0x00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 00, 0x7C, 0x80, 00, 0x80, 00, 0x80, 00, 0x80});
+        uart_telegram({0xB0, 0x0B, 0xFF, 00, 0x02, 0x62, 00, 0x44, 0x02, 0x7A, 0x80, 00, 0x80, 0x00, 0x80, 00,
+                       0x80, 00,   0x80, 00, 0x80, 00,   00, 0x7C, 0x80, 00,   0x80, 00, 0x80, 00,   0x80});
 
-        uart_telegram({0xB0, 0x0B, 0xFF, 0x00, 0x02, 0x62, 0x01, 0x44, 0x03, 0x30, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 0x33});
+        uart_telegram({0xB0, 0x0B, 0xFF, 0x00, 0x02, 0x62, 0x01, 0x44, 0x03, 0x30, 0x80, 00, 0x80, 00, 0x80, 00,
+                       0x80, 00,   0x80, 00,   0x80, 00,   0x80, 00,   0x80, 00,   0x80, 00, 0x80, 00, 0x80, 0x33});
 
         uart_telegram({0xB0, 00, 0xFF, 0x18, 02, 0x62, 0x80, 00, 0xB8});
 
@@ -329,7 +336,7 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
         // test call
         DynamicJsonDocument doc(EMSESP_JSON_SIZE_XLARGE_DYN);
         JsonObject          json = doc.to<JsonObject>();
-        (void)emsesp::Command::call(EMSdevice::DeviceType::BOILER, "info", nullptr, -1, json);
+        Command::call(EMSdevice::DeviceType::BOILER, "info", nullptr, -1, json);
 #if defined(EMSESP_STANDALONE)
         Serial.print(COLOR_YELLOW);
         if (json.size() != 0) {
@@ -477,7 +484,8 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
         add_device(0x18, 202); // Bosch TC100 - https://github.com/emsesp/EMS-ESP/issues/474
 
         // 0x0A
-        uart_telegram({0x98, 0x0B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
+        uart_telegram({0x98, 0x0B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
     }
 
     if (command == "solar") {
@@ -507,9 +515,11 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
 
         // 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, 0x80, 00, 0x80, 00, 0x80, 00, 00, 0x7C, 0x80, 00, 0x80, 00, 0x80, 00, 0x80});
+        rx_telegram({0xB0, 0x0B, 0xFF, 00, 0x02, 0x62, 00, 0x44, 0x02, 0x7A, 0x80, 00, 0x80, 0x00, 0x80, 00,
+                     0x80, 00,   0x80, 00, 0x80, 00,   00, 0x7C, 0x80, 00,   0x80, 00, 0x80, 00,   0x80});
 
-        rx_telegram({0xB0, 0x0B, 0xFF, 0x00, 0x02, 0x62, 0x01, 0x44, 0x03, 0x30, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 0x33});
+        rx_telegram({0xB0, 0x0B, 0xFF, 0x00, 0x02, 0x62, 0x01, 0x44, 0x03, 0x30, 0x80, 00, 0x80, 00, 0x80, 00,
+                     0x80, 00,   0x80, 00,   0x80, 00,   0x80, 00,   0x80, 00,   0x80, 00, 0x80, 00, 0x80, 0x33});
 
         rx_telegram({0xB0, 00, 0xFF, 0x18, 02, 0x62, 0x80, 00, 0xB8});
 
@@ -588,7 +598,8 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
 
         // 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)
-        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({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 A6 00 CF 21 2E 00 00 2E 24 03 25 03 03 01 03 25 00 C8 00 00 11 01 03 6B"); // with CRC
@@ -617,7 +628,8 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
 
         // fake telegrams. length includes CRC
         // 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});
+        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, 0x97, 0x33, 0x00, 0x23, 0x24});
@@ -643,10 +655,12 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
 
         // Thermostat -> all, telegram: 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
         // 0x1A5 test ems+
-        uart_telegram({0x10, 0x00, 0xFF, 0x00, 0x01, 0xA5, 0x00, 0xD7, 0x21, 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x84, 0x01, 0x01, 0x03, 0x01, 0x84, 0x01, 0xF1, 0x00, 0x00, 0x11, 0x01, 0x00, 0x08, 0x63, 0x00});
+        uart_telegram({0x10, 0x00, 0xFF, 0x00, 0x01, 0xA5, 0x00, 0xD7, 0x21, 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x84,
+                       0x01, 0x01, 0x03, 0x01, 0x84, 0x01, 0xF1, 0x00, 0x00, 0x11, 0x01, 0x00, 0x08, 0x63, 0x00});
 
         // setting temp from 21.5 to 19.9C
-        uart_telegram({0x10, 0x00, 0xFF, 0x00, 0x01, 0xA5, 0x00, 0xC7, 0x21, 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x84, 0x01, 0x01, 0x03, 0x01, 0x84, 0x01, 0xF1, 0x00, 0x00, 0x11, 0x01, 0x00, 0x08, 0x63, 0x00});
+        uart_telegram({0x10, 0x00, 0xFF, 0x00, 0x01, 0xA5, 0x00, 0xC7, 0x21, 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x84,
+                       0x01, 0x01, 0x03, 0x01, 0x84, 0x01, 0xF1, 0x00, 0x00, 0x11, 0x01, 0x00, 0x08, 0x63, 0x00});
 
         // Thermostat -> Boiler, UBAFlags(0x35), telegram: 17 08 35 00 11 00 (#data=2)
         uart_telegram({0x17, 0x08, 0x35, 0x00, 0x11, 0x00});
@@ -655,10 +669,12 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
         uart_telegram({0x17, 0x08, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00});
 
         // Thermostat -> Me, RC20Set(0xA8), telegram: 17 0B A8 00 01 00 FF F6 01 06 00 01 0D 01 00 FF FF 01 02 02 02 00 00 05 1F 05 1F 02 0E 00 FF (#data=27)
-        uart_telegram({0x17, 0x0B, 0xA8, 0x00, 0x01, 0x00, 0xFF, 0xF6, 0x01, 0x06, 0x00, 0x01, 0x0D, 0x01, 0x00, 0xFF, 0xFF, 0x01, 0x02, 0x02, 0x02, 0x00, 0x00, 0x05, 0x1F, 0x05, 0x1F, 0x02, 0x0E, 0x00, 0xFF});
+        uart_telegram({0x17, 0x0B, 0xA8, 0x00, 0x01, 0x00, 0xFF, 0xF6, 0x01, 0x06, 0x00, 0x01, 0x0D, 0x01, 0x00, 0xFF,
+                       0xFF, 0x01, 0x02, 0x02, 0x02, 0x00, 0x00, 0x05, 0x1F, 0x05, 0x1F, 0x02, 0x0E, 0x00, 0xFF});
 
         //  Boiler(0x08) -> All(0x00), UBAMonitorWW(0x34), data: 36 01 A5 80 00 21 00 00 01 00 01 3E 8D 03 77 91 00 80 00
-        uart_telegram({0x08, 0x00, 0x34, 0x00, 0x36, 0x01, 0xA5, 0x80, 0x00, 0x21, 0x00, 0x00, 0x01, 0x00, 0x01, 0x3E, 0x8D, 0x03, 0x77, 0x91, 0x00, 0x80, 0x00});
+        uart_telegram(
+            {0x08, 0x00, 0x34, 0x00, 0x36, 0x01, 0xA5, 0x80, 0x00, 0x21, 0x00, 0x00, 0x01, 0x00, 0x01, 0x3E, 0x8D, 0x03, 0x77, 0x91, 0x00, 0x80, 0x00});
 
         // test 0x2A - DHWStatus3
         uart_telegram({0x88, 00, 0x2A, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0xD2, 00, 00, 0x80, 00, 00, 01, 0x9D, 0x80, 0x00, 0x02, 0x79, 00});
@@ -686,7 +702,8 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
         EMSESP::send_write_request(0x91, 0x17, 0x00, t18, sizeof(t18), 0x00);
 
         // TX - send EMS+
-        const uint8_t t13[] = {0x90, 0x0B, 0xFF, 00, 01, 0xBA, 00, 0x2E, 0x2A, 0x26, 0x1E, 0x03, 00, 0xFF, 0xFF, 05, 0x2A, 01, 0xE1, 0x20, 0x01, 0x0F, 05, 0x2A};
+        const uint8_t t13[] = {0x90, 0x0B, 0xFF, 00, 01,   0xBA, 00,   0x2E, 0x2A, 0x26, 0x1E, 0x03,
+                               00,   0xFF, 0xFF, 05, 0x2A, 01,   0xE1, 0x20, 0x01, 0x0F, 05,   0x2A};
         EMSESP::txservice_.add(Telegram::Operation::TX_RAW, t13, sizeof(t13), 0);
 
         // EMS+ Junkers read request
@@ -791,7 +808,8 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
         add_device(0x18, 157); // Bosch CR100 - https://github.com/emsesp/EMS-ESP/issues/355
 
         // RCPLUSStatusMessage_HC1(0x01A5) - HC1
-        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({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
 
@@ -858,7 +876,8 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd) {
     if (command == "rx2") {
         shell.printfln(F("Testing rx2..."));
 
-        uart_telegram({0x1B, 0x5B, 0xFD, 0x2D, 0x9E, 0x3A, 0xB6, 0xE5, 0x02, 0x20, 0x33, 0x30, 0x32, 0x3A, 0x20, 0x5B, 0x73, 0xFF, 0xFF, 0xCB, 0xDF, 0xB7, 0xA7, 0xB5, 0x67, 0x77, 0x77, 0xE4, 0xFF, 0xFD, 0x77, 0xFF});
+        uart_telegram({0x1B, 0x5B, 0xFD, 0x2D, 0x9E, 0x3A, 0xB6, 0xE5, 0x02, 0x20, 0x33, 0x30, 0x32, 0x3A, 0x20, 0x5B,
+                       0x73, 0xFF, 0xFF, 0xCB, 0xDF, 0xB7, 0xA7, 0xB5, 0x67, 0x77, 0x77, 0xE4, 0xFF, 0xFD, 0x77, 0xFF});
     }
 
     // https://github.com/emsesp/EMS-ESP/issues/380#issuecomment-633663007

src/test/test.h

@@ -22,6 +22,7 @@
 #define EMSESP_TEST_H
 
 #include "emsesp.h"
+#include <ESPAsyncWebServer.h>
 
 namespace emsesp {
 
@@ -29,14 +30,13 @@ namespace emsesp {
 // #define EMSESP_DEBUG_DEFAULT "solar"
 // #define EMSESP_DEBUG_DEFAULT "mixer"
 // #define EMSESP_DEBUG_DEFAULT "web"
-// #define EMSESP_DEBUG_DEFAULT "general"
+#define EMSESP_DEBUG_DEFAULT "general"
 // #define EMSESP_DEBUG_DEFAULT "boiler"
 // #define EMSESP_DEBUG_DEFAULT "mqtt2"
 // #define EMSESP_DEBUG_DEFAULT "mqtt_nested"
 // #define EMSESP_DEBUG_DEFAULT "ha"
 // #define EMSESP_DEBUG_DEFAULT "board_profile"
-#define EMSESP_DEBUG_DEFAULT "shower_alert"
+// #define EMSESP_DEBUG_DEFAULT "shower_alert"
-
 
 class Test {
   public:

src/uart/emsuart_esp32.cpp

@@ -140,7 +140,6 @@ void EMSuart::restart() {
     EMS_UART.int_ena.brk_det = 1; // activate only break
     EMS_UART.conf0.txd_brk   = (tx_mode_ == EMS_TXMODE_HW) ? 1 : 0;
     portEXIT_CRITICAL(&mux_);
-
 }
 
 /*

src/version.h

@@ -1,2 +1,2 @@
-#define EMSESP_APP_VERSION "3.1.0"
+#define EMSESP_APP_VERSION "3.1.1b0"
 #define EMSESP_PLATFORM "ESP32"