From 01fd90f3ed8eae63028a44eec0a88d59a3cd5605 Mon Sep 17 00:00:00 2001 From: proddy Date: Sun, 16 May 2021 12:42:36 +0200 Subject: [PATCH] added more HA icons --- src/devices/boiler.cpp | 21 ++++---- src/devices/heatpump.cpp | 2 +- src/devices/mixer.cpp | 6 ++- src/devices/solar.cpp | 103 +++++++++++++++++++++++++++------------ src/devices/switch.cpp | 1 + src/devices/thermostat.h | 2 +- src/emsdevice.cpp | 6 ++- src/locale_EN.h | 18 ++++--- src/version.h | 2 +- 9 files changed, 105 insertions(+), 56 deletions(-) diff --git a/src/devices/boiler.cpp b/src/devices/boiler.cpp index 32ca88d2b..eaa658a71 100644 --- a/src/devices/boiler.cpp +++ b/src/devices/boiler.cpp @@ -111,7 +111,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_BOILER_DATA, &exhaustTemp_, DeviceValueType::USHORT, FL_(div10), FL_(exhaustTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_BOILER_DATA, &burnGas_, DeviceValueType::BOOL, nullptr, FL_(burnGas), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &flameCurr_, DeviceValueType::USHORT, FL_(div10), FL_(flameCurr), DeviceValueUOM::UA); - register_device_value(TAG_BOILER_DATA, &heatingPump_, DeviceValueType::BOOL, nullptr, FL_(heatingPump), DeviceValueUOM::PUMP); + register_device_value(TAG_BOILER_DATA, &heatingPump_, DeviceValueType::BOOL, nullptr, FL_(heatingPump), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &fanWork_, DeviceValueType::BOOL, nullptr, FL_(fanWork), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &ignWork_, DeviceValueType::BOOL, nullptr, FL_(ignWork), DeviceValueUOM::NONE); register_device_value( @@ -128,7 +128,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_BOILER_DATA, &setFlowTemp_, DeviceValueType::UINT, nullptr, FL_(setFlowTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_BOILER_DATA, &setBurnPow_, DeviceValueType::UINT, nullptr, FL_(setBurnPow), DeviceValueUOM::PERCENT); register_device_value(TAG_BOILER_DATA, &curBurnPow_, DeviceValueType::UINT, nullptr, FL_(curBurnPow), DeviceValueUOM::PERCENT); - register_device_value(TAG_BOILER_DATA, &burnStarts_, DeviceValueType::ULONG, nullptr, FL_(burnStarts), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &burnStarts_, DeviceValueType::ULONG, nullptr, FL_(burnStarts), DeviceValueUOM::NUM); register_device_value(TAG_BOILER_DATA, &burnWorkMin_, DeviceValueType::TIME, nullptr, FL_(burnWorkMin), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &heatWorkMin_, DeviceValueType::TIME, nullptr, FL_(heatWorkMin), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &UBAuptime_, DeviceValueType::TIME, nullptr, FL_(UBAuptime), DeviceValueUOM::MINUTES); @@ -151,8 +151,8 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_BOILER_DATA, &upTimeCompHeating_, DeviceValueType::TIME, FL_(div60), FL_(upTimeCompHeating), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &upTimeCompCooling_, DeviceValueType::TIME, FL_(div60), FL_(upTimeCompCooling), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &upTimeCompWw_, DeviceValueType::TIME, FL_(div60), FL_(upTimeCompWw), DeviceValueUOM::MINUTES); - register_device_value(TAG_BOILER_DATA, &heatingStarts_, DeviceValueType::ULONG, nullptr, FL_(heatingStarts), DeviceValueUOM::NONE); - register_device_value(TAG_BOILER_DATA, &coolingStarts_, DeviceValueType::ULONG, nullptr, FL_(coolingStarts), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &heatingStarts_, DeviceValueType::ULONG, nullptr, FL_(heatingStarts), DeviceValueUOM::NUM); + register_device_value(TAG_BOILER_DATA, &coolingStarts_, DeviceValueType::ULONG, nullptr, FL_(coolingStarts), DeviceValueUOM::NUM); register_device_value(TAG_BOILER_DATA, &nrgConsTotal_, DeviceValueType::ULONG, nullptr, FL_(nrgConsTotal), DeviceValueUOM::KWH); register_device_value(TAG_BOILER_DATA, &nrgConsCompTotal_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompTotal), DeviceValueUOM::KWH); register_device_value(TAG_BOILER_DATA, &nrgConsCompHeating_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompHeating), DeviceValueUOM::KWH); @@ -224,8 +224,8 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_DEVICE_DATA_WW, &wWSetPumpPower_, DeviceValueType::UINT, nullptr, FL_(wWSetPumpPower), DeviceValueUOM::PERCENT); register_device_value(TAG_DEVICE_DATA_WW, &mixerTemp_, DeviceValueType::USHORT, FL_(div10), FL_(mixerTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_DEVICE_DATA_WW, &tankMiddleTemp_, DeviceValueType::USHORT, FL_(div10), FL_(tankMiddleTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_DEVICE_DATA_WW, &wWStarts_, DeviceValueType::ULONG, nullptr, FL_(wWStarts), DeviceValueUOM::NONE); - register_device_value(TAG_DEVICE_DATA_WW, &wWStarts2_, DeviceValueType::ULONG, nullptr, FL_(wWStarts2), DeviceValueUOM::NONE); + register_device_value(TAG_DEVICE_DATA_WW, &wWStarts_, DeviceValueType::ULONG, nullptr, FL_(wWStarts), DeviceValueUOM::NUM); + register_device_value(TAG_DEVICE_DATA_WW, &wWStarts2_, DeviceValueType::ULONG, nullptr, FL_(wWStarts2), DeviceValueUOM::NUM); register_device_value(TAG_DEVICE_DATA_WW, &wWWorkM_, DeviceValueType::TIME, nullptr, FL_(wWWorkM), DeviceValueUOM::MINUTES); // fetch some initial data @@ -243,6 +243,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const bool Boiler::publish_ha_config() { StaticJsonDocument doc; doc["uniq_id"] = F_(boiler); + doc["ic"] = F_(icondevice); char stat_t[Mqtt::MQTT_TOPIC_MAX_SIZE]; snprintf_P(stat_t, sizeof(stat_t), PSTR("%s/%s"), Mqtt::base().c_str(), Mqtt::tag_to_topic(device_type(), DeviceValueTAG::TAG_NONE).c_str()); @@ -804,11 +805,11 @@ bool Boiler::set_flow_temp(const char * value, const int8_t id) { bool Boiler::set_burn_power(const char * value, const int8_t id) { int v = 0; if (!Helpers::value2number(value, v)) { - LOG_WARNING(F("Set burner max. power: Invalid value")); + LOG_WARNING(F("Set burner max power: Invalid value")); return false; } - LOG_INFO(F("Setting burner max. power to %d %"), v); + LOG_INFO(F("Setting burner max power to %d %"), v); write_command(EMS_TYPE_UBASetPoints, 1, v, EMS_TYPE_UBASetPoints); return true; @@ -990,11 +991,11 @@ bool Boiler::set_hyst_off(const char * value, const int8_t id) { bool Boiler::set_burn_period(const char * value, const int8_t id) { int v = 0; if (!Helpers::value2number(value, v)) { - LOG_WARNING(F("Set burner min. period: Invalid value")); + LOG_WARNING(F("Set burner min period: Invalid value")); return false; } - LOG_INFO(F("Setting burner min. period to %d min"), v); + LOG_INFO(F("Setting burner min period to %d min"), v); if (get_toggle_fetch(EMS_TYPE_UBAParametersPlus)) { write_command(EMS_TYPE_UBAParametersPlus, 10, v, EMS_TYPE_UBAParametersPlus); } else { diff --git a/src/devices/heatpump.cpp b/src/devices/heatpump.cpp index 77544287a..54c5e833c 100644 --- a/src/devices/heatpump.cpp +++ b/src/devices/heatpump.cpp @@ -44,7 +44,7 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c bool Heatpump::publish_ha_config() { StaticJsonDocument doc; doc["uniq_id"] = F_(heatpump); - doc["ic"] = F_(iconheatpump); + doc["ic"] = F_(icondevice); char stat_t[Mqtt::MQTT_TOPIC_MAX_SIZE]; snprintf_P(stat_t, sizeof(stat_t), PSTR("%s/%s"), Mqtt::base().c_str(), Mqtt::tag_to_topic(device_type(), DeviceValueTAG::TAG_NONE).c_str()); diff --git a/src/devices/mixer.cpp b/src/devices/mixer.cpp index 721fa12bc..7fc481bd0 100644 --- a/src/devices/mixer.cpp +++ b/src/devices/mixer.cpp @@ -60,7 +60,7 @@ Mixer::Mixer(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s register_device_value(tag, &id_, DeviceValueType::UINT, nullptr, FL_(ID), DeviceValueUOM::NONE); register_device_value(tag, &flowSetTemp_, DeviceValueType::UINT, nullptr, FL_(flowSetTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &flowTempHc_, DeviceValueType::USHORT, FL_(div10), FL_(flowTempHc), DeviceValueUOM::DEGREES); - register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, nullptr, FL_(pumpStatus), DeviceValueUOM::PUMP); + register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, nullptr, FL_(pumpStatus), DeviceValueUOM::NONE); register_device_value(tag, &status_, DeviceValueType::INT, nullptr, FL_(mixerStatus), DeviceValueUOM::PERCENT); register_device_value(tag, &flowTempVf_, DeviceValueType::USHORT, FL_(div10), FL_(flowTempVf), DeviceValueUOM::DEGREES); } else { @@ -69,7 +69,7 @@ Mixer::Mixer(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s uint8_t tag = TAG_WWC1 + hc_ - 1; register_device_value(tag, &id_, DeviceValueType::UINT, nullptr, FL_(ID), DeviceValueUOM::NONE); register_device_value(tag, &flowTempHc_, DeviceValueType::USHORT, FL_(div10), FL_(wwTemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, nullptr, FL_(wwPumpStatus), DeviceValueUOM::PUMP); + register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, nullptr, FL_(wwPumpStatus), DeviceValueUOM::NONE); register_device_value(tag, &status_, DeviceValueType::INT, nullptr, FL_(wwTempStatus), DeviceValueUOM::NONE); } @@ -89,6 +89,8 @@ bool Mixer::publish_ha_config() { snprintf_P(uniq_id, sizeof(uniq_id), PSTR("Mixer%02X"), device_id() - 0x20 + 1); doc["uniq_id"] = uniq_id; + doc["ic"] = F_(icondevice); + char stat_t[Mqtt::MQTT_TOPIC_MAX_SIZE]; snprintf_P(stat_t, sizeof(stat_t), PSTR("%s/%s"), Mqtt::base().c_str(), Mqtt::tag_to_topic(device_type(), DeviceValueTAG::TAG_NONE).c_str()); doc["stat_t"] = stat_t; diff --git a/src/devices/solar.cpp b/src/devices/solar.cpp index 7b20b97c9..8c9f43949 100644 --- a/src/devices/solar.cpp +++ b/src/devices/solar.cpp @@ -80,7 +80,7 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s register_device_value(TAG_NONE, &collectorTemp_, DeviceValueType::SHORT, FL_(div10), FL_(collectorTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_NONE, &tankBottomTemp_, DeviceValueType::SHORT, FL_(div10), FL_(tankBottomTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_NONE, &solarPump_, DeviceValueType::BOOL, nullptr, FL_(solarPump), DeviceValueUOM::PUMP); + register_device_value(TAG_NONE, &solarPump_, DeviceValueType::BOOL, nullptr, FL_(solarPump), DeviceValueUOM::NONE); register_device_value(TAG_NONE, &pumpWorkTime_, DeviceValueType::TIME, nullptr, FL_(pumpWorkTime), DeviceValueUOM::MINUTES); register_device_value(TAG_NONE, &tankMaxTemp_, DeviceValueType::UINT, nullptr, FL_(tankMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TankMaxTemp)); @@ -88,10 +88,14 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s // register_device_value(TAG_NONE, &collectorMaxTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMaxTemp)); register_device_value(TAG_NONE, &solarPumpModulation_, DeviceValueType::UINT, nullptr, FL_(solarPumpModulation), DeviceValueUOM::PERCENT); register_device_value(TAG_NONE, &solarPumpMinMod_, DeviceValueType::UINT, nullptr, FL_(pumpMinMod), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_PumpMinMod)); - register_device_value(TAG_NONE, &solarPumpTurnonDiff_, DeviceValueType::UINT, nullptr, FL_(solarPumpTurnonDiff), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TurnonDiff)); - register_device_value(TAG_NONE, &solarPumpTurnoffDiff_, DeviceValueType::UINT, nullptr, FL_(solarPumpTurnoffDiff), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TurnoffDiff)); - register_device_value(TAG_NONE, &collectorMaxTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMaxTemp)); - register_device_value(TAG_NONE, &collectorMinTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMinTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMinTemp)); + register_device_value( + TAG_NONE, &solarPumpTurnonDiff_, DeviceValueType::UINT, nullptr, FL_(solarPumpTurnonDiff), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TurnonDiff)); + register_device_value( + TAG_NONE, &solarPumpTurnoffDiff_, DeviceValueType::UINT, nullptr, FL_(solarPumpTurnoffDiff), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TurnoffDiff)); + register_device_value( + TAG_NONE, &collectorMaxTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMaxTemp)); + register_device_value( + TAG_NONE, &collectorMinTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMinTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMinTemp)); register_device_value(TAG_NONE, &collectorShutdown_, DeviceValueType::BOOL, nullptr, FL_(collectorShutdown), DeviceValueUOM::NONE); // register_device_value(TAG_NONE, &tankHeated_, DeviceValueType::BOOL, nullptr, FL_(tankHeated), DeviceValueUOM::NONE); register_device_value(TAG_NONE, &solarPower_, DeviceValueType::ULONG, nullptr, FL_(solarPower), DeviceValueUOM::W); @@ -108,36 +112,73 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s if (flags == EMSdevice::EMS_DEVICE_FLAG_SM100) { register_device_value(TAG_NONE, &solarPumpModulation_, DeviceValueType::UINT, nullptr, FL_(solarPumpModulation), DeviceValueUOM::PERCENT); register_device_value(TAG_NONE, &solarPumpMinMod_, DeviceValueType::UINT, nullptr, FL_(pumpMinMod), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_PumpMinMod)); - register_device_value(TAG_NONE, &solarPumpTurnonDiff_, DeviceValueType::UINT, nullptr, FL_(solarPumpTurnonDiff), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TurnonDiff)); - register_device_value(TAG_NONE, &solarPumpTurnoffDiff_, DeviceValueType::UINT, nullptr, FL_(solarPumpTurnoffDiff), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TurnoffDiff)); + register_device_value( + TAG_NONE, &solarPumpTurnonDiff_, DeviceValueType::UINT, nullptr, FL_(solarPumpTurnonDiff), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TurnonDiff)); + register_device_value( + TAG_NONE, &solarPumpTurnoffDiff_, DeviceValueType::UINT, nullptr, FL_(solarPumpTurnoffDiff), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_TurnoffDiff)); register_device_value(TAG_NONE, &tankBottomTemp2_, DeviceValueType::SHORT, FL_(div10), FL_(tank2BottomTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_NONE, &heatExchangerTemp_, DeviceValueType::SHORT, FL_(div10), FL_(heatExchangerTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_NONE, &cylinderPumpModulation_, DeviceValueType::UINT, nullptr, FL_(cylinderPumpModulation), DeviceValueUOM::PERCENT); register_device_value(TAG_NONE, &valveStatus_, DeviceValueType::BOOL, nullptr, FL_(valveStatus), DeviceValueUOM::NONE); register_device_value(TAG_NONE, &tankHeated_, DeviceValueType::BOOL, nullptr, FL_(tankHeated), DeviceValueUOM::NONE); register_device_value(TAG_NONE, &collectorShutdown_, DeviceValueType::BOOL, nullptr, FL_(collectorShutdown), DeviceValueUOM::NONE); - register_device_value(TAG_NONE, &collectorMaxTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMaxTemp)); - register_device_value(TAG_NONE, &collectorMinTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMinTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMinTemp)); + register_device_value( + TAG_NONE, &collectorMaxTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMaxTemp)); + register_device_value( + TAG_NONE, &collectorMinTemp_, DeviceValueType::UINT, nullptr, FL_(collectorMinTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_CollectorMinTemp)); register_device_value(TAG_NONE, &energyLastHour_, DeviceValueType::ULONG, FL_(div10), FL_(energyLastHour), DeviceValueUOM::WH); register_device_value(TAG_NONE, &energyToday_, DeviceValueType::ULONG, nullptr, FL_(energyToday), DeviceValueUOM::WH); register_device_value(TAG_NONE, &energyTotal_, DeviceValueType::ULONG, FL_(div10), FL_(energyTotal), DeviceValueUOM::KWH); - register_device_value(TAG_NONE, &heatTransferSystem_, DeviceValueType::BOOL, nullptr, FL_(heatTransferSystem), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatTransferSystem)); + register_device_value( + TAG_NONE, &heatTransferSystem_, DeviceValueType::BOOL, nullptr, FL_(heatTransferSystem), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatTransferSystem)); register_device_value(TAG_NONE, &externalTank_, DeviceValueType::BOOL, nullptr, FL_(externalTank), DeviceValueUOM::NONE, MAKE_CF_CB(set_externalTank)); - register_device_value(TAG_NONE, &thermalDisinfect_, DeviceValueType::BOOL, nullptr, FL_(thermalDisinfect), DeviceValueUOM::NONE, MAKE_CF_CB(set_thermalDisinfect)); + register_device_value( + TAG_NONE, &thermalDisinfect_, DeviceValueType::BOOL, nullptr, FL_(thermalDisinfect), DeviceValueUOM::NONE, MAKE_CF_CB(set_thermalDisinfect)); register_device_value(TAG_NONE, &heatMetering_, DeviceValueType::BOOL, nullptr, FL_(heatMetering), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatMetering)); register_device_value(TAG_NONE, &solarIsEnabled_, DeviceValueType::BOOL, nullptr, FL_(activated), DeviceValueUOM::NONE, MAKE_CF_CB(set_solarEnabled)); // telegram 0x035A - register_device_value(TAG_NONE, &solarPumpMode_, DeviceValueType::ENUM, FL_(enum_solarmode), FL_(solarPumpMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_solarMode)); - register_device_value(TAG_NONE, &solarPumpKick_, DeviceValueType::BOOL, nullptr, FL_(solarPumpKick), DeviceValueUOM::NONE, MAKE_CF_CB(set_solarPumpKick)); // pump kick for vacuum collector, 00=off - register_device_value(TAG_NONE, &plainWaterMode_, DeviceValueType::BOOL, nullptr, FL_(plainWaterMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_plainWaterMode)); // system does not use antifreeze, 00=off - register_device_value(TAG_NONE, &doubleMatchFlow_, DeviceValueType::BOOL, nullptr, FL_(doubleMatchFlow), DeviceValueUOM::NONE, MAKE_CF_CB(set_doubleMatchFlow)); // double Match Flow, 00=off + register_device_value( + TAG_NONE, &solarPumpMode_, DeviceValueType::ENUM, FL_(enum_solarmode), FL_(solarPumpMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_solarMode)); + register_device_value(TAG_NONE, + &solarPumpKick_, + DeviceValueType::BOOL, + nullptr, + FL_(solarPumpKick), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_solarPumpKick)); // pump kick for vacuum collector, 00=off + register_device_value(TAG_NONE, + &plainWaterMode_, + DeviceValueType::BOOL, + nullptr, + FL_(plainWaterMode), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_plainWaterMode)); // system does not use antifreeze, 00=off + register_device_value(TAG_NONE, + &doubleMatchFlow_, + DeviceValueType::BOOL, + nullptr, + FL_(doubleMatchFlow), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_doubleMatchFlow)); // double Match Flow, 00=off // telegram 0x380 - register_device_value(TAG_NONE, &climateZone_, DeviceValueType::UINT, nullptr, FL_(climateZone), DeviceValueUOM::NONE, MAKE_CF_CB(set_climateZone)); // climate zone identifier - register_device_value(TAG_NONE, &collector1Area_, DeviceValueType::USHORT, FL_(div10), FL_(collector1Area), DeviceValueUOM::NONE, MAKE_CF_CB(set_collector1Area)); // Area of collector field 1 - register_device_value(TAG_NONE, &collector1Type_, DeviceValueType::ENUM, FL_(enum_collectortype), FL_(collector1Type), DeviceValueUOM::NONE, MAKE_CF_CB(set_collector1Type)); // Type of collector field 1, 01=flat, 02=vacuum + register_device_value(TAG_NONE, &climateZone_, DeviceValueType::UINT, nullptr, FL_(climateZone), DeviceValueUOM::NONE, MAKE_CF_CB(set_climateZone)); // climate zone identifier + register_device_value(TAG_NONE, + &collector1Area_, + DeviceValueType::USHORT, + FL_(div10), + FL_(collector1Area), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_collector1Area)); // Area of collector field 1 + register_device_value(TAG_NONE, + &collector1Type_, + DeviceValueType::ENUM, + FL_(enum_collectortype), + FL_(collector1Type), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_collector1Type)); // Type of collector field 1, 01=flat, 02=vacuum } } @@ -146,6 +187,7 @@ bool Solar::publish_ha_config() { StaticJsonDocument doc; doc["name"] = FJSON("ID"); doc["uniq_id"] = F_(solar); + doc["ic"] = F_(icondevice); char stat_t[Mqtt::MQTT_TOPIC_MAX_SIZE]; snprintf_P(stat_t, sizeof(stat_t), PSTR("%s/%s"), Mqtt::base().c_str(), Mqtt::tag_to_topic(device_type(), DeviceValueTAG::TAG_NONE).c_str()); @@ -174,7 +216,7 @@ void Solar::process_SM10Config(std::shared_ptr telegram) { uint8_t colmax = collectorMaxTemp_ / 10; has_update(telegram->read_value(colmax, 3)); collectorMaxTemp_ = colmax * 10; - uint8_t colmin = collectorMinTemp_ / 10; + uint8_t colmin = collectorMinTemp_ / 10; has_update(telegram->read_value(colmin, 4)); collectorMinTemp_ = colmin * 10; has_update(telegram->read_value(solarPumpMinMod_, 2)); @@ -202,9 +244,7 @@ void Solar::process_SM10Monitor(std::shared_ptr telegram) { } if (!Helpers::hasValue(maxFlow_)) { - EMSESP::webSettingsService.read([&](WebSettings & settings) { - maxFlow_ = settings.solar_maxflow; - }); + EMSESP::webSettingsService.read([&](WebSettings & settings) { maxFlow_ = settings.solar_maxflow; }); } // solar publishes every minute, do not count reads by other devices @@ -411,7 +451,7 @@ void Solar::process_ISM1StatusMessage(std::shared_ptr telegram) has_update(telegram->read_value(tankBottomTemp_, 6)); // Temperature Bottom of Solar Boiler tank uint16_t Wh = energyLastHour_ / 10; has_update(telegram->read_value(Wh, 2)); // Solar Energy produced in last hour only ushort, is not * 10 - energyLastHour_ = Wh * 10; // set to *10 + energyLastHour_ = Wh * 10; // set to *10 has_update(telegram->read_bitvalue(solarPump_, 8, 0)); // PS1 Solar pump on (1) or off (0) has_update(telegram->read_value(pumpWorkTime_, 10, 3)); // force to 3 bytes @@ -489,7 +529,7 @@ bool Solar::set_wwMinTemp(const char * value, const int8_t id) { return true; } -bool Solar::set_TurnoffDiff(const char * value, const int8_t id){ +bool Solar::set_TurnoffDiff(const char * value, const int8_t id) { int temperature; if (!Helpers::value2number(value, temperature)) { return false; @@ -500,10 +540,9 @@ bool Solar::set_TurnoffDiff(const char * value, const int8_t id){ write_command(0x35A, 7, (uint8_t)temperature, 0x35A); } return true; - } -bool Solar::set_TurnonDiff(const char * value, const int8_t id){ +bool Solar::set_TurnonDiff(const char * value, const int8_t id) { int temperature; if (!Helpers::value2number(value, temperature)) { return false; @@ -523,10 +562,12 @@ bool Solar::set_SM10MaxFlow(const char * value, const int8_t id) { return false; } maxFlow_ = (flow * 10); - EMSESP::webSettingsService.update([&](WebSettings & settings) { - settings.solar_maxflow = maxFlow_; - return StateUpdateResult::CHANGED; - }, "local"); + EMSESP::webSettingsService.update( + [&](WebSettings & settings) { + settings.solar_maxflow = maxFlow_; + return StateUpdateResult::CHANGED; + }, + "local"); return true; } @@ -629,7 +670,7 @@ bool Solar::set_collector1Area(const char * value, const int8_t id) { if (!Helpers::value2float(value, v)) { return false; } - write_command(0x380, 3, (uint16_t)( v * 10), 0x380); + write_command(0x380, 3, (uint16_t)(v * 10), 0x380); return true; } diff --git a/src/devices/switch.cpp b/src/devices/switch.cpp index 248ab10d4..333281c2d 100644 --- a/src/devices/switch.cpp +++ b/src/devices/switch.cpp @@ -50,6 +50,7 @@ bool Switch::publish_ha_config() { StaticJsonDocument doc; doc["uniq_id"] = F_(switch); + doc["ic"] = F_(icondevice); char stat_t[Mqtt::MQTT_TOPIC_MAX_SIZE]; snprintf_P(stat_t, sizeof(stat_t), PSTR("%s/%s"), Mqtt::base().c_str(), Mqtt::tag_to_topic(device_type(), DeviceValueTAG::TAG_NONE).c_str()); diff --git a/src/devices/thermostat.h b/src/devices/thermostat.h index 075b43a2d..fddf9caea 100644 --- a/src/devices/thermostat.h +++ b/src/devices/thermostat.h @@ -254,7 +254,7 @@ class Thermostat : public EMSdevice { std::shared_ptr heating_circuit(std::shared_ptr telegram); std::shared_ptr heating_circuit(const uint8_t hc_num); - void register_mqtt_ha_config_hc(uint8_t hc_num); + void publish_ha_config_hc(uint8_t hc_num); void register_device_values_hc(std::shared_ptr hc); bool thermostat_ha_cmd(const char * message, uint8_t hc_num); diff --git a/src/emsdevice.cpp b/src/emsdevice.cpp index 208514f58..580bfd187 100644 --- a/src/emsdevice.cpp +++ b/src/emsdevice.cpp @@ -37,7 +37,9 @@ static const __FlashStringHelper * DeviceValueUOM_s[] __attribute__((__aligned__ F_(kw), F_(w), F_(kb), - F_(seconds) + F_(seconds), + F_(dbm), + F_(num) }; @@ -121,7 +123,7 @@ const std::string EMSdevice::tag_to_mqtt(uint8_t tag) { } const std::string EMSdevice::uom_to_string(uint8_t uom) { - if (uom == DeviceValueUOM::NONE || uom >= DeviceValueUOM::PUMP) { + if (uom == DeviceValueUOM::NONE) { return std::string{}; } return uuid::read_flash_string(DeviceValueUOM_s[uom - 1]); // offset by 1 to account for NONE diff --git a/src/locale_EN.h b/src/locale_EN.h index 3de949bcf..2a9828e62 100644 --- a/src/locale_EN.h +++ b/src/locale_EN.h @@ -156,7 +156,7 @@ MAKE_PSTR_LIST(div100, F_(100)) MAKE_PSTR_LIST(div60, F_(60)) // Unit Of Measurement mapping - maps to DeviceValueUOM_s in emsdevice.cpp -// uom - also used with HA +// uom - also used with HA see https://github.com/home-assistant/core/blob/d7ac4bd65379e11461c7ce0893d3533d8d8b8cbf/homeassistant/const.py#L384 MAKE_PSTR(percent, "%") MAKE_PSTR(degrees, "°C") MAKE_PSTR(kwh, "kWh") @@ -170,6 +170,8 @@ MAKE_PSTR(kw, "kW") MAKE_PSTR(w, "W") MAKE_PSTR(kb, "KB") MAKE_PSTR(seconds, "seconds") +MAKE_PSTR(dbm, "dBm") +MAKE_PSTR(num, " ") // this is hack so HA renders numbers correctly // TAG mapping - maps to DeviceValueTAG_s in emsdevice.cpp // use empty string if want to suppress showing tags @@ -313,11 +315,11 @@ MAKE_PSTR_LIST(enum_wwCircMode2, F_(off), F_(on), F_(auto)) MAKE_PSTR_LIST(enum_heatingtype, F_(off), F_(radiator), F_(convector), F_(floor)) MAKE_PSTR_LIST(enum_summermode, F_(summer), F_(auto), F_(winter)) -MAKE_PSTR_LIST(enum_mode, F_(manual), F_(auto)) -MAKE_PSTR_LIST(enum_mode2, F_(off), F_(manual), F_(auto)) -MAKE_PSTR_LIST(enum_mode3, F_(night), F_(day), F_(auto)) -MAKE_PSTR_LIST(enum_mode4, F_(blank), F_(manual), F_(auto), F_(holiday)) -MAKE_PSTR_LIST(enum_mode5, F_(auto), F_(off)) +MAKE_PSTR_LIST(enum_mode, F_(manual), F_(auto)) // RC100, RC300, RC310 +MAKE_PSTR_LIST(enum_mode2, F_(off), F_(manual), F_(auto)) // RC20 +MAKE_PSTR_LIST(enum_mode3, F_(night), F_(day), F_(auto)) // RC35, RC30 +MAKE_PSTR_LIST(enum_mode4, F_(blank), F_(manual), F_(auto), F_(holiday)) // JUNKERS +MAKE_PSTR_LIST(enum_mode5, F_(auto), F_(off)) // CRF MAKE_PSTR_LIST(enum_modetype, F_(eco), F_(comfort)) MAKE_PSTR_LIST(enum_modetype2, F_(day)) @@ -592,13 +594,13 @@ MAKE_PSTR_LIST(thermalDisinfect, F("thermaldisinfect"), F("thermal disinfection" MAKE_PSTR_LIST(heatMetering, F("heatmetering"), F("heatmetering")) // MAKE_PSTR_LIST(solarIsEnabled, F("solarenabled"), F("")) - // telegram 0x035A +// telegram 0x035A MAKE_PSTR_LIST(solarPumpMode, F("solarpumpmode"), F("solar pump mode")) MAKE_PSTR_LIST(solarPumpKick, F("pumpkick"), F("pumpkick")) MAKE_PSTR_LIST(plainWaterMode, F("plainwatermode"), F("plain water mode")) MAKE_PSTR_LIST(doubleMatchFlow, F("doublematchflow"), F("doublematchflow")) - // telegram 0x380 +// telegram 0x380 MAKE_PSTR_LIST(climateZone, F("climatezone"), F("climate zone")) MAKE_PSTR_LIST(collector1Area, F("collector1area"), F("collector 1 area")) MAKE_PSTR_LIST(collector1Type, F("collector1type"), F("collector 1 type")) diff --git a/src/version.h b/src/version.h index aca9e3cd8..780d2f060 100644 --- a/src/version.h +++ b/src/version.h @@ -1 +1 @@ -#define EMSESP_APP_VERSION "3.1.1b2" +#define EMSESP_APP_VERSION "3.1.1b3"