diff --git a/src/EMSESPDevicesService.h b/src/EMSESPDevicesService.h index 40b33ab2b..f91212fc0 100644 --- a/src/EMSESPDevicesService.h +++ b/src/EMSESPDevicesService.h @@ -24,7 +24,7 @@ #include #include -#define MAX_EMSESP_DEVICE_SIZE 2500 +#define MAX_EMSESP_DEVICE_SIZE 4096 #define EMSESP_DEVICES_SERVICE_PATH "/rest/allDevices" #define SCAN_DEVICES_SERVICE_PATH "/rest/scanDevices" diff --git a/src/devices/boiler.cpp b/src/devices/boiler.cpp index 19477d0c6..f5a1fb392 100644 --- a/src/devices/boiler.cpp +++ b/src/devices/boiler.cpp @@ -76,10 +76,6 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const Command::add_with_json(this->device_type(), F("info"), [&](const char * value, const int8_t id, JsonObject & object) { return command_info(value, id, object); }); - - if (Mqtt::mqtt_format() == Mqtt::Format::HA) { - register_mqtt_ha_config(); - } } // create the config topics for Home Assistant MQTT Discovery @@ -117,15 +113,12 @@ void Boiler::register_mqtt_ha_config() { Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWType), this->device_type(), "wWType", nullptr, nullptr); Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWChargeType), this->device_type(), "wWChargeType", nullptr, nullptr); Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCircPump), this->device_type(), "wWCircPump", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCiPuMode), this->device_type(), "wWCiPuMode", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCircPumpMode), this->device_type(), "wWCircPumpMode", nullptr, nullptr); Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCirc), this->device_type(), "wWCirc", nullptr, nullptr); - // TODO add remaining values to MQTT - /* - Mqtt::register_mqtt_ha_sensor(nullptr, F_(outdoorTemp), this->device_type(), "outdoorTemp", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCurTmp), this->device_type(), "wWCurTmp", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCurTmp2), this->device_type(), "wWCurTmp2", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCurTemp), this->device_type(), "wWCurTemp", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCurTemp2), this->device_type(), "wWCurTemp2", F_(degrees), F_(icontemperature)); Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCurFlow), this->device_type(), "wWCurFlow", F("l/min"), F_(icontemperature)); Mqtt::register_mqtt_ha_sensor(nullptr, F_(curFlowTemp), this->device_type(), "curFlowTemp", F_(degrees), F_(icontemperature)); Mqtt::register_mqtt_ha_sensor(nullptr, F_(retTemp), this->device_type(), "retTemp", F_(degrees), F_(icontemperature)); @@ -133,129 +126,109 @@ void Boiler::register_mqtt_ha_config() { Mqtt::register_mqtt_ha_sensor(nullptr, F_(sysPress), this->device_type(), "sysPress", F_(bar), nullptr); Mqtt::register_mqtt_ha_sensor(nullptr, F_(boilTemp), this->device_type(), "boilTemp", F_(degrees), nullptr); - Mqtt::register_mqtt_ha_sensor(F_(burnGas), this->device_type(), "burnGas", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(flameCurr), this->device_type(), "flameCurr", F_(uA), nullptr); - Mqtt::register_mqtt_ha_sensor(F_(heatPump), this->device_type(), "heatPump", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(fanWork), this->device_type(), "fanWork", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(ignWork), this->device_type(), "ignWork", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wWHeat), this->device_type(), "wWHeat", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(burnGas), this->device_type(), "burnGas", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(flameCurr), this->device_type(), "flameCurr", F_(uA), nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(heatPump), this->device_type(), "heatPump", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(fanWork), this->device_type(), "fanWork", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(ignWork), this->device_type(), "ignWork", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWHeat), this->device_type(), "wWHeat", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wwStorageTemp1), this->device_type(), "wwStorageTemp1", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(wwStorageTemp2), this->device_type(), "wwStorageTemp2", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(exhaustTemp), this->device_type(), "exhaustTemp", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(wWActivated), this->device_type(), "wWActivated", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wWOnetime), this->device_type(), "wWOnetime", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wwStorageTemp1), this->device_type(), "wwStorageTemp1", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wwStorageTemp2), this->device_type(), "wwStorageTemp2", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(exhaustTemp), this->device_type(), "exhaustTemp", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWActivated), this->device_type(), "wWActivated", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWOneTime), this->device_type(), "wWOneTime", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wWDisinfecting), this->device_type(), "wWDisinfecting", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wWCharge), this->device_type(), "wWCharge", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wWRecharge), this->device_type(), "wWRecharge", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wWTempOK), this->device_type(), "wWTempOK", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wWActive), this->device_type(), "wWActive", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWDisinfecting), this->device_type(), "wWDisinfecting", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWCharging), this->device_type(), "wWCharging", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWRecharging), this->device_type(), "wWRecharging", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWTempOK), this->device_type(), "wWTempOK", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWActive), this->device_type(), "wWActive", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(heatingActivated), this->device_type(), "heatingActivated", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(heatingTemp), this->device_type(), "heatingTemp", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(pumpModMax), this->device_type(), "pumpModMax", F_(percent), F_(iconpercent)); - Mqtt::register_mqtt_ha_sensor(F_(pumpModMin), this->device_type(), "pumpModMin", F_(percent), F_(iconpercent)); - Mqtt::register_mqtt_ha_sensor(F_(pumpDelay), this->device_type(), "pumpDelay", F_(min), nullptr); - Mqtt::register_mqtt_ha_sensor(F_(burnMinPeriod), this->device_type(), "burnMinPeriod", F_(min), nullptr); - Mqtt::register_mqtt_ha_sensor(F_(burnMinPower), this->device_type(), "burnMinPower", F_(percent), F_(iconpercent)); - Mqtt::register_mqtt_ha_sensor(F_(burnMaxPower), this->device_type(), "burnMaxPower", F_(percent), F_(iconpercent)); - Mqtt::register_mqtt_ha_sensor(F_(boilHystOn), this->device_type(), "boilHystOn", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(boilHystOff), this->device_type(), "boilHystOff", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(setFlowTemp), this->device_type(), "setFlowTemp", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(wWSetPumpPower), this->device_type(), "wWSetPumpPower", F_(percent), F_(iconpercent)); - Mqtt::register_mqtt_ha_sensor(F_(wwMixTemperature), this->device_type(), "wwMixTemperature", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(wwBufferBoilerTemperature), this->device_type(), "wwBufferBoilerTemperature", F_(degrees), F_(icontemperature)); - Mqtt::register_mqtt_ha_sensor(F_(wWStarts), this->device_type(), "wWStarts", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(wWWorkM), this->device_type(), "wWWorkM", nullptr, nullptr); - Mqtt::register_mqtt_ha_sensor(F_(setBurnPow), this->device_type(), "setBurnPow", F_(percent), F_(iconpercent)); - Mqtt::register_mqtt_ha_sensor(F_(burnStarts), this->device_type(), "burnStarts", nullptr, nullptr); - - - */ + Mqtt::register_mqtt_ha_sensor(nullptr, F_(heatingActivated), this->device_type(), "heatingActivated", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(heatingTemp), this->device_type(), "heatingTemp", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(pumpModMax), this->device_type(), "pumpModMax", F_(percent), F_(iconpercent)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(pumpModMin), this->device_type(), "pumpModMin", F_(percent), F_(iconpercent)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(pumpDelay), this->device_type(), "pumpDelay", F_(min), nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(burnMinPeriod), this->device_type(), "burnMinPeriod", F_(min), nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(burnMinPower), this->device_type(), "burnMinPower", F_(percent), F_(iconpercent)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(burnMaxPower), this->device_type(), "burnMaxPower", F_(percent), F_(iconpercent)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(boilHystOn), this->device_type(), "boilHystOn", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(boilHystOff), this->device_type(), "boilHystOff", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(setFlowTemp), this->device_type(), "setFlowTemp", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWSetPumpPower), this->device_type(), "wWSetPumpPower", F_(percent), F_(iconpercent)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wwMixTemperature), this->device_type(), "wwMixTemperature", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wwBufferBoilerTemperature), this->device_type(), "wwBufferBoilerTemperature", F_(degrees), F_(icontemperature)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWStarts), this->device_type(), "wWStarts", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(wWWorkM), this->device_type(), "wWWorkM", nullptr, nullptr); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(setBurnPow), this->device_type(), "setBurnPow", F_(percent), F_(iconpercent)); + Mqtt::register_mqtt_ha_sensor(nullptr, F_(burnStarts), this->device_type(), "burnStarts", nullptr, nullptr); } // send stuff to the Web UI void Boiler::device_info_web(JsonArray & root) { JsonObject dataElement; - render_value_json(root, "", F_(serviceCode), serviceCodeChar_, nullptr); - render_value_json(root, "", F_(serviceCodeNumber), serviceCode_, nullptr); - render_value_json(root, "", F_(tapwaterActive), tap_water_active_, nullptr, EMS_VALUE_BOOL); - render_value_json(root, "", F_(heatingActive), heating_active_, nullptr, EMS_VALUE_BOOL); - render_value_json(root, "", F_(selFlowTemp), selFlowTemp_, F_(degrees)); - render_value_json(root, "", F_(curFlowTemp), curFlowTemp_, F_(degrees), 10); + render_value_json(root, "", F_(heatingActive), heatingActive_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(tapwaterActive), tapwaterActive_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(serviceCode), serviceCode_, nullptr); + render_value_json(root, "", F_(serviceCodeNumber), serviceCodeNumber_, nullptr); render_value_json(root, "", F_(wWSelTemp), wWSelTemp_, F_(degrees)); - render_value_json(root, "", F_(wWSetTemp), wWSetTmp_, F_(degrees)); - render_value_json(root, "", F_(wWCurTmp), wWCurTmp_, F_(degrees), 10); - render_value_json(root, "", F_(wWCurTmp2), wWCurTmp2_, F_(degrees), 10); + render_value_json(root, "", F_(wWSetTemp), wWSetTemp_, F_(degrees)); + render_value_json(root, "", F_(wWDisinfectionTemp), wWDisinfectionTemp_, F_(degrees)); + render_value_json(root, "", F_(selFlowTemp), selFlowTemp_, F_(degrees)); + render_value_json(root, "", F_(selBurnPow), selBurnPow_, F_(percent)); + render_value_json(root, "", F_(curBurnPow), curBurnPow_, F_(percent)); render_value_json(root, "", F_(pumpMod), pumpMod_, F_(percent)); render_value_json(root, "", F_(pumpMod2), pumpMod2_, F_(percent)); + render_value_json(root, "", F_(wWType), wWType_, nullptr); + render_value_json(root, "", F_(wWChargeType), wWChargeType_, nullptr); + render_value_json(root, "", F_(wWCircPump), wWCircPump_, nullptr); + render_value_json(root, "", F_(wWCircPumpMode), wWCircPumpMode_, nullptr); + render_value_json(root, "", F_(wWCirc), wWCirc_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(outdoorTemp), outdoorTemp_, F_(degrees), 10); + render_value_json(root, "", F_(wWCurTemp), wWCurTemp_, F_(degrees), 10); + render_value_json(root, "", F_(wWCurTemp2), wWCurTemp2_, F_(degrees), 10); + render_value_json(root, "", F_(wWCurFlow), wWCurFlow_, F("l/min"), 10); + render_value_json(root, "", F_(curFlowTemp), curFlowTemp_, F_(degrees), 10); + render_value_json(root, "", F_(retTemp), retTemp_, F_(degrees), 10); + render_value_json(root, "", F_(switchTemp), switchTemp_, F_(degrees), 10); render_value_json(root, "", F_(sysPress), sysPress_, F_(bar), 10); - - // TODO add remaining values to web - /* - render_value_json(root, "", F_(heatingActive), "heatingActive", nullptr, nullptr); - render_value_json(root, "", F_(tapwaterActive), "tapwaterActive", nullptr, nullptr); - render_value_json(root, "", F_(serviceCode), "serviceCode", nullptr, nullptr); - render_value_json(root, "", F_(serviceCodeNumber), "serviceCodeNumber", nullptr, nullptr); - render_value_json(root, "", F_(wWSelTemp), "wWSelTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wWSetTemp), "wWSetTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wWDisinfectionTemp), "wWDisinfectionTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(selFlowTemp), "selFlowTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(selBurnPow), "selBurnPow", F_(percent), nullptr); - render_value_json(root, "", F_(curBurnPow), "curBurnPow", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(pumpMod), "pumpMod", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(pumpMod2), "pumpMod2", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(wWType), "wWType", nullptr, nullptr); - render_value_json(root, "", F_(wWChargeType), "wWChargeType", nullptr, nullptr); - render_value_json(root, "", F_(wWCircPump), "wWCircPump", nullptr, nullptr); - render_value_json(root, "", F_(wWCiPuMode), "wWCiPuMode", nullptr, nullptr); - render_value_json(root, "", F_(wWCirc), "wWCirc", nullptr, nullptr); - render_value_json(root, "", F_(outdoorTemp), "outdoorTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wWCurTmp), "wWCurTmp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wWCurTmp2), "wWCurTmp2", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wWCurFlow), "wWCurFlow", F("l/min"), F_(icontemperature)); - render_value_json(root, "", F_(curFlowTemp), "curFlowTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(retTemp), "retTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(switchTemp), "switchTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(sysPress), "sysPress", F_(bar), nullptr); - render_value_json(root, "", F_(boilTemp), "boilTemp", F_(degrees), nullptr); - render_value_json(root, "", F_(wwStorageTemp1), "wwStorageTemp1", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wwStorageTemp2), "wwStorageTemp2", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(exhaustTemp), "exhaustTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wWActivated), "wWActivated", nullptr, nullptr); - render_value_json(root, "", F_(wWOnetime), "wWOnetime", nullptr, nullptr); - render_value_json(root, "", F_(wWDisinfecting), "wWDisinfecting", nullptr, nullptr); - render_value_json(root, "", F_(wWCharge), "wWCharge", nullptr, nullptr); - render_value_json(root, "", F_(wWRecharge), "wWRecharge", nullptr, nullptr); - render_value_json(root, "", F_(wWTempOK), "wWTempOK", nullptr, nullptr); - render_value_json(root, "", F_(wWActive), "wWActive", nullptr, nullptr); - render_value_json(root, "", F_(burnGas), "burnGas", nullptr, nullptr); - render_value_json(root, "", F_(flameCurr), "flameCurr", F_(uA), nullptr); - render_value_json(root, "", F_(heatPump), "heatPump", nullptr, nullptr); - render_value_json(root, "", F_(fanWork), "fanWork", nullptr, nullptr); - render_value_json(root, "", F_(ignWork), "ignWork", nullptr, nullptr); - render_value_json(root, "", F_(wWHeat), "wWHeat", nullptr, nullptr); - render_value_json(root, "", F_(heatingActivated), "heatingActivated", nullptr, nullptr); - render_value_json(root, "", F_(heatingTemp), "heatingTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(pumpModMax), "pumpModMax", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(pumpModMin), "pumpModMin", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(pumpDelay), "pumpDelay", F_(min), nullptr); - render_value_json(root, "", F_(burnMinPeriod), "burnMinPeriod", F_(min), nullptr); - render_value_json(root, "", F_(burnMinPower), "burnMinPower", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(burnMaxPower), "burnMaxPower", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(boilHystOn), "boilHystOn", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(boilHystOff), "boilHystOff", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(setFlowTemp), "setFlowTemp", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wWSetPumpPower), "wWSetPumpPower", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(wwMixTemperature), "wwMixTemperature", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wwBufferBoilerTemperature), "wwBufferBoilerTemperature", F_(degrees), F_(icontemperature)); - render_value_json(root, "", F_(wWStarts), "wWStarts", nullptr, nullptr); - render_value_json(root, "", F_(wWWorkM), "wWWorkM", nullptr, nullptr); - render_value_json(root, "", F_(setBurnPow), "setBurnPow", F_(percent), F_(iconpercent)); - render_value_json(root, "", F_(burnStarts), "burnStarts", nullptr, nullptr); -*/ + render_value_json(root, "", F_(boilTemp), boilTemp_, F_(degrees), 10); + render_value_json(root, "", F_(wwStorageTemp1), wwStorageTemp1_, F_(degrees), 10); + render_value_json(root, "", F_(wwStorageTemp2), wwStorageTemp2_, F_(degrees), 10); + render_value_json(root, "", F_(exhaustTemp), exhaustTemp_, F_(degrees), 10); + render_value_json(root, "", F_(wWActivated), wWActivated_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(wWOneTime), wWOneTime_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(wWDisinfecting), wWDisinfecting_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(wWCharging), wWCharging_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(wWRecharging), wWRecharging_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(wWTempOK), wWTempOK_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(wWActive), wWActive_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(burnGas), burnGas_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(flameCurr), flameCurr_, F_(uA), 10); + render_value_json(root, "", F_(heatPump), heatPump_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(fanWork), fanWork_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(ignWork), ignWork_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(wWHeat), wWHeat_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(heatingActivated), heatingActivated_, nullptr, EMS_VALUE_BOOL); + render_value_json(root, "", F_(heatingTemp), heatingTemp_, F_(degrees)); + render_value_json(root, "", F_(pumpModMax), pumpModMax_, F_(percent)); + render_value_json(root, "", F_(pumpModMin), pumpModMin_, F_(percent)); + render_value_json(root, "", F_(pumpDelay), pumpDelay_, F_(min)); + render_value_json(root, "", F_(burnMinPeriod), burnMinPeriod_, F_(min)); + render_value_json(root, "", F_(burnMinPower), burnMinPower_, F_(percent)); + render_value_json(root, "", F_(burnMaxPower), burnMaxPower_, F_(percent)); + render_value_json(root, "", F_(boilHystOn), boilHystOn_, F_(degrees)); + render_value_json(root, "", F_(boilHystOff), boilHystOff_, F_(degrees)); + render_value_json(root, "", F_(setFlowTemp), setFlowTemp_, F_(degrees)); + render_value_json(root, "", F_(wWSetPumpPower), wWSetPumpPower_, F_(percent)); + render_value_json(root, "", F_(wwMixTemperature), wwMixTemperature_, F_(degrees)); + render_value_json(root, "", F_(wwBufferBoilerTemperature), wwBufferBoilerTemperature_, F_(degrees)); + render_value_json(root, "", F_(wWStarts), wWStarts_, nullptr); + render_value_json(root, "", F_(wWWorkM), wWWorkM_, nullptr); + render_value_json(root, "", F_(setBurnPow), setBurnPow_, F_(percent)); + render_value_json(root, "", F_(burnStarts), burnStarts_, nullptr); } bool Boiler::command_info(const char * value, const int8_t id, JsonObject & output) { @@ -268,13 +241,13 @@ bool Boiler::export_values(JsonObject & output) { char s[10]; // for formatting strings // Hot tap water bool - if (Helpers::hasValue(heating_active_, EMS_VALUE_BOOL)) { - output["heatingActive"] = Helpers::render_value(s, heating_active_, EMS_VALUE_BOOL); + if (Helpers::hasValue(heatingActive_, EMS_VALUE_BOOL)) { + output["heatingActive"] = Helpers::render_value(s, heatingActive_, EMS_VALUE_BOOL); } // Central heating bool - if (Helpers::hasValue(tap_water_active_, EMS_VALUE_BOOL)) { - output["tapwaterActive"] = Helpers::render_value(s, tap_water_active_, EMS_VALUE_BOOL); + if (Helpers::hasValue(tapwaterActive_, EMS_VALUE_BOOL)) { + output["tapwaterActive"] = Helpers::render_value(s, tapwaterActive_, EMS_VALUE_BOOL); } // Warm Water comfort setting @@ -294,13 +267,13 @@ bool Boiler::export_values(JsonObject & output) { } // Warm Water set temperature - if (Helpers::hasValue(wWSetTmp_)) { - output["wWSetTemp"] = wWSetTmp_; + if (Helpers::hasValue(wWSetTemp_)) { + output["wWSetTemp"] = wWSetTemp_; } // Warm Water disinfection temperature - if (Helpers::hasValue(wWDisinfectTemp_)) { - output["wWDisinfectionTemp"] = wWDisinfectTemp_; + if (Helpers::hasValue(wWDisinfectionTemp_)) { + output["wWDisinfectionTemp"] = wWDisinfectionTemp_; } // Selected flow temperature deg @@ -354,7 +327,7 @@ bool Boiler::export_values(JsonObject & output) { // Warm Water circulation pump freq if (Helpers::hasValue(wWCircPumpMode_)) { if (wWCircPumpMode_ == 7) { - output["wWCiPuMode"] = F("continuous"); + output["wWCircPumpMode"] = F("continuous"); } else { char s[7]; char buffer[2]; @@ -362,7 +335,7 @@ bool Boiler::export_values(JsonObject & output) { buffer[1] = '\0'; strlcpy(s, buffer, 7); strlcat(s, "x3min", 7); - output["wWCiPuMode"] = s; + output["wWCircPumpMode"] = s; } } @@ -372,18 +345,18 @@ bool Boiler::export_values(JsonObject & output) { } // Outside temperature - if (Helpers::hasValue(extTemp_)) { - output["outdoorTemp"] = (float)extTemp_ / 10; + if (Helpers::hasValue(outdoorTemp_)) { + output["outdoorTemp"] = (float)outdoorTemp_ / 10; } // Warm Water current temperature (intern) - if (Helpers::hasValue(wWCurTmp_)) { - output["wWCurTmp"] = (float)wWCurTmp_ / 10; + if (Helpers::hasValue(wWCurTemp_)) { + output["wWCurTemp"] = (float)wWCurTemp_ / 10; } // Warm Water current temperature (extern) - if (Helpers::hasValue(wWCurTmp2_)) { - output["wWCurTmp2"] = (float)wWCurTmp2_ / 10; + if (Helpers::hasValue(wWCurTemp2_)) { + output["wWCurTemp2"] = (float)wWCurTemp2_ / 10; } // Warm Water current tap water flow l/min @@ -438,7 +411,7 @@ bool Boiler::export_values(JsonObject & output) { // Warm Water one time charging bool if (Helpers::hasValue(wWOneTime_, EMS_VALUE_BOOL)) { - output["wWOnetime"] = Helpers::render_value(s, wWOneTime_, EMS_VALUE_BOOL); + output["wWOneTime"] = Helpers::render_value(s, wWOneTime_, EMS_VALUE_BOOL); } // Warm Water disinfecting bool @@ -448,17 +421,17 @@ bool Boiler::export_values(JsonObject & output) { // Warm water charging bool if (Helpers::hasValue(wWCharging_, EMS_VALUE_BOOL)) { - output["wWCharge"] = Helpers::render_value(s, wWCharging_, EMS_VALUE_BOOL); + output["wWCharging"] = Helpers::render_value(s, wWCharging_, EMS_VALUE_BOOL); } // Warm water recharge bool if (Helpers::hasValue(wWRecharging_, EMS_VALUE_BOOL)) { - output["wWRecharge"] = Helpers::render_value(s, wWRecharging_, EMS_VALUE_BOOL); + output["wWRecharging"] = Helpers::render_value(s, wWRecharging_, EMS_VALUE_BOOL); } // Warm water temperature ok bool - if (Helpers::hasValue(wWTemperatureOK_, EMS_VALUE_BOOL)) { - output["wWTempOK"] = Helpers::render_value(s, wWTemperatureOK_, EMS_VALUE_BOOL); + if (Helpers::hasValue(wWTempOK_, EMS_VALUE_BOOL)) { + output["wWTempOK"] = Helpers::render_value(s, wWTempOK_, EMS_VALUE_BOOL); } // Warm water active bool @@ -477,8 +450,8 @@ bool Boiler::export_values(JsonObject & output) { } // Boiler pump bool - if (Helpers::hasValue(heatPmp_, EMS_VALUE_BOOL)) { - output["heatPump"] = Helpers::render_value(s, heatPmp_, EMS_VALUE_BOOL); + if (Helpers::hasValue(heatPump_, EMS_VALUE_BOOL)) { + output["heatPump"] = Helpers::render_value(s, heatPump_, EMS_VALUE_BOOL); } // Fan bool @@ -497,23 +470,23 @@ bool Boiler::export_values(JsonObject & output) { } // heating activated bool - if (Helpers::hasValue(heating_activated_, EMS_VALUE_BOOL)) { - output["heatingActivated"] = Helpers::render_value(s, heating_activated_, EMS_VALUE_BOOL); + if (Helpers::hasValue(heatingActivated_, EMS_VALUE_BOOL)) { + output["heatingActivated"] = Helpers::render_value(s, heatingActivated_, EMS_VALUE_BOOL); } // Heating temperature setting on the boiler - if (Helpers::hasValue(heating_temp_)) { - output["heatingTemp"] = heating_temp_; + if (Helpers::hasValue(heatingTemp_)) { + output["heatingTemp"] = heatingTemp_; } // Boiler circuit pump modulation max power % - if (Helpers::hasValue(pump_mod_max_)) { - output["pumpModMax"] = pump_mod_max_; + if (Helpers::hasValue(pumpModMax_)) { + output["pumpModMax"] = pumpModMax_; } // Boiler circuit pump modulation min power % - if (Helpers::hasValue(pump_mod_min_)) { - output["pumpModMin"] = pump_mod_min_; + if (Helpers::hasValue(pumpModMin_)) { + output["pumpModMin"] = pumpModMin_; } // Boiler circuit pump delay time min @@ -522,28 +495,28 @@ bool Boiler::export_values(JsonObject & output) { } // Boiler burner min period min - if (Helpers::hasValue(burnPeriod_)) { - output["burnMinPeriod"] = burnPeriod_; + if (Helpers::hasValue(burnMinPeriod_)) { + output["burnMinPeriod"] = burnMinPeriod_; } // Boiler burner min power % - if (Helpers::hasValue(burnPowermin_)) { - output["burnMinPower"] = burnPowermin_; + if (Helpers::hasValue(burnMinPower_)) { + output["burnMinPower"] = burnMinPower_; } // Boiler burner max power % - if (Helpers::hasValue(burnPowermax_)) { - output["burnMaxPower"] = burnPowermax_; + if (Helpers::hasValue(burnMaxPower_)) { + output["burnMaxPower"] = burnMaxPower_; } // Boiler temp hysteresis on degrees - if (Helpers::hasValue(boilTemp_on_)) { - output["boilHystOn"] = boilTemp_on_; + if (Helpers::hasValue(boilHystOn_)) { + output["boilHystOn"] = boilHystOn_; } // Boiler temp hysteresis off degrees - if (Helpers::hasValue(boilTemp_off_)) { - output["boilHystOff"] = boilTemp_off_; + if (Helpers::hasValue(boilHystOff_)) { + output["boilHystOff"] = boilHystOff_; } // Set Flow temperature @@ -552,8 +525,8 @@ bool Boiler::export_values(JsonObject & output) { } // Warm Water pump set power % - if (Helpers::hasValue(setWWPumpPow_)) { - output["wWSetPumpPower"] = setWWPumpPow_; + if (Helpers::hasValue(wWSetPumpPower_)) { + output["wWSetPumpPower"] = wWSetPumpPower_; } // Warm water mix temperature @@ -603,9 +576,9 @@ bool Boiler::export_values(JsonObject & output) { // Service Code // Service Code Number - if (Helpers::hasValue(serviceCode_)) { - output["serviceCode"] = serviceCodeChar_; - output["serviceCodeNumber"] = serviceCode_; + if (Helpers::hasValue(serviceCodeNumber_)) { + output["serviceCode"] = serviceCode_; + output["serviceCodeNumber"] = serviceCodeNumber_; } return (output.size()); @@ -613,9 +586,16 @@ bool Boiler::export_values(JsonObject & output) { // publish values via MQTT void Boiler::publish_values() { - StaticJsonDocument doc; - JsonObject output = doc.to(); + // must make sure this doesn't exist 1000. Currently (2.1.0) its 950b. + // otheerwise use DynamicJsonDocument with max size and use .shrinkToFit() + StaticJsonDocument<1024> doc; + JsonObject output = doc.to(); if (export_values(output)) { + // see if we need to send out HA MQTT Discovery topics + if ((Mqtt::mqtt_format() == Mqtt::Format::HA) && (!mqtt_ha_config_)) { + register_mqtt_ha_config(); + mqtt_ha_config_ = true; + } Mqtt::publish(F("boiler_data"), doc.as()); } @@ -658,11 +638,11 @@ void Boiler::show_values(uuid::console::Shell & shell) { print_value_json(shell, F("wWType"), F_(wWType), nullptr, output); print_value_json(shell, F("wWChargeType"), F_(wWChargeType), nullptr, output); print_value_json(shell, F("wWCircPump"), F_(wWCircPump), nullptr, output); - print_value_json(shell, F("wWCiPuMode"), F_(wWCiPuMode), nullptr, output); + print_value_json(shell, F("wWCircPumpMode"), F_(wWCircPumpMode), nullptr, output); print_value_json(shell, F("wWCirc"), F_(wWCirc), nullptr, output); print_value_json(shell, F("outdoorTemp"), F_(outdoorTemp), F_(degrees), output); - print_value_json(shell, F("wWCurTmp"), F_(wWCurTmp), F_(degrees), output); - print_value_json(shell, F("wWCurTmp2"), F_(wWCurTmp2), F_(degrees), output); + print_value_json(shell, F("wWCurTemp"), F_(wWCurTemp), F_(degrees), output); + print_value_json(shell, F("wWCurTemp2"), F_(wWCurTemp2), F_(degrees), output); print_value_json(shell, F("wWCurFlow"), F_(wWCurFlow), F("l/min"), output); print_value_json(shell, F("curFlowTemp"), F_(curFlowTemp), F_(degrees), output); print_value_json(shell, F("retTemp"), F_(retTemp), F_(degrees), output); @@ -673,10 +653,10 @@ void Boiler::show_values(uuid::console::Shell & shell) { print_value_json(shell, F("wwStorageTemp2"), F_(wwStorageTemp2), F_(degrees), output); print_value_json(shell, F("exhaustTemp"), F_(exhaustTemp), F_(degrees), output); print_value_json(shell, F("wWActivated"), F_(wWActivated), nullptr, output); - print_value_json(shell, F("wWOnetime"), F_(wWOnetime), nullptr, output); + print_value_json(shell, F("wWOneTime"), F_(wWOneTime), nullptr, output); print_value_json(shell, F("wWDisinfecting"), F_(wWDisinfecting), nullptr, output); - print_value_json(shell, F("wWCharge"), F_(wWCharge), nullptr, output); - print_value_json(shell, F("wWRecharge"), F_(wWRecharge), nullptr, output); + print_value_json(shell, F("wWCharging"), F_(wWCharging), nullptr, output); + print_value_json(shell, F("wWRecharging"), F_(wWRecharging), nullptr, output); print_value_json(shell, F("wWTempOK"), F_(wWTempOK), nullptr, output); print_value_json(shell, F("wWActive"), F_(wWActive), nullptr, output); print_value_json(shell, F("burnGas"), F_(burnGas), nullptr, output); @@ -730,14 +710,14 @@ void Boiler::check_active() { char s[7]; bool b = ((boilerState_ & 0x09) == 0x09); Mqtt::publish(F("heating_active"), Helpers::render_boolean(s, b)); - heating_active_ = b ? EMS_VALUE_BOOL_ON : EMS_VALUE_BOOL_OFF; + heatingActive_ = b ? EMS_VALUE_BOOL_ON : EMS_VALUE_BOOL_OFF; } if ((boilerState_ & 0x0A) != (last_boilerState & 0x0A)) { char s[7]; bool b = ((boilerState_ & 0x0A) == 0x0A); Mqtt::publish(F("tapwater_active"), Helpers::render_boolean(s, b)); - tap_water_active_ = b ? EMS_VALUE_BOOL_ON : EMS_VALUE_BOOL_OFF; + tapwaterActive_ = b ? EMS_VALUE_BOOL_ON : EMS_VALUE_BOOL_OFF; EMSESP::tap_water_active(b); // let EMS-ESP know, used in the Shower class } @@ -777,7 +757,7 @@ void Boiler::process_UBAParameterWW(std::shared_ptr telegram) { changed_ |= telegram->read_value(wWCircPumpMode_, 7); // 1=1x3min... 6=6x3min, 7=continuous changed_ |= telegram->read_value(wWChargeType_, 10); // 0 = charge pump, 0xff = 3-way valve changed_ |= telegram->read_value(wWSelTemp_, 2); - changed_ |= telegram->read_value(wWDisinfectTemp_, 8); + changed_ |= telegram->read_value(wWDisinfectionTemp_, 8); changed_ |= telegram->read_value(wWComfort_, 9); } @@ -792,7 +772,7 @@ void Boiler::process_UBAMonitorFast(std::shared_ptr telegram) { changed_ |= telegram->read_bitvalue(burnGas_, 7, 0); changed_ |= telegram->read_bitvalue(fanWork_, 7, 2); changed_ |= telegram->read_bitvalue(ignWork_, 7, 3); - changed_ |= telegram->read_bitvalue(heatPmp_, 7, 5); + changed_ |= telegram->read_bitvalue(heatPump_, 7, 5); changed_ |= telegram->read_bitvalue(wWHeat_, 7, 6); changed_ |= telegram->read_bitvalue(wWCirc_, 7, 7); @@ -803,18 +783,19 @@ void Boiler::process_UBAMonitorFast(std::shared_ptr telegram) { changed_ |= telegram->read_value(retTemp_, 13); changed_ |= telegram->read_value(flameCurr_, 15); - changed_ |= telegram->read_value(serviceCode_, 20); // system pressure. FF means missing changed_ |= telegram->read_value(sysPress_, 17); // is *10 // read the service code / installation status as appears on the display if ((telegram->message_length > 18) && (telegram->offset == 0)) { - changed_ |= telegram->read_value(serviceCodeChar_[0], 18); - changed_ |= telegram->read_value(serviceCodeChar_[1], 19); - serviceCodeChar_[2] = '\0'; // null terminate string + changed_ |= telegram->read_value(serviceCode_[0], 18); + changed_ |= telegram->read_value(serviceCode_[1], 19); + serviceCode_[2] = '\0'; // null terminate string } + changed_ |= telegram->read_value(serviceCodeNumber_, 20); + // at this point do a quick check to see if the hot water or heating is active check_active(); } @@ -831,16 +812,16 @@ void Boiler::process_UBATotalUptime(std::shared_ptr telegram) { * UBAParameters - type 0x16 */ void Boiler::process_UBAParameters(std::shared_ptr telegram) { - changed_ |= telegram->read_value(heating_activated_, 0); - changed_ |= telegram->read_value(heating_temp_, 1); - changed_ |= telegram->read_value(burnPowermax_, 2); - changed_ |= telegram->read_value(burnPowermin_, 3); - changed_ |= telegram->read_value(boilTemp_off_, 4); - changed_ |= telegram->read_value(boilTemp_on_, 5); - changed_ |= telegram->read_value(burnPeriod_, 6); + changed_ |= telegram->read_value(heatingActivated_, 0); + changed_ |= telegram->read_value(heatingTemp_, 1); + changed_ |= telegram->read_value(burnMaxPower_, 2); + changed_ |= telegram->read_value(burnMinPower_, 3); + changed_ |= telegram->read_value(boilHystOff_, 4); + changed_ |= telegram->read_value(boilHystOn_, 5); + changed_ |= telegram->read_value(burnMinPeriod_, 6); changed_ |= telegram->read_value(pumpDelay_, 8); - changed_ |= telegram->read_value(pump_mod_max_, 9); - changed_ |= telegram->read_value(pump_mod_min_, 10); + changed_ |= telegram->read_value(pumpModMax_, 9); + changed_ |= telegram->read_value(pumpModMin_, 10); } /* @@ -848,9 +829,9 @@ void Boiler::process_UBAParameters(std::shared_ptr telegram) { * received every 10 seconds */ void Boiler::process_UBAMonitorWW(std::shared_ptr telegram) { - changed_ |= telegram->read_value(wWSetTmp_, 0); - changed_ |= telegram->read_value(wWCurTmp_, 1); - changed_ |= telegram->read_value(wWCurTmp2_, 3); + changed_ |= telegram->read_value(wWSetTemp_, 0); + changed_ |= telegram->read_value(wWCurTemp_, 1); + changed_ |= telegram->read_value(wWCurTemp2_, 3); changed_ |= telegram->read_value(wWCurFlow_, 9); changed_ |= telegram->read_value(wWType_, 8); @@ -861,7 +842,7 @@ void Boiler::process_UBAMonitorWW(std::shared_ptr telegram) { changed_ |= telegram->read_bitvalue(wWDisinfecting_, 5, 2); changed_ |= telegram->read_bitvalue(wWCharging_, 5, 3); changed_ |= telegram->read_bitvalue(wWRecharging_, 5, 4); - changed_ |= telegram->read_bitvalue(wWTemperatureOK_, 5, 5); + changed_ |= telegram->read_bitvalue(wWTempOK_, 5, 5); changed_ |= telegram->read_bitvalue(wWActive_, 5, 6); } @@ -880,9 +861,9 @@ void Boiler::process_UBAMonitorFastPlus(std::shared_ptr telegram // read the service code / installation status as appears on the display if ((telegram->message_length > 4) && (telegram->offset == 0)) { - changed_ |= telegram->read_value(serviceCodeChar_[0], 4); - changed_ |= telegram->read_value(serviceCodeChar_[1], 5); - serviceCodeChar_[2] = '\0'; + changed_ |= telegram->read_value(serviceCode_[0], 4); + changed_ |= telegram->read_value(serviceCode_[1], 5); + serviceCode_[2] = '\0'; } // at this point do a quick check to see if the hot water or heating is active @@ -897,7 +878,7 @@ void Boiler::process_UBAMonitorFastPlus(std::shared_ptr telegram * 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 17 19 20 21 22 23 24 */ void Boiler::process_UBAMonitorSlow(std::shared_ptr telegram) { - changed_ |= telegram->read_value(extTemp_, 0); + changed_ |= telegram->read_value(outdoorTemp_, 0); changed_ |= telegram->read_value(boilTemp_, 2); changed_ |= telegram->read_value(exhaustTemp_, 4); changed_ |= telegram->read_value(switchTemp_, 25); // only if there is a mixing module present @@ -920,7 +901,7 @@ void Boiler::process_UBAMonitorSlowPlus2(std::shared_ptr telegra void Boiler::process_UBAMonitorSlowPlus(std::shared_ptr telegram) { changed_ |= telegram->read_bitvalue(fanWork_, 2, 2); changed_ |= telegram->read_bitvalue(ignWork_, 2, 3); - changed_ |= telegram->read_bitvalue(heatPmp_, 2, 5); + changed_ |= telegram->read_bitvalue(heatPump_, 2, 5); changed_ |= telegram->read_bitvalue(wWCirc_, 2, 7); changed_ |= telegram->read_value(burnStarts_, 10, 3); // force to 3 bytes changed_ |= telegram->read_value(burnWorkMin_, 13, 3); // force to 3 bytes @@ -932,13 +913,13 @@ void Boiler::process_UBAMonitorSlowPlus(std::shared_ptr telegram * UBAParametersPlus - type 0xe6 */ void Boiler::process_UBAParametersPlus(std::shared_ptr telegram) { - changed_ |= telegram->read_value(heating_activated_, 0); - changed_ |= telegram->read_value(heating_temp_, 1); - changed_ |= telegram->read_value(burnPowermax_, 6); - changed_ |= telegram->read_value(burnPowermin_, 7); - changed_ |= telegram->read_value(boilTemp_off_, 8); - changed_ |= telegram->read_value(boilTemp_on_, 9); - changed_ |= telegram->read_value(burnPeriod_, 10); + changed_ |= telegram->read_value(heatingActivated_, 0); + changed_ |= telegram->read_value(heatingTemp_, 1); + changed_ |= telegram->read_value(burnMaxPower_, 6); + changed_ |= telegram->read_value(burnMinPower_, 7); + changed_ |= telegram->read_value(boilHystOff_, 8); + changed_ |= telegram->read_value(boilHystOn_, 9); + changed_ |= telegram->read_value(burnMinPeriod_, 10); } // 0xEA @@ -953,9 +934,9 @@ void Boiler::process_UBAParameterWWPlus(std::shared_ptr telegram // 0xE9 - DHW Status // e.g. 08 00 E9 00 37 01 F6 01 ED 00 00 00 00 41 3C 00 00 00 00 00 00 00 00 00 00 00 00 37 00 00 00 (CRC=77) #data=27 void Boiler::process_UBADHWStatus(std::shared_ptr telegram) { - changed_ |= telegram->read_value(wWSetTmp_, 0); - changed_ |= telegram->read_value(wWCurTmp_, 1); - changed_ |= telegram->read_value(wWCurTmp2_, 3); + changed_ |= telegram->read_value(wWSetTemp_, 0); + changed_ |= telegram->read_value(wWCurTemp_, 1); + changed_ |= telegram->read_value(wWCurTemp2_, 3); changed_ |= telegram->read_value(wWWorkM_, 17, 3); // force to 3 bytes changed_ |= telegram->read_value(wWStarts_, 14, 3); // force to 3 bytes @@ -964,12 +945,12 @@ void Boiler::process_UBADHWStatus(std::shared_ptr telegram) { changed_ |= telegram->read_bitvalue(wWDisinfecting_, 12, 3); changed_ |= telegram->read_bitvalue(wWCharging_, 12, 4); changed_ |= telegram->read_bitvalue(wWRecharging_, 13, 4); - changed_ |= telegram->read_bitvalue(wWTemperatureOK_, 13, 5); + changed_ |= telegram->read_bitvalue(wWTempOK_, 13, 5); changed_ |= telegram->read_bitvalue(wWCircPump_, 13, 2); // changed_ |= telegram->read_value(wWActivated_, 20); // Activated is in 0xEA, this is something other 0/100% changed_ |= telegram->read_value(wWSelTemp_, 10); - changed_ |= telegram->read_value(wWDisinfectTemp_, 9); + changed_ |= telegram->read_value(wWDisinfectionTemp_, 9); } // 0x2A - MC10Status @@ -984,14 +965,14 @@ void Boiler::process_MC10Status(std::shared_ptr telegram) { * UBAOutdoorTemp - type 0xD1 - external temperature EMS+ */ void Boiler::process_UBAOutdoorTemp(std::shared_ptr telegram) { - changed_ |= telegram->read_value(extTemp_, 0); + changed_ |= telegram->read_value(outdoorTemp_, 0); } // UBASetPoint 0x1A void Boiler::process_UBASetPoints(std::shared_ptr telegram) { - changed_ |= telegram->read_value(setFlowTemp_, 0); // boiler set temp from thermostat - changed_ |= telegram->read_value(setBurnPow_, 1); // max output power in % - changed_ |= telegram->read_value(setWWPumpPow_, 2); // ww pump speed/power? + changed_ |= telegram->read_value(setFlowTemp_, 0); // boiler set temp from thermostat + changed_ |= telegram->read_value(setBurnPow_, 1); // max output power in % + changed_ |= telegram->read_value(wWSetPumpPower_, 2); // ww pump speed/power? } #pragma GCC diagnostic push diff --git a/src/devices/boiler.h b/src/devices/boiler.h index f58ca3a17..ccc1e7f35 100644 --- a/src/devices/boiler.h +++ b/src/devices/boiler.h @@ -54,6 +54,7 @@ class Boiler : public EMSdevice { uint8_t last_boilerState = 0xFF; // remember last state of heating and warm water on/off bool changed_ = false; + bool mqtt_ha_config_ = false; // HA MQTT Discovery static constexpr uint8_t EMS_TYPE_UBAParameterWW = 0x33; static constexpr uint8_t EMS_TYPE_UBAFunctionTest = 0x1D; @@ -66,40 +67,40 @@ class Boiler : public EMSdevice { static constexpr uint8_t EMS_BOILER_SELFLOWTEMP_HEATING = 20; // was originally 70, changed to 30 for issue #193, then to 20 with issue #344 // UBAParameterWW - uint8_t wWActivated_ = EMS_VALUE_BOOL_NOTSET; // Warm Water activated - uint8_t wWSelTemp_ = EMS_VALUE_UINT_NOTSET; // Warm Water selected temperature - uint8_t wWCircPump_ = EMS_VALUE_BOOL_NOTSET; // Warm Water circulation pump available - uint8_t wWCircPumpMode_ = EMS_VALUE_UINT_NOTSET; // Warm Water circulation pump mode - uint8_t wWChargeType_ = EMS_VALUE_BOOL_NOTSET; // Warm Water charge type (pump or 3-way-valve) - uint8_t wWDisinfectTemp_ = EMS_VALUE_UINT_NOTSET; // Warm Water disinfection temperature to prevent infection - uint8_t wWComfort_ = EMS_VALUE_UINT_NOTSET; // WW comfort mode + uint8_t wWActivated_ = EMS_VALUE_BOOL_NOTSET; // Warm Water activated + uint8_t wWSelTemp_ = EMS_VALUE_UINT_NOTSET; // Warm Water selected temperature + uint8_t wWCircPump_ = EMS_VALUE_BOOL_NOTSET; // Warm Water circulation pump available + uint8_t wWCircPumpMode_ = EMS_VALUE_UINT_NOTSET; // Warm Water circulation pump mode + uint8_t wWChargeType_ = EMS_VALUE_BOOL_NOTSET; // Warm Water charge type (pump or 3-way-valve) + uint8_t wWDisinfectionTemp_ = EMS_VALUE_UINT_NOTSET; // Warm Water disinfection temperature to prevent infection + uint8_t wWComfort_ = EMS_VALUE_UINT_NOTSET; // WW comfort mode // MC10Status uint16_t wwMixTemperature_ = EMS_VALUE_USHORT_NOTSET; // mengertemperatuur uint16_t wwBufferBoilerTemperature_ = EMS_VALUE_USHORT_NOTSET; // bufferboilertemperature // UBAMonitorFast - 0x18 on EMS1 - uint8_t selFlowTemp_ = EMS_VALUE_UINT_NOTSET; // Selected flow temperature - uint16_t curFlowTemp_ = EMS_VALUE_USHORT_NOTSET; // Current flow temperature - uint16_t wwStorageTemp1_ = EMS_VALUE_USHORT_NOTSET; // warm water storage temp 1 - uint16_t wwStorageTemp2_ = EMS_VALUE_USHORT_NOTSET; // warm water storage temp 2 - uint16_t retTemp_ = EMS_VALUE_USHORT_NOTSET; // Return temperature - uint8_t burnGas_ = EMS_VALUE_BOOL_NOTSET; // Gas on/off - uint8_t fanWork_ = EMS_VALUE_BOOL_NOTSET; // Fan on/off - uint8_t ignWork_ = EMS_VALUE_BOOL_NOTSET; // Ignition on/off - uint8_t heatPmp_ = EMS_VALUE_BOOL_NOTSET; // Boiler pump on/off - uint8_t wWHeat_ = EMS_VALUE_BOOL_NOTSET; // 3-way valve on WW - uint8_t wWCirc_ = EMS_VALUE_BOOL_NOTSET; // Circulation on/off - uint8_t selBurnPow_ = EMS_VALUE_UINT_NOTSET; // Burner max power % - uint8_t curBurnPow_ = EMS_VALUE_UINT_NOTSET; // Burner current power % - uint16_t flameCurr_ = EMS_VALUE_USHORT_NOTSET; // Flame current in micro amps - uint8_t sysPress_ = EMS_VALUE_UINT_NOTSET; // System pressure - char serviceCodeChar_[3] = {'\0'}; // 2 character status/service code - uint16_t serviceCode_ = EMS_VALUE_USHORT_NOTSET; // error/service code - uint8_t boilerState_ = EMS_VALUE_BOOL_NOTSET; // State flag, used on HT3 + uint8_t selFlowTemp_ = EMS_VALUE_UINT_NOTSET; // Selected flow temperature + uint16_t curFlowTemp_ = EMS_VALUE_USHORT_NOTSET; // Current flow temperature + uint16_t wwStorageTemp1_ = EMS_VALUE_USHORT_NOTSET; // warm water storage temp 1 + uint16_t wwStorageTemp2_ = EMS_VALUE_USHORT_NOTSET; // warm water storage temp 2 + uint16_t retTemp_ = EMS_VALUE_USHORT_NOTSET; // Return temperature + uint8_t burnGas_ = EMS_VALUE_BOOL_NOTSET; // Gas on/off + uint8_t fanWork_ = EMS_VALUE_BOOL_NOTSET; // Fan on/off + uint8_t ignWork_ = EMS_VALUE_BOOL_NOTSET; // Ignition on/off + uint8_t heatPump_ = EMS_VALUE_BOOL_NOTSET; // Boiler pump on/off + uint8_t wWHeat_ = EMS_VALUE_BOOL_NOTSET; // 3-way valve on WW + uint8_t wWCirc_ = EMS_VALUE_BOOL_NOTSET; // Circulation on/off + uint8_t selBurnPow_ = EMS_VALUE_UINT_NOTSET; // Burner max power % + uint8_t curBurnPow_ = EMS_VALUE_UINT_NOTSET; // Burner current power % + uint16_t flameCurr_ = EMS_VALUE_USHORT_NOTSET; // Flame current in micro amps + uint8_t sysPress_ = EMS_VALUE_UINT_NOTSET; // System pressure + char serviceCode_[3] = {'\0'}; // 2 character status/service code + uint16_t serviceCodeNumber_ = EMS_VALUE_USHORT_NOTSET; // error/service code + uint8_t boilerState_ = EMS_VALUE_BOOL_NOTSET; // State flag, used on HT3 // UBAMonitorSlow - 0x19 on EMS1 - int16_t extTemp_ = EMS_VALUE_SHORT_NOTSET; // Outside temperature + int16_t outdoorTemp_ = EMS_VALUE_SHORT_NOTSET; // Outside temperature uint16_t boilTemp_ = EMS_VALUE_USHORT_NOTSET; // Boiler temperature uint16_t exhaustTemp_ = EMS_VALUE_USHORT_NOTSET; // Exhaust temperature uint8_t pumpMod_ = EMS_VALUE_UINT_NOTSET; // Pump modulation % @@ -109,44 +110,44 @@ class Boiler : public EMSdevice { uint16_t switchTemp_ = EMS_VALUE_USHORT_NOTSET; // Switch temperature // UBAMonitorWW - uint8_t wWSetTmp_ = EMS_VALUE_UINT_NOTSET; // Warm Water set temperature - uint16_t wWCurTmp_ = EMS_VALUE_USHORT_NOTSET; // Warm Water current temperature - uint16_t wWCurTmp2_ = EMS_VALUE_USHORT_NOTSET; // Warm Water current temperature storage - uint32_t wWStarts_ = EMS_VALUE_ULONG_NOTSET; // Warm Water # starts - uint32_t wWWorkM_ = EMS_VALUE_ULONG_NOTSET; // Warm Water # minutes - uint8_t wWOneTime_ = EMS_VALUE_BOOL_NOTSET; // Warm Water one time function on/off - uint8_t wWDisinfecting_ = EMS_VALUE_BOOL_NOTSET; // Warm Water disinfection on/off - uint8_t wWCharging_ = EMS_VALUE_BOOL_NOTSET; // Warm Water charging on/off - uint8_t wWRecharging_ = EMS_VALUE_BOOL_NOTSET; // Warm Water recharge on/off - uint8_t wWTemperatureOK_ = EMS_VALUE_BOOL_NOTSET; // Warm Water temperature ok on/off - uint8_t wWCurFlow_ = EMS_VALUE_UINT_NOTSET; // Warm Water current flow temp in l/min - uint8_t wWType_ = EMS_VALUE_UINT_NOTSET; // 0-off, 1-flow, 2-flowbuffer, 3-buffer, 4-layered buffer - uint8_t wWActive_ = EMS_VALUE_BOOL_NOTSET; + uint8_t wWSetTemp_ = EMS_VALUE_UINT_NOTSET; // Warm Water set temperature + uint16_t wWCurTemp_ = EMS_VALUE_USHORT_NOTSET; // Warm Water current temperature + uint16_t wWCurTemp2_ = EMS_VALUE_USHORT_NOTSET; // Warm Water current temperature storage + uint32_t wWStarts_ = EMS_VALUE_ULONG_NOTSET; // Warm Water # starts + uint32_t wWWorkM_ = EMS_VALUE_ULONG_NOTSET; // Warm Water # minutes + uint8_t wWOneTime_ = EMS_VALUE_BOOL_NOTSET; // Warm Water one time function on/off + uint8_t wWDisinfecting_ = EMS_VALUE_BOOL_NOTSET; // Warm Water disinfection on/off + uint8_t wWCharging_ = EMS_VALUE_BOOL_NOTSET; // Warm Water charging on/off + uint8_t wWRecharging_ = EMS_VALUE_BOOL_NOTSET; // Warm Water recharge on/off + uint8_t wWTempOK_ = EMS_VALUE_BOOL_NOTSET; // Warm Water temperature ok on/off + uint8_t wWCurFlow_ = EMS_VALUE_UINT_NOTSET; // Warm Water current flow temp in l/min + uint8_t wWType_ = EMS_VALUE_UINT_NOTSET; // 0-off, 1-flow, 2-flowbuffer, 3-buffer, 4-layered buffer + uint8_t wWActive_ = EMS_VALUE_BOOL_NOTSET; // UBATotalUptime uint32_t UBAuptime_ = EMS_VALUE_ULONG_NOTSET; // Total UBA working hours // UBAParameters - uint8_t heating_activated_ = EMS_VALUE_BOOL_NOTSET; // Heating activated on the boiler - uint8_t heating_temp_ = EMS_VALUE_UINT_NOTSET; // Heating temperature setting on the boiler - uint8_t pump_mod_max_ = EMS_VALUE_UINT_NOTSET; // Boiler circuit pump modulation max. power % - uint8_t pump_mod_min_ = EMS_VALUE_UINT_NOTSET; // Boiler circuit pump modulation min. power - uint8_t burnPowermin_ = EMS_VALUE_UINT_NOTSET; - uint8_t burnPowermax_ = EMS_VALUE_UINT_NOTSET; - int8_t boilTemp_off_ = EMS_VALUE_INT_NOTSET; - int8_t boilTemp_on_ = EMS_VALUE_INT_NOTSET; - uint8_t burnPeriod_ = EMS_VALUE_UINT_NOTSET; - uint8_t pumpDelay_ = EMS_VALUE_UINT_NOTSET; + uint8_t heatingActivated_ = EMS_VALUE_BOOL_NOTSET; // Heating activated on the boiler + uint8_t heatingTemp_ = EMS_VALUE_UINT_NOTSET; // Heating temperature setting on the boiler + uint8_t pumpModMax_ = EMS_VALUE_UINT_NOTSET; // Boiler circuit pump modulation max. power % + uint8_t pumpModMin_ = EMS_VALUE_UINT_NOTSET; // Boiler circuit pump modulation min. power + uint8_t burnMinPower_ = EMS_VALUE_UINT_NOTSET; + uint8_t burnMaxPower_ = EMS_VALUE_UINT_NOTSET; + int8_t boilHystOff_ = EMS_VALUE_INT_NOTSET; + int8_t boilHystOn_ = EMS_VALUE_INT_NOTSET; + uint8_t burnMinPeriod_ = EMS_VALUE_UINT_NOTSET; + uint8_t pumpDelay_ = EMS_VALUE_UINT_NOTSET; // UBASetPoint - uint8_t setFlowTemp_ = EMS_VALUE_UINT_NOTSET; // boiler setpoint temp - uint8_t setBurnPow_ = EMS_VALUE_UINT_NOTSET; // max output power in % - uint8_t setWWPumpPow_ = EMS_VALUE_UINT_NOTSET; // ww pump speed/power? + uint8_t setFlowTemp_ = EMS_VALUE_UINT_NOTSET; // boiler setpoint temp + uint8_t setBurnPow_ = EMS_VALUE_UINT_NOTSET; // max output power in % + uint8_t wWSetPumpPower_ = EMS_VALUE_UINT_NOTSET; // ww pump speed/power? // other internal calculated params - uint8_t tap_water_active_ = EMS_VALUE_BOOL_NOTSET; // Hot tap water is on/off - uint8_t heating_active_ = EMS_VALUE_BOOL_NOTSET; // Central heating is on/off - uint8_t pumpMod2_ = EMS_VALUE_UINT_NOTSET; // heatpump modulation from 0xE3 (heatpumps) + uint8_t tapwaterActive_ = EMS_VALUE_BOOL_NOTSET; // Hot tap water is on/off + uint8_t heatingActive_ = EMS_VALUE_BOOL_NOTSET; // Central heating is on/off + uint8_t pumpMod2_ = EMS_VALUE_UINT_NOTSET; // heatpump modulation from 0xE3 (heatpumps) bool command_info(const char * value, const int8_t id, JsonObject & output); diff --git a/src/devices/mixing.cpp b/src/devices/mixing.cpp index 21a4a8440..b27aac696 100644 --- a/src/devices/mixing.cpp +++ b/src/devices/mixing.cpp @@ -138,8 +138,9 @@ void Mixing::publish_values() { Mqtt::publish(topic, doc.as()); // if we're using Home Assistant and haven't created the MQTT Discovery topics, do it now - if ((Mqtt::mqtt_format() == Mqtt::Format::HA) && (!ha_created_)) { + if ((Mqtt::mqtt_format() == Mqtt::Format::HA) && (!mqtt_ha_config_)) { register_mqtt_ha_config(topic); + mqtt_ha_config_ = true; } } } @@ -177,7 +178,6 @@ void Mixing::register_mqtt_ha_config(const char * topic) { Mqtt::register_mqtt_ha_sensor(nullptr, F_(pumpStatus), this->device_type(), "pumpStatus", nullptr, nullptr); Mqtt::register_mqtt_ha_sensor(nullptr, F_(tempStatus), this->device_type(), "tempStatus", nullptr, nullptr); } - ha_created_ = true; } // creates JSON doc from values diff --git a/src/devices/mixing.h b/src/devices/mixing.h index 28b145241..b9c4a95e2 100644 --- a/src/devices/mixing.h +++ b/src/devices/mixing.h @@ -77,8 +77,8 @@ class Mixing : public EMSdevice { uint8_t flowSetTemp_ = EMS_VALUE_UINT_NOTSET; Type type_ = Type::NONE; - bool changed_ = false; - bool ha_created_ = false; // for HA MQTT Discovery + bool changed_ = false; + bool mqtt_ha_config_ = false; // for HA MQTT Discovery }; } // namespace emsesp diff --git a/src/devices/solar.cpp b/src/devices/solar.cpp index 0c14594b5..0daaa69ba 100644 --- a/src/devices/solar.cpp +++ b/src/devices/solar.cpp @@ -127,8 +127,9 @@ void Solar::publish_values() { } // if we're using Home Assistant and haven't created the MQTT Discovery topics, do it now - if ((Mqtt::mqtt_format() == Mqtt::Format::HA) && (!ha_created_)) { + if ((Mqtt::mqtt_format() == Mqtt::Format::HA) && (!mqtt_ha_config_)) { register_mqtt_ha_config(); + mqtt_ha_config_ = true; } } @@ -164,8 +165,6 @@ void Solar::register_mqtt_ha_config() { Mqtt::register_mqtt_ha_sensor(nullptr, F_(valveStatus), this->device_type(), "valveStatus", nullptr, nullptr); Mqtt::register_mqtt_ha_sensor(nullptr, F_(tankHeated), this->device_type(), "tankHeated", nullptr, nullptr); Mqtt::register_mqtt_ha_sensor(nullptr, F_(collectorShutdown), this->device_type(), "collectorShutdown", nullptr, nullptr); - - ha_created_ = true; } // creates JSON doc from values diff --git a/src/devices/solar.h b/src/devices/solar.h index 6ba24e251..6a11f5362 100644 --- a/src/devices/solar.h +++ b/src/devices/solar.h @@ -68,8 +68,8 @@ class Solar : public EMSdevice { uint8_t configFlag_ = EMS_VALUE_BOOL_NOTSET; uint8_t userFlag_ = EMS_VALUE_BOOL_NOTSET; - bool changed_ = false; - bool ha_created_ = false; // for HA MQTT Discovery + bool changed_ = false; + bool mqtt_ha_config_ = false; // for HA MQTT Discovery void process_SM10Monitor(std::shared_ptr telegram); void process_SM100Monitor(std::shared_ptr telegram); diff --git a/src/mqtt.cpp b/src/mqtt.cpp index e25912c91..912c83a53 100644 --- a/src/mqtt.cpp +++ b/src/mqtt.cpp @@ -514,12 +514,12 @@ std::shared_ptr Mqtt::queue_message(const uint8_t operation, std::shared_ptr message; if ((strncmp(topic.c_str(), "homeassistant/", 13) == 0)) { // leave topic as it is - message = std::make_shared(operation, topic, std::move(payload), retain); + message = std::make_shared(operation, topic, payload, retain); } else { // prefix the hostname std::string full_topic(100, '\0'); snprintf_P(&full_topic[0], full_topic.capacity() + 1, PSTR("%s/%s"), hostname_.c_str(), topic.c_str()); - message = std::make_shared(operation, full_topic, std::move(payload), retain); + message = std::make_shared(operation, full_topic, payload, retain); } // if the queue is full, make room but removing the last one @@ -565,20 +565,7 @@ void Mqtt::publish(const __FlashStringHelper * topic, const JsonObject & payload // publish json doc, only if its not empty void Mqtt::publish(const std::string & topic, const JsonObject & payload) { - if (enabled() && payload.size()) { - std::string payload_text; - serializeJson(payload, payload_text); // convert json to string - queue_publish_message(topic, payload_text, mqtt_retain_); - } -} - -// for booleans, which get converted to string values 1 and 0 -void Mqtt::publish(const std::string & topic, bool value) { - queue_publish_message(topic, value ? "1" : "0", false); -} - -void Mqtt::publish(const __FlashStringHelper * topic, bool value) { - queue_publish_message(uuid::read_flash_string(topic), value ? "1" : "0", false); + publish_retain(topic, payload, mqtt_retain_); } // no payload @@ -593,6 +580,13 @@ void Mqtt::publish_retain(const __FlashStringHelper * topic, const std::string & // publish json doc, only if its not empty, using the retain flag void Mqtt::publish_retain(const std::string & topic, const JsonObject & payload, bool retain) { + /* + // for HA, empty payload will remove the previous config + if (retain == true) { + publish(topic); + } + */ + if (enabled() && payload.size()) { std::string payload_text; serializeJson(payload, payload_text); // convert json to string @@ -677,7 +671,9 @@ void Mqtt::process_queue() { // but add the packet_id so we can check it later if (mqtt_qos_ != 0) { mqtt_messages_.front().packet_id_ = packet_id; - // LOG_DEBUG(F("Setting packetID for ACK to %d"), packet_id); +#if defined(EMSESP_DEBUG) + LOG_DEBUG(F("Setting packetID for ACK to %d"), packet_id); +#endif return; } @@ -686,12 +682,11 @@ void Mqtt::process_queue() { // HA config for a binary_sensor void Mqtt::register_mqtt_ha_binary_sensor(const __FlashStringHelper * name, const uint8_t device_type, const char * entity) { - if (mqtt_format() != Format::HA) { return; } - StaticJsonDocument doc; + DynamicJsonDocument doc(EMSESP_MAX_JSON_SIZE_MEDIUM); doc["name"] = name; doc["uniq_id"] = entity; @@ -713,16 +708,27 @@ void Mqtt::register_mqtt_ha_binary_sensor(const __FlashStringHelper * name, cons } }); - JsonObject dev = doc.createNestedObject(F("dev")); - JsonArray ids = dev.createNestedArray(F("ids")); - char ha_device[40]; + JsonObject dev = doc.createNestedObject(F("dev")); + JsonArray ids = dev.createNestedArray(F("ids")); + char ha_device[40]; snprintf_P(ha_device, sizeof(ha_device), PSTR("ems-esp-%s"), EMSdevice::device_type_2_device_name(device_type).c_str()); ids.add(ha_device); - std::string topic(100, '\0'); - snprintf_P(&topic[0], topic.capacity() + 1, PSTR("homeassistant/binary_sensor/ems-esp/%s/config"), entity); + char topic[MQTT_TOPIC_MAX_SIZE]; + snprintf_P(topic, sizeof(topic), PSTR("homeassistant/binary_sensor/ems-esp/%s/config"), entity); - Mqtt::publish_retain(topic, doc.as(), true); // publish the config payload with retain flag + // convert json to string and publish immediately with retain forced to true + doc.shrinkToFit(); + std::string payload_text; + serializeJson(doc, payload_text); // convert json to string + uint16_t packet_id = mqttClient_->publish(topic, 0, true, payload_text.c_str(), payload_text.size()); + if (packet_id == 0) { + LOG_ERROR(F("Failed to publish topic %s"), topic); + } else { + LOG_DEBUG(F("Publishing topic %s"), topic); + } + + delay(MQTT_PUBLISH_WAIT); } // HA config for a normal 'sensor' type @@ -737,52 +743,64 @@ void Mqtt::register_mqtt_ha_sensor(const char * prefix, return; } - StaticJsonDocument doc; - - std::string device_name = EMSdevice::device_type_2_device_name(device_type); - - char new_entity[20]; - // add prefix to entity if its specified + // create entity by prefixing any given prefix + char new_entity[50]; if (prefix != nullptr) { snprintf_P(new_entity, sizeof(new_entity), PSTR("%s.%s"), prefix, entity); } else { strcpy(new_entity, entity); } - doc["name"] = name; + std::string device_name = EMSdevice::device_type_2_device_name(device_type); // build unique identifier, replacing all . with _ as not to break HA std::string uniq(50, '\0'); snprintf_P(&uniq[0], uniq.capacity() + 1, PSTR("%s_%s"), device_name.c_str(), new_entity); std::replace(uniq.begin(), uniq.end(), '.', '_'); - doc["uniq_id"] = uniq; + // topic + char topic[MQTT_TOPIC_MAX_SIZE]; + snprintf_P(topic, sizeof(topic), PSTR("homeassistant/sensor/ems-esp/%s/config"), uniq.c_str()); + + // state topic + char state_t[50]; + snprintf_P(state_t, sizeof(state_t), PSTR("%s/%s_data"), hostname_.c_str(), device_name.c_str()); + + // state template + char tpl[50]; + snprintf_P(tpl, sizeof(tpl), PSTR("{{value_json.%s}}"), new_entity); + + // ha device + char ha_device[40]; + snprintf_P(ha_device, sizeof(ha_device), PSTR("ems-esp-%s"), device_name.c_str()); + + DynamicJsonDocument doc(EMSESP_MAX_JSON_SIZE_MEDIUM); + doc["name"] = name; + doc["uniq_id"] = uniq; if (uom != nullptr) { doc["unit_of_meas"] = uom; } - - char state_t[50]; - snprintf_P(state_t, sizeof(state_t), PSTR("%s/%s_data"), hostname_.c_str(), device_name.c_str()); - doc["stat_t"] = state_t; - - char tpl[50]; - snprintf_P(tpl, sizeof(tpl), PSTR("{{value_json.%s}}"), new_entity); + doc["stat_t"] = state_t; doc["val_tpl"] = tpl; - if (icon != nullptr) { doc["ic"] = icon; } - - JsonObject dev = doc.createNestedObject(F("dev")); - JsonArray ids = dev.createNestedArray(F("ids")); - char ha_device[40]; - snprintf_P(ha_device, sizeof(ha_device), PSTR("ems-esp-%s"), device_name.c_str()); + JsonObject dev = doc.createNestedObject(F("dev")); + JsonArray ids = dev.createNestedArray(F("ids")); ids.add(ha_device); - std::string topic(100, '\0'); - snprintf_P(&topic[0], topic.capacity() + 1, PSTR("homeassistant/sensor/ems-esp/%s/config"), uniq.c_str()); + // convert json to string and publish immediately with retain forced to true + doc.shrinkToFit(); + std::string payload_text; + serializeJson(doc, payload_text); // convert json to string + uint16_t packet_id = mqttClient_->publish(topic, 0, true, payload_text.c_str(), payload_text.size()); + if (packet_id == 0) { + LOG_ERROR(F("Failed to publish topic %s"), topic); + } else { + LOG_DEBUG(F("Publishing topic %s"), topic); + } - Mqtt::publish_retain(topic, doc.as(), true); // publish the config payload with retain flag + delay(MQTT_PUBLISH_WAIT); } } // namespace emsesp diff --git a/src/mqtt.h b/src/mqtt.h index 03b9ffaee..80fd8a94c 100644 --- a/src/mqtt.h +++ b/src/mqtt.h @@ -48,20 +48,18 @@ using mqtt_subfunction_p = std::function; using cmdfunction_p = std::function; struct MqttMessage { - ~MqttMessage() = default; - const uint8_t operation; const std::string topic; const std::string payload; const bool retain; - // MqttMessage(const uint8_t operation, const std::string & topic, const std::string & payload, bool retain) - MqttMessage(const uint8_t operation, const std::string & topic, const std::string && payload, bool retain) + MqttMessage(const uint8_t operation, const std::string & topic, const std::string & payload, bool retain) : operation(operation) , topic(topic) , payload(payload) , retain(retain) { } + ~MqttMessage() = default; }; class Mqtt { @@ -89,17 +87,12 @@ class Mqtt { static void subscribe(const std::string & topic, mqtt_subfunction_p cb); static void resubscribe(); - static void register_command(const uint8_t device_type, const uint8_t device_id, const __FlashStringHelper * cmd, cmdfunction_p cb); - static void publish(const std::string & topic, const std::string & payload); static void publish(const __FlashStringHelper * topic, const char * payload); static void publish(const std::string & topic, const JsonObject & payload); static void publish(const __FlashStringHelper * topic, const JsonObject & payload); static void publish(const __FlashStringHelper * topic, const std::string & payload); - static void publish(const std::string & topic, bool value); - static void publish(const __FlashStringHelper * topic, bool value); static void publish(const std::string & topic); - static void publish_retain(const std::string & topic, const JsonObject & payload, bool retain); static void publish_retain(const __FlashStringHelper * topic, const std::string & payload, bool retain); static void publish_retain(const __FlashStringHelper * topic, const JsonObject & payload, bool retain); @@ -111,6 +104,7 @@ class Mqtt { const char * entity, const __FlashStringHelper * uom, const __FlashStringHelper * icon); + static void register_command(const uint8_t device_type, const uint8_t device_id, const __FlashStringHelper * cmd, cmdfunction_p cb); static void show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_type); static void show_mqtt(uuid::console::Shell & shell); diff --git a/src/shower.cpp b/src/shower.cpp index 82ffab030..b43719fa9 100644 --- a/src/shower.cpp +++ b/src/shower.cpp @@ -28,8 +28,9 @@ void Shower::start() { shower_alert_ = settings.shower_alert; }); - if (Mqtt::mqtt_format() == Mqtt::Format::HA) { - Mqtt::register_mqtt_ha_binary_sensor(F("Shower Active"), EMSdevice::DeviceType::BOILER, "shower_active"); + if (shower_timer_ || shower_alert_) { + char s[7]; + Mqtt::publish(F("shower_active"), Helpers::render_boolean(s, false)); } } @@ -57,8 +58,7 @@ void Shower::loop() { // first check to see if hot water has been on long enough to be recognized as a Shower/Bath if (!shower_on_ && (time_now - timer_start_) > SHOWER_MIN_DURATION) { shower_on_ = true; - char s[7]; - Mqtt::publish("shower_active", Helpers::render_boolean(s, true)); + send_mqtt_stat(true); LOG_DEBUG(F("[Shower] hot water still running, starting shower timer")); } // check if the shower has been on too long @@ -79,8 +79,7 @@ void Shower::loop() { if ((timer_pause_ - timer_start_) > SHOWER_OFFSET_TIME) { duration_ = (timer_pause_ - timer_start_ - SHOWER_OFFSET_TIME); if (duration_ > SHOWER_MIN_DURATION) { - char s[7]; - Mqtt::publish(F("shower_active"), Helpers::render_boolean(s, false)); + send_mqtt_stat(false); LOG_DEBUG(F("[Shower] finished with duration %d"), duration_); publish_values(); } @@ -96,6 +95,17 @@ void Shower::loop() { } } +void Shower::send_mqtt_stat(bool state) { + // if we're in HA mode make sure we've first sent out the HA MQTT Discovery config topic + if ((Mqtt::mqtt_format() == Mqtt::Format::HA) && (!ha_config_)) { + Mqtt::register_mqtt_ha_binary_sensor(F("Shower Active"), EMSdevice::DeviceType::BOILER, "shower_active"); + ha_config_ = true; + } + + char s[7]; + Mqtt::publish(F("shower_active"), Helpers::render_boolean(s, state)); +} + // turn back on the hot water for the shower void Shower::shower_alert_stop() { if (doing_cold_shot_) { @@ -120,8 +130,9 @@ void Shower::shower_alert_start() { // Publish shower data // returns true if added to MQTT queue went ok void Shower::publish_values() { - StaticJsonDocument<90> doc; - char s[50]; + StaticJsonDocument doc; + + char s[50]; doc["shower_timer"] = Helpers::render_boolean(s, shower_timer_); doc["shower_alert"] = Helpers::render_boolean(s, shower_alert_); diff --git a/src/shower.h b/src/shower.h index 6ed19a30f..ff4b55e71 100644 --- a/src/shower.h +++ b/src/shower.h @@ -65,10 +65,11 @@ class Shower { void publish_values(); void shower_alert_start(); void shower_alert_stop(); + void send_mqtt_stat(bool state); - bool shower_timer_; // true if we want to report back on shower times - bool shower_alert_; // true if we want the alert of cold water - + bool shower_timer_; // true if we want to report back on shower times + bool shower_alert_; // true if we want the alert of cold water + bool ha_config_ = false; // for HA MQTT Discovery bool shower_on_; uint32_t timer_start_; // ms uint32_t timer_pause_; // ms diff --git a/src/version.h b/src/version.h index 24c9cc4eb..7596e0782 100644 --- a/src/version.h +++ b/src/version.h @@ -1 +1 @@ -#define EMSESP_APP_VERSION "2.1.0b4" +#define EMSESP_APP_VERSION "2.1.0b5"