refactor: small changes

Building on ``Arduino``+``ESP-IDF`` with ``h2zero/esp-nimble-cpp`` for ESP32 C6

lib/CustomOpenTherm/CustomOpenTherm.h

@@ -7,7 +7,7 @@ public:
   typedef std::function<void(unsigned long, byte)> BeforeSendRequestCallback;
   typedef std::function<void(unsigned long, unsigned long, OpenThermResponseStatus, byte)> AfterSendRequestCallback;
 
-  CustomOpenTherm(int inPin = 4, int outPin = 5, bool isSlave = false) : OpenTherm(inPin, outPin, isSlave) {}
+  CustomOpenTherm(int inPin = 4, int outPin = 5, bool isSlave = false, bool alwaysReceive = false) : OpenTherm(inPin, outPin, isSlave, alwaysReceive) {}
   ~CustomOpenTherm() {}
 
   CustomOpenTherm* setDelayCallback(DelayCallback callback = nullptr) {
@@ -28,8 +28,8 @@ public:
     return this;
   }
 
-  unsigned long sendRequest(unsigned long request, byte attempts = 5, byte _attempt = 0) {
+  unsigned long sendRequest(unsigned long request) override {
-    _attempt++;
+    this->sendRequestAttempt++;
 
     while (!this->isReady()) {
       if (this->delayCallback) {
@@ -40,15 +40,10 @@ public:
     }
 
     if (this->beforeSendRequestCallback) {
-      this->beforeSendRequestCallback(request, _attempt);
+      this->beforeSendRequestCallback(request, this->sendRequestAttempt);
     }
 
-    unsigned long _response;
+    if (this->sendRequestAsync(request)) {
-    OpenThermResponseStatus _responseStatus = OpenThermResponseStatus::NONE;
-    if (!this->sendRequestAsync(request)) {
-      _response = 0;
-
-    } else {
       do {
         if (this->delayCallback) {
           this->delayCallback(150);
@@ -56,42 +51,25 @@ public:
 
         this->process();
       } while (this->status != OpenThermStatus::READY && this->status != OpenThermStatus::DELAY);
-
-      _response = this->getLastResponse();
-      _responseStatus = this->getLastResponseStatus();
     }
 
     if (this->afterSendRequestCallback) {
-      this->afterSendRequestCallback(request, _response, _responseStatus, _attempt);
+      this->afterSendRequestCallback(request, this->response, this->responseStatus, this->sendRequestAttempt);
     }
 
-    if (_responseStatus == OpenThermResponseStatus::SUCCESS || _responseStatus == OpenThermResponseStatus::INVALID || _attempt >= attempts) {
+    if (this->responseStatus == OpenThermResponseStatus::SUCCESS || this->responseStatus == OpenThermResponseStatus::INVALID) {
-      return _response;
+      this->sendRequestAttempt = 0;
+      return this->response;
+
+    } else if (this->sendRequestAttempt >= this->sendRequestMaxAttempts) {
+      this->sendRequestAttempt = 0;
+      return this->response;
 
     } else {
-      return this->sendRequest(request, attempts, _attempt);
+      return this->sendRequest(request);
     }
   }
 
-  unsigned long setBoilerStatus(bool enableCentralHeating, bool enableHotWater, bool enableCooling, bool enableOutsideTemperatureCompensation, bool enableCentralHeating2, bool summerWinterMode, bool dhwBlocking, uint8_t lb = 0) {
-    unsigned int data = enableCentralHeating
-      | (enableHotWater << 1)
-      | (enableCooling << 2)
-      | (enableOutsideTemperatureCompensation << 3)
-      | (enableCentralHeating2 << 4)
-      | (summerWinterMode << 5)
-      | (dhwBlocking << 6);
-    
-    data <<= 8;
-    data |= lb;
-
-    return this->sendRequest(buildRequest(
-      OpenThermMessageType::READ_DATA,
-      OpenThermMessageID::Status,
-      data
-    ));
-  }
-
   bool sendBoilerReset() {
     unsigned int data = 1;
     data <<= 8;
@@ -134,6 +112,27 @@ public:
     return (byte)id == responseId;
   }
 
+  static uint8_t getResponseMessageTypeId(unsigned long response) {
+    return (response << 1) >> 29;
+  }
+
+  static const char* getResponseMessageTypeString(unsigned long response) {
+    uint8_t msgType = getResponseMessageTypeId(response);
+
+    switch (msgType) {
+      case (uint8_t) OpenThermMessageType::READ_ACK:
+      case (uint8_t) OpenThermMessageType::WRITE_ACK:
+      case (uint8_t) OpenThermMessageType::DATA_INVALID:
+      case (uint8_t) OpenThermMessageType::UNKNOWN_DATA_ID:
+        return CustomOpenTherm::messageTypeToString(
+          static_cast<OpenThermMessageType>(msgType)
+        );
+
+      default:
+        return "UNKNOWN";
+    }
+  }
+
   // converters
   template <class T>
   static unsigned int toFloat(const T val) {
@@ -145,6 +144,8 @@ public:
   }
 
 protected:
+  const uint8_t sendRequestMaxAttempts = 5;
+  uint8_t sendRequestAttempt = 0;
   DelayCallback delayCallback;
   BeforeSendRequestCallback beforeSendRequestCallback;
   AfterSendRequestCallback afterSendRequestCallback;

platformio.ini

@@ -14,12 +14,12 @@ extra_configs = secrets.default.ini
 core_dir = .pio
 
 [env]
-version = 1.5.3
+version = 1.5.4
 framework = arduino
 lib_deps = 
 	bblanchon/ArduinoJson@^7.3.0
 	;ihormelnyk/OpenTherm Library@^1.1.5
-	https://github.com/ihormelnyk/opentherm_library#master
+	https://github.com/Laxilef/opentherm_library#esp32_timer
 	arduino-libraries/ArduinoMqttClient@^0.1.8
 	lennarthennigs/ESP Telnet@^2.2
 	gyverlibs/FileData@^1.0.2

src/HaHelper.h

@@ -1215,7 +1215,7 @@ public:
 
     doc[FPSTR(HA_MIN_TEMP)] = minTemp;
     doc[FPSTR(HA_MAX_TEMP)] = maxTemp;
-    doc[FPSTR(HA_TEMP_STEP)] = 0.5f;
+    doc[FPSTR(HA_TEMP_STEP)] = 0.1f;
     doc[FPSTR(HA_EXPIRE_AFTER)] = this->expireAfter;
     doc.shrinkToFit();
 

src/OpenThermTask.h

@@ -93,8 +93,13 @@ protected:
     this->instance->setAfterSendRequestCallback([this](unsigned long request, unsigned long response, OpenThermResponseStatus status, byte attempt) {
       Log.sverboseln(
         FPSTR(L_OT),
-        F("ID: %4d   Request: %8lx   Response: %8lx   Attempt: %2d   Status: %s"),
+        F("ID: %4d   Request: %8lx   Response: %8lx   Msg type: %s   Attempt: %2d   Status: %s"),
-        CustomOpenTherm::getDataID(request), request, response, attempt, CustomOpenTherm::statusToString(status)
+        CustomOpenTherm::getDataID(request),
+        request,
+        response,
+        CustomOpenTherm::getResponseMessageTypeString(response),
+        attempt,
+        CustomOpenTherm::statusToString(status)
       );
 
       if (status == OpenThermResponseStatus::SUCCESS) {
@@ -138,7 +143,12 @@ protected:
       return;
 
     } else if (this->instance->status == OpenThermStatus::NOT_INITIALIZED) {
-      this->instance->begin();
+      if (!this->instance->begin()) {
+        Log.swarningln(FPSTR(L_OT), F("Failed begin"));
+
+        this->delay(5000);
+        return;
+      }
     }
 
     // RX LED GPIO setup
@@ -212,6 +222,20 @@ protected:
         F("Failed receive boiler status: %s"),
         CustomOpenTherm::statusToString(this->instance->getLastResponseStatus())
       );
+      
+    } else {
+      vars.slave.heating.active = CustomOpenTherm::isCentralHeatingActive(response);
+      vars.slave.dhw.active = settings.opentherm.options.dhwSupport ? CustomOpenTherm::isHotWaterActive(response) : false;
+      vars.slave.flame = CustomOpenTherm::isFlameOn(response);
+      vars.slave.cooling = CustomOpenTherm::isCoolingActive(response);
+      vars.slave.fault.active = CustomOpenTherm::isFault(response);
+      vars.slave.diag.active = CustomOpenTherm::isDiagnostic(response);
+  
+      Log.snoticeln(
+        FPSTR(L_OT), F("Received boiler status. Heating: %hhu; DHW: %hhu; flame: %hhu; cooling: %hhu; fault: %hhu; diag: %hhu"),
+        vars.slave.heating.active, vars.slave.dhw.active,
+        vars.slave.flame, vars.slave.cooling, vars.slave.fault.active, vars.slave.diag.active
+      );
     }
 
     // 5 request retries
@@ -310,19 +334,6 @@ protected:
       Log.sinfoln(FPSTR(L_OT_DHW), vars.master.dhw.enabled ? F("Enabled") : F("Disabled"));
     }
 
-    vars.slave.heating.active = CustomOpenTherm::isCentralHeatingActive(response);
-    vars.slave.dhw.active = settings.opentherm.options.dhwSupport ? CustomOpenTherm::isHotWaterActive(response) : false;
-    vars.slave.flame = CustomOpenTherm::isFlameOn(response);
-    vars.slave.cooling = CustomOpenTherm::isCoolingActive(response);
-    vars.slave.fault.active = CustomOpenTherm::isFault(response);
-    vars.slave.diag.active = CustomOpenTherm::isDiagnostic(response);
-
-    Log.snoticeln(
-      FPSTR(L_OT), F("Received boiler status. Heating: %hhu; DHW: %hhu; flame: %hhu; cooling: %hhu; fault: %hhu; diag: %hhu"),
-      vars.slave.heating.active, vars.slave.dhw.active,
-      vars.slave.flame, vars.slave.cooling, vars.slave.fault.active, vars.slave.diag.active
-    );
-
     // These parameters will be updated every minute
     if (millis() - this->prevUpdateNonEssentialVars > 60000) {
       if (this->updateMinModulationLevel()) {
@@ -1179,17 +1190,17 @@ protected:
 
   bool needSetDhwTemp(const float target) {
     return millis() - this->dhwSetTempTime > this->dhwSetTempInterval
-      || fabsf(target - vars.slave.dhw.targetTemp) > 0.001f;
+      || fabsf(target - vars.slave.dhw.targetTemp) > 0.05f;
   }
 
   bool needSetHeatingTemp(const float target) {
     return millis() - this->heatingSetTempTime > this->heatingSetTempInterval
-      || fabsf(target - vars.slave.heating.targetTemp) > 0.001f;
+      || fabsf(target - vars.slave.heating.targetTemp) > 0.05f;
   }
 
   bool needSetCh2Temp(const float target) {
     return millis() - this->ch2SetTempTime > this->ch2SetTempInterval
-      || fabsf(target - vars.slave.ch2.targetTemp) > 0.001f;
+      || fabsf(target - vars.slave.ch2.targetTemp) > 0.05f;
   }
 
   bool updateSlaveConfig() {
@@ -1350,7 +1361,7 @@ protected:
     return CustomOpenTherm::getUInt(response) == request;
   }
 
-  bool setMaxHeatingTemp(const uint8_t temperature) {
+  bool setMaxHeatingTemp(const float temperature) {
     const unsigned int request = CustomOpenTherm::temperatureToData(temperature);
     const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
       OpenThermMessageType::WRITE_DATA,

src/SensorsTask.h

@@ -496,9 +496,8 @@ protected:
         }
       }
 
-      if (!rSensor.connected) {
+      // Mark connected
-        rSensor.connected = true;
+      Sensors::setConnectionStatusById(sensorId, true, true);
-      }
 
       if (!this->bleLastSetDtTime[sensorId] || millis() - this->bleLastSetDtTime[sensorId] > this->bleSetDtInterval) {
         struct tm ti;
@@ -521,7 +520,6 @@ protected:
 
           this->bleLastSetDtTime[sensorId] = millis();
         }
-        
       }
     }
   }
@@ -981,16 +979,16 @@ protected:
       auto& rSensor = Sensors::results[sensorId];
 
       if (rSensor.connected && !sSensor.enabled) {
-        rSensor.connected = false;
+        Sensors::setConnectionStatusById(sensorId, false, false);
 
       } else if (rSensor.connected && sSensor.type == Sensors::Type::NOT_CONFIGURED) {
-        rSensor.connected = false;
+        Sensors::setConnectionStatusById(sensorId, false, false);
 
       } else if (rSensor.connected && sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
-        rSensor.connected = false;
+        Sensors::setConnectionStatusById(sensorId, false, false);
 
       } else if (sSensor.type != Sensors::Type::MANUAL && rSensor.connected && (millis() - rSensor.activityTime) > this->disconnectedTimeout) {
-        rSensor.connected = false;
+        Sensors::setConnectionStatusById(sensorId, false, false);
 
       }/* else if (!rSensor.connected) {
         rSensor.connected = true;

src_data/pages/dashboard.html

@@ -41,14 +41,18 @@
           <details open>
             <summary><b data-i18n>dashboard.section.control</b></summary>
             <div class="grid">
-              <div class="thermostat" id="thermostat-heating">
+              <div class="thermostat tHeat" data-purpose="heating" data-min="0" data-max="100" data-step="0.1" data-big-step="1">
                 <div class="thermostat-header" data-i18n>dashboard.thermostat.heating</div>
                 <div class="thermostat-temp">
-                  <div class="thermostat-temp-target"><span id="tHeatTargetTemp"></span> <span class="tempUnit"></span></div>
+                  <div class="thermostat-temp-target"><span class="targetTemp"></span> <span class="tempUnit"></span></div>
                   <div class="thermostat-temp-current"><span data-i18n>dashboard.thermostat.temp.current</span>: <span id="tHeatCurrentTemp"></span> <span class="tempUnit"></span></div>
                 </div>
-                <div class="thermostat-minus"><button id="tHeatActionMinus" class="outline"><i class="icons-down"></i></button></div>
+                <div class="thermostat-minus">
-                <div class="thermostat-plus"><button id="tHeatActionPlus" class="outline"><i class="icons-up"></i></button></div>
+                  <button class="tAction outline" data-action="decrement"><i class="icons-down"></i></button>
+                </div>
+                <div class="thermostat-plus">
+                  <button class="tAction outline" data-action="increment"><i class="icons-up"></i></button>
+                </div>
                 <div class="thermostat-control">
                   <input type="checkbox" role="switch" id="tHeatEnabled" value="true">
                   <label htmlFor="tHeatEnabled" data-i18n>dashboard.thermostat.enable</label>
@@ -58,14 +62,18 @@
                 </div>
               </div>
 
-              <div class="thermostat" id="thermostat-dhw">
+              <div class="thermostat tDhw" data-purpose="dhw" data-min="0" data-max="100" data-step="1" data-big-step="5">
                 <div class="thermostat-header" data-i18n>dashboard.thermostat.dhw</div>
                 <div class="thermostat-temp">
-                  <div class="thermostat-temp-target"><span id="tDhwTargetTemp"></span> <span class="tempUnit"></span></div>
+                  <div class="thermostat-temp-target"><span class="targetTemp"></span> <span class="tempUnit"></span></div>
                   <div class="thermostat-temp-current"><span data-i18n>dashboard.thermostat.temp.current</span>: <span id="tDhwCurrentTemp"></span> <span class="tempUnit"></span></div>
                 </div>
-                <div class="thermostat-minus"><button class="outline" id="tDhwActionMinus"><i class="icons-down"></i></button></div>
+                <div class="thermostat-minus">
-                <div class="thermostat-plus"><button class="outline" id="tDhwActionPlus"><i class="icons-up"></i></button></div>
+                  <button class="tAction outline" data-action="decrement"><i class="icons-down"></i></button>
+                </div>
+                <div class="thermostat-plus">
+                  <button class="tAction outline" data-action="increment"><i class="icons-up"></i></button>
+                </div>
                 <div class="thermostat-control">
                   <input type="checkbox" role="switch" id="tDhwEnabled" value="true">
                   <label htmlFor="tDhwEnabled" data-i18n>dashboard.thermostat.enable</label>
@@ -282,7 +290,6 @@
     <script src="/static/app.js?{BUILD_TIME}"></script>
     <script>
       let modifiedTime = null;
-      let noRegulators;
       let prevSettings;
       let newSettings = {
         heating: {
@@ -300,78 +307,69 @@
         const lang = new Lang(document.getElementById('lang'));
         lang.build();
 
-        document.querySelector('#tHeatActionMinus').addEventListener('click', (event) => {
+        let actionTimer = null;
-          if (!prevSettings) {
+        let actionLongPress = false;
-            return;
+        document.querySelectorAll('.tAction').forEach((item) => {
+          const action = item.dataset.action;
+          const tContainer = item.parentNode.parentNode;
+
+          for (const eName of ['pointerup', 'pointercancel']) {
+            item.addEventListener(eName, (event) => {
+              clearInterval(actionTimer);
+
+              const purpose = tContainer.dataset.purpose;
+              const minTemp = parseFloat(tContainer.dataset.min);
+              const maxTemp = parseFloat(tContainer.dataset.max);
+              const step = parseFloat(tContainer.dataset.step);
+              const bigStep = parseFloat(tContainer.dataset.bigStep);
+
+              if (!actionLongPress && prevSettings) {
+                let value = 0;
+                if (action == 'increment') {
+                  value = step;
+
+                } else if (action == 'decrement') {
+                  value = -(step);
+                }
+
+                newSettings[purpose].target = parseFloat(constrain(newSettings[purpose].target + value, minTemp, maxTemp).toFixed(2));
+                modifiedTime = Date.now();
+                setValue('.targetTemp', newSettings[purpose].target, tContainer);
+              }
+            });
           }
 
-          newSettings.heating.target -= 0.5;
+          item.addEventListener('pointerdown', (event) => {
-          modifiedTime = Date.now();
+            if (!prevSettings) {
+              return;
+            }
 
-          let minTemp;
+            const purpose = tContainer.dataset.purpose;
-          if (noRegulators) {
+            const minTemp = parseFloat(tContainer.dataset.min);
-            minTemp = prevSettings.heating.minTemp;
+            const maxTemp = parseFloat(tContainer.dataset.max);
-          } else {
+            const step = parseFloat(tContainer.dataset.step);
-            minTemp = prevSettings.system.unitSystem == 0 ? 5 : 41;
+            const bigStep = parseFloat(tContainer.dataset.bigStep);
-          }
 
-          if (prevSettings && newSettings.heating.target < minTemp) {
+            actionLongPress = false;
-            newSettings.heating.target = minTemp;
+            actionTimer = setInterval(() => {
-          }
+              if (!actionLongPress) {
+                actionLongPress = true;
+              }
 
-          setValue('#tHeatTargetTemp', newSettings.heating.target);
+              let value = 0;
-        });
+              if (action == 'increment') {
+                value = bigStep;
 
-        document.querySelector('#tHeatActionPlus').addEventListener('click', (event) => {
+              } else if (action == 'decrement') {
-          if (!prevSettings) {
+                value = -(bigStep);
-            return;
+              }
-          }
 
-          newSettings.heating.target += 0.5;
+              newSettings[purpose].target = parseFloat(constrain(newSettings[purpose].target + value, minTemp, maxTemp).toFixed(2));
-          modifiedTime = Date.now();
+              modifiedTime = Date.now();
 
-          let maxTemp;
+              setValue('.targetTemp', newSettings[purpose].target, tContainer);
-          if (noRegulators) {
+            }, 500);
-            maxTemp = prevSettings.heating.maxTemp;
+          });
-          } else {
-            maxTemp = prevSettings.system.unitSystem == 0 ? 30 : 86;
-          }
-
-          if (prevSettings && newSettings.heating.target > maxTemp) {
-            newSettings.heating.target = maxTemp;
-          }
-
-          setValue('#tHeatTargetTemp', newSettings.heating.target);
-        });
-
-        document.querySelector('#tDhwActionMinus').addEventListener('click', (event) => {
-          if (!prevSettings) {
-            return;
-          }
-
-          newSettings.dhw.target -= 1.0;
-          modifiedTime = Date.now();
-
-          if (newSettings.dhw.target < prevSettings.dhw.minTemp) {
-            newSettings.dhw.target = prevSettings.dhw.minTemp;
-          }
-
-          setValue('#tDhwTargetTemp', newSettings.dhw.target);
-        });
-
-        document.querySelector('#tDhwActionPlus').addEventListener('click', (event) => {
-          if (!prevSettings) {
-            return;
-          }
-
-          newSettings.dhw.target += 1.0;
-          modifiedTime = Date.now();
-
-          if (newSettings.dhw.target > prevSettings.dhw.maxTemp) {
-            newSettings.dhw.target = prevSettings.dhw.maxTemp;
-          }
-
-          setValue('#tDhwTargetTemp', newSettings.dhw.target);
         });
 
         document.querySelector('#tHeatEnabled').addEventListener('change', (event) => {
@@ -486,7 +484,6 @@
             }
 
             const result = await response.json();
-            noRegulators = !result.opentherm.options.nativeHeatingControl && !result.equitherm.enabled && !result.pid.enabled;
             prevSettings = result;
             unitSystem = result.system.unitSystem;
             newSettings.heating.enabled = result.heating.enabled;
@@ -496,17 +493,17 @@
             newSettings.dhw.target = result.dhw.target;
 
             if (result.opentherm.options.dhwSupport) {
-              show('#thermostat-dhw');
+              show('.tDhw');
             } else {
-              hide('#thermostat-dhw');
+              hide('.tDhw');
             }
 
             setCheckboxValue('#tHeatEnabled', result.heating.enabled);
             setCheckboxValue('#tHeatTurbo', result.heating.turbo);
-            setValue('#tHeatTargetTemp', result.heating.target);
+            setValue('.tHeat .targetTemp', result.heating.target);
 
             setCheckboxValue('#tDhwEnabled', result.dhw.enabled);
-            setValue('#tDhwTargetTemp', result.dhw.target);
+            setValue('.tDhw .targetTemp', result.dhw.target);
 
             setValue('.tempUnit', temperatureUnit(unitSystem));
             setValue('.pressureUnit', pressureUnit(unitSystem));
@@ -646,6 +643,14 @@
             setState('.mCascadeControlInput', result.master.cascadeControl.input);
             setState('.mCascadeControlOutput', result.master.cascadeControl.output);
 
+            const tHeat = document.querySelector('.tHeat');
+            tHeat.dataset.min = result.master.heating.minTemp;
+            tHeat.dataset.max = result.master.heating.maxTemp;
+
+            const tDhw = document.querySelector('.tDhw');
+            tDhw.dataset.min = result.master.dhw.minTemp;
+            tDhw.dataset.max = result.master.dhw.maxTemp;
+
             setBusy('#dashboard-busy', '#dashboard-container', false);
 
           } catch (error) {

src_data/scripts/utils.js

@@ -850,3 +850,7 @@ function dec2hex(i) {
   
   return hex.toUpperCase();
 }
+
+function constrain(amt, low, high) {
+  return ((amt) < (low) ? (low) : ((amt) > (high) ? (high) : (amt)));
+}