fix: change of log level when wifi is not connected

platformio.ini

@@ -37,7 +37,7 @@ build_flags =
 	-D BUILD_ENV='"$PIOENV"'
 	-D USE_SERIAL=${secrets.use_serial}
 	-D USE_TELNET=${secrets.use_telnet}
-	-D DEBUG_BY_DEFAULT=${secrets.debug}
+	-D DEFAULT_LOG_LEVEL=${secrets.log_level}
 	-D DEFAULT_HOSTNAME='"${secrets.hostname}"'
 	-D DEFAULT_AP_SSID='"${secrets.ap_ssid}"'
 	-D DEFAULT_AP_PASSWORD='"${secrets.ap_password}"'

secrets.default.ini

@@ -1,7 +1,7 @@
 [secrets]
 use_serial = true
 use_telnet = true
-debug = true
+log_level = 5
 hostname = opentherm
 
 ap_ssid = OpenTherm Gateway

src/HaHelper.h

@@ -266,30 +266,6 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_max_temp")).c_str(), doc);
   }
 
-  bool publishNumberHeatingMaxModulation(bool enabledByDefault = true) {
-    JsonDocument doc;
-    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("heating_max_modulation"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_max_modulation"));
-    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
-    doc[FPSTR(HA_DEVICE_CLASS)] = F("power_factor");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("%");
-    doc[FPSTR(HA_NAME)] = F("Max modulation");
-    doc[FPSTR(HA_ICON)] = F("mdi:speedometer");
-    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.heating.maxModulation|int(1) }}");
-    doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
-    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"heating\": {\"maxModulation\" : {{ value }}}}");
-    doc[FPSTR(HA_MIN)] = 1;
-    doc[FPSTR(HA_MAX)] = 100;
-    doc[FPSTR(HA_STEP)] = 1;
-    doc[FPSTR(HA_MODE)] = "box";
-    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
-    doc.shrinkToFit();
-
-    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_max_modulation")).c_str(), doc);
-  }
-
 
   bool publishSwitchDhw(bool enabledByDefault = true) {
     JsonDocument doc;
@@ -872,6 +848,29 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("diagnostic")).c_str(), doc);
   }
 
+  bool publishSensorPower(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'online', 'offline') }}");
+    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("power"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("power"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("power");
+    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("kW");
+    doc[FPSTR(HA_NAME)] = F("Current power");
+    doc[FPSTR(HA_ICON)] = F("mdi:chart-bar");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.power|float(0)|round(2) }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("power")).c_str(), doc);
+  }
+
   bool publishSensorFaultCode(bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));

src/MainTask.h

@@ -86,6 +86,12 @@ protected:
     vars.states.mqtt = tMqtt->isConnected();
     vars.sensors.rssi = network->isConnected() ? WiFi.RSSI() : 0;
 
+    if (settings.system.logLevel >= TinyLogger::Level::SILENT && settings.system.logLevel <= TinyLogger::Level::VERBOSE) {
+      if (Log.getLevel() != settings.system.logLevel) {
+        Log.setLevel(static_cast<TinyLogger::Level>(settings.system.logLevel));
+      }
+    }
+
     if (network->isConnected()) {
       if (!this->telnetStarted && telnetStream != nullptr) {
         telnetStream->begin(23, false);
@@ -99,13 +105,6 @@ protected:
         tMqtt->disable();
       }
 
-      if ( Log.getLevel() != TinyLogger::Level::INFO && !settings.system.debug ) {
-        Log.setLevel(TinyLogger::Level::INFO);
-
-      } else if ( Log.getLevel() != TinyLogger::Level::VERBOSE && settings.system.debug ) {
-        Log.setLevel(TinyLogger::Level::VERBOSE);
-      }
-
     } else {
       if (this->telnetStarted) {
         telnetStream->stop();
@@ -120,6 +119,7 @@ protected:
 
     this->emergency();
     this->ledStatus();
+    this->cascadeControl();
     this->externalPump();
     this->yield();
 
@@ -160,7 +160,7 @@ protected:
       this->restartSignalTime = millis();
     }
 
-    if (!settings.system.debug) {
+    if (settings.system.logLevel < TinyLogger::Level::VERBOSE) {
       return;
     }
 
@@ -337,6 +337,170 @@ protected:
     this->blinker->tick();
   }
 
+  void cascadeControl() {
+    static uint8_t configuredInputGpio = GPIO_IS_NOT_CONFIGURED;
+    static uint8_t configuredOutputGpio = GPIO_IS_NOT_CONFIGURED;
+    static bool inputTempValue = false;
+    static unsigned long inputChangedTs = 0;
+    static bool outputTempValue = false;
+    static unsigned long outputChangedTs = 0;
+
+    // input
+    if (settings.cascadeControl.input.enable) {
+      if (settings.cascadeControl.input.gpio != configuredInputGpio) {
+        if (configuredInputGpio != GPIO_IS_NOT_CONFIGURED) {
+          pinMode(configuredInputGpio, OUTPUT);
+          digitalWrite(configuredInputGpio, LOW);
+
+          Log.sinfoln(FPSTR(L_CASCADE_INPUT), F("Deinitialized on GPIO %hhu"), configuredInputGpio);
+        }
+        
+        if (GPIO_IS_VALID(settings.cascadeControl.input.gpio)) {
+          configuredInputGpio = settings.cascadeControl.input.gpio;
+          pinMode(configuredInputGpio, INPUT);
+
+          Log.sinfoln(FPSTR(L_CASCADE_INPUT), F("Initialized on GPIO %hhu"), configuredInputGpio);
+
+        } else if (configuredInputGpio != GPIO_IS_NOT_CONFIGURED) {
+          configuredInputGpio = GPIO_IS_NOT_CONFIGURED;
+
+          Log.swarningln(FPSTR(L_CASCADE_INPUT), F("Failed initialize: GPIO %hhu is not valid!"), configuredInputGpio);
+        }
+      }
+
+      if (configuredInputGpio != GPIO_IS_NOT_CONFIGURED) {
+        bool value;
+        if (digitalRead(configuredInputGpio) == HIGH) {
+          value = true ^ settings.cascadeControl.input.invertState;
+        } else {
+          value = false ^ settings.cascadeControl.input.invertState;
+        }
+
+        if (value != vars.cascadeControl.input) {
+          if (value != inputTempValue) {
+            inputTempValue = value;
+            inputChangedTs = millis();
+
+          } else if (millis() - inputChangedTs >= settings.cascadeControl.input.thresholdTime * 1000u) {
+            vars.cascadeControl.input = value;
+
+            Log.sinfoln(
+              FPSTR(L_CASCADE_INPUT),
+              F("State changed to %s"),
+              value ? F("TRUE") : F("FALSE")
+            );
+          }
+
+        } else if (value != inputTempValue) {
+          inputTempValue = value;
+        }
+      }
+    }
+    
+    if (!settings.cascadeControl.input.enable || configuredInputGpio == GPIO_IS_NOT_CONFIGURED) {
+      if (!vars.cascadeControl.input) {
+        vars.cascadeControl.input = true;
+
+        Log.sinfoln(
+          FPSTR(L_CASCADE_INPUT),
+          F("Disabled, state changed to %s"),
+          vars.cascadeControl.input ? F("TRUE") : F("FALSE")
+        );
+      }
+    }
+
+
+    // output
+    if (settings.cascadeControl.output.enable) {
+      if (settings.cascadeControl.output.gpio != configuredOutputGpio) {
+        if (configuredOutputGpio != GPIO_IS_NOT_CONFIGURED) {
+          pinMode(configuredOutputGpio, OUTPUT);
+          digitalWrite(configuredOutputGpio, LOW);
+
+          Log.sinfoln(FPSTR(L_CASCADE_OUTPUT), F("Deinitialized on GPIO %hhu"), configuredOutputGpio);
+        }
+        
+        if (GPIO_IS_VALID(settings.cascadeControl.output.gpio)) {
+          configuredOutputGpio = settings.cascadeControl.output.gpio;
+          pinMode(configuredOutputGpio, OUTPUT);
+          digitalWrite(
+            configuredOutputGpio,
+            settings.cascadeControl.output.invertState
+              ? HIGH 
+              : LOW
+          );
+
+          Log.sinfoln(FPSTR(L_CASCADE_OUTPUT), F("Initialized on GPIO %hhu"), configuredOutputGpio);
+
+        } else if (configuredOutputGpio != GPIO_IS_NOT_CONFIGURED) {
+          configuredOutputGpio = GPIO_IS_NOT_CONFIGURED;
+
+          Log.swarningln(FPSTR(L_CASCADE_OUTPUT), F("Failed initialize: GPIO %hhu is not valid!"), configuredOutputGpio);
+        }
+      }
+
+      if (configuredOutputGpio != GPIO_IS_NOT_CONFIGURED) {
+        bool value = false;
+        if (settings.cascadeControl.output.onFault && vars.states.fault) {
+          value = true;
+
+        } else if (settings.cascadeControl.output.onLossConnection && !vars.states.otStatus) {
+          value = true;
+
+        } else if (settings.cascadeControl.output.onEnabledHeating && settings.heating.enable && vars.cascadeControl.input) {
+          value = true;
+        }
+
+        if (value != vars.cascadeControl.output) {
+          if (value != outputTempValue) {
+            outputTempValue = value;
+            outputChangedTs = millis();
+            
+          } else if (millis() - outputChangedTs >= settings.cascadeControl.output.thresholdTime * 1000u) {
+            vars.cascadeControl.output = value;
+
+            digitalWrite(
+              configuredOutputGpio,
+              vars.cascadeControl.output ^ settings.cascadeControl.output.invertState
+                ? HIGH
+                : LOW
+            );
+
+            Log.sinfoln(
+              FPSTR(L_CASCADE_OUTPUT),
+              F("State changed to %s"),
+              value ? F("TRUE") : F("FALSE")
+            );
+          }
+
+        } else if (value != outputTempValue) {
+          outputTempValue = value;
+        }
+      }
+    }
+
+    if (!settings.cascadeControl.output.enable || configuredOutputGpio == GPIO_IS_NOT_CONFIGURED) {
+      if (vars.cascadeControl.output) {
+        vars.cascadeControl.output = false;
+
+        if (configuredOutputGpio != GPIO_IS_NOT_CONFIGURED) {
+          digitalWrite(
+            configuredOutputGpio,
+            vars.cascadeControl.output ^ settings.cascadeControl.output.invertState
+              ? HIGH
+              : LOW
+          );
+        }
+
+        Log.sinfoln(
+          FPSTR(L_CASCADE_OUTPUT),
+          F("Disabled, state changed to %s"),
+          vars.cascadeControl.output ? F("TRUE") : F("FALSE")
+        );
+      }
+    }
+  }
+
   void externalPump() {
     static uint8_t configuredGpio = GPIO_IS_NOT_CONFIGURED;
 

src/MqttTask.h

@@ -270,7 +270,7 @@ protected:
       return;
     }
 
-    if (settings.system.debug) {
+    if (settings.system.logLevel >= TinyLogger::Level::TRACE) {
       Log.strace(FPSTR(L_MQTT_MSG), F("Topic: %s\r\n>  "), topic);
       if (Log.lock()) {
         for (size_t i = 0; i < length; i++) {
@@ -329,7 +329,6 @@ protected:
     this->haHelper->publishSensorBoilerHeatingMaxTemp(settings.system.unitSystem, false);
     this->haHelper->publishNumberHeatingMinTemp(settings.system.unitSystem, false);
     this->haHelper->publishNumberHeatingMaxTemp(settings.system.unitSystem, false);
-    this->haHelper->publishNumberHeatingMaxModulation(false);
 
     // pid
     this->haHelper->publishSwitchPid();
@@ -357,6 +356,7 @@ protected:
     // sensors
     this->haHelper->publishSensorModulation(false);
     this->haHelper->publishSensorPressure(settings.system.unitSystem, false);
+    this->haHelper->publishSensorPower();
     this->haHelper->publishSensorFaultCode();
     this->haHelper->publishSensorDiagnosticCode();
     this->haHelper->publishSensorRssi(false);

src/OpenThermTask.h

@@ -28,8 +28,6 @@ protected:
   unsigned long dhwSetTempTime = 0;
   unsigned long heatingSetTempTime = 0;
   byte configuredRxLedGpio = GPIO_IS_NOT_CONFIGURED;
-  byte configuredFaultStateGpio = GPIO_IS_NOT_CONFIGURED;
-  bool faultState = false;
 
   #if defined(ARDUINO_ARCH_ESP32)
   const char* getTaskName() override {
@@ -133,28 +131,7 @@ protected:
       }
     }
 
-    // Fault state setup
-    if (settings.opentherm.faultStateGpio != this->configuredFaultStateGpio) {
-      if (this->configuredFaultStateGpio != GPIO_IS_NOT_CONFIGURED) {
-        digitalWrite(this->configuredFaultStateGpio, LOW);
-      }
-      
-      if (GPIO_IS_VALID(settings.opentherm.faultStateGpio)) {
-        this->configuredFaultStateGpio = settings.opentherm.faultStateGpio;
-        this->faultState = false ^ settings.opentherm.invertFaultState ? HIGH : LOW;
-
-        pinMode(this->configuredFaultStateGpio, OUTPUT);
-        digitalWrite(
-          this->configuredFaultStateGpio,
-          this->faultState
-        );
-
-      } else if (this->configuredFaultStateGpio != GPIO_IS_NOT_CONFIGURED) {
-        this->configuredFaultStateGpio = GPIO_IS_NOT_CONFIGURED;
-      }
-    }
-
-    bool heatingEnabled = (vars.states.emergency || settings.heating.enable) && this->pump && this->isReady();
+    bool heatingEnabled = (vars.states.emergency || settings.heating.enable) && this->pump && vars.cascadeControl.input && this->isReady();
     bool heatingCh2Enabled = settings.opentherm.heatingCh2Enabled;
     if (settings.opentherm.heatingCh1ToCh2) {
       heatingCh2Enabled = heatingEnabled;
@@ -185,7 +162,11 @@ protected:
     );
 
     if (!CustomOpenTherm::isValidResponse(response)) {
-      Log.swarningln(FPSTR(L_OT), F("Invalid response after setBoilerStatus: %s"), CustomOpenTherm::statusToString(this->instance->getLastResponseStatus()));
+      Log.swarningln(
+        FPSTR(L_OT),
+        F("Failed receive boiler status: %s"),
+        CustomOpenTherm::statusToString(this->instance->getLastResponseStatus())
+      );
     }
 
     if (!vars.states.otStatus && millis() - this->lastSuccessResponse < 1150) {
@@ -208,16 +189,6 @@ protected:
       vars.states.fault = false;
       vars.states.diagnostic = false;
 
-      // Force fault state = on
-      if (this->configuredFaultStateGpio != GPIO_IS_NOT_CONFIGURED) {
-        bool fState = true ^ settings.opentherm.invertFaultState ? HIGH : LOW;
-
-        if (fState != this->faultState) {
-          this->faultState = fState;
-          digitalWrite(this->configuredFaultStateGpio, this->faultState);
-        }
-      }
-
       return;
     }
 
@@ -241,32 +212,52 @@ protected:
     vars.states.fault = CustomOpenTherm::isFault(response);
     vars.states.diagnostic = CustomOpenTherm::isDiagnostic(response);
 
-    // Fault state
-    if (this->configuredFaultStateGpio != GPIO_IS_NOT_CONFIGURED) {
-      bool fState = vars.states.fault ^ settings.opentherm.invertFaultState ? HIGH : LOW;
-      
-      if (fState != this->faultState) {
-        this->faultState = fState;
-        digitalWrite(this->configuredFaultStateGpio, this->faultState);
-      }
-    }
+    Log.snoticeln(
+      FPSTR(L_OT),
+      F("Received boiler status. Heating: %hhu; DHW: %hhu; flame: %hhu; fault: %hhu; diag: %hhu"),
+      vars.states.heating, vars.states.dhw, vars.states.flame, vars.states.fault, vars.states.diagnostic
+    );
 
     // These parameters will be updated every minute
     if (millis() - this->prevUpdateNonEssentialVars > 60000) {
-      if (!heatingEnabled && settings.opentherm.modulationSyncWithHeating) {
-        if (this->setMaxModulationLevel(0)) {
-          Log.snoticeln(FPSTR(L_OT_HEATING), F("Set max modulation 0% (off)"));
+      if (this->updateMinModulationLevel()) {
+        Log.snoticeln(
+          FPSTR(L_OT),
+          F("Received min modulation: %hhu%%, max power: %hhu kW"),
+          vars.parameters.minModulation,
+          vars.parameters.maxPower
+        );
+        
+        if (settings.opentherm.maxModulation < vars.parameters.minModulation) {
+          settings.opentherm.maxModulation = vars.parameters.minModulation;
+          fsSettings.update();
+          Log.swarningln(FPSTR(L_SETTINGS_OT), F("Updated min modulation: %hhu%%"), settings.opentherm.maxModulation);
+        }
 
-        } else {
-          Log.swarningln(FPSTR(L_OT_HEATING), F("Failed set max modulation 0% (off)"));
+        if (fabsf(settings.opentherm.maxPower) < 0.1f && vars.parameters.maxPower > 0) {
+          settings.opentherm.maxPower = vars.parameters.maxPower;
+          fsSettings.update();
+          Log.swarningln(FPSTR(L_SETTINGS_OT), F("Updated max power: %.2f kW"), settings.opentherm.maxPower);
         }
 
       } else {
-        if (this->setMaxModulationLevel(settings.heating.maxModulation)) {
-          Log.snoticeln(FPSTR(L_OT_HEATING), F("Set max modulation %hhu%%"), settings.heating.maxModulation);
+        Log.swarningln(FPSTR(L_OT), F("Failed receive min modulation and max power"));
+      }
+
+      if (!heatingEnabled && settings.opentherm.modulationSyncWithHeating) {
+        if (this->setMaxModulationLevel(0)) {
+          Log.snoticeln(FPSTR(L_OT), F("Set max modulation: 0% (off)"));
 
         } else {
-          Log.swarningln(FPSTR(L_OT_HEATING), F("Failed set max modulation %hhu%%"), settings.heating.maxModulation);
+          Log.swarningln(FPSTR(L_OT), F("Failed set max modulation: 0% (off)"));
+        }
+
+      } else {
+        if (this->setMaxModulationLevel(settings.opentherm.maxModulation)) {
+          Log.snoticeln(FPSTR(L_OT), F("Set max modulation: %hhu%%"), settings.opentherm.maxModulation);
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed set max modulation: %hhu%%"), settings.opentherm.maxModulation);
         }
       }
 
@@ -274,23 +265,30 @@ protected:
       // Get DHW min/max temp (if necessary)
       if (settings.opentherm.dhwPresent && settings.opentherm.getMinMaxTemp) {
         if (this->updateMinMaxDhwTemp()) {
+          Log.snoticeln(
+            FPSTR(L_OT_DHW),
+            F("Received min temp: %hhu, max temp: %hhu"),
+            vars.parameters.dhwMinTemp,
+            vars.parameters.dhwMaxTemp
+          );
+
           if (settings.dhw.minTemp < vars.parameters.dhwMinTemp) {
             settings.dhw.minTemp = vars.parameters.dhwMinTemp;
             fsSettings.update();
-            Log.snoticeln(FPSTR(L_OT_DHW), F("Updated min temp: %hhu"), settings.dhw.minTemp);
+            Log.swarningln(FPSTR(L_SETTINGS_DHW), F("Updated min temp: %hhu"), settings.dhw.minTemp);
           }
 
           if (settings.dhw.maxTemp > vars.parameters.dhwMaxTemp) {
             settings.dhw.maxTemp = vars.parameters.dhwMaxTemp;
             fsSettings.update();
-            Log.snoticeln(FPSTR(L_OT_DHW), F("Updated max temp: %hhu"), settings.dhw.maxTemp);
+            Log.swarningln(FPSTR(L_SETTINGS_DHW), F("Updated max temp: %hhu"), settings.dhw.maxTemp);
           }
 
         } else {
           vars.parameters.dhwMinTemp = convertTemp(DEFAULT_DHW_MIN_TEMP, UnitSystem::METRIC, settings.system.unitSystem);
           vars.parameters.dhwMaxTemp = convertTemp(DEFAULT_DHW_MAX_TEMP, UnitSystem::METRIC, settings.system.unitSystem);
 
-          Log.swarningln(FPSTR(L_OT_DHW), F("Failed get min/max temp"));
+          Log.swarningln(FPSTR(L_OT_DHW), F("Failed receive min/max temp"));
         }
 
         if (settings.dhw.minTemp >= settings.dhw.maxTemp) {
@@ -304,23 +302,30 @@ protected:
       // Get heating min/max temp
       if (settings.opentherm.getMinMaxTemp) {
         if (this->updateMinMaxHeatingTemp()) {
+          Log.snoticeln(
+            FPSTR(L_OT_HEATING),
+            F("Received min temp: %hhu, max temp: %hhu"),
+            vars.parameters.heatingMinTemp,
+            vars.parameters.heatingMaxTemp
+          );
+
           if (settings.heating.minTemp < vars.parameters.heatingMinTemp) {
             settings.heating.minTemp = vars.parameters.heatingMinTemp;
             fsSettings.update();
-            Log.snoticeln(FPSTR(L_OT_HEATING), F("Updated min temp: %hhu"), settings.heating.minTemp);
+            Log.swarningln(FPSTR(L_SETTINGS_HEATING), F("Updated min temp: %hhu"), settings.heating.minTemp);
           }
 
           if (settings.heating.maxTemp > vars.parameters.heatingMaxTemp) {
             settings.heating.maxTemp = vars.parameters.heatingMaxTemp;
             fsSettings.update();
-            Log.snoticeln(FPSTR(L_OT_HEATING), F("Updated max temp: %hhu"), settings.heating.maxTemp);
+            Log.swarningln(FPSTR(L_SETTINGS_HEATING), F("Updated max temp: %hhu"), settings.heating.maxTemp);
           }
           
         } else {
           vars.parameters.heatingMinTemp = convertTemp(DEFAULT_HEATING_MIN_TEMP, UnitSystem::METRIC, settings.system.unitSystem);
           vars.parameters.heatingMaxTemp = convertTemp(DEFAULT_HEATING_MAX_TEMP, UnitSystem::METRIC, settings.system.unitSystem);
 
-          Log.swarningln(FPSTR(L_OT_HEATING), F("Failed get min/max temp"));
+          Log.swarningln(FPSTR(L_OT_HEATING), F("Failed receive min/max temp"));
         }
       }
 
@@ -332,7 +337,19 @@ protected:
 
       // Get fault code (if necessary)
       if (vars.states.fault) {
-        this->updateFaultCode();
+        if (this->updateFaultCode()) {
+          Log.snoticeln(
+            FPSTR(L_OT),
+            F("Received fault code: %hhu%% (0x%02X)"),
+            vars.sensors.faultCode,
+            vars.sensors.faultCode
+          );
+
+        } else {
+          vars.sensors.faultCode = 0;
+
+          Log.swarningln(FPSTR(L_OT), F("Failed receive fault code"));
+        }
         
       } else if (vars.sensors.faultCode != 0) {
         vars.sensors.faultCode = 0;
@@ -340,7 +357,19 @@ protected:
 
       // Get diagnostic code (if necessary)
       if (vars.states.fault || vars.states.diagnostic) {
-        this->updateDiagCode();
+        if (this->updateDiagCode()) {
+          Log.snoticeln(
+            FPSTR(L_OT),
+            F("Received diag code: %hhu%% (0x%02X)"),
+            vars.sensors.diagnosticCode,
+            vars.sensors.diagnosticCode
+          );
+
+        } else {
+          vars.sensors.diagnosticCode = 0;
+
+          Log.swarningln(FPSTR(L_OT), F("Failed receive diag code"));
+        }
         
       } else if (vars.sensors.diagnosticCode != 0) {
         vars.sensors.diagnosticCode = 0;
@@ -351,11 +380,21 @@ protected:
       if (!settings.opentherm.filterNumValues.enable) {
         // Get outdoor temp (if necessary)
         if (settings.sensors.outdoor.type == SensorType::BOILER) {
-          this->updateOutdoorTemp();
+          if (this->updateOutdoorTemp()) {
+            Log.snoticeln(FPSTR(L_OT), F("Received outdoor temp: %.2f"), vars.temperatures.outdoor);
+
+          } else {
+            Log.swarningln(FPSTR(L_OT), F("Failed receive outdoor temp"));
+          }
         }
         
         // Get pressure
-        this->updatePressure();
+        if (this->updatePressure()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received pressure: %.2f"), vars.sensors.pressure);
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive pressure"));
+        }
       }
 
       this->prevUpdateNonEssentialVars = millis();
@@ -364,16 +403,51 @@ protected:
 
     // Get current modulation level (if necessary)
     if (vars.states.flame) {
-      this->updateModulationLevel();
+      if (this->updateModulationLevel()) {
+        if (settings.opentherm.maxPower > 0.1f) {
+          float modulatedPower = settings.opentherm.maxPower - settings.opentherm.minPower;
+          vars.sensors.power = settings.opentherm.minPower + (modulatedPower / 100.0f * vars.sensors.modulation);
+
+        } else {
+          vars.sensors.power = 0.0f;
+        }
+        
+        Log.snoticeln(
+          FPSTR(L_OT),
+          F("Received modulation level: %.2f%%, power: %.2f of %.2f kW (min: %.2f kW)"),
+          vars.sensors.modulation,
+          vars.sensors.power,
+          settings.opentherm.maxPower,
+          settings.opentherm.minPower
+        );
+
+      } else {
+        vars.sensors.modulation = 0;
+        vars.sensors.power = 0;
+
+        Log.swarningln(FPSTR(L_OT), F("Failed receive modulation level"));
+      }
 
     } else {
       vars.sensors.modulation = 0;
+      vars.sensors.power = 0;
     }
 
     // Update DHW sensors (if necessary)
     if (settings.opentherm.dhwPresent) {
-      this->updateDhwTemp();
-      this->updateDhwFlowRate();
+      if (this->updateDhwTemp()) {
+        Log.snoticeln(FPSTR(L_OT_DHW), F("Received temp: %.2f"), vars.temperatures.dhw);
+
+      } else {
+        Log.swarningln(FPSTR(L_OT_DHW), F("Failed receive temp"));
+      }
+
+      if (this->updateDhwFlowRate()) {
+        Log.snoticeln(FPSTR(L_OT_DHW), F("Received flow rate: %.2f"), vars.sensors.dhwFlowRate);
+
+      } else {
+        Log.swarningln(FPSTR(L_OT_DHW), F("Failed receive flow rate"));
+      }
 
     } else {
       vars.temperatures.dhw = 0.0f;
@@ -381,24 +455,49 @@ protected:
     }
 
     // Get current heating temp
-    this->updateHeatingTemp();
+    if (this->updateHeatingTemp()) {
+      Log.snoticeln(FPSTR(L_OT_HEATING), F("Received temp: %.2f"), vars.temperatures.heating);
+
+    } else {
+      Log.swarningln(FPSTR(L_OT_HEATING), F("Failed receive temp"));
+    }
 
     // Get heating return temp
-    this->updateHeatingReturnTemp();
+    if (this->updateHeatingReturnTemp()) {
+      Log.snoticeln(FPSTR(L_OT_HEATING), F("Received return temp: %.2f"), vars.temperatures.heatingReturn);
+
+    } else {
+      Log.swarningln(FPSTR(L_OT_HEATING), F("Failed receive return temp"));
+    }
 
     // Get exhaust temp
-    this->updateExhaustTemp();
+    if (this->updateExhaustTemp()) {
+      Log.snoticeln(FPSTR(L_OT), F("Received exhaust temp: %.2f"), vars.temperatures.exhaust);
+
+    } else {
+      Log.swarningln(FPSTR(L_OT), F("Failed receive exhaust temp"));
+    }
 
     // If filtering is enabled, these parameters
     // must be updated every time.
     if (settings.opentherm.filterNumValues.enable) {
       // Get outdoor temp (if necessary)
       if (settings.sensors.outdoor.type == SensorType::BOILER) {
-        this->updateOutdoorTemp();
+        if (this->updateOutdoorTemp()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received outdoor temp: %.2f"), vars.temperatures.outdoor);
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive outdoor temp"));
+        }
       }
       
       // Get pressure
-      this->updatePressure();
+      if (this->updatePressure()) {
+        Log.snoticeln(FPSTR(L_OT), F("Received pressure: %.2f"), vars.sensors.pressure);
+
+      } else {
+        Log.swarningln(FPSTR(L_OT), F("Failed receive pressure"));
+      }
     }
 
 
@@ -549,46 +648,46 @@ protected:
   void initialize() {
     // Not all boilers support these, only try once when the boiler becomes connected
     if (this->updateSlaveVersion()) {
-      Log.straceln(FPSTR(L_OT), F("Slave version: %u, type: %u"), vars.parameters.slaveVersion, vars.parameters.slaveType);
+      Log.snoticeln(FPSTR(L_OT), F("Received slave version: %u, type: %u"), vars.parameters.slaveVersion, vars.parameters.slaveType);
 
     } else {
-      Log.swarningln(FPSTR(L_OT), F("Get slave version failed"));
+      Log.swarningln(FPSTR(L_OT), F("Failed receive slave version"));
     }
 
     // 0x013F
     if (this->setMasterVersion(0x3F, 0x01)) {
-      Log.straceln(FPSTR(L_OT), F("Master version: %u, type: %u"), vars.parameters.masterVersion, vars.parameters.masterType);
+      Log.snoticeln(FPSTR(L_OT), F("Set master version: %u, type: %u"), vars.parameters.masterVersion, vars.parameters.masterType);
       
     } else {
-      Log.swarningln(FPSTR(L_OT), F("Set master version failed"));
+      Log.swarningln(FPSTR(L_OT), F("Failed set master version"));
     }
 
     if (this->updateSlaveOtVersion()) {
-      Log.straceln(FPSTR(L_OT), F("Slave OT version: %f"), vars.parameters.slaveOtVersion);
+      Log.snoticeln(FPSTR(L_OT), F("Received slave OT version: %f"), vars.parameters.slaveOtVersion);
 
     } else {
-      Log.swarningln(FPSTR(L_OT), F("Get slave OT version failed"));
+      Log.swarningln(FPSTR(L_OT), F("Failed receive slave OT version"));
     }
 
     if (this->setMasterOtVersion(2.2f)) {
-      Log.straceln(FPSTR(L_OT), F("Master OT version: %f"), vars.parameters.masterOtVersion);
+      Log.snoticeln(FPSTR(L_OT), F("Set master OT version: %f"), vars.parameters.masterOtVersion);
 
     } else {
-      Log.swarningln(FPSTR(L_OT), F("Set master OT version failed"));
+      Log.swarningln(FPSTR(L_OT), F("Failed set master OT version"));
     }
 
     if (this->updateSlaveConfig()) {
-      Log.straceln(FPSTR(L_OT), F("Slave member id: %u, flags: %u"), vars.parameters.slaveMemberId, vars.parameters.slaveFlags);
+      Log.snoticeln(FPSTR(L_OT), F("Received slave member id: %u, flags: %u"), vars.parameters.slaveMemberId, vars.parameters.slaveFlags);
 
     } else {
-      Log.swarningln(FPSTR(L_OT), F("Get slave config failed"));
+      Log.swarningln(FPSTR(L_OT), F("Failed receive slave config"));
     }
 
     if (this->setMasterConfig(settings.opentherm.memberIdCode & 0xFF, (settings.opentherm.memberIdCode & 0xFFFF) >> 8)) {
-      Log.straceln(FPSTR(L_OT), F("Master member id: %u, flags: %u"), vars.parameters.masterMemberId, vars.parameters.masterFlags);
+      Log.snoticeln(FPSTR(L_OT), F("Set master member id: %u, flags: %u"), vars.parameters.masterMemberId, vars.parameters.masterFlags);
       
     } else {
-      Log.swarningln(FPSTR(L_OT), F("Set master config failed"));
+      Log.swarningln(FPSTR(L_OT), F("Failed set master config"));
     }
   }
 
@@ -999,7 +1098,6 @@ protected:
     ));
 
     if (!CustomOpenTherm::isValidResponse(response)) {
-      vars.sensors.faultCode = 0;
       return false;
     }
 
@@ -1015,7 +1113,6 @@ protected:
     ));
 
     if (!CustomOpenTherm::isValidResponse(response)) {
-      vars.sensors.diagnosticCode = 0;
       return false;
     }
 
@@ -1035,6 +1132,10 @@ protected:
     }
 
     float value = CustomOpenTherm::getFloat(response);
+    if (value < 0) {
+      return false;
+    }
+
     if (settings.opentherm.filterNumValues.enable && fabs(vars.sensors.modulation) >= 0.1f) {
       vars.sensors.modulation += (value - vars.sensors.modulation) * settings.opentherm.filterNumValues.factor;
       
@@ -1045,6 +1146,23 @@ protected:
     return true;
   }
 
+  bool updateMinModulationLevel() {
+    unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::MaxCapacityMinModLevel,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+    }
+
+    vars.parameters.minModulation = response & 0xFF;
+    vars.parameters.maxPower = (response & 0xFFFF) >> 8;
+
+    return true;
+  }
+
   bool updatePressure() {
     unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
       OpenThermRequestType::READ_DATA,

src/PortalTask.h

@@ -1,5 +1,5 @@
 #define PORTAL_CACHE_TIME "max-age=86400"
-#define PORTAL_CACHE settings.system.debug ? nullptr : PORTAL_CACHE_TIME
+#define PORTAL_CACHE (settings.system.logLevel >= TinyLogger::Level::TRACE ? nullptr : PORTAL_CACHE_TIME)
 #ifdef ARDUINO_ARCH_ESP8266
 #include <ESP8266WebServer.h>
 #include <Updater.h>

src/Settings.h

@@ -24,7 +24,7 @@ struct NetworkSettings {
 
 struct Settings {
   struct {
-    bool debug = DEBUG_BY_DEFAULT;
+    uint8_t logLevel = DEFAULT_LOG_LEVEL;
 
     struct {
       bool enable = USE_SERIAL;
@@ -51,11 +51,12 @@ struct Settings {
     byte inGpio = DEFAULT_OT_IN_GPIO;
     byte outGpio = DEFAULT_OT_OUT_GPIO;
     byte rxLedGpio = DEFAULT_OT_RX_LED_GPIO;
-    byte faultStateGpio = DEFAULT_OT_FAULT_STATE_GPIO;
-    byte invertFaultState = false;
     unsigned int memberIdCode = 0;
+    uint8_t maxModulation = 100;
     float pressureFactor = 1.0f;
     float dhwFlowRateFactor = 1.0f;
+    float minPower = 0.0f;
+    float maxPower = 0.0f;
     bool dhwPresent = true;
     bool summerWinterMode = false;
     bool heatingCh2Enabled = true;
@@ -103,7 +104,6 @@ struct Settings {
     float hysteresis = 0.5f;
     byte minTemp = DEFAULT_HEATING_MIN_TEMP;
     byte maxTemp = DEFAULT_HEATING_MAX_TEMP;
-    byte maxModulation = 100;
   } heating;
 
   struct {
@@ -154,6 +154,25 @@ struct Settings {
     unsigned short antiStuckTime = 300;
   } externalPump;
 
+  struct {
+    struct {
+      bool enable = false;
+      byte gpio = GPIO_IS_NOT_CONFIGURED;
+      byte invertState = false;
+      unsigned short thresholdTime = 60;
+    } input;
+
+    struct {
+      bool enable = false;
+      byte gpio = GPIO_IS_NOT_CONFIGURED;
+      byte invertState = false;
+      unsigned short thresholdTime = 60;
+      bool onFault = true;
+      bool onLossConnection = true;
+      bool onEnabledHeating = false;
+    } output;
+  } cascadeControl;
+
   char validationValue[8] = SETTINGS_VALID_VALUE;
 } settings;
 
@@ -174,6 +193,7 @@ struct Variables {
     float modulation = 0.0f;
     float pressure = 0.0f;
     float dhwFlowRate = 0.0f;
+    float power = 0.0f;
     byte faultCode = 0;
     unsigned short diagnosticCode = 0;
     int8_t rssi = 0;
@@ -202,6 +222,11 @@ struct Variables {
     float exhaust = 0.0f;
   } temperatures;
 
+  struct {
+    bool input = false;
+    bool output = false;
+  } cascadeControl;
+
   struct {
     bool heatingEnabled = false;
     byte heatingMinTemp = DEFAULT_HEATING_MIN_TEMP;
@@ -210,7 +235,9 @@ struct Variables {
     unsigned long extPumpLastEnableTime = 0;
     byte dhwMinTemp = DEFAULT_DHW_MIN_TEMP;
     byte dhwMaxTemp = DEFAULT_DHW_MAX_TEMP;
+    byte minModulation = 0;
     byte maxModulation = 0;
+    uint8_t maxPower = 0;
     uint8_t slaveMemberId = 0;
     uint8_t slaveFlags = 0;
     uint8_t slaveType = 0;

src/defines.h

@@ -62,8 +62,8 @@
   #define DEFAULT_STA_PASSWORD ""
 #endif
 
-#ifndef DEBUG_BY_DEFAULT
-  #define DEBUG_BY_DEFAULT false
+#ifndef DEFAULT_LOG_LEVEL
+  #define DEFAULT_LOG_LEVEL TinyLogger::Level::VERBOSE
 #endif
 
 #ifndef DEFAULT_STATUS_LED_GPIO

src/main.cpp

@@ -129,7 +129,9 @@ void setup() {
     Log.addStream(telnetStream);
   }
 
-  Log.setLevel(settings.system.debug ? TinyLogger::Level::VERBOSE : TinyLogger::Level::INFO);
+  if (settings.system.logLevel >= TinyLogger::Level::SILENT && settings.system.logLevel <= TinyLogger::Level::VERBOSE) {
+    Log.setLevel(static_cast<TinyLogger::Level>(settings.system.logLevel));
+  }
 
   // network
   network = (new NetworkMgr)

src/strings.h

@@ -4,6 +4,9 @@
 #endif
 
 const char L_SETTINGS[]             PROGMEM = "SETTINGS";
+const char L_SETTINGS_OT[]          PROGMEM = "SETTINGS.OT";
+const char L_SETTINGS_DHW[]         PROGMEM = "SETTINGS.DHW";
+const char L_SETTINGS_HEATING[]     PROGMEM = "SETTINGS.HEATING";
 const char L_NETWORK[]              PROGMEM = "NETWORK";
 const char L_NETWORK_SETTINGS[]     PROGMEM = "NETWORK.SETTINGS";
 const char L_PORTAL_WEBSERVER[]     PROGMEM = "PORTAL.WEBSERVER";
@@ -21,4 +24,6 @@ const char L_SENSORS_INDOOR[]       PROGMEM = "SENSORS.INDOOR";
 const char L_SENSORS_BLE[]          PROGMEM = "SENSORS.BLE";
 const char L_REGULATOR[]            PROGMEM = "REGULATOR";
 const char L_REGULATOR_PID[]        PROGMEM = "REGULATOR.PID";
-const char L_REGULATOR_EQUITHERM[]  PROGMEM = "REGULATOR.EQUITHERM";
+const char L_REGULATOR_EQUITHERM[]  PROGMEM = "REGULATOR.EQUITHERM";
+const char L_CASCADE_INPUT[]        PROGMEM = "CASCADE.INPUT";
+const char L_CASCADE_OUTPUT[]       PROGMEM = "CASCADE.OUTPUT";

src/utils.h

@@ -326,7 +326,7 @@ bool jsonToNetworkSettings(const JsonVariantConst src, NetworkSettings& dst) {
 
 void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
   if (!safe) {
-    dst["system"]["debug"] = src.system.debug;
+    dst["system"]["logLevel"] = static_cast<uint8_t>(src.system.logLevel);
     dst["system"]["serial"]["enable"] = src.system.serial.enable;
     dst["system"]["serial"]["baudrate"] = src.system.serial.baudrate;
     dst["system"]["telnet"]["enable"] = src.system.telnet.enable;
@@ -342,11 +342,12 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
     dst["opentherm"]["inGpio"] = src.opentherm.inGpio;
     dst["opentherm"]["outGpio"] = src.opentherm.outGpio;
     dst["opentherm"]["rxLedGpio"] = src.opentherm.rxLedGpio;
-    dst["opentherm"]["faultStateGpio"] = src.opentherm.faultStateGpio;
-    dst["opentherm"]["invertFaultState"] = src.opentherm.invertFaultState;
     dst["opentherm"]["memberIdCode"] = src.opentherm.memberIdCode;
+    dst["opentherm"]["maxModulation"] = src.opentherm.maxModulation;
     dst["opentherm"]["pressureFactor"] = roundd(src.opentherm.pressureFactor, 2);
     dst["opentherm"]["dhwFlowRateFactor"] = roundd(src.opentherm.dhwFlowRateFactor, 2);
+    dst["opentherm"]["minPower"] = roundd(src.opentherm.minPower, 2);
+    dst["opentherm"]["maxPower"] = roundd(src.opentherm.maxPower, 2);
     dst["opentherm"]["dhwPresent"] = src.opentherm.dhwPresent;
     dst["opentherm"]["summerWinterMode"] = src.opentherm.summerWinterMode;
     dst["opentherm"]["heatingCh2Enabled"] = src.opentherm.heatingCh2Enabled;
@@ -386,7 +387,6 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
   dst["heating"]["hysteresis"] = roundd(src.heating.hysteresis, 2);
   dst["heating"]["minTemp"] = src.heating.minTemp;
   dst["heating"]["maxTemp"] = src.heating.maxTemp;
-  dst["heating"]["maxModulation"] = src.heating.maxModulation;
 
   dst["dhw"]["enable"] = src.dhw.enable;
   dst["dhw"]["target"] = roundd(src.dhw.target, 1);
@@ -445,6 +445,19 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
     dst["externalPump"]["postCirculationTime"] = roundd(src.externalPump.postCirculationTime / 60, 0);
     dst["externalPump"]["antiStuckInterval"] = roundd(src.externalPump.antiStuckInterval / 86400, 0);
     dst["externalPump"]["antiStuckTime"] = roundd(src.externalPump.antiStuckTime / 60, 0);
+
+    dst["cascadeControl"]["input"]["enable"] = src.cascadeControl.input.enable;
+    dst["cascadeControl"]["input"]["gpio"] = src.cascadeControl.input.gpio;
+    dst["cascadeControl"]["input"]["invertState"] = src.cascadeControl.input.invertState;
+    dst["cascadeControl"]["input"]["thresholdTime"] = src.cascadeControl.input.thresholdTime;
+
+    dst["cascadeControl"]["output"]["enable"] = src.cascadeControl.output.enable;
+    dst["cascadeControl"]["output"]["gpio"] = src.cascadeControl.output.gpio;
+    dst["cascadeControl"]["output"]["invertState"] = src.cascadeControl.output.invertState;
+    dst["cascadeControl"]["output"]["thresholdTime"] = src.cascadeControl.output.thresholdTime;
+    dst["cascadeControl"]["output"]["onFault"] = src.cascadeControl.output.onFault;
+    dst["cascadeControl"]["output"]["onLossConnection"] = src.cascadeControl.output.onLossConnection;
+    dst["cascadeControl"]["output"]["onEnabledHeating"] = src.cascadeControl.output.onEnabledHeating;
   }
 }
 
@@ -457,11 +470,11 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
 
   if (!safe) {
     // system
-    if (src["system"]["debug"].is<bool>()) {
-      bool value = src["system"]["debug"].as<bool>();
+    if (!src["system"]["logLevel"].isNull()) {
+      uint8_t value = src["system"]["logLevel"].as<uint8_t>();
 
-      if (value != dst.system.debug) {
-        dst.system.debug = value;
+      if (value != dst.system.logLevel && value >= TinyLogger::Level::SILENT && value <= TinyLogger::Level::VERBOSE) {
+        dst.system.logLevel = value;
         changed = true;
       }
     }
@@ -663,32 +676,6 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
-    if (!src["opentherm"]["faultStateGpio"].isNull()) {
-      if (src["opentherm"]["faultStateGpio"].is<JsonString>() && src["opentherm"]["faultStateGpio"].as<JsonString>().size() == 0) {
-        if (dst.opentherm.faultStateGpio != GPIO_IS_NOT_CONFIGURED) {
-          dst.opentherm.faultStateGpio = GPIO_IS_NOT_CONFIGURED;
-          changed = true;
-        }
-        
-      } else {
-        unsigned char value = src["opentherm"]["faultStateGpio"].as<unsigned char>();
-
-        if (GPIO_IS_VALID(value) && value != dst.opentherm.faultStateGpio) {
-          dst.opentherm.faultStateGpio = value;
-          changed = true;
-        }
-      }
-    }
-
-    if (src["opentherm"]["invertFaultState"].is<bool>()) {
-      bool value = src["opentherm"]["invertFaultState"].as<bool>();
-
-      if (value != dst.opentherm.invertFaultState) {
-        dst.opentherm.invertFaultState = value;
-        changed = true;
-      }
-    }
-
     if (!src["opentherm"]["memberIdCode"].isNull()) {
       unsigned int value = src["opentherm"]["memberIdCode"].as<unsigned int>();
 
@@ -698,6 +685,15 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
+    if (!src["opentherm"]["maxModulation"].isNull()) {
+      unsigned char value = src["opentherm"]["maxModulation"].as<unsigned char>();
+
+      if (value > 0 && value <= 100 && value != dst.opentherm.maxModulation) {
+        dst.opentherm.maxModulation = value;
+        changed = true;
+      }
+    }
+
     if (!src["opentherm"]["pressureFactor"].isNull()) {
       float value = src["opentherm"]["pressureFactor"].as<float>();
 
@@ -716,6 +712,24 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
+    if (!src["opentherm"]["minPower"].isNull()) {
+      float value = src["opentherm"]["minPower"].as<float>();
+
+      if (value >= 0 && value <= 1000 && fabs(value - dst.opentherm.minPower) > 0.0001f) {
+        dst.opentherm.minPower = roundd(value, 2);
+        changed = true;
+      }
+    }
+
+    if (!src["opentherm"]["maxPower"].isNull()) {
+      float value = src["opentherm"]["maxPower"].as<float>();
+
+      if (value >= 0 && value <= 1000 && fabs(value - dst.opentherm.maxPower) > 0.0001f) {
+        dst.opentherm.maxPower = roundd(value, 2);
+        changed = true;
+      }
+    }
+
     if (src["opentherm"]["filterNumValues"]["enable"].is<bool>()) {
       bool value = src["opentherm"]["filterNumValues"]["enable"].as<bool>();
 
@@ -1185,15 +1199,6 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
     }
   }
 
-  if (!src["heating"]["maxModulation"].isNull()) {
-    unsigned char value = src["heating"]["maxModulation"].as<unsigned char>();
-
-    if (value > 0 && value <= 100 && value != dst.heating.maxModulation) {
-      dst.heating.maxModulation = value;
-      changed = true;
-    }
-  }
-
 
   // dhw
   if (src["dhw"]["enable"].is<bool>()) {
@@ -1450,6 +1455,127 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
         }
       }
     }
+
+
+    // cascade control
+    if (src["cascadeControl"]["input"]["enable"].is<bool>()) {
+      bool value = src["cascadeControl"]["input"]["enable"].as<bool>();
+
+      if (value != dst.cascadeControl.input.enable) {
+        dst.cascadeControl.input.enable = value;
+        changed = true;
+      }
+    }
+
+    if (!src["cascadeControl"]["input"]["gpio"].isNull()) {
+      if (src["cascadeControl"]["input"]["gpio"].is<JsonString>() && src["cascadeControl"]["input"]["gpio"].as<JsonString>().size() == 0) {
+        if (dst.cascadeControl.input.gpio != GPIO_IS_NOT_CONFIGURED) {
+          dst.cascadeControl.input.gpio = GPIO_IS_NOT_CONFIGURED;
+          changed = true;
+        }
+        
+      } else {
+        unsigned char value = src["cascadeControl"]["input"]["gpio"].as<unsigned char>();
+
+        if (GPIO_IS_VALID(value) && value != dst.cascadeControl.input.gpio) {
+          dst.cascadeControl.input.gpio = value;
+          changed = true;
+        }
+      }
+    }
+
+    if (src["cascadeControl"]["input"]["invertState"].is<bool>()) {
+      bool value = src["cascadeControl"]["input"]["invertState"].as<bool>();
+
+      if (value != dst.cascadeControl.input.invertState) {
+        dst.cascadeControl.input.invertState = value;
+        changed = true;
+      }
+    }
+
+    if (!src["cascadeControl"]["input"]["thresholdTime"].isNull()) {
+      unsigned short value = src["cascadeControl"]["input"]["thresholdTime"].as<unsigned short>();
+
+      if (value >= 5 && value <= 600) {
+        if (value != dst.cascadeControl.input.thresholdTime) {
+          dst.cascadeControl.input.thresholdTime = value;
+          changed = true;
+        }
+      }
+    }
+
+    if (src["cascadeControl"]["output"]["enable"].is<bool>()) {
+      bool value = src["cascadeControl"]["output"]["enable"].as<bool>();
+
+      if (value != dst.cascadeControl.output.enable) {
+        dst.cascadeControl.output.enable = value;
+        changed = true;
+      }
+    }
+
+    if (!src["cascadeControl"]["output"]["gpio"].isNull()) {
+      if (src["cascadeControl"]["output"]["gpio"].is<JsonString>() && src["cascadeControl"]["output"]["gpio"].as<JsonString>().size() == 0) {
+        if (dst.cascadeControl.output.gpio != GPIO_IS_NOT_CONFIGURED) {
+          dst.cascadeControl.output.gpio = GPIO_IS_NOT_CONFIGURED;
+          changed = true;
+        }
+        
+      } else {
+        unsigned char value = src["cascadeControl"]["output"]["gpio"].as<unsigned char>();
+
+        if (GPIO_IS_VALID(value) && value != dst.cascadeControl.output.gpio) {
+          dst.cascadeControl.output.gpio = value;
+          changed = true;
+        }
+      }
+    }
+
+    if (src["cascadeControl"]["output"]["invertState"].is<bool>()) {
+      bool value = src["cascadeControl"]["output"]["invertState"].as<bool>();
+
+      if (value != dst.cascadeControl.output.invertState) {
+        dst.cascadeControl.output.invertState = value;
+        changed = true;
+      }
+    }
+
+    if (!src["cascadeControl"]["output"]["thresholdTime"].isNull()) {
+      unsigned short value = src["cascadeControl"]["output"]["thresholdTime"].as<unsigned short>();
+
+      if (value >= 5 && value <= 600) {
+        if (value != dst.cascadeControl.output.thresholdTime) {
+          dst.cascadeControl.output.thresholdTime = value;
+          changed = true;
+        }
+      }
+    }
+
+    if (src["cascadeControl"]["output"]["onFault"].is<bool>()) {
+      bool value = src["cascadeControl"]["output"]["onFault"].as<bool>();
+
+      if (value != dst.cascadeControl.output.onFault) {
+        dst.cascadeControl.output.onFault = value;
+        changed = true;
+      }
+    }
+
+    if (src["cascadeControl"]["output"]["onLossConnection"].is<bool>()) {
+      bool value = src["cascadeControl"]["output"]["onLossConnection"].as<bool>();
+
+      if (value != dst.cascadeControl.output.onLossConnection) {
+        dst.cascadeControl.output.onLossConnection = value;
+        changed = true;
+      }
+    }
+
+    if (src["cascadeControl"]["output"]["onEnabledHeating"].is<bool>()) {
+      bool value = src["cascadeControl"]["output"]["onEnabledHeating"].as<bool>();
+
+      if (value != dst.cascadeControl.output.onEnabledHeating) {
+        dst.cascadeControl.output.onEnabledHeating = value;
+        changed = true;
+      }
+    }
   }
 
   // force check emergency target
@@ -1546,6 +1672,7 @@ void varsToJson(const Variables& src, JsonVariant dst) {
   dst["sensors"]["modulation"] = roundd(src.sensors.modulation, 2);
   dst["sensors"]["pressure"] = roundd(src.sensors.pressure, 2);
   dst["sensors"]["dhwFlowRate"] = roundd(src.sensors.dhwFlowRate, 2);
+  dst["sensors"]["power"] = roundd(src.sensors.power, 2);
   dst["sensors"]["faultCode"] = src.sensors.faultCode;
   dst["sensors"]["diagnosticCode"] = src.sensors.diagnosticCode;
   dst["sensors"]["rssi"] = src.sensors.rssi;
@@ -1566,6 +1693,9 @@ void varsToJson(const Variables& src, JsonVariant dst) {
   dst["temperatures"]["dhw"] = roundd(src.temperatures.dhw, 2);
   dst["temperatures"]["exhaust"] = roundd(src.temperatures.exhaust, 2);
 
+  dst["cascadeControl"]["input"] = src.cascadeControl.input;
+  dst["cascadeControl"]["output"] = src.cascadeControl.output;
+
   dst["parameters"]["heatingEnabled"] = src.parameters.heatingEnabled;
   dst["parameters"]["heatingMinTemp"] = src.parameters.heatingMinTemp;
   dst["parameters"]["heatingMaxTemp"] = src.parameters.heatingMaxTemp;

src_data/locales/en.json

@@ -9,6 +9,7 @@
       "releases": "Releases"
     },
     "dbm": "dBm",
+    "kw": "kW",
 
     "button": {
       "upgrade": "Upgrade",
@@ -93,12 +94,15 @@
         "outdoorSensorHumidity": "Outdoor sensor humidity",
         "outdoorSensorBattery": "Outdoor sensor battery",
         "indoorSensorConnected": "Indoor sensor connected",
+        "cascadeControlInput": "Cascade control (input)",
+        "cascadeControlOutput": "Cascade control (output)",
         "indoorSensorRssi": "Indoor sensor RSSI",
         "indoorSensorHumidity": "Indoor sensor humidity",
         "indoorSensorBattery": "Indoor sensor battery",
         "modulation": "Modulation",
         "pressure": "Pressure",
         "dhwFlowRate": "DHW flow rate",
+        "power": "Current power",
         "faultCode": "Fault code",
         "diagCode": "Diagnostic code",
         "indoorTemp": "Indoor temp",
@@ -161,16 +165,14 @@
         "heating": "Heating settings",
         "dhw": "DHW settings",
         "emergency": "Emergency mode settings",
-        "emergency.events": "Events",
-        "emergency.regulators": "Using regulators",
         "equitherm": "Equitherm settings",
         "pid": "PID settings",
         "ot": "OpenTherm settings",
-        "ot.options": "Options",
         "mqtt": "MQTT settings",
         "outdorSensor": "Outdoor sensor settings",
         "indoorSensor": "Indoor sensor settings",
-        "extPump": "External pump settings"
+        "extPump": "External pump settings",
+        "cascadeControl": "Cascade control settings"
       },
 
       "enable": "Enable",
@@ -196,13 +198,10 @@
         "metric": "Metric <small>(celsius, liters, bar)</small>",
         "imperial": "Imperial <small>(fahrenheit, gallons, psi)</small>",
         "statusLedGpio": "Status LED GPIO",
-        "debug": "Debug mode",
+        "logLevel": "Log level",
         "serial": {
           "enable": "Enable Serial port",
-          "baud": {
-            "title": "Serial port baud rate",
-            "note": "Available: 9600, 19200, 38400, 57600, 74880, 115200"
-          }
+          "baud": "Serial port baud rate"
         },
         "telnet": {
           "enable": "Enable Telnet",
@@ -214,8 +213,7 @@
       },
 
       "heating": {
-        "hyst": "Hysteresis <small>(in degrees)</small>",
-        "maxMod": "Max modulation level"
+        "hyst": "Hysteresis <small>(in degrees)</small>"
       },
 
       "emergency": {
@@ -228,6 +226,7 @@
         "treshold": "Treshold time <small>(sec)</small>",
 
         "events": {
+          "desc": "Events",
           "network": "On network fault",
           "mqtt": "On MQTT fault",
           "indoorSensorDisconnect": "On loss connection with indoor sensor",
@@ -235,6 +234,7 @@
         },
 
         "regulators": {
+          "desc": "Using regulators",
           "equitherm": "Equitherm <small>(requires at least an external (DS18B20) or boiler <u>outdoor</u> sensor)</small>",
           "pid": "PID <small>(requires at least an external (DS18B20) <u>indoor</u> sensor)</small>"
         }
@@ -257,10 +257,12 @@
       },
 
       "ot": {
+        "advanced": "Advanced Settings",
         "inGpio": "In GPIO",
         "outGpio": "Out GPIO",
         "ledGpio": "RX LED GPIO",
         "memberIdCode": "Master MemberID code",
+        "maxMod": "Max modulation level",
         "pressureFactor": {
           "title": "Coeff. pressure correction",
           "note": "If the pressure displayed is <b>X10</b> from the real one, set the <b>0.1</b>."
@@ -269,6 +271,14 @@
           "title": "Coeff. DHW flow rate correction",
           "note": "If the DHW flow rate displayed is <b>X10</b> from the real one, set the <b>0.1</b>."
         },
+        "minPower": {
+          "title": "Min boiler power <small>(kW)</small>",
+          "note": "This value is at 0-1% boiler modulation level. Typically found in the boiler specification as \"minimum useful heat output\"."
+        },
+        "maxPower": {
+          "title": "Max boiler power <small>(kW)</small>",
+          "note": "<b>0</b> - try detect automatically. Typically found in the boiler specification as \"maximum useful heat output\"."
+        },
         "fnv": {
           "title": "Filtering numeric values",
           "enable": {
@@ -282,6 +292,7 @@
         },
 
         "options": {
+          "desc": "Options",
           "dhwPresent": "DHW present",
           "summerWinterMode": "Summer/winter mode",
           "heatingCh2Enabled": "Heating CH2 always enabled",
@@ -293,12 +304,6 @@
           "immergasFix": "Fix for Immergas boilers"
         },
 
-        "faultState": {
-          "gpio": "Fault state GPIO",
-          "note": "Can be useful to switch on another boiler <u>via relay</u>. Blank - not use.",
-          "invert": "Invert fault state"
-        },
-
         "nativeHeating": {
           "title": "Native heating control (boiler)",
           "note": "Works <u>ONLY</u> if the boiler requires the desired room temperature and regulates the temperature of the coolant itself. Not compatible with PID and Equitherm regulators and hysteresis in firmware."
@@ -334,6 +339,29 @@
         "postCirculationTime": "Post circulation time <small>(min)</small>",
         "antiStuckInterval": "Anti stuck interval <small>(days)</small>",
         "antiStuckTime": "Anti stuck time <small>(min)</small>"
+      },
+
+      "cascadeControl": {
+        "input": {
+          "desc": "Can be used to turn on the heating only if another boiler is faulty. The other boiler controller must change the state of the GPIO input in the event of a fault.",
+          "enable": "Enable input",
+          "gpio": "GPIO",
+          "invertState": "Invert GPIO state",
+          "thresholdTime": "State change threshold time <small>(sec)</small>"
+        },
+        "output": {
+          "desc": "Can be used to switch on another boiler <u>via relay</u>.",
+          "enable": "Enable output",
+          "gpio": "GPIO",
+          "invertState": "Invert GPIO state",
+          "thresholdTime": "State change threshold time <small>(sec)</small>",
+          "events": {
+            "title": "Events",
+            "onFault": "If the fault state is active",
+            "onLossConnection": "If the connection via Opentherm is lost",
+            "onEnabledHeating": "If heating is enabled"
+          }
+        }
       }
     },
 

src_data/locales/ru.json

@@ -9,6 +9,7 @@
       "releases": "Релизы"
     },
     "dbm": "дБм",
+    "kw": "кВт",
 
     "button": {
       "upgrade": "Обновить",
@@ -93,12 +94,15 @@
         "outdoorSensorHumidity": "Влажность с наруж. датчика темп.",
         "outdoorSensorBattery": "Заряд наруж. датчика темп.",
         "indoorSensorConnected": "Датчик внутр. темп.",
+        "cascadeControlInput": "Каскадное управление (вход)",
+        "cascadeControlOutput": "Каскадное управление (выход)",
         "indoorSensorRssi": "RSSI датчика внутр. темп.",
         "indoorSensorHumidity": "Влажность с внутр. датчика темп.",
         "indoorSensorBattery": "Заряд внутр. датчика темп.",
         "modulation": "Уровень модуляции",
         "pressure": "Давление",
         "dhwFlowRate": "Расход ГВС",
+        "power": "Текущая мощность",
         "faultCode": "Код ошибки",
         "diagCode": "Диагностический код",
         "indoorTemp": "Внутренняя темп.",
@@ -161,16 +165,14 @@
         "heating": "Настройки отопления",
         "dhw": "Настройки ГВС",
         "emergency": "Настройки аварийного режима",
-        "emergency.events": "События",
-        "emergency.regulators": "Используемые регуляторы",
         "equitherm": "Настройки ПЗА",
         "pid": "Настройки ПИД",
         "ot": "Настройки OpenTherm",
-        "ot.options": "Опции",
         "mqtt": "Настройки MQTT",
         "outdorSensor": "Настройки наружного датчика температуры",
         "indoorSensor": "Настройки внутреннего датчика температуры",
-        "extPump": "Настройки дополнительного насоса"
+        "extPump": "Настройки дополнительного насоса",
+        "cascadeControl": "Настройки каскадного управления"
       },
 
       "enable": "Вкл",
@@ -196,13 +198,10 @@
         "metric": "Метрическая <small>(цильсии, литры, бары)</small>",
         "imperial": "Imperial <small>(фаренгейты, галлоны, psi)</small>",
         "statusLedGpio": "Статус LED GPIO",
-        "debug": "Отладка",
+        "logLevel": "Уровень логирования",
         "serial": {
           "enable": "Вкл. Serial порт",
-          "baud": {
-            "title": "Скорость Serial порта",
-            "note": "Доступно: 9600, 19200, 38400, 57600, 74880, 115200"
-          }
+          "baud": "Скорость Serial порта"
         },
         "telnet": {
           "enable": "Вкл. Telnet",
@@ -214,8 +213,7 @@
       },
 
       "heating": {
-        "hyst": "Гистерезис <small>(в градусах)</small>",
-        "maxMod": "Макс. уровень модуляции"
+        "hyst": "Гистерезис <small>(в градусах)</small>"
       },
 
       "emergency": {
@@ -228,6 +226,7 @@
         "treshold": "Пороговое время включения <small>(сек)</small>",
 
         "events": {
+          "desc": "События",
           "network": "При отключении сети",
           "mqtt": "При отключении MQTT",
           "indoorSensorDisconnect": "При потере связи с датчиком внутренней темп.",
@@ -235,6 +234,7 @@
         },
 
         "regulators": {
+          "desc": "Используемые регуляторы",
           "equitherm": "ПЗА <small>(требуется внешний (DS18B20) или подключенный к котлу датчик <u>наружной</u> температуры)</small>",
           "pid": "ПИД <small>(требуется внешний (DS18B20) датчик <u>внутренней</u> температуры)</small>"
         }
@@ -257,10 +257,12 @@
       },
 
       "ot": {
+        "advanced": "Дополнительные настройки",
         "inGpio": "Вход GPIO",
         "outGpio": "Выход GPIO",
         "ledGpio": "RX LED GPIO",
         "memberIdCode": "Master MemberID код",
+        "maxMod": "Макс. уровень модуляции",
         "pressureFactor": {
           "title": "Коэфф. коррекции давления",
           "note": "Если давление отображается <b>Х10</b> от реального, установите значение <b>0.1</b>."
@@ -269,6 +271,14 @@
           "title": "Коэфф. коррекции потока ГВС",
           "note": "Если поток ГВС отображается <b>Х10</b> от реального, установите значение <b>0.1</b>."
         },
+        "minPower": {
+          "title": "Мин. мощность котла <small>(кВт)</small>",
+          "note": "Это значение соответствует уровню модуляции котла 0–1%. Обычно можно найти в спецификации котла как \"минимальная полезная тепловая мощность\"."
+        },
+        "maxPower": {
+          "title": "Макс. мощность котла <small>(кВт)</small>",
+          "note": "<b>0</b> - попробовать определить автоматически. Обычно можно найти в спецификации котла как \"максимальная полезная тепловая мощность\"."
+        },
         "fnv": {
           "title": "Фильтрация числовых значений",
           "enable": {
@@ -282,6 +292,7 @@
         },
 
         "options": {
+          "desc": "Опции",
           "dhwPresent": "Контур ГВС",
           "summerWinterMode": "Летний/зимний режим",
           "heatingCh2Enabled": "Канал 2 отопления всегда вкл.",
@@ -293,12 +304,6 @@
           "immergasFix": "Фикс для котлов Immergas"
         },
 
-        "faultState": {
-          "gpio": "Fault state GPIO",
-          "note": "Can be useful to switch on another boiler <u>via relay</u>. Blank - not use.",
-          "invert": "Invert fault state"
-        },
-
         "nativeHeating": {
           "title": "Передать управление отоплением котлу",
           "note": "Работает <u>ТОЛЬКО</u> если котел требует и принимает целевую температуру в помещении и сам регулирует температуру теплоносителя на основе встроенного режима кривых. Несовместимо с ПИД, ПЗА и гистерезисом."
@@ -334,6 +339,29 @@
         "postCirculationTime": "Время постциркуляции <small>(в минутах)</small>",
         "antiStuckInterval": "Интервал защиты от блокировки <small>(в днях)</small>",
         "antiStuckTime": "Время работы насоса <small>(в минутах)</small>"
+      },
+
+      "cascadeControl": {
+        "input": {
+          "desc": "Может использоваться для включения отопления только при неисправности другого котла. Контроллер другого котла должен изменить состояние входа GPIO в случае неисправности.",
+          "enable": "Включить вход",
+          "gpio": "GPIO",
+          "invertState": "Инвертировать состояние GPIO",
+          "thresholdTime": "Пороговое время изменения состояния <small>(сек)</small>"
+        },
+        "output": {
+          "desc": "Может использоваться для включения другого котла <u>через реле</u>.",
+          "enable": "Включить выход",
+          "gpio": "GPIO",
+          "invertState": "Инвертировать состояние GPIO",
+          "thresholdTime": "Пороговое время изменения состояния <small>(сек)</small>",
+          "events": {
+            "title": "События",
+            "onFault": "Если состояние fault (ошибки) активно",
+            "onLossConnection": "Если соединение по OpenTherm потеряно",
+            "onEnabledHeating": "Если отопление включено"
+          }
+        }
       }
     },
 

src_data/pages/dashboard.html

@@ -134,6 +134,14 @@
                   <th scope="row" data-i18n>dashboard.state.indoorSensorConnected</th>
                   <td><input type="radio" id="indoor-sensor-connected" aria-invalid="false" checked disabled /></td>
                 </tr>
+                <tr>
+                  <th scope="row" data-i18n>dashboard.state.cascadeControlInput</th>
+                  <td><input type="radio" id="cc-input" aria-invalid="false" checked disabled /></td>
+                </tr>
+                <tr>
+                  <th scope="row" data-i18n>dashboard.state.cascadeControlOutput</th>
+                  <td><input type="radio" id="cc-output" aria-invalid="false" checked disabled /></td>
+                </tr>
                 <tr>
                   <th scope="row" data-i18n>dashboard.state.indoorSensorRssi</th>
                   <td><b id="indoor-sensor-rssi"></b> <span data-i18n>dbm</span></td>
@@ -158,6 +166,10 @@
                   <th scope="row" data-i18n>dashboard.state.dhwFlowRate</th>
                   <td><b id="ot-dhw-flow-rate"></b> <span class="volume-unit"></span>/min</td>
                 </tr>
+                <tr>
+                  <th scope="row" data-i18n>dashboard.state.power</th>
+                  <td><b id="ot-power"></b> <span data-i18n>kw</span></td>
+                </tr>
                 <tr>
                   <th scope="row" data-i18n>dashboard.state.faultCode</th>
                   <td><b id="ot-fault-code"></b></td>
@@ -423,6 +435,8 @@
             setState('#ot-external-pump', result.states.externalPump);
             setState('#outdoor-sensor-connected', result.sensors.outdoor.connected);
             setState('#indoor-sensor-connected', result.sensors.indoor.connected);
+            setState('#cc-input', result.cascadeControl.input);
+            setState('#cc-output', result.cascadeControl.output);
 
             setValue('#outdoor-sensor-rssi', result.sensors.outdoor.rssi);
             setValue('#outdoor-sensor-humidity', result.sensors.outdoor.humidity);
@@ -434,6 +448,7 @@
             setValue('#ot-modulation', result.sensors.modulation);
             setValue('#ot-pressure', result.sensors.pressure);
             setValue('#ot-dhw-flow-rate', result.sensors.dhwFlowRate);
+            setValue('#ot-power', result.sensors.power);
             setValue(
               '#ot-fault-code',
               result.sensors.faultCode

src_data/pages/settings.html

@@ -94,11 +94,6 @@
               <fieldset>
                 <legend data-i18n>settings.section.diag</legend>
 
-                <label for="system-debug">
-                  <input type="checkbox" id="system-debug" name="system[debug]" value="true">
-                  <span data-i18n>settings.system.debug</span>
-                </label>
-
                 <label for="system-serial-enable">
                   <input type="checkbox" id="system-serial-enable" name="system[serial][enable]" value="true">
                   <span data-i18n>settings.system.serial.enable</span>
@@ -109,11 +104,31 @@
                   <span data-i18n>settings.system.telnet.enable</span>
                 </label>
 
+                <label for="system-log-level">
+                  <span data-i18n>settings.system.logLevel</span>
+                  <select id="system-log-level" name="system[logLevel]">
+                    <option value="0">SILENT</option>
+                    <option value="1">FATAL</option>
+                    <option value="2">ERROR</option>
+                    <option value="3">WARNING</option>
+                    <option value="4">INFO</option>
+                    <option value="5">NOTICE</option>
+                    <option value="6">TRACE</option>
+                    <option value="7">VERBOSE</option>
+                  </select>
+                </label>
+
                 <div class="grid">
                   <label for="system-serial-baudrate">
-                    <span data-i18n>settings.system.serial.baud.title</span>
-                    <input type="number" inputmode="numeric" id="system-serial-baudrate" name="system[serial][baudrate]" min="9600" max="115200" step="1" required>
-                    <small data-i18n>settings.system.serial.baud.note</small>
+                    <span data-i18n>settings.system.serial.baud</span>
+                    <select id="system-serial-baudrate" name="system[serial][baudrate]" required>
+                      <option value="9600">9600</option>
+                      <option value="19200">19200</option>
+                      <option value="38400">38400</option>
+                      <option value="57600">57600</option>
+                      <option value="74880">74880</option>
+                      <option value="115200">115200</option>
+                    </select>
                   </label>
 
                   <label for="system-telnet-port">
@@ -151,17 +166,10 @@
                 </label>
               </div>
 
-              <div class="grid">
-                <label for="heating-hysteresis">
-                  <span data-i18n>settings.heating.hyst</span>
-                  <input type="number" inputmode="numeric" id="heating-hysteresis" name="heating[hysteresis]" min="0" max="5" step="0.05" required>
-                </label>
-
-                <label for="heating-max-modulation">
-                  <span data-i18n>settings.heating.maxMod</span>
-                  <input type="number" inputmode="numeric" id="heating-max-modulation" name="heating[maxModulation]" min="1" max="100" step="1" required>
-                </label>
-              </div>
+              <label for="heating-hysteresis">
+                <span data-i18n>settings.heating.hyst</span>
+                <input type="number" inputmode="numeric" id="heating-hysteresis" name="heating[hysteresis]" min="0" max="5" step="0.05" required>
+              </label>
 
               <button type="submit" data-i18n>button.save</button>
             </form>
@@ -222,7 +230,7 @@
               </div>
 
               <fieldset>
-                <legend data-i18n>settings.section.emergency.events</legend>
+                <legend data-i18n>settings.emergency.events.title</legend>
 
                 <label for="emergency-on-network-fault">
                   <input type="checkbox" id="emergency-on-network-fault" name="emergency[onNetworkFault]" value="true">
@@ -246,7 +254,7 @@
               </fieldset>
 
               <fieldset>
-                <legend data-i18n>settings.section.emergency.regulators</legend>
+                <legend data-i18n>settings.emergency.regulators.title</legend>
 
                 <label for="emergency-use-equitherm">
                   <input type="checkbox" id="emergency-use-equitherm" name="emergency[useEquitherm]" value="true">
@@ -386,37 +394,43 @@
                   <span data-i18n>settings.ot.outGpio</span>
                   <input type="number" inputmode="numeric" id="opentherm-out-gpio" name="opentherm[outGpio]" min="0" max="254" step="1">
                 </label>
-              </div>
 
-              <div class="grid">
                 <label for="opentherm-rx-led-gpio">
                   <span data-i18n>settings.ot.ledGpio</span>
                   <input type="number" inputmode="numeric" id="opentherm-rx-led-gpio" name="opentherm[rxLedGpio]" min="0" max="254" step="1">
                   <small data-i18n>settings.note.blankNotUse</small>
                 </label>
+              </div>
 
+              <div class="grid">
                 <label for="opentherm-member-id-code">
                   <span data-i18n>settings.ot.memberIdCode</span>
                   <input type="number" inputmode="numeric" id="opentherm-member-id-code" name="opentherm[memberIdCode]" min="0" max="65535" step="1" required>
                 </label>
+
+                <label for="opentherm-max-modulation">
+                  <span data-i18n>settings.ot.maxMod</span>
+                  <input type="number" inputmode="numeric" id="opentherm-max-modulation" name="opentherm[maxModulation]" min="1" max="100" step="1" required>
+                </label>
               </div>
 
               <div class="grid">
-                <label for="opentherm-pressure-factor">
-                  <span data-i18n>settings.ot.pressureFactor.title</span>
-                  <input type="number" inputmode="numeric" id="opentherm-pressure-factor" name="opentherm[pressureFactor]" min="0.1" max="100" step="0.01">
-                  <small data-i18n>settings.ot.pressureFactor.note</small>
+                <label for="opentherm-min-power">
+                  <span data-i18n>settings.ot.minPower.title</span>
+                  <input type="number" inputmode="numeric" id="opentherm-min-power" name="opentherm[minPower]" min="0" max="1000" step="0.1">
+                  <small data-i18n>settings.ot.minPower.note</small>
                 </label>
 
-                <label for="opentherm-dhw-fr-factor">
-                  <span data-i18n>settings.ot.dhwFlowRateFactor.title</span>
-                  <input type="number" inputmode="numeric" id="opentherm-dhw-fr-factor" name="opentherm[dhwFlowRateFactor]" min="0.1" max="100" step="0.01">
-                  <small data-i18n>settings.ot.dhwFlowRateFactor.note</small>
+                <label for="opentherm-max-power">
+                  <span data-i18n>settings.ot.maxPower.title</span>
+                  <input type="number" inputmode="numeric" id="opentherm-max-power" name="opentherm[maxPower]" min="0" max="1000" step="0.1">
+                  <small data-i18n>settings.ot.maxPower.note</small>
                 </label>
               </div>
 
               <fieldset>
-                <legend data-i18n>settings.section.ot.options</legend>
+                <legend data-i18n>settings.ot.options.title</legend>
+
                 <label for="opentherm-dhw-present">
                   <input type="checkbox" id="opentherm-dhw-present" name="opentherm[dhwPresent]" value="true">
                   <span data-i18n>settings.ot.options.dhwPresent</span>
@@ -462,40 +476,6 @@
                   <span data-i18n>settings.ot.options.immergasFix</span>
                 </label>
 
-                <hr />
-                <fieldset>
-                  <legend>
-                    <span data-i18n>settings.ot.fnv.title</span>
-                  </legend>
-
-                  <label for="opentherm-fnv-enable">
-                    <input type="checkbox" id="opentherm-fnv-enable" name="opentherm[filterNumValues][enable]" value="true">
-                    <span data-i18n>settings.ot.fnv.enable.title</span>
-                    <br>
-                    <small data-i18n>settings.ot.fnv.enable.note</small>
-                  </label>
-
-                  <label for="opentherm-fnv-factor">
-                    <span data-i18n>settings.ot.fnv.factor.title</span>
-                    <input type="number" inputmode="numeric" id="opentherm-fnv-factor" name="opentherm[filterNumValues][factor]" min="0.01" max="1" step="0.01">
-                    <small data-i18n>settings.ot.fnv.factor.note</small>
-                  </label>
-                </fieldset>
-
-                <hr />
-                <fieldset>
-                  <label for="opentherm-fault-state-gpio">
-                    <span data-i18n>settings.ot.faultState.gpio</span>
-                    <input type="number" inputmode="numeric" id="opentherm-fault-state-gpio" name="opentherm[faultStateGpio]" min="0" max="254" step="1">
-                    <small data-i18n>settings.ot.faultState.note</small>
-                  </label>
-
-                  <label for="opentherm-invert-fault-state">
-                    <input type="checkbox" id="opentherm-invert-fault-state" name="opentherm[invertFaultState]" value="true">
-                    <span data-i18n>settings.ot.faultState.invert</span>
-                  </label>
-                </fieldset>
-
                 <hr />
                 <label for="opentherm-native-heating-control">
                   <input type="checkbox" id="opentherm-native-heating-control" name="opentherm[nativeHeatingControl]" value="true">
@@ -503,6 +483,44 @@
                   <small data-i18n>settings.ot.nativeHeating.note</small>
                 </label>
               </fieldset>
+              <hr />
+
+              <details>
+                <summary role="button" class="secondary" data-i18n>settings.ot.advanced</summary>
+                <div>
+                  <div class="grid">
+                    <label for="opentherm-pressure-factor">
+                      <span data-i18n>settings.ot.pressureFactor.title</span>
+                      <input type="number" inputmode="numeric" id="opentherm-pressure-factor" name="opentherm[pressureFactor]" min="0.1" max="100" step="0.01">
+                      <small data-i18n>settings.ot.pressureFactor.note</small>
+                    </label>
+    
+                    <label for="opentherm-dhw-fr-factor">
+                      <span data-i18n>settings.ot.dhwFlowRateFactor.title</span>
+                      <input type="number" inputmode="numeric" id="opentherm-dhw-fr-factor" name="opentherm[dhwFlowRateFactor]" min="0.1" max="100" step="0.01">
+                      <small data-i18n>settings.ot.dhwFlowRateFactor.note</small>
+                    </label>
+                  </div>
+                  <hr />
+
+                  <fieldset>
+                    <legend data-i18n>settings.ot.fnv.title</legend>
+
+                    <label for="opentherm-fnv-enable">
+                      <input type="checkbox" id="opentherm-fnv-enable" name="opentherm[filterNumValues][enable]" value="true">
+                      <span data-i18n>settings.ot.fnv.enable.title</span>
+                      <br>
+                      <small data-i18n>settings.ot.fnv.enable.note</small>
+                    </label>
+
+                    <label for="opentherm-fnv-factor">
+                      <span data-i18n>settings.ot.fnv.factor.title</span>
+                      <input type="number" inputmode="numeric" id="opentherm-fnv-factor" name="opentherm[filterNumValues][factor]" min="0.01" max="1" step="0.01">
+                      <small data-i18n>settings.ot.fnv.factor.note</small>
+                    </label>
+                  </fieldset>
+                </div>
+              </details>
 
               <button type="submit" data-i18n>button.save</button>
             </form>
@@ -720,6 +738,91 @@
             </form>
           </div>
         </details>
+
+        <hr />
+
+        <details>
+          <summary><b data-i18n>settings.section.cascadeControl</b></summary>
+          <div>
+            <div id="cc-settings-busy" aria-busy="true"></div>
+            <form action="/api/settings" id="cc-settings" class="hidden">
+              <fieldset>
+                <label for="cc-input-enable">
+                  <input type="checkbox" id="cc-input-enable" name="cascadeControl[input][enable]" value="true">
+                  <span data-i18n>settings.cascadeControl.input.enable</span>
+                  <br>
+                  <small data-i18n>settings.cascadeControl.input.desc</small>
+                </label>
+
+                <label for="cc-input-invert-state">
+                  <input type="checkbox" id="cc-input-invert-state" name="cascadeControl[input][invertState]" value="true">
+                  <span data-i18n>settings.cascadeControl.input.invertState</span>
+                </label>
+              </fieldset>
+
+              <div class="grid">
+                <label for="cc-input-gpio">
+                  <span data-i18n>settings.cascadeControl.input.gpio</span>
+                  <input type="number" inputmode="numeric" id="cc-input-gpio" name="cascadeControl[input][gpio]" min="0" max="254" step="1">
+                </label>
+
+                <label for="cc-input-tt">
+                  <span data-i18n>settings.cascadeControl.input.thresholdTime</span>
+                  <input type="number" inputmode="numeric" id="cc-input-tt" name="cascadeControl[input][thresholdTime]" min="5" max="600" step="1" required>
+                </label>
+              </div>
+
+              <hr />
+
+              <fieldset>
+                <label for="cc-output-enable">
+                  <input type="checkbox" id="cc-output-enable" name="cascadeControl[output][enable]" value="true">
+                  <span data-i18n>settings.cascadeControl.output.enable</span>
+                  <br>
+                  <small data-i18n>settings.cascadeControl.output.desc</small>
+                </label>
+
+                <label for="cc-output-invert-state">
+                  <input type="checkbox" id="cc-output-invert-state" name="cascadeControl[output][invertState]" value="true">
+                  <span data-i18n>settings.cascadeControl.output.invertState</span>
+                </label>
+              </fieldset>
+
+              <div class="grid">
+                <label for="cc-output-gpio">
+                  <span data-i18n>settings.cascadeControl.output.gpio</span>
+                  <input type="number" outputmode="numeric" id="cc-output-gpio" name="cascadeControl[output][gpio]" min="0" max="254" step="1">
+                </label>
+
+                <label for="cc-output-tt">
+                  <span data-i18n>settings.cascadeControl.output.thresholdTime</span>
+                  <input type="number" outputmode="numeric" id="cc-output-tt" name="cascadeControl[output][thresholdTime]" min="5" max="600" step="1" required>
+                </label>
+              </div>
+
+              <fieldset>
+                <legend data-i18n>settings.cascadeControl.output.events.title</legend>
+
+                <label for="cc-on-fault">
+                  <input type="checkbox" id="cc-on-fault" name="cascadeControl[output][onFault]" value="true">
+                  <span data-i18n>settings.cascadeControl.output.events.onFault</span>
+                </label>
+
+                <label for="cc-on-loss-conn">
+                  <input type="checkbox" id="cc-on-loss-conn" name="cascadeControl[output][onLossConnection]" value="true">
+                  <span data-i18n>settings.cascadeControl.output.events.onLossConnection</span>
+                </label>
+
+                <label for="cc-on-enabled-heating">
+                  <input type="checkbox" id="cc-on-enabled-heating" name="cascadeControl[output][onEnabledHeating]" value="true">
+                  <span data-i18n>settings.cascadeControl.output.events.onEnabledHeating</span>
+                </label>
+              </fieldset>
+
+              <button type="submit" data-i18n>button.save</button>
+            </form>
+          </div>
+        </details>
       </article>
     </main>
 
@@ -743,9 +846,9 @@
 
         const fillData = (data) => {
           // System
-          setCheckboxValue('#system-debug', data.system.debug);
+          setSelectValue('#system-log-level', data.system.logLevel);
           setCheckboxValue('#system-serial-enable', data.system.serial.enable);
-          setInputValue('#system-serial-baudrate', data.system.serial.baudrate);
+          setSelectValue('#system-serial-baudrate', data.system.serial.baudrate);
           setCheckboxValue('#system-telnet-enable', data.system.telnet.enable);
           setInputValue('#system-telnet-port', data.system.telnet.port);
           setRadioValue('.system-unit-system', data.system.unitSystem);
@@ -763,11 +866,12 @@
           setInputValue('#opentherm-in-gpio', data.opentherm.inGpio < 255 ? data.opentherm.inGpio : '');
           setInputValue('#opentherm-out-gpio', data.opentherm.outGpio < 255 ? data.opentherm.outGpio : '');
           setInputValue('#opentherm-rx-led-gpio', data.opentherm.rxLedGpio < 255 ? data.opentherm.rxLedGpio : '');
-          setInputValue('#opentherm-fault-state-gpio', data.opentherm.faultStateGpio < 255 ? data.opentherm.faultStateGpio : '');
-          setCheckboxValue('#opentherm-invert-fault-state', data.opentherm.invertFaultState);
           setInputValue('#opentherm-member-id-code', data.opentherm.memberIdCode);
+          setInputValue('#opentherm-max-modulation', data.opentherm.maxModulation);
           setInputValue('#opentherm-pressure-factor', data.opentherm.pressureFactor);
           setInputValue('#opentherm-dhw-fr-factor', data.opentherm.dhwFlowRateFactor);
+          setInputValue('#opentherm-min-power', data.opentherm.minPower);
+          setInputValue('#opentherm-max-power', data.opentherm.maxPower);
           setCheckboxValue('#opentherm-dhw-present', data.opentherm.dhwPresent);
           setCheckboxValue('#opentherm-sw-mode', data.opentherm.summerWinterMode);
           setCheckboxValue('#opentherm-heating-ch2-enabled', data.opentherm.heatingCh2Enabled);
@@ -815,6 +919,21 @@
           setInputValue('#extpump-as-time', data.externalPump.antiStuckTime);
           setBusy('#extpump-settings-busy', '#extpump-settings', false);
 
+          // Cascade control
+          setCheckboxValue('#cc-input-enable', data.cascadeControl.input.enable);
+          setInputValue('#cc-input-gpio', data.cascadeControl.input.gpio < 255 ? data.cascadeControl.input.gpio : '');
+          setCheckboxValue('#cc-input-invert-state', data.cascadeControl.input.invertState);
+          setInputValue('#cc-input-tt', data.cascadeControl.input.thresholdTime);
+
+          setCheckboxValue('#cc-output-enable', data.cascadeControl.output.enable);
+          setInputValue('#cc-output-gpio', data.cascadeControl.output.gpio < 255 ? data.cascadeControl.output.gpio : '');
+          setCheckboxValue('#cc-output-invert-state', data.cascadeControl.output.invertState);
+          setInputValue('#cc-output-tt', data.cascadeControl.output.thresholdTime);
+          setCheckboxValue('#cc-on-fault', data.cascadeControl.output.onFault);
+          setCheckboxValue('#cc-on-loss-conn', data.cascadeControl.output.onLossConnection);
+          setCheckboxValue('#cc-on-enabled-heating', data.cascadeControl.output.onEnabledHeating);
+          setBusy('#cc-settings-busy', '#cc-settings', false);
+
           // Heating
           setInputValue('#heating-min-temp', data.heating.minTemp, {
             "min": data.system.unitSystem == 0 ? 0 : 32,
@@ -825,7 +944,6 @@
             "max": data.system.unitSystem == 0 ? 100 : 212
           });
           setInputValue('#heating-hysteresis', data.heating.hysteresis);
-          setInputValue('#heating-max-modulation', data.heating.maxModulation);
           setBusy('#heating-settings-busy', '#heating-settings', false);
 
           // DHW
@@ -899,6 +1017,7 @@
           setupForm('#outdoor-sensor-settings', fillData);
           setupForm('#indoor-sensor-settings', fillData, ['sensors.indoor.bleAddress']);
           setupForm('#extpump-settings', fillData);
+          setupForm('#cc-settings', fillData);
 
         } catch (error) {
           console.log(error);

src_data/scripts/utils.js

@@ -539,6 +539,17 @@ function setInputValue(selector, value, attrs = {}) {
   }
 }
 
+function setSelectValue(selector, value) {
+  let item = document.querySelector(selector);
+  if (!item) {
+    return;
+  }
+
+  for (let option of item.options) {
+    option.selected = option.value == value;
+  }
+}
+
 function show(selector) {
   let items = document.querySelectorAll(selector);
   if (!items.length) {