From b9c08a58adf245037f37febe5a2891d75cb979c6 Mon Sep 17 00:00:00 2001 From: proddy Date: Sun, 21 Mar 2021 17:31:52 +0100 Subject: [PATCH] fix: only create mqtt subs for Boiler (expose individual commands via MQTT topics #31) --- src/devices/boiler.cpp | 102 ++++++++++----------- src/devices/heatpump.cpp | 4 +- src/devices/mixer.cpp | 12 +-- src/devices/solar.cpp | 36 ++++---- src/devices/switch.cpp | 6 +- src/devices/thermostat.cpp | 180 ++++++++++++++++++------------------- src/emsesp.h | 4 + src/mqtt.cpp | 9 +- 8 files changed, 180 insertions(+), 173 deletions(-) diff --git a/src/devices/boiler.cpp b/src/devices/boiler.cpp index d3cc75136..430b3d81d 100644 --- a/src/devices/boiler.cpp +++ b/src/devices/boiler.cpp @@ -49,59 +49,53 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const reserve_telgram_functions(25); // reserve some space for the telegram registries, to avoid memory fragmentation // the telegram handlers... - register_telegram_type(0x10, F("UBAErrorMessage1"), false, [&](std::shared_ptr t) { process_UBAErrorMessage(t); }); - register_telegram_type(0x11, F("UBAErrorMessage2"), false, [&](std::shared_ptr t) { process_UBAErrorMessage(t); }); - register_telegram_type(0x14, F("UBATotalUptime"), true, [&](std::shared_ptr t) { process_UBATotalUptime(t); }); - register_telegram_type(0x15, F("UBAMaintenanceData"), false, [&](std::shared_ptr t) { process_UBAMaintenanceData(t); }); - register_telegram_type(0x16, F("UBAParameters"), true, [&](std::shared_ptr t) { process_UBAParameters(t); }); - register_telegram_type(0x18, F("UBAMonitorFast"), false, [&](std::shared_ptr t) { process_UBAMonitorFast(t); }); - register_telegram_type(0x19, F("UBAMonitorSlow"), true, [&](std::shared_ptr t) { process_UBAMonitorSlow(t); }); - register_telegram_type(0x1A, F("UBASetPoints"), false, [&](std::shared_ptr t) { process_UBASetPoints(t); }); - register_telegram_type(0x1C, F("UBAMaintenanceStatus"), false, [&](std::shared_ptr t) { process_UBAMaintenanceStatus(t); }); - register_telegram_type(0x26, F("UBASettingsWW"), true, [&](std::shared_ptr t) { process_UBASettingsWW(t); }); - register_telegram_type(0x2A, F("MC10Status"), false, [&](std::shared_ptr t) { process_MC10Status(t); }); - register_telegram_type(0x33, F("UBAParameterWW"), true, [&](std::shared_ptr t) { process_UBAParameterWW(t); }); - register_telegram_type(0x34, F("UBAMonitorWW"), false, [&](std::shared_ptr t) { process_UBAMonitorWW(t); }); - register_telegram_type(0x35, F("UBAFlags"), false, [&](std::shared_ptr t) { process_UBAFlags(t); }); - register_telegram_type(0xD1, F("UBAOutdoorTemp"), false, [&](std::shared_ptr t) { process_UBAOutdoorTemp(t); }); - register_telegram_type(0xE3, F("UBAMonitorSlowPlus"), false, [&](std::shared_ptr t) { process_UBAMonitorSlowPlus2(t); }); - register_telegram_type(0xE4, F("UBAMonitorFastPlus"), false, [&](std::shared_ptr t) { process_UBAMonitorFastPlus(t); }); - register_telegram_type(0xE5, F("UBAMonitorSlowPlus"), false, [&](std::shared_ptr t) { process_UBAMonitorSlowPlus(t); }); - register_telegram_type(0xE6, F("UBAParametersPlus"), true, [&](std::shared_ptr t) { process_UBAParametersPlus(t); }); - register_telegram_type(0xE9, F("UBADHWStatus"), false, [&](std::shared_ptr t) { process_UBADHWStatus(t); }); - register_telegram_type(0xEA, F("UBAParameterWWPlus"), true, [&](std::shared_ptr t) { process_UBAParameterWWPlus(t); }); - register_telegram_type(0x494, F("UBAEnergySupplied"), false, [&](std::shared_ptr t) { process_UBAEnergySupplied(t); }); - register_telegram_type(0x495, F("UBAInformation"), false, [&](std::shared_ptr t) { process_UBAInformation(t); }); - - EMSESP::send_read_request(0x10, device_id); // read last errorcode on start (only published on errors) - EMSESP::send_read_request(0x11, device_id); // read last errorcode on start (only published on errors) - EMSESP::send_read_request(0x15, device_id); // read maintenace data on start (only published on change) - EMSESP::send_read_request(0x1C, device_id); // read maintenace status on start (only published on change) + register_telegram_type(0x10, F("UBAErrorMessage1"), false, MAKE_PF_CB(process_UBAErrorMessage)); + register_telegram_type(0x11, F("UBAErrorMessage2"), false, MAKE_PF_CB(process_UBAErrorMessage)); + register_telegram_type(0x14, F("UBATotalUptime"), true, MAKE_PF_CB(process_UBATotalUptime)); + register_telegram_type(0x15, F("UBAMaintenanceData"), false, MAKE_PF_CB(process_UBAMaintenanceData)); + register_telegram_type(0x16, F("UBAParameters"), true, MAKE_PF_CB(process_UBAParameters)); + register_telegram_type(0x18, F("UBAMonitorFast"), false, MAKE_PF_CB(process_UBAMonitorFast)); + register_telegram_type(0x19, F("UBAMonitorSlow"), true, MAKE_PF_CB(process_UBAMonitorSlow)); + register_telegram_type(0x1A, F("UBASetPoints"), false, MAKE_PF_CB(process_UBASetPoints)); + register_telegram_type(0x1C, F("UBAMaintenanceStatus"), false, MAKE_PF_CB(process_UBAMaintenanceStatus)); + register_telegram_type(0x26, F("UBASettingsWW"), true, MAKE_PF_CB(process_UBASettingsWW)); + register_telegram_type(0x2A, F("MC10Status"), false, MAKE_PF_CB(process_MC10Status)); + register_telegram_type(0x33, F("UBAParameterWW"), true, MAKE_PF_CB(process_UBAParameterWW)); + register_telegram_type(0x34, F("UBAMonitorWW"), false, MAKE_PF_CB(process_UBAMonitorWW)); + register_telegram_type(0x35, F("UBAFlags"), false, MAKE_PF_CB(process_UBAFlags)); + register_telegram_type(0xD1, F("UBAOutdoorTemp"), false, MAKE_PF_CB(process_UBAOutdoorTemp)); + register_telegram_type(0xE3, F("UBAMonitorSlowPlus"), false, MAKE_PF_CB(process_UBAMonitorSlowPlus2)); + register_telegram_type(0xE4, F("UBAMonitorFastPlus"), false, MAKE_PF_CB(process_UBAMonitorFastPlus)); + register_telegram_type(0xE5, F("UBAMonitorSlowPlus"), false, MAKE_PF_CB(process_UBAMonitorSlowPlus)); + register_telegram_type(0xE6, F("UBAParametersPlus"), true, MAKE_PF_CB(process_UBAParametersPlus)); + register_telegram_type(0xE9, F("UBADHWStatus"), false, MAKE_PF_CB(process_UBADHWStatus)); + register_telegram_type(0xEA, F("UBAParameterWWPlus"), true, MAKE_PF_CB(process_UBAParameterWWPlus)); + register_telegram_type(0x494, F("UBAEnergySupplied"), false, MAKE_PF_CB(process_UBAEnergySupplied)); + register_telegram_type(0x495, F("UBAInformation"), false, MAKE_PF_CB(process_UBAInformation)); // MQTT commands for boiler topic - register_mqtt_cmd(F("comfort"), [&](const char * value, const int8_t id) { return set_warmwater_mode(value, id); }); - register_mqtt_cmd(F("wwactivated"), [&](const char * value, const int8_t id) { return set_warmwater_activated(value, id); }); - register_mqtt_cmd(F("wwtapactivated"), [&](const char * value, const int8_t id) { return set_tapwarmwater_activated(value, id); }); - register_mqtt_cmd(F("wwflowtempoffset"), [&](const char * value, const int8_t id) { return set_wWFlowTempOffset(value, id); }); - register_mqtt_cmd(F("wwmaxpower"), [&](const char * value, const int8_t id) { return set_warmwater_maxpower(value, id); }); - register_mqtt_cmd(F("wwonetime"), [&](const char * value, const int8_t id) { return set_warmwater_onetime(value, id); }); - register_mqtt_cmd(F("wwcircpump"), [&](const char * value, const int8_t id) { return set_warmwater_circulation_pump(value, id); }); - register_mqtt_cmd(F("wwcirculation"), [&](const char * value, const int8_t id) { return set_warmwater_circulation(value, id); }); - register_mqtt_cmd(F("wwcircmode"), [&](const char * value, const int8_t id) { return set_warmwater_circulation_mode(value, id); }); - register_mqtt_cmd(F("flowtemp"), [&](const char * value, const int8_t id) { return set_flow_temp(value, id); }); - register_mqtt_cmd(F("wwsettemp"), [&](const char * value, const int8_t id) { return set_warmwater_temp(value, id); }); - register_mqtt_cmd(F("heatingactivated"), [&](const char * value, const int8_t id) { return set_heating_activated(value, id); }); - register_mqtt_cmd(F("heatingtemp"), [&](const char * value, const int8_t id) { return set_heating_temp(value, id); }); - register_mqtt_cmd(F("burnmaxpower"), [&](const char * value, const int8_t id) { return set_max_power(value, id); }); - register_mqtt_cmd(F("burnminpower"), [&](const char * value, const int8_t id) { return set_min_power(value, id); }); - register_mqtt_cmd(F("boilhyston"), [&](const char * value, const int8_t id) { return set_hyst_on(value, id); }); - register_mqtt_cmd(F("boilhystoff"), [&](const char * value, const int8_t id) { return set_hyst_off(value, id); }); - register_mqtt_cmd(F("burnperiod"), [&](const char * value, const int8_t id) { return set_burn_period(value, id); }); - register_mqtt_cmd(F("pumpdelay"), [&](const char * value, const int8_t id) { return set_pump_delay(value, id); }); - register_mqtt_cmd(F("maintenance"), [&](const char * value, const int8_t id) { return set_maintenance(value, id); }); - register_mqtt_cmd(F("pumpmodmax"), [&](const char * value, const int8_t id) { return set_max_pump(value, id); }); - register_mqtt_cmd(F("pumpmodmin"), [&](const char * value, const int8_t id) { return set_min_pump(value, id); }); - // register_mqtt_cmd(F("reset"), [&](const char * value, const int8_t id) { return set_reset(value, id); }); + register_mqtt_cmd(F("comfort"), MAKE_CF_CB(set_warmwater_mode)); + register_mqtt_cmd(F("wwactivated"), MAKE_CF_CB(set_warmwater_activated)); + register_mqtt_cmd(F("wwtapactivated"), MAKE_CF_CB(set_tapwarmwater_activated)); + register_mqtt_cmd(F("wwflowtempoffset"), MAKE_CF_CB(set_wWFlowTempOffset)); + register_mqtt_cmd(F("wwmaxpower"), MAKE_CF_CB(set_warmwater_maxpower)); + register_mqtt_cmd(F("wwonetime"), MAKE_CF_CB(set_warmwater_onetime)); + register_mqtt_cmd(F("wwcircpump"), MAKE_CF_CB(set_warmwater_circulation_pump)); + register_mqtt_cmd(F("wwcirculation"), MAKE_CF_CB(set_warmwater_circulation)); + register_mqtt_cmd(F("wwcircmode"), MAKE_CF_CB(set_warmwater_circulation_mode)); + register_mqtt_cmd(F("flowtemp"), MAKE_CF_CB(set_flow_temp)); + register_mqtt_cmd(F("wwsettemp"), MAKE_CF_CB(set_warmwater_temp)); + register_mqtt_cmd(F("heatingactivated"), MAKE_CF_CB(set_heating_activated)); + register_mqtt_cmd(F("heatingtemp"), MAKE_CF_CB(set_heating_temp)); + register_mqtt_cmd(F("burnmaxpower"), MAKE_CF_CB(set_max_power)); + register_mqtt_cmd(F("burnminpower"), MAKE_CF_CB(set_min_power)); + register_mqtt_cmd(F("boilhyston"), MAKE_CF_CB(set_hyst_on)); + register_mqtt_cmd(F("boilhystoff"), MAKE_CF_CB(set_hyst_off)); + register_mqtt_cmd(F("burnperiod"), MAKE_CF_CB(set_burn_period)); + register_mqtt_cmd(F("pumpdelay"), MAKE_CF_CB(set_pump_delay)); + register_mqtt_cmd(F("maintenance"), MAKE_CF_CB(set_maintenance)); + register_mqtt_cmd(F("pumpmodmax"), MAKE_CF_CB(set_max_pump)); + register_mqtt_cmd(F("pumpmodmin"), MAKE_CF_CB(set_min_pump)); // add values reserve_device_values(50); @@ -204,6 +198,12 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_BOILER_DATA_WW, &wWStarts_, DeviceValueType::ULONG, nullptr, F("wWStarts"), F("# starts")); register_device_value(TAG_BOILER_DATA_WW, &wWStarts2_, DeviceValueType::ULONG, nullptr, F("wWStarts2"), F("# control starts")); register_device_value(TAG_BOILER_DATA_WW, &wWWorkM_, DeviceValueType::TIME, nullptr, F("wWWorkM"), F("active time"), DeviceValueUOM::MINUTES); + + // fetch some initial data + EMSESP::send_read_request(0x10, device_id); // read last errorcode on start (only published on errors) + EMSESP::send_read_request(0x11, device_id); // read last errorcode on start (only published on errors) + EMSESP::send_read_request(0x15, device_id); // read maintenace data on start (only published on change) + EMSESP::send_read_request(0x1C, device_id); // read maintenace status on start (only published on change) } // publish HA config diff --git a/src/devices/heatpump.cpp b/src/devices/heatpump.cpp index 4a01aa34b..c820438c8 100644 --- a/src/devices/heatpump.cpp +++ b/src/devices/heatpump.cpp @@ -29,8 +29,8 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c LOG_DEBUG(F("Adding new Heat Pump module with device ID 0x%02X"), device_id); // telegram handlers - register_telegram_type(0x042B, F("HP1"), true, [&](std::shared_ptr t) { process_HPMonitor1(t); }); - register_telegram_type(0x047B, F("HP2"), true, [&](std::shared_ptr t) { process_HPMonitor2(t); }); + register_telegram_type(0x042B, F("HP1"), true, MAKE_PF_CB(process_HPMonitor1)); + register_telegram_type(0x047B, F("HP2"), true, MAKE_PF_CB(process_HPMonitor2)); // device values register_device_value(TAG_NONE, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr); // empty full name to prevent being shown in web or console diff --git a/src/devices/mixer.cpp b/src/devices/mixer.cpp index e6d7818d0..5600e1222 100644 --- a/src/devices/mixer.cpp +++ b/src/devices/mixer.cpp @@ -31,23 +31,23 @@ Mixer::Mixer(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s if (flags == EMSdevice::EMS_DEVICE_FLAG_MMPLUS) { if (device_id <= 0x27) { // telegram handlers 0x20 - 0x27 for HC - register_telegram_type(device_id - 0x20 + 0x02D7, F("MMPLUSStatusMessage_HC"), true, [&](std::shared_ptr t) { process_MMPLUSStatusMessage_HC(t); }); + register_telegram_type(device_id - 0x20 + 0x02D7, F("MMPLUSStatusMessage_HC"), true, MAKE_PF_CB(process_MMPLUSStatusMessage_HC)); } else { // telegram handlers for warm water/DHW 0x28, 0x29 - register_telegram_type(device_id - 0x28 + 0x0331, F("MMPLUSStatusMessage_WWC"), true, [&](std::shared_ptr t) { process_MMPLUSStatusMessage_WWC(t); }); + register_telegram_type(device_id - 0x28 + 0x0331, F("MMPLUSStatusMessage_WWC"), true, MAKE_PF_CB(process_MMPLUSStatusMessage_WWC)); } } // EMS 1.0 if (flags == EMSdevice::EMS_DEVICE_FLAG_MM10) { - register_telegram_type(0x00AA, F("MMConfigMessage"), false, [&](std::shared_ptr t) { process_MMConfigMessage(t); }); - register_telegram_type(0x00AB, F("MMStatusMessage"), true, [&](std::shared_ptr t) { process_MMStatusMessage(t); }); - register_telegram_type(0x00AC, F("MMSetMessage"), false, [&](std::shared_ptr t) { process_MMSetMessage(t); }); + register_telegram_type(0x00AA, F("MMConfigMessage"), false, MAKE_PF_CB(process_MMConfigMessage)); + register_telegram_type(0x00AB, F("MMStatusMessage"), true, MAKE_PF_CB(process_MMStatusMessage)); + register_telegram_type(0x00AC, F("MMSetMessage"), false, MAKE_PF_CB(process_MMSetMessage)); } // HT3 if (flags == EMSdevice::EMS_DEVICE_FLAG_IPM) { - register_telegram_type(0x010C, F("IPMSetMessage"), false, [&](std::shared_ptr t) { process_IPMStatusMessage(t); }); + register_telegram_type(0x010C, F("IPMSetMessage"), false, MAKE_PF_CB(process_IPMStatusMessage)); } // register the device values and set hc_ and type_ diff --git a/src/devices/solar.cpp b/src/devices/solar.cpp index b2bb17e40..69fe8d489 100644 --- a/src/devices/solar.cpp +++ b/src/devices/solar.cpp @@ -30,34 +30,34 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s // telegram handlers if (flags == EMSdevice::EMS_DEVICE_FLAG_SM10) { - register_telegram_type(0x0097, F("SM10Monitor"), true, [&](std::shared_ptr t) { process_SM10Monitor(t); }); + register_telegram_type(0x0097, F("SM10Monitor"), true, MAKE_PF_CB(process_SM10Monitor)); } if (flags == EMSdevice::EMS_DEVICE_FLAG_SM100) { if (device_id == 0x2A) { - register_telegram_type(0x07D6, F("SM100wwTemperature"), false, [&](std::shared_ptr t) { process_SM100wwTemperature(t); }); - register_telegram_type(0x07AA, F("SM100wwStatus"), false, [&](std::shared_ptr t) { process_SM100wwStatus(t); }); - register_telegram_type(0x07AB, F("SM100wwCommand"), false, [&](std::shared_ptr t) { process_SM100wwCommand(t); }); + register_telegram_type(0x07D6, F("SM100wwTemperature"), false, MAKE_PF_CB(process_SM100wwTemperature)); + register_telegram_type(0x07AA, F("SM100wwStatus"), false, MAKE_PF_CB(process_SM100wwStatus)); + register_telegram_type(0x07AB, F("SM100wwCommand"), false, MAKE_PF_CB(process_SM100wwCommand)); } else { - register_telegram_type(0xF9, F("ParamCfg"), false, [&](std::shared_ptr t) { process_SM100ParamCfg(t); }); - register_telegram_type(0x0358, F("SM100SystemConfig"), true, [&](std::shared_ptr t) { process_SM100SystemConfig(t); }); - register_telegram_type(0x035A, F("SM100SolarCircuitConfig"), true, [&](std::shared_ptr t) { process_SM100SolarCircuitConfig(t); }); - register_telegram_type(0x0362, F("SM100Monitor"), true, [&](std::shared_ptr t) { process_SM100Monitor(t); }); - register_telegram_type(0x0363, F("SM100Monitor2"), true, [&](std::shared_ptr t) { process_SM100Monitor2(t); }); - register_telegram_type(0x0366, F("SM100Config"), true, [&](std::shared_ptr t) { process_SM100Config(t); }); - register_telegram_type(0x0364, F("SM100Status"), false, [&](std::shared_ptr t) { process_SM100Status(t); }); - register_telegram_type(0x036A, F("SM100Status2"), false, [&](std::shared_ptr t) { process_SM100Status2(t); }); - register_telegram_type(0x0380, F("SM100CollectorConfig"), true, [&](std::shared_ptr t) { process_SM100CollectorConfig(t); }); - register_telegram_type(0x038E, F("SM100Energy"), true, [&](std::shared_ptr t) { process_SM100Energy(t); }); - register_telegram_type(0x0391, F("SM100Time"), true, [&](std::shared_ptr t) { process_SM100Time(t); }); + register_telegram_type(0xF9, F("ParamCfg"), false, MAKE_PF_CB(process_SM100ParamCfg)); + register_telegram_type(0x0358, F("SM100SystemConfig"), true, MAKE_PF_CB(process_SM100SystemConfig)); + register_telegram_type(0x035A, F("SM100SolarCircuitConfig"), true, MAKE_PF_CB(process_SM100SolarCircuitConfig)); + register_telegram_type(0x0362, F("SM100Monitor"), true, MAKE_PF_CB(process_SM100Monitor)); + register_telegram_type(0x0363, F("SM100Monitor2"), true, MAKE_PF_CB(process_SM100Monitor2)); + register_telegram_type(0x0366, F("SM100Config"), true, MAKE_PF_CB(process_SM100Config)); + register_telegram_type(0x0364, F("SM100Status"), false, MAKE_PF_CB(process_SM100Status)); + register_telegram_type(0x036A, F("SM100Status2"), false, MAKE_PF_CB(process_SM100Status2)); + register_telegram_type(0x0380, F("SM100CollectorConfig"), true, MAKE_PF_CB(process_SM100CollectorConfig)); + register_telegram_type(0x038E, F("SM100Energy"), true, MAKE_PF_CB(process_SM100Energy)); + register_telegram_type(0x0391, F("SM100Time"), true, MAKE_PF_CB(process_SM100Time)); - register_mqtt_cmd(F("SM100TankBottomMaxTemp"), [&](const char * value, const int8_t id) { return set_SM100TankBottomMaxTemp(value, id); }); + register_mqtt_cmd(F("SM100TankBottomMaxTemp"), MAKE_CF_CB(set_SM100TankBottomMaxTemp)); } } if (flags == EMSdevice::EMS_DEVICE_FLAG_ISM) { - register_telegram_type(0x0103, F("ISM1StatusMessage"), true, [&](std::shared_ptr t) { process_ISM1StatusMessage(t); }); - register_telegram_type(0x0101, F("ISM1Set"), false, [&](std::shared_ptr t) { process_ISM1Set(t); }); + register_telegram_type(0x0103, F("ISM1StatusMessage"), true, MAKE_PF_CB(process_ISM1StatusMessage)); + register_telegram_type(0x0101, F("ISM1Set"), false, MAKE_PF_CB(process_ISM1Set)); } // device values... diff --git a/src/devices/switch.cpp b/src/devices/switch.cpp index 04a54cb8e..4144f812f 100644 --- a/src/devices/switch.cpp +++ b/src/devices/switch.cpp @@ -30,9 +30,9 @@ Switch::Switch(uint8_t device_type, uint8_t device_id, uint8_t product_id, const : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { LOG_DEBUG(F("Adding new Switch with device ID 0x%02X"), device_id); - register_telegram_type(0x9C, F("WM10MonitorMessage"), false, [&](std::shared_ptr t) { process_WM10MonitorMessage(t); }); - register_telegram_type(0x9D, F("WM10SetMessage"), false, [&](std::shared_ptr t) { process_WM10SetMessage(t); }); - register_telegram_type(0x1E, F("WM10TempMessage"), false, [&](std::shared_ptr t) { process_WM10TempMessage(t); }); + register_telegram_type(0x9C, F("WM10MonitorMessage"), false, MAKE_PF_CB(process_WM10MonitorMessage)); + register_telegram_type(0x9D, F("WM10SetMessage"), false, MAKE_PF_CB(process_WM10SetMessage)); + register_telegram_type(0x1E, F("WM10TempMessage"), false, MAKE_PF_CB(process_WM10TempMessage)); register_device_value(TAG_NONE, &activated_, DeviceValueType::BOOL, nullptr, F("activated"), F("activated")); register_device_value(TAG_NONE, &flowTempHc_, DeviceValueType::USHORT, FL_(div10), F("flowTempHc"), F("flow temperature in assigned hc (TC1)"), DeviceValueUOM::DEGREES); diff --git a/src/devices/thermostat.cpp b/src/devices/thermostat.cpp index 0ea2609da..42dfe4f0a 100644 --- a/src/devices/thermostat.cpp +++ b/src/devices/thermostat.cpp @@ -44,18 +44,18 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i reserve_telgram_functions(25); // reserve some space for the telegram registries, to avoid memory fragmentation // common telegram handlers - register_telegram_type(EMS_TYPE_RCOutdoorTemp, F("RCOutdoorTemp"), false, [&](std::shared_ptr t) { process_RCOutdoorTemp(t); }); - register_telegram_type(EMS_TYPE_RCTime, F("RCTime"), false, [&](std::shared_ptr t) { process_RCTime(t); }); - register_telegram_type(0xA2, F("RCError"), false, [&](std::shared_ptr t) { process_RCError(t); }); - register_telegram_type(0x12, F("RCErrorMessage"), false, [&](std::shared_ptr t) { process_RCErrorMessage(t); }); + register_telegram_type(EMS_TYPE_RCOutdoorTemp, F("RCOutdoorTemp"), false, MAKE_PF_CB(process_RCOutdoorTemp)); + register_telegram_type(EMS_TYPE_RCTime, F("RCTime"), false, MAKE_PF_CB(process_RCTime)); + register_telegram_type(0xA2, F("RCError"), false, MAKE_PF_CB(process_RCError)); + register_telegram_type(0x12, F("RCErrorMessage"), false, MAKE_PF_CB(process_RCErrorMessage)); } // RC10 if (model == EMSdevice::EMS_DEVICE_FLAG_RC10) { monitor_typeids = {0xB1}; set_typeids = {0xB0}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC10Monitor"), false, [&](std::shared_ptr t) { process_RC10Monitor(t); }); - register_telegram_type(set_typeids[i], F("RC10Set"), false, [&](std::shared_ptr t) { process_RC10Set(t); }); + register_telegram_type(monitor_typeids[i], F("RC10Monitor"), false, MAKE_PF_CB(process_RC10Monitor)); + register_telegram_type(set_typeids[i], F("RC10Set"), false, MAKE_PF_CB(process_RC10Set)); } // RC35 @@ -64,12 +64,12 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i set_typeids = {0x3D, 0x47, 0x51, 0x5B}; timer_typeids = {0x3F, 0x49, 0x53, 0x5D}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC35Monitor"), false, [&](std::shared_ptr t) { process_RC35Monitor(t); }); - register_telegram_type(set_typeids[i], F("RC35Set"), false, [&](std::shared_ptr t) { process_RC35Set(t); }); - register_telegram_type(timer_typeids[i], F("RC35Timer"), false, [&](std::shared_ptr t) { process_RC35Timer(t); }); + register_telegram_type(monitor_typeids[i], F("RC35Monitor"), false, MAKE_PF_CB(process_RC35Monitor)); + register_telegram_type(set_typeids[i], F("RC35Set"), false, MAKE_PF_CB(process_RC35Set)); + register_telegram_type(timer_typeids[i], F("RC35Timer"), false, MAKE_PF_CB(process_RC35Timer)); } - register_telegram_type(EMS_TYPE_IBASettings, F("IBASettings"), true, [&](std::shared_ptr t) { process_IBASettings(t); }); - register_telegram_type(EMS_TYPE_wwSettings, F("WWSettings"), true, [&](std::shared_ptr t) { process_RC35wwSettings(t); }); + register_telegram_type(EMS_TYPE_IBASettings, F("IBASettings"), true, MAKE_PF_CB(process_IBASettings)); + register_telegram_type(EMS_TYPE_wwSettings, F("WWSettings"), true, MAKE_PF_CB(process_RC35wwSettings)); // RC20 } else if (model == EMSdevice::EMS_DEVICE_FLAG_RC20) { @@ -77,11 +77,11 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i set_typeids = {0xA8}; if (actual_master_thermostat == device_id) { for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC20Monitor"), false, [&](std::shared_ptr t) { process_RC20Monitor(t); }); - register_telegram_type(set_typeids[i], F("RC20Set"), false, [&](std::shared_ptr t) { process_RC20Set(t); }); + register_telegram_type(monitor_typeids[i], F("RC20Monitor"), false, MAKE_PF_CB(process_RC20Monitor)); + register_telegram_type(set_typeids[i], F("RC20Set"), false, MAKE_PF_CB(process_RC20Set)); } } else { - register_telegram_type(0xAF, F("RC20Remote"), false, [&](std::shared_ptr t) { process_RC20Remote(t); }); + register_telegram_type(0xAF, F("RC20Remote"), false, MAKE_PF_CB(process_RC20Remote)); } // RC20 newer } else if (model == EMSdevice::EMS_DEVICE_FLAG_RC20_2) { @@ -89,26 +89,26 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i set_typeids = {0xAD}; if (actual_master_thermostat == device_id) { for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC20Monitor"), false, [&](std::shared_ptr t) { process_RC20Monitor_2(t); }); - register_telegram_type(set_typeids[i], F("RC20Set"), false, [&](std::shared_ptr t) { process_RC20Set_2(t); }); + register_telegram_type(monitor_typeids[i], F("RC20Monitor"), false, MAKE_PF_CB(process_RC20Monitor_2)); + register_telegram_type(set_typeids[i], F("RC20Set"), false, MAKE_PF_CB(process_RC20Set_2)); } } else { - register_telegram_type(0xAF, F("RC20Remote"), false, [&](std::shared_ptr t) { process_RC20Remote(t); }); + register_telegram_type(0xAF, F("RC20Remote"), false, MAKE_PF_CB(process_RC20Remote)); } // RC30 } else if (model == EMSdevice::EMS_DEVICE_FLAG_RC30) { monitor_typeids = {0x41}; set_typeids = {0xA7}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC30Monitor"), false, [&](std::shared_ptr t) { process_RC30Monitor(t); }); - register_telegram_type(set_typeids[i], F("RC30Set"), false, [&](std::shared_ptr t) { process_RC30Set(t); }); + register_telegram_type(monitor_typeids[i], F("RC30Monitor"), false, MAKE_PF_CB(process_RC30Monitor)); + register_telegram_type(set_typeids[i], F("RC30Set"), false, MAKE_PF_CB(process_RC30Set)); } // EASY } else if (model == EMSdevice::EMS_DEVICE_FLAG_EASY) { monitor_typeids = {0x0A}; set_typeids = {}; - register_telegram_type(monitor_typeids[0], F("EasyMonitor"), true, [&](std::shared_ptr t) { process_EasyMonitor(t); }); + register_telegram_type(monitor_typeids[0], F("EasyMonitor"), true, MAKE_PF_CB(process_EasyMonitor)); // RC300/RC100 } else if ((model == EMSdevice::EMS_DEVICE_FLAG_RC300) || (model == EMSdevice::EMS_DEVICE_FLAG_RC100)) { @@ -117,36 +117,36 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i summer_typeids = {0x02AF, 0x02B0, 0x02B1, 0x02B2}; curve_typeids = {0x029B, 0x029C, 0x029D, 0x029E}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("RC300Monitor"), false, [&](std::shared_ptr t) { process_RC300Monitor(t); }); - register_telegram_type(set_typeids[i], F("RC300Set"), false, [&](std::shared_ptr t) { process_RC300Set(t); }); - register_telegram_type(summer_typeids[i], F("RC300Summer"), false, [&](std::shared_ptr t) { process_RC300Summer(t); }); - register_telegram_type(curve_typeids[i], F("RC300Curves"), false, [&](std::shared_ptr t) { process_RC300Curve(t); }); + register_telegram_type(monitor_typeids[i], F("RC300Monitor"), false, MAKE_PF_CB(process_RC300Monitor)); + register_telegram_type(set_typeids[i], F("RC300Set"), false, MAKE_PF_CB(process_RC300Set)); + register_telegram_type(summer_typeids[i], F("RC300Summer"), false, MAKE_PF_CB(process_RC300Summer)); + register_telegram_type(curve_typeids[i], F("RC300Curves"), false, MAKE_PF_CB(process_RC300Curve)); } - register_telegram_type(0x2F5, F("RC300WWmode"), true, [&](std::shared_ptr t) { process_RC300WWmode(t); }); - register_telegram_type(0x31B, F("RC300WWtemp"), true, [&](std::shared_ptr t) { process_RC300WWtemp(t); }); - register_telegram_type(0x31D, F("RC300WWmode2"), false, [&](std::shared_ptr t) { process_RC300WWmode2(t); }); - register_telegram_type(0x31E, F("RC300WWmode2"), false, [&](std::shared_ptr t) { process_RC300WWmode2(t); }); - register_telegram_type(0x23A, F("RC300OutdoorTemp"), true, [&](std::shared_ptr t) { process_RC300OutdoorTemp(t); }); - register_telegram_type(0x267, F("RC300Floordry"), false, [&](std::shared_ptr t) { process_RC300Floordry(t); }); - register_telegram_type(0x240, F("RC300Settings"), true, [&](std::shared_ptr t) { process_RC300Settings(t); }); + register_telegram_type(0x2F5, F("RC300WWmode"), true, MAKE_PF_CB(process_RC300WWmode)); + register_telegram_type(0x31B, F("RC300WWtemp"), true, MAKE_PF_CB(process_RC300WWtemp)); + register_telegram_type(0x31D, F("RC300WWmode2"), false, MAKE_PF_CB(process_RC300WWmode2)); + register_telegram_type(0x31E, F("RC300WWmode2"), false, MAKE_PF_CB(process_RC300WWmode2)); + register_telegram_type(0x23A, F("RC300OutdoorTemp"), true, MAKE_PF_CB(process_RC300OutdoorTemp)); + register_telegram_type(0x267, F("RC300Floordry"), false, MAKE_PF_CB(process_RC300Floordry)); + register_telegram_type(0x240, F("RC300Settings"), true, MAKE_PF_CB(process_RC300Settings)); // JUNKERS/HT3 } else if (model == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) { monitor_typeids = {0x016F, 0x0170, 0x0171, 0x0172}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(monitor_typeids[i], F("JunkersMonitor"), false, [&](std::shared_ptr t) { process_JunkersMonitor(t); }); + register_telegram_type(monitor_typeids[i], F("JunkersMonitor"), false, MAKE_PF_CB(process_JunkersMonitor)); } if (has_flags(EMS_DEVICE_FLAG_JUNKERS_OLD)) { // FR120, FR100 set_typeids = {0x0179, 0x017A, 0x017B, 0x017C}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(set_typeids[i], F("JunkersSet"), false, [&](std::shared_ptr t) { process_JunkersSet2(t); }); + register_telegram_type(set_typeids[i], F("JunkersSet"), false, MAKE_PF_CB(process_JunkersSet2)); } } else { set_typeids = {0x0165, 0x0166, 0x0167, 0x0168}; for (uint8_t i = 0; i < monitor_typeids.size(); i++) { - register_telegram_type(set_typeids[i], F("JunkersSet"), false, [&](std::shared_ptr t) { process_JunkersSet(t); }); + register_telegram_type(set_typeids[i], F("JunkersSet"), false, MAKE_PF_CB(process_JunkersSet)); } } } @@ -1986,74 +1986,74 @@ void Thermostat::add_commands() { } // common to all thermostats - register_mqtt_cmd(F("temp"), [&](const char * value, const int8_t id) { return set_temp(value, id); }); - register_mqtt_cmd(F("mode"), [&](const char * value, const int8_t id) { return set_mode(value, id); }); - register_mqtt_cmd(F("datetime"), [&](const char * value, const int8_t id) { return set_datetime(value, id); }); + register_mqtt_cmd(F("temp"), MAKE_CF_CB(set_temp)); + register_mqtt_cmd(F("mode"), MAKE_CF_CB(set_mode)); + register_mqtt_cmd(F("datetime"), MAKE_CF_CB(set_datetime)); switch (model()) { case EMS_DEVICE_FLAG_RC100: case EMS_DEVICE_FLAG_RC300: - register_mqtt_cmd(F("manualtemp"), [&](const char * value, const int8_t id) { return set_manualtemp(value, id); }); - register_mqtt_cmd(F("ecotemp"), [&](const char * value, const int8_t id) { return set_ecotemp(value, id); }); - register_mqtt_cmd(F("comforttemp"), [&](const char * value, const int8_t id) { return set_comforttemp(value, id); }); - register_mqtt_cmd(F("summermode"), [&](const char * value, const int8_t id) { return set_summermode(value, id); }); - register_mqtt_cmd(F("summertemp"), [&](const char * value, const int8_t id) { return set_summertemp(value, id); }); - register_mqtt_cmd(F("wwmode"), [&](const char * value, const int8_t id) { return set_wwmode(value, id); }); - register_mqtt_cmd(F("wwsettemp"), [&](const char * value, const int8_t id) { return set_wwtemp(value, id); }); - register_mqtt_cmd(F("wwsettemplow"), [&](const char * value, const int8_t id) { return set_wwtemplow(value, id); }); - register_mqtt_cmd(F("wwonetime"), [&](const char * value, const int8_t id) { return set_wwonetime(value, id); }); - register_mqtt_cmd(F("wwcircmode"), [&](const char * value, const int8_t id) { return set_wwcircmode(value, id); }); - register_mqtt_cmd(F("building"), [&](const char * value, const int8_t id) { return set_building(value, id); }); - register_mqtt_cmd(F("nofrosttemp"), [&](const char * value, const int8_t id) { return set_nofrosttemp(value, id); }); - register_mqtt_cmd(F("designtemp"), [&](const char * value, const int8_t id) { return set_designtemp(value, id); }); - register_mqtt_cmd(F("offsettemp"), [&](const char * value, const int8_t id) { return set_offsettemp(value, id); }); - register_mqtt_cmd(F("minflowtemp"), [&](const char * value, const int8_t id) { return set_minflowtemp(value, id); }); - register_mqtt_cmd(F("maxflowtemp"), [&](const char * value, const int8_t id) { return set_maxflowtemp(value, id); }); - register_mqtt_cmd(F("minexttemp"), [&](const char * value, const int8_t id) { return set_minexttemp(value, id); }); - register_mqtt_cmd(F("roominfluence"), [&](const char * value, const int8_t id) { return set_roominfluence(value, id); }); - register_mqtt_cmd(F("program"), [&](const char * value, const int8_t id) { return set_program(value, id); }); - register_mqtt_cmd(F("controlmode"), [&](const char * value, const int8_t id) { return set_controlmode(value, id); }); + register_mqtt_cmd(F("manualtemp"), MAKE_CF_CB(set_manualtemp)); + register_mqtt_cmd(F("ecotemp"), MAKE_CF_CB(set_ecotemp)); + register_mqtt_cmd(F("comforttemp"), MAKE_CF_CB(set_comforttemp)); + register_mqtt_cmd(F("summermode"), MAKE_CF_CB(set_summermode)); + register_mqtt_cmd(F("summertemp"), MAKE_CF_CB(set_summertemp)); + register_mqtt_cmd(F("wwmode"), MAKE_CF_CB(set_wwmode)); + register_mqtt_cmd(F("wwsettemp"), MAKE_CF_CB(set_wwtemp)); + register_mqtt_cmd(F("wwsettemplow"), MAKE_CF_CB(set_wwtemplow)); + register_mqtt_cmd(F("wwonetime"), MAKE_CF_CB(set_wwonetime)); + register_mqtt_cmd(F("wwcircmode"), MAKE_CF_CB(set_wwcircmode)); + register_mqtt_cmd(F("building"), MAKE_CF_CB(set_building)); + register_mqtt_cmd(F("nofrosttemp"), MAKE_CF_CB(set_nofrosttemp)); + register_mqtt_cmd(F("designtemp"), MAKE_CF_CB(set_designtemp)); + register_mqtt_cmd(F("offsettemp"), MAKE_CF_CB(set_offsettemp)); + register_mqtt_cmd(F("minflowtemp"), MAKE_CF_CB(set_minflowtemp)); + register_mqtt_cmd(F("maxflowtemp"), MAKE_CF_CB(set_maxflowtemp)); + register_mqtt_cmd(F("minexttemp"), MAKE_CF_CB(set_minexttemp)); + register_mqtt_cmd(F("roominfluence"), MAKE_CF_CB(set_roominfluence)); + register_mqtt_cmd(F("program"), MAKE_CF_CB(set_program)); + register_mqtt_cmd(F("controlmode"), MAKE_CF_CB(set_controlmode)); break; case EMS_DEVICE_FLAG_RC20_2: - register_mqtt_cmd(F("nighttemp"), [&](const char * value, const int8_t id) { return set_nighttemp(value, id); }); - register_mqtt_cmd(F("daytemp"), [&](const char * value, const int8_t id) { return set_daytemp(value, id); }); - register_mqtt_cmd(F("program"), [&](const char * value, const int8_t id) { return set_program(value, id); }); + register_mqtt_cmd(F("nighttemp"), MAKE_CF_CB(set_nighttemp)); + register_mqtt_cmd(F("daytemp"), MAKE_CF_CB(set_daytemp)); + register_mqtt_cmd(F("program"), MAKE_CF_CB(set_program)); break; case EMS_DEVICE_FLAG_RC30_1: // only RC30_1 - register_mqtt_cmd(F("clockoffset"), [&](const char * value, const int8_t id) { return set_clockoffset(value, id); }); - register_mqtt_cmd(F("language"), [&](const char * value, const int8_t id) { return set_language(value, id); }); - register_mqtt_cmd(F("display"), [&](const char * value, const int8_t id) { return set_display(value, id); }); + register_mqtt_cmd(F("clockoffset"), MAKE_CF_CB(set_clockoffset)); + register_mqtt_cmd(F("language"), MAKE_CF_CB(set_language)); + register_mqtt_cmd(F("display"), MAKE_CF_CB(set_display)); break; case EMS_DEVICE_FLAG_RC35: // RC30 and RC35 - register_mqtt_cmd(F("nighttemp"), [&](const char * value, const int8_t id) { return set_nighttemp(value, id); }); - register_mqtt_cmd(F("daytemp"), [&](const char * value, const int8_t id) { return set_daytemp(value, id); }); - register_mqtt_cmd(F("nofrosttemp"), [&](const char * value, const int8_t id) { return set_nofrosttemp(value, id); }); - register_mqtt_cmd(F("remotetemp"), [&](const char * value, const int8_t id) { return set_remotetemp(value, id); }); - register_mqtt_cmd(F("minexttemp"), [&](const char * value, const int8_t id) { return set_minexttemp(value, id); }); - register_mqtt_cmd(F("calinttemp"), [&](const char * value, const int8_t id) { return set_calinttemp(value, id); }); - register_mqtt_cmd(F("building"), [&](const char * value, const int8_t id) { return set_building(value, id); }); - register_mqtt_cmd(F("control"), [&](const char * value, const int8_t id) { return set_control(value, id); }); - register_mqtt_cmd(F("pause"), [&](const char * value, const int8_t id) { return set_pause(value, id); }); - register_mqtt_cmd(F("party"), [&](const char * value, const int8_t id) { return set_party(value, id); }); - register_mqtt_cmd(F("holiday"), [&](const char * value, const int8_t id) { return set_holiday(value, id); }); - register_mqtt_cmd(F("summertemp"), [&](const char * value, const int8_t id) { return set_summertemp(value, id); }); - register_mqtt_cmd(F("designtemp"), [&](const char * value, const int8_t id) { return set_designtemp(value, id); }); - register_mqtt_cmd(F("offsettemp"), [&](const char * value, const int8_t id) { return set_offsettemp(value, id); }); - register_mqtt_cmd(F("holidaytemp"), [&](const char * value, const int8_t id) { return set_holidaytemp(value, id); }); - register_mqtt_cmd(F("wwmode"), [&](const char * value, const int8_t id) { return set_wwmode(value, id); }); - register_mqtt_cmd(F("wwcircmode"), [&](const char * value, const int8_t id) { return set_wwcircmode(value, id); }); - register_mqtt_cmd(F("roominfluence"), [&](const char * value, const int8_t id) { return set_roominfluence(value, id); }); - register_mqtt_cmd(F("flowtempoffset"), [&](const char * value, const int8_t id) { return set_flowtempoffset(value, id); }); - register_mqtt_cmd(F("minflowtemp"), [&](const char * value, const int8_t id) { return set_minflowtemp(value, id); }); - register_mqtt_cmd(F("maxflowtemp"), [&](const char * value, const int8_t id) { return set_maxflowtemp(value, id); }); - register_mqtt_cmd(F("reducemode"), [&](const char * value, const int8_t id) { return set_reducemode(value, id); }); - register_mqtt_cmd(F("program"), [&](const char * value, const int8_t id) { return set_program(value, id); }); - register_mqtt_cmd(F("controlmode"), [&](const char * value, const int8_t id) { return set_controlmode(value, id); }); + register_mqtt_cmd(F("nighttemp"), MAKE_CF_CB(set_nighttemp)); + register_mqtt_cmd(F("daytemp"), MAKE_CF_CB(set_daytemp)); + register_mqtt_cmd(F("nofrosttemp"), MAKE_CF_CB(set_nofrosttemp)); + register_mqtt_cmd(F("remotetemp"), MAKE_CF_CB(set_remotetemp)); + register_mqtt_cmd(F("minexttemp"), MAKE_CF_CB(set_minexttemp)); + register_mqtt_cmd(F("calinttemp"), MAKE_CF_CB(set_calinttemp)); + register_mqtt_cmd(F("building"), MAKE_CF_CB(set_building)); + register_mqtt_cmd(F("control"), MAKE_CF_CB(set_control)); + register_mqtt_cmd(F("pause"), MAKE_CF_CB(set_pause)); + register_mqtt_cmd(F("party"), MAKE_CF_CB(set_party)); + register_mqtt_cmd(F("holiday"), MAKE_CF_CB(set_holiday)); + register_mqtt_cmd(F("summertemp"), MAKE_CF_CB(set_summertemp)); + register_mqtt_cmd(F("designtemp"), MAKE_CF_CB(set_designtemp)); + register_mqtt_cmd(F("offsettemp"), MAKE_CF_CB(set_offsettemp)); + register_mqtt_cmd(F("holidaytemp"), MAKE_CF_CB(set_holidaytemp)); + register_mqtt_cmd(F("wwmode"), MAKE_CF_CB(set_wwmode)); + register_mqtt_cmd(F("wwcircmode"), MAKE_CF_CB(set_wwcircmode)); + register_mqtt_cmd(F("roominfluence"), MAKE_CF_CB(set_roominfluence)); + register_mqtt_cmd(F("flowtempoffset"), MAKE_CF_CB(set_flowtempoffset)); + register_mqtt_cmd(F("minflowtemp"), MAKE_CF_CB(set_minflowtemp)); + register_mqtt_cmd(F("maxflowtemp"), MAKE_CF_CB(set_maxflowtemp)); + register_mqtt_cmd(F("reducemode"), MAKE_CF_CB(set_reducemode)); + register_mqtt_cmd(F("program"), MAKE_CF_CB(set_program)); + register_mqtt_cmd(F("controlmode"), MAKE_CF_CB(set_controlmode)); break; case EMS_DEVICE_FLAG_JUNKERS: - register_mqtt_cmd(F("nofrosttemp"), [&](const char * value, const int8_t id) { return set_nofrosttemp(value, id); }); - register_mqtt_cmd(F("ecotemp"), [&](const char * value, const int8_t id) { return set_ecotemp(value, id); }); - register_mqtt_cmd(F("heattemp"), [&](const char * value, const int8_t id) { return set_heattemp(value, id); }); + register_mqtt_cmd(F("nofrosttemp"), MAKE_CF_CB(set_nofrosttemp)); + register_mqtt_cmd(F("ecotemp"), MAKE_CF_CB(set_ecotemp)); + register_mqtt_cmd(F("heattemp"), MAKE_CF_CB(set_heattemp)); break; default: break; diff --git a/src/emsesp.h b/src/emsesp.h index 02cd7ee60..99f0cdc55 100644 --- a/src/emsesp.h +++ b/src/emsesp.h @@ -63,6 +63,10 @@ #define EMSESP_JSON_SIZE_XLARGE_DYN 4096 // for very very large json docs, using DynamicJsonDocument #define EMSESP_JSON_SIZE_XXLARGE_DYN 5120 // for extra very very large json docs, using DynamicJsonDocument +// helpers for call back functions +#define MAKE_PF_CB(__f) [&](std::shared_ptr t) { __f(t); } // for process function callbacks to register_telegram_type() +#define MAKE_CF_CB(__f) [&](const char * value, const int8_t id) { return __f(value, id); } // for command function callbacks to register_mqtt_cmd() + namespace emsesp { class Shower; // forward declaration for compiler diff --git a/src/mqtt.cpp b/src/mqtt.cpp index fb045fce6..9375f789a 100644 --- a/src/mqtt.cpp +++ b/src/mqtt.cpp @@ -108,9 +108,12 @@ void Mqtt::register_command(const uint8_t device_type, const __FlashStringHelper // register the individual commands too (e.g. ems-esp/boiler/wwonetime) // https://github.com/emsesp/EMS-ESP32/issues/31 - std::string topic(100, '\0'); - topic = cmd_topic + "/" + uuid::read_flash_string(cmd); - Mqtt::subscribe(device_type, topic, nullptr); + // for now only do this for the boiler + if (device_type == EMSdevice::DeviceType::BOILER) { + std::string topic(100, '\0'); + topic = cmd_topic + "/" + uuid::read_flash_string(cmd); + Mqtt::subscribe(device_type, topic, nullptr); + } } // subscribe to an MQTT topic, and store the associated callback function