From b6d8e55b00ce31815f69e8badd695216191a7441 Mon Sep 17 00:00:00 2001 From: MichaelDvP Date: Mon, 10 Oct 2022 14:12:52 +0200 Subject: [PATCH] heatpump values, german translations --- src/devices/heatpump.cpp | 256 +++++++++++++++++++++++++++++++++++++- src/devices/heatpump.h | 38 ++++++ src/locale_common.h | 6 +- src/locale_translations.h | 57 ++++++--- 4 files changed, 336 insertions(+), 21 deletions(-) diff --git a/src/devices/heatpump.cpp b/src/devices/heatpump.cpp index b88287b70..ecdb0faca 100644 --- a/src/devices/heatpump.cpp +++ b/src/devices/heatpump.cpp @@ -25,12 +25,97 @@ REGISTER_FACTORY(Heatpump, EMSdevice::DeviceType::HEATPUMP); Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, const char * version, const char * name, uint8_t flags, uint8_t brand) : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) { // telegram handlers - register_telegram_type(0x042B, "HP1", false, MAKE_PF_CB(process_HPMonitor1)); + // register_telegram_type(0x042B, "HP1", false, MAKE_PF_CB(process_HPMonitor1)); register_telegram_type(0x047B, "HP2", false, MAKE_PF_CB(process_HPMonitor2)); + register_telegram_type(0x998, "HPSettings", true, MAKE_PF_CB(process_HPSettings)); + register_telegram_type(0x999, "HPFunctionTest", true, MAKE_PF_CB(process_HPFunctionTest)); + // device values register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &airHumidity_, DeviceValueType::UINT, FL_(airHumidity), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dewTemperature_, DeviceValueType::UINT, FL_(dewTemperature), DeviceValueUOM::DEGREES); + + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &controlStrategy_, + DeviceValueType::ENUM, + FL_(enum_hybridStrategy), + FL_(hybridStrategy), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_controlStrategy)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &lowNoiseMode_, + DeviceValueType::ENUM, + FL_(enum_lowNoiseMode), + FL_(lowNoiseMode), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_lowNoiseMode)); + register_device_value( + DeviceValueTAG::TAG_DEVICE_DATA, &lowNoiseStart_, DeviceValueType::UINT, FL_(lowNoiseStart), DeviceValueUOM::NONE, MAKE_CF_CB(set_lowNoiseStart), 0, 23); + register_device_value( + DeviceValueTAG::TAG_DEVICE_DATA, &lowNoiseStop_, DeviceValueType::UINT, FL_(lowNoiseStop), DeviceValueUOM::NONE, MAKE_CF_CB(set_lowNoiseStop), 0, 23); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &hybridDHW_, + DeviceValueType::ENUM, + FL_(enum_comfort2), + FL_(hybridDHW), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_hybridDHW)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &energyPriceGas_, + DeviceValueType::UINT, + FL_(energyPriceGas), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_energyPriceGas)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &energyPriceEl_, + DeviceValueType::UINT, + FL_(energyPriceEl), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_energyPriceEl)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &energyPricePV_, + DeviceValueType::UINT, + FL_(energyPricePV), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_energyPricePV)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &switchOverTemp_, + DeviceValueType::INT, + FL_(switchOverTemp), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_switchOverTemp)); + // Function test + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &airPurgeMode_, + DeviceValueType::BOOL, + FL_(airPurgeMode), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_airPurgeMode)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &heatPumpOutput_, + DeviceValueType::UINT, + FL_(heatPumpOutput), + DeviceValueUOM::PERCENT, + MAKE_CF_CB(set_heatPumpOutput)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &coolingCircuit_, + DeviceValueType::BOOL, + FL_(coolingCircuit), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_coolingCircuit)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &compStartMod_, + DeviceValueType::UINT, + FL_(compStartMod), + DeviceValueUOM::PERCENT, + MAKE_CF_CB(set_compStartMod)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, + &heatDrainPan_, + DeviceValueType::BOOL, + FL_(heatDrainPan), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_heatDrainPan)); + register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatCable_, DeviceValueType::BOOL, FL_(heatCable), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatCable)); } /* @@ -53,6 +138,175 @@ void Heatpump::process_HPMonitor1(std::shared_ptr telegram) { // still to implement } +// 0x0998 HPSettings +// [emsesp] Heatpump(0x53) -> Me(0x0B), ?(0x0998), data: 00 00 0B 00 00 1F 01 00 01 01 16 06 00 04 02 FF 00 01 7C 01 +void Heatpump::process_HPSettings(std::shared_ptr telegram) { + has_update(telegram, controlStrategy_, 0); + has_update(telegram, hybridDHW_, 1); + has_update(telegram, energyPriceGas_, 2); + has_update(telegram, energyPriceEl_, 5); + has_update(telegram, energyPricePV_, 6); + has_update(telegram, lowNoiseMode_, 9); + has_update(telegram, lowNoiseStart_, 10); + has_update(telegram, lowNoiseStop_, 11); + has_update(telegram, switchOverTemp_, 14); +} + +void Heatpump::process_HPFunctionTest(std::shared_ptr telegram) { + has_update(telegram, airPurgeMode_, 0); + has_update(telegram, heatPumpOutput_, 2); + has_update(telegram, coolingCircuit_, 6); + has_update(telegram, compStartMod_, 7); + has_update(telegram, heatDrainPan_, 9); + has_update(telegram, heatCable_, 10); +} + +/* + * Broadcast (0x099A), data: 05 00 00 00 00 00 00 37 00 00 1D 00 00 52 00 00 13 01 00 01 7C + * Broadcast (0x099B), data: 80 00 80 00 01 3C 01 38 80 00 80 00 80 00 01 37 00 00 00 00 64 + * Broadcast (0x099C), data: 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02 76 00 00 + data: 00 2B 00 03 04 13 00 00 00 00 00 02 02 02 (offset 24) + * Broadcast (0x099D), data: 02 02 00 00 02 00 01 38 00 00 63 03 E8 00 00 00 00 + * Broadcast (0x099E), data: 03 + * Broadcast (0x099F), data 05 4E 20 00 00 00 00 02 00 01 34 00 00 3F 00 00 5C 00 01 DD 00 01 37 00 + data 00 3F 00 00 5D 00 00 57 00 02 23 00 01 3D 02 80 00 5A 01 86 01 68 00 00 C0 (offset 24) + data 00 00 00 00 (offset 49) + * Broadcast (0x09A0), data: 02 23 01 3E 01 39 00 5D 01 DE 01 38 00 40 00 5E 00 58 00 3F 01 34 00 02 + * Broadcast (0x09A2), data: 00 00 00 00 + * Broadcast (0x09A3), data: 01 01 01 00 0A 01 0A 00 00 00 00 00 00 01 01 00 00 (offset 2) + * Broadcast (0x09A4), data: 00 35 00 00 01 42 00 00 00 00 30 01 00 00 00 00 00 00 00 00 00 00 00 00 00 + data: 02 (offset 25) + * Broadcast (0x09A5), data: 00 00 00 00 00 00 00 00 0A 01 00 01 03 03 00 5A 00 00 00 00 00 00 00 00 14 + data: 00 00 00 (offset 25) + * Broadcast (0x09A6), data: 05 01 00 01 F4 1F 01 1F 01 01 03 00 3F 00 00 00 19 64 00 3C 00 01 01 19 + data: 02 EC 01 19 00 (offset 24) + * Broadcast (0x09A8), data: 01 18 01 00 01 17 00 06 00 00 86 06 00 2E 07 D0 00 00 00 45 00 04 + + * Broadcast (0x04AA), data: 00 00 + +*/ #pragma GCC diagnostic pop +bool Heatpump::set_controlStrategy(const char * value, const int8_t id) { + uint8_t v; + if (!Helpers::value2enum(value, v, FL_(enum_hybridStrategy1))) { + return false; + } + write_command(0x998, 0, v, 0x998); + return true; +} +bool Heatpump::set_lowNoiseMode(const char * value, const int8_t id) { + uint8_t v; + if (!Helpers::value2enum(value, v, FL_(enum_lowNoiseMode))) { + return false; + } + write_command(0x998, 9, v, 0x998); + return true; +} +bool Heatpump::set_lowNoiseStart(const char * value, const int8_t id) { + int v; + if (!Helpers::value2number(value, v, 0, 23)) { + return false; + } + write_command(0x998, 10, v, 0x998); + return true; +} +bool Heatpump::set_lowNoiseStop(const char * value, const int8_t id) { + int v; + if (!Helpers::value2number(value, v, 0, 23)) { + return false; + } + write_command(0x998, 11, v, 0x998); + return true; +} +bool Heatpump::set_hybridDHW(const char * value, const int8_t id) { + uint8_t v; + if (!Helpers::value2enum(value, v, FL_(enum_comfort2))) { + return false; + } + write_command(0x998, 1, v, 0x998); + return true; +} +bool Heatpump::set_energyPriceGas(const char * value, const int8_t id) { + int v; + if (!Helpers::value2number(value, v)) { + return false; + } + write_command(0x998, 2, v, 0x998); + return true; +} +bool Heatpump::set_energyPriceEl(const char * value, const int8_t id) { + int v; + if (!Helpers::value2number(value, v)) { + return false; + } + write_command(0x998, 5, v, 0x998); + return true; +} +bool Heatpump::set_energyPricePV(const char * value, const int8_t id) { + int v; + if (!Helpers::value2number(value, v)) { + return false; + } + write_command(0x998, 6, v, 0x998); + return true; +} +bool Heatpump::set_switchOverTemp(const char * value, const int8_t id) { + int v; + if (!Helpers::value2number(value, v)) { + return false; + } + write_command(0x998, 14, v, 0x998); + return true; +} +// Function tests: +bool Heatpump::set_airPurgeMode(const char * value, const int8_t id) { + bool v; + if (!Helpers::value2bool(value, v)) { + return false; + } + write_command(0x999, 0, v, 0x999); + return true; +} +bool Heatpump::set_heatPumpOutput(const char * value, const int8_t id) { + int v; + if (!Helpers::value2number(value, v, 0, 100)) { + return false; + } + write_command(0x999, 2, v, 0x999); + return true; +} +bool Heatpump::set_coolingCircuit(const char * value, const int8_t id) { + bool v; + if (!Helpers::value2bool(value, v)) { + return false; + } + write_command(0x999, 6, v, 0x999); + return true; +} +bool Heatpump::set_compStartMod(const char * value, const int8_t id) { + int v; + if (!Helpers::value2number(value, v, 0, 100)) { + return false; + } + write_command(0x999, 7, v, 0x999); + return true; +} +bool Heatpump::set_heatDrainPan(const char * value, const int8_t id) { + bool v; + if (!Helpers::value2bool(value, v)) { + return false; + } + write_command(0x999, 9, v, 0x999); + return true; +} +bool Heatpump::set_heatCable(const char * value, const int8_t id) { + bool v; + if (!Helpers::value2bool(value, v)) { + return false; + } + write_command(0x999, 10, v, 0x999); + return true; +} + } // namespace emsesp diff --git a/src/devices/heatpump.h b/src/devices/heatpump.h index cf723e8ca..d3df135eb 100644 --- a/src/devices/heatpump.h +++ b/src/devices/heatpump.h @@ -31,8 +31,46 @@ class Heatpump : public EMSdevice { uint8_t airHumidity_; uint8_t dewTemperature_; + // HM200 + uint8_t controlStrategy_; + uint8_t lowNoiseMode_; + uint8_t lowNoiseStart_; + uint8_t lowNoiseStop_; + uint8_t hybridDHW_; + uint8_t energyPriceGas_; + uint8_t energyPriceEl_; + uint8_t energyPricePV_; + int8_t switchOverTemp_; + + // Function test + uint8_t airPurgeMode_; + uint8_t heatPumpOutput_; + uint8_t coolingCircuit_; + uint8_t compStartMod_; + uint8_t heatDrainPan_; + uint8_t heatCable_; + void process_HPMonitor1(std::shared_ptr telegram); void process_HPMonitor2(std::shared_ptr telegram); + void process_HPSettings(std::shared_ptr telegram); + void process_HPFunctionTest(std::shared_ptr telegram); + + bool set_controlStrategy(const char * value, const int8_t id); + bool set_lowNoiseMode(const char * value, const int8_t id); + bool set_lowNoiseStart(const char * value, const int8_t id); + bool set_lowNoiseStop(const char * value, const int8_t id); + bool set_hybridDHW(const char * value, const int8_t id); + bool set_energyPriceGas(const char * value, const int8_t id); + bool set_energyPriceEl(const char * value, const int8_t id); + bool set_energyPricePV(const char * value, const int8_t id); + bool set_switchOverTemp(const char * value, const int8_t id); + + bool set_airPurgeMode(const char * value, const int8_t id); + bool set_heatPumpOutput(const char * value, const int8_t id); + bool set_coolingCircuit(const char * value, const int8_t id); + bool set_compStartMod(const char * value, const int8_t id); + bool set_heatDrainPan(const char * value, const int8_t id); + bool set_heatCable(const char * value, const int8_t id); }; } // namespace emsesp diff --git a/src/locale_common.h b/src/locale_common.h index 6cbdca30f..1f9042134 100644 --- a/src/locale_common.h +++ b/src/locale_common.h @@ -159,7 +159,6 @@ MAKE_PSTR_LIST(rc20, "rc20") MAKE_PSTR_LIST(fb10, "fb10") MAKE_PSTR_LIST(fb100, "fb100") MAKE_PSTR_LIST(dash, "-") -MAKE_PSTR_LIST(error, "error") MAKE_PSTR_LIST(BLANK, "") MAKE_PSTR_LIST(pwm, "pwm") MAKE_PSTR_LIST(pwm_invers, "pwm inverse") @@ -295,6 +294,7 @@ MAKE_PSTR_ENUM(enum_freq, FL_(off), FL_(1x3min), FL_(2x3min), FL_(3x3min), FL_(4 MAKE_PSTR_ENUM(enum_off_time_date_manual, FL_(off), FL_(time), FL_(date), FL_(manual)) MAKE_PSTR_ENUM(enum_comfort, FL_(hot), FL_(eco), FL_(intelligent)) MAKE_PSTR_ENUM(enum_comfort1, FL_(high_comfort), FL_(eco)) +MAKE_PSTR_ENUM(enum_comfort2, FL_(eco), FL_(high_comfort)) MAKE_PSTR_ENUM(enum_flow, FL_(off), FL_(flow), FL_(bufferedflow), FL_(buffer), FL_(layeredbuffer)) MAKE_PSTR_ENUM(enum_reset, FL_(dash), FL_(maintenance), FL_(error)) MAKE_PSTR_ENUM(enum_maxHeat, FL_(0kW), FL_(2kW), FL_(3kW), FL_(4kW), FL_(6kW), FL_(9kW)) @@ -334,7 +334,7 @@ MAKE_PSTR_ENUM(enum_nofrostmode, FL_(off), FL_(room), FL_(outdoor)) MAKE_PSTR_ENUM(enum_nofrostmode1, FL_(room), FL_(outdoor), FL_(room_outdoor)) MAKE_PSTR_ENUM(enum_controlmode, FL_(off), FL_(optimized), FL_(simple), FL_(mpc), FL_(room), FL_(power), FL_(constant)) -MAKE_PSTR_ENUM(enum_controlmode1, FL_(weather_compensated), FL_(outside_basepoint), FL_(na), FL_(room)) // RC310 1-4 +MAKE_PSTR_ENUM(enum_controlmode1, FL_(weather_compensated), FL_(outside_basepoint), FL_(na), FL_(room), FL_(power), FL_(constant)) // RC310 1-4 MAKE_PSTR_ENUM(enum_controlmode2, FL_(outdoor), FL_(room)) MAKE_PSTR_ENUM(enum_control, FL_(off), FL_(rc20), FL_(rc3x)) MAKE_PSTR_ENUM(enum_j_control, FL_(off), FL_(fb10), FL_(fb100)) @@ -346,6 +346,8 @@ MAKE_PSTR_ENUM(enum_dayOfWeek, FL_(day_mo), FL_(day_tu), FL_(day_we), FL_(day_th MAKE_PSTR_ENUM(enum_progMode2, FL_(own_1), FL_(family), FL_(morning), FL_(evening), FL_(am), FL_(pm), FL_(midday), FL_(singles), FL_(seniors), FL_(new), FL_(own_2)) MAKE_PSTR_ENUM(enum_progMode3, FL_(family), FL_(morning), FL_(evening), FL_(am), FL_(pm), FL_(midday), FL_(singles), FL_(seniors)) MAKE_PSTR_ENUM(enum_hybridStrategy, FL_(co2_optimized), FL_(cost_optimized), FL_(outside_temp_switched), FL_(co2_cost_mix)) +MAKE_PSTR_ENUM(enum_hybridStrategy1, FL_(cost_optimized), FL_(co2_optimized), FL_(outside_temp_alt), FL_(outside_temp_par), FL_(hp_prefered), FL_(boiler_only)) +MAKE_PSTR_ENUM(enum_lowNoiseMode, FL_(off), FL_(reduced_output), FL_(switchoff), FL_(perm)) // heat pump MAKE_PSTR_ENUM(enum_hpactivity, FL_(none), FL_(heating), FL_(cooling), FL_(hot_water), FL_(pool)) diff --git a/src/locale_translations.h b/src/locale_translations.h index d1e42ff6c..972f0cdcd 100644 --- a/src/locale_translations.h +++ b/src/locale_translations.h @@ -32,17 +32,17 @@ // if there is no translation, it will default to en // commands -MAKE_PSTR_LIST(info_cmd, "lists all values") -MAKE_PSTR_LIST(commands_cmd, "lists all commands") -MAKE_PSTR_LIST(entities_cmd, "lists all entities") -MAKE_PSTR_LIST(send_cmd, "send a telegram") -MAKE_PSTR_LIST(setiovalue_cmd, "set io value") +MAKE_PSTR_LIST(info_cmd, "lists all values", "Liste aller Werte") +MAKE_PSTR_LIST(commands_cmd, "lists all commands", "Liste aller Kommandos") +MAKE_PSTR_LIST(entities_cmd, "lists all entities", "Liste aller Entitäten") +MAKE_PSTR_LIST(send_cmd, "send a telegram", "Sende EMS-Telegramm") +MAKE_PSTR_LIST(setiovalue_cmd, "set io value", "Setze Wertevorgabe") MAKE_PSTR_LIST(changeloglevel_cmd, "change log level") -MAKE_PSTR_LIST(fetch_cmd, "refresh all EMS values") -MAKE_PSTR_LIST(restart_cmd, "restart EMS-ESP") -MAKE_PSTR_LIST(watch_cmd, "watch incoming telegrams") -MAKE_PSTR_LIST(publish_cmd, "publish all to MQTT") -MAKE_PSTR_LIST(system_info_cmd, "show system status") +MAKE_PSTR_LIST(fetch_cmd, "refresh all EMS values", "Lese alle EMS-Werte neu") +MAKE_PSTR_LIST(restart_cmd, "restart EMS-ESP", "Neustart") +MAKE_PSTR_LIST(watch_cmd, "watch incoming telegrams", "Watch auf eingehende Telegramme") +MAKE_PSTR_LIST(publish_cmd, "publish all to MQTT", "Publiziere MQTT") +MAKE_PSTR_LIST(system_info_cmd, "show system status", "Zeige System-Status") #if defined(EMSESP_DEBUG) MAKE_PSTR_LIST(test_cmd, "run a test") @@ -96,6 +96,7 @@ MAKE_PSTR_LIST(blocking, "blocking", "Blockierung", "Blokkering", "Blockering") MAKE_PSTR_LIST(extern, "extern", "extern", "extern", "extern") MAKE_PSTR_LIST(intern, "intern", "intern", "intern", "intern") MAKE_PSTR_LIST(lower, "lower", "niedirger", "lager", "lägre") +MAKE_PSTR_LIST(error, "error", "Fehler") // boiler MAKE_PSTR_LIST(time, "time", "Zeit", "Tijd", "Tid") @@ -124,6 +125,13 @@ MAKE_PSTR_LIST(valve, "valve", "Ventil", "Klep", "Ventil") MAKE_PSTR_LIST(none, "none", "keine", "geen", "ingen") MAKE_PSTR_LIST(hot_water, "hot water", "Warmwasser", "warm water", "varmvatten") MAKE_PSTR_LIST(pool, "pool", "Pool", "zwembad", "pool") +MAKE_PSTR_LIST(outside_temp_alt, "outside temperature alt.", "Außentemp. alternativ") +MAKE_PSTR_LIST(outside_temp_par, "outside temperature parallel", "Außentemp. parallel") +MAKE_PSTR_LIST(hp_prefered, "heatpump prefered", "Wärmepumpe bevorzugt") +MAKE_PSTR_LIST(boiler_only, "boiler only", "nur Kessel") +MAKE_PSTR_LIST(reduced_output, "reduced output", "Reduzierte Leistung") +MAKE_PSTR_LIST(switchoff, "switch off hp", "WP ausschalten") +MAKE_PSTR_LIST(perm, "perm. reduced", "perm. reduziert") // thermostat MAKE_PSTR_LIST(seltemp, "selTemp", "Solltemperatur", "Doeltemperatuur", "Börtemperatur") @@ -193,7 +201,7 @@ MAKE_PSTR_LIST(cyl2, "cyl 2", "Zyl_2", "Cil 2", "Cyl 2") // Entity translations // Boiler MAKE_PSTR_LIST(wwtapactivated, "wwtapactivated", "turn on/off", "Durchlauferhitzer aktiv", "zet aan/uit", "sätt på/av") -MAKE_PSTR_LIST(reset, "reset", "Reset", "Reset", "Nollställ", "reset") +MAKE_PSTR_LIST(reset, "reset", "Reset", "Reset", "Reset", "Nollställ") MAKE_PSTR_LIST(oilPreHeat, "oilpreheat", "oil preheating", "Ölvorwärmung", "Olie voorverwarming", "Förvärmning olja") MAKE_PSTR_LIST(heatingActive, "heatingactive", "heating active", "Heizen aktiv", "Verwarming actief", "Uppvärmning aktiv") MAKE_PSTR_LIST(tapwaterActive, "tapwateractive", "tapwater active", "Warmwasser aktiv", "Warm water actief", "Varmvatten aktiv") @@ -234,13 +242,13 @@ MAKE_PSTR_LIST(heatWorkMin, "heatworkmin", "total heat operating time", "Heizung MAKE_PSTR_LIST(UBAuptime, "ubauptime", "total UBA operating time", "Anlagen-Gesamtlaufzeit", "totale looptijd branderautomaat (UBA)", "Total Tid") MAKE_PSTR_LIST(lastCode, "lastcode", "last error code", "Fehlerspeicher", "Laatste foutcode", "Senaste Felkod") MAKE_PSTR_LIST(serviceCode, "servicecode", "service code", "Statusmeldung", "Statuscode", "Servicekod") -MAKE_PSTR_LIST(serviceCodeNumber, "servicecodenumber", "service code number", "Statusmeldungsnummer", "Status codenummer", "Servicekodsnummer") +MAKE_PSTR_LIST(serviceCodeNumber, "servicecodenumber", "service code number", "Statusmeldungsnummer", "Status codenummer", "Servicekod") MAKE_PSTR_LIST(maintenanceMessage, "maintenancemessage", "maintenance message", "Wartungsmeldung", "Onderhoudsmelding", "Servicemeddelande") MAKE_PSTR_LIST(maintenanceDate, "maintenancedate", "next maintenance date", "Wartungsdatum", "Onderhoudsdatum", "Datum nästa Service") MAKE_PSTR_LIST(maintenanceType, "maintenance", "maintenance scheduled", "Wartungsplan", "Onderhoud gepland", "Underhåll schemlagt") MAKE_PSTR_LIST(maintenanceTime, "maintenancetime", "time to next maintenance", "Wartung in", "Onderhoud in", "Tid till nästa underhåll") MAKE_PSTR_LIST(emergencyOps, "emergencyops", "emergency operation", "Notoperation", "Noodoperatie", "Nöddrift") -MAKE_PSTR_LIST(emergencyTemp, "emergencytemp", "emergency temperature", "Nottemperatur", "Noodtemperatuur", "Nödtemperatur") +MAKE_PSTR_LIST(emergencyTemp, "emergencytemp", "emergency temperature", "Nottemperatur", "Noodtemperatuur", "Nöddrift temperatur") // heatpump/compress specific MAKE_PSTR_LIST(upTimeControl, "uptimecontrol", "total operating time heat", "Betriebszeit Heizen gesamt", "Totale bedrijfstijd", "Total tid uppvärmning") @@ -276,8 +284,8 @@ MAKE_PSTR_LIST(hpPoolOn, "hppoolon", "hp pool", "WP Pool", "WP zwembadbedrijf", MAKE_PSTR_LIST(hpBrinePumpSpd, "hpbrinepumpspd", "brine pump speed", "Solepumpen-Geschw.", "Snelheid pekelpomp", "Hastighet Brine-pump") MAKE_PSTR_LIST(hpCompSpd, "hpcompspd", "compressor speed", "Kompressor-Geschw.", "Snelheid compressor", "Kompressorhastighet") MAKE_PSTR_LIST(hpCircSpd, "hpcircspd", "circulation pump speed", "Zirkulationspumpen-Geschw.", "Snelheid circulatiepomp", "Hastighet Cirkulationspump") -MAKE_PSTR_LIST(hpBrineIn, "hpbrinein", "brine in/evaporator", "Sole in/Verdampfer", "pekel in/verdamper", "Brine in/förångare") -MAKE_PSTR_LIST(hpBrineOut, "hpbrineout", "brine out/condenser", "Sole aus/Kondensator", "pekel uit/condensor", "Brine ut/kondensor") +MAKE_PSTR_LIST(hpBrineIn, "hpbrinein", "brine in/evaporator", "Sole in/Verdampfer", "pekel in/verdamper", "Brine in (förångare)") +MAKE_PSTR_LIST(hpBrineOut, "hpbrineout", "brine out/condenser", "Sole aus/Kondensator", "pekel uit/condensor", "Brine ut (kondensor)") MAKE_PSTR_LIST(hpSuctionGas, "hpsuctiongas", "suction gas", "Gasansaugung", "Gasaanzuiging", "Gasintag") MAKE_PSTR_LIST(hpHotGas, "hphotgas", "hot gas/compressed", "Heißgas/verdichtet", "heet gas/samengeperst", "Hetgas/komprimerad") MAKE_PSTR_LIST(hpSwitchValve, "hpswitchvalve", "switch valve", "Schaltventil", "schakelklep", "Växelventil") @@ -316,6 +324,19 @@ MAKE_PSTR_LIST(fossileFactor, "fossilefactor", "fossile energy factor", "Energie MAKE_PSTR_LIST(electricFactor, "electricfactor", "electric energy factor", "Energiefaktor elektrisch", "Energiefactor electrisch", "Elektrisk energifaktor") MAKE_PSTR_LIST(delayBoiler, "delayboiler", "delay boiler support", "Verzögerungs-Option", "Vertragingsoptie", "Fördörjningsoption") MAKE_PSTR_LIST(tempDiffBoiler, "tempdiffboiler", "temp diff boiler support", "Temperaturdifferenz-Option", "Verschiltemperatuuroptie", "Temperaturskillnadsoption") +MAKE_PSTR_LIST(lowNoiseMode, "lownoisemode", "low noise mode", "Geräuscharmer Betrieb") +MAKE_PSTR_LIST(lowNoiseStart, "lownoisestart", "low noise starttime", "Start geräuscharmer Betrieb") +MAKE_PSTR_LIST(lowNoiseStop, "lownoisestop", "low noise stoptime", "Stopp geräuscharmer Betrieb") +MAKE_PSTR_LIST(energyPriceGas, "energypricegas", "energy price gas", "Energiepreis Gas") +MAKE_PSTR_LIST(energyPriceEl, "energypriceel", "energy price electric", "Energiepreis Eletrizität") +MAKE_PSTR_LIST(energyPricePV, "energyfeedpv", "feed in PV", "PV Einspeisevergütung") +MAKE_PSTR_LIST(hybridDHW, "hybriddhw", "hybrid DHW", "Hybrid Warmwasser") +MAKE_PSTR_LIST(airPurgeMode, "airpurgemode", "air purge mode", "Luftspülung") +MAKE_PSTR_LIST(heatPumpOutput, "heatpumpoutput", "heatpump output", "WP Leistung") +MAKE_PSTR_LIST(coolingCircuit, "coolingcircuit", "cooling circuit", "Kühlkreislauf") +MAKE_PSTR_LIST(compStartMod, "compstartmod", "compressor start modulation", "Kompressor Startleistung") +MAKE_PSTR_LIST(heatDrainPan, "heatdrainpan", "heat drain pan", "Wärmeausgleichsgefäß") +MAKE_PSTR_LIST(heatCable, "heatcable", "heating cable", "Heizband") // alternative heatsource AM200 MAKE_PSTR_LIST(aCylTopTemp, "cyltoptemp", "cylinder top temperature", "Speichertemperatur Oben", "Buffer temperatuur boven", "Cylindertemperatur Toppen") @@ -398,7 +419,7 @@ MAKE_PSTR_LIST(switchtime2, "switchtime2", "own2 program switchtime", "Programm MAKE_PSTR_LIST(wwswitchtime, "wwswitchtime", "program switchtime", "Programm Schaltzeit", "Warm water programma schakeltijd", "Varmvattenprogram Bytestid") MAKE_PSTR_LIST(wwcircswitchtime, "wwcircswitchtime", "circulation program switchtime", "Zirculationsprogramm Schaltzeit", "Schakeltijd circulatieprogramma", "Cirkulationsprogram Bytestid") MAKE_PSTR_LIST(dateTime, "datetime", "date/time", "Datum/Zeit", "Datum/Tijd", "Datum/Tid") -MAKE_PSTR_LIST(errorCode, "errorcode", "error code", "Fehlermeldung", "Foutmeldingscode", "Felkod") +MAKE_PSTR_LIST(errorCode, "errorcode", "error code", "Fehlernummer", "Foutmeldingscode", "Felkod") MAKE_PSTR_LIST(ibaMainDisplay, "display", "display", "Anzeige", "Display", "Display") MAKE_PSTR_LIST(ibaLanguage, "language", "language", "Sprache", "Taal", "Språk") MAKE_PSTR_LIST(ibaClockOffset, "clockoffset", "clock offset", "Uhrkorrektur", "Klokcorrectie", "Tidskorrigering") @@ -407,10 +428,10 @@ MAKE_PSTR_LIST(heatingPID, "heatingpid", "heating PID", "Heizungs-PID", "", "Upp MAKE_PSTR_LIST(ibaCalIntTemperature, "intoffset", "internal temperature offset", "Korrektur interner Temperatur", "", "Korrigering interntemperatur") MAKE_PSTR_LIST(ibaMinExtTemperature, "minexttemp", "minimal external temperature", "min. Aussentemperatur", "", "Min Extern Temperatur") MAKE_PSTR_LIST(backlight, "backlight", "key backlight", "Gegenlicht", "Toetsverlichting", "Bakgrundsbelysning") -MAKE_PSTR_LIST(damping, "damping", "damping outdoor temperature", "Dämpfung der Außentemperatur", "Demping buitentemperatuur", "Dämpning Utomhustemperatur") +MAKE_PSTR_LIST(damping, "damping", "damping outdoor temperature", "Dämpfung der Außentemperatur", "Demping buitentemperatuur", "Utomhustemperatur dämpning") MAKE_PSTR_LIST(tempsensor1, "inttemp1", "temperature sensor 1", "Temperatursensor 1", "Temperatuursensor 1", "Temperatursensor 1") MAKE_PSTR_LIST(tempsensor2, "inttemp2", "temperature sensor 2", "Temperatursensor 2", "Temperatuursensor 2", "Temperatursensor 2") -MAKE_PSTR_LIST(dampedoutdoortemp, "dampedoutdoortemp", "damped outdoor temperature", "gedämpfte Außentemperatur", "Gedempte buitentemperatuur", "Dämpad Utomhustemperatur") +MAKE_PSTR_LIST(dampedoutdoortemp, "dampedoutdoortemp", "damped outdoor temperature", "gedämpfte Außentemperatur", "Gedempte buitentemperatuur", "Utomhustemperatur dämpad") MAKE_PSTR_LIST(floordrystatus, "floordry", "floor drying", "Estrichtrocknung", "Vloerdroogprogramma", "Golvtorkning") MAKE_PSTR_LIST(floordrytemp, "floordrytemp", "floor drying temperature", "Estrichtrocknungs Temperatur", "Temperatuur vloerdroogprogramma", "Golvtorkning Temperatur") MAKE_PSTR_LIST(brightness, "brightness", "screen brightness", "Bildschirmhelligkeit", "Schermhelderheid", "Ljusstyrka")