Merge branch 'dev' of https://github.com/proddy/EMS-ESP into dev

CHANGELOG_LATEST.md

@@ -1,7 +1,7 @@
 # Changelog
 
 ### Added
-- function keys in editor: cursor, del, pos1, end. F1=help, F2=show, F10=report
+- function keys in editor: cursor, del, home, end. F1=help, F2=show, and other shortcuts
 - add sm100 pump working time and energy units
 - heating curve parameters for RC300
 
@@ -10,6 +10,7 @@
 
 ### Changed
 - optimized MQTT for HA to reduce mem fragmentation issues
+- change syslog settings without reboot
 
 ### Removed
 - old scripts

interface/src/project/EMSESPSettingsController.tsx

@@ -237,7 +237,9 @@ function EMSESPSettingsControllerForm(props: EMSESPSettingsControllerFormProps)
                 variant="outlined"
                 onChange={handleValueChange('syslog_level')}
                 margin="normal">
+                <MenuItem value={-1}>OFF</MenuItem>
                 <MenuItem value={3}>ERR</MenuItem>
+                <MenuItem value={5}>NOTICE</MenuItem>
                 <MenuItem value={6}>INFO</MenuItem>
                 <MenuItem value={7}>DEBUG</MenuItem>
             </SelectValidator>
@@ -245,7 +247,7 @@ function EMSESPSettingsControllerForm(props: EMSESPSettingsControllerFormProps)
                 validators={['required', 'isNumber', 'minNumber:0', 'maxNumber:65535']}
                 errorMessages={['Syslog Mark is required', "Must be a number", "Must be 0 or higher", "Max value is 10"]}
                 name="syslog_mark_interval"
-                label="Syslog Mark Interval (seconds)"
+                label="Syslog Mark Interval (seconds, 0=off)"
                 fullWidth
                 variant="outlined"
                 value={data.syslog_mark_interval}

src/console.cpp

@@ -300,6 +300,18 @@ void EMSESPShell::add_console_commands() {
                                   "local");
                           });
 
+#ifndef EMSESP_STANDALONE
+    commands->add_command(ShellContext::MAIN,
+                          CommandFlags::USER,
+                          flash_string_vector{F_(set), F_(timeout)},
+                          flash_string_vector{F_(n_mandatory)},
+                          [](Shell & shell, const std::vector<std::string> & arguments) {
+                              uint16_t value = Helpers::atoint(arguments.front().c_str());
+                              telnet_.initial_idle_timeout(value * 60);
+                              shell.printfln(F("Telnet timout is %d minutes"), value);
+                          });
+#endif
+
     commands->add_command(ShellContext::MAIN,
                           CommandFlags::ADMIN,
                           flash_string_vector{F_(send), F_(telegram)},

src/devices/thermostat.cpp

@@ -199,6 +199,7 @@ void Thermostat::device_info_web(JsonArray & root) {
         print_value_json(root, F("wwmode"), nullptr, F_(wwmode), nullptr, json_main);
         print_value_json(root, F("wwtemp"), nullptr, F_(wwtemp), nullptr, json_main);
         print_value_json(root, F("wwtemplow"), nullptr, F_(wwtemplow), nullptr, json_main);
+        print_value_json(root, F("wwextra1"), nullptr, F_(wwextra1), nullptr, json_main);
         print_value_json(root, F("wwcircmode"), nullptr, F_(wwcircmode), nullptr, json_main);
     }
 
@@ -231,7 +232,8 @@ void Thermostat::device_info_web(JsonArray & root) {
                 print_value_json(root, F("designtemp"), FPSTR(prefix_str), F_(designtemp), F_(degrees), json);
                 print_value_json(root, F("roominfluence"), FPSTR(prefix_str), F_(roominfluence), F_(degrees), json);
                 print_value_json(root, F("flowtempoffset"), FPSTR(prefix_str), F_(flowtempoffset), F_(degrees), json);
-                print_value_json(root, F("maxflowtemp"), F_(2spaces), F_(maxflowtemp), F_(degrees), json);
+                print_value_json(root, F("minflowtemp"), FPSTR(prefix_str), F_(minflowtemp), F_(degrees), json);
+                print_value_json(root, F("maxflowtemp"), FPSTR(prefix_str), F_(maxflowtemp), F_(degrees), json);
                 print_value_json(root, F("summertemp"), FPSTR(prefix_str), F_(summertemp), F_(degrees), json);
                 print_value_json(root, F("summermode"), FPSTR(prefix_str), F_(summermode), F_(degrees), json);
                 print_value_json(root, F("mode"), FPSTR(prefix_str), F_(mode), nullptr, json);
@@ -284,6 +286,7 @@ void Thermostat::show_values(uuid::console::Shell & shell) {
         print_value_json(shell, F("wwmode"), nullptr, F_(wwmode), nullptr, json_main);
         print_value_json(shell, F("wwtemp"), nullptr, F_(wwtemp), nullptr, json_main);
         print_value_json(shell, F("wwtemplow"), nullptr, F_(wwtemplow), nullptr, json_main);
+        print_value_json(shell, F("wwextra1"), nullptr, F_(wwextra1), nullptr, json_main);
         print_value_json(shell, F("wwcircmode"), nullptr, F_(wwcircmode), nullptr, json_main);
     }
 
@@ -316,6 +319,7 @@ void Thermostat::show_values(uuid::console::Shell & shell) {
                 print_value_json(shell, F("designtemp"), F_(2spaces), F_(designtemp), F_(degrees), json);
                 print_value_json(shell, F("roominfluence"), F_(2spaces), F_(roominfluence), F_(degrees), json);
                 print_value_json(shell, F("flowtempoffset"), F_(2spaces), F_(flowtempoffset), F_(degrees), json);
+                print_value_json(shell, F("minflowtemp"), F_(2spaces), F_(minflowtemp), F_(degrees), json);
                 print_value_json(shell, F("maxflowtemp"), F_(2spaces), F_(maxflowtemp), F_(degrees), json);
                 print_value_json(shell, F("summertemp"), F_(2spaces), F_(summertemp), F_(degrees), json);
                 print_value_json(shell, F("summermode"), F_(2spaces), F_(summermode), F_(degrees), json);
@@ -480,6 +484,16 @@ bool Thermostat::export_values_main(JsonObject & rootThermostat) {
         rootThermostat["wwtemplow"] = wwTempLow_;
     }
 
+    // Warm water extra1
+    if (Helpers::hasValue(wwExtra1_)) {
+        rootThermostat["wwextra1"] = wwExtra1_;
+    }
+
+    // Warm water extra2
+    if (Helpers::hasValue(wwExtra2_)) {
+        rootThermostat["wwextra2"] = wwExtra2_;
+    }
+
     // Warm Water circulation mode
     if (Helpers::hasValue(wwCircMode_)) {
         char s[7];
@@ -607,7 +621,12 @@ bool Thermostat::export_values_hc(uint8_t mqtt_format, JsonObject & rootThermost
                 dataThermostat["flowtempoffset"] = hc->flowtempoffset;
             }
 
-            // Flow temperature offset
+            // Min Flow temperature offset
+            if (Helpers::hasValue(hc->minflowtemp)) {
+                dataThermostat["minflowtemp"] = hc->minflowtemp;
+            }
+
+            // Max Flow temperature offset
             if (Helpers::hasValue(hc->maxflowtemp)) {
                 dataThermostat["maxflowtemp"] = hc->maxflowtemp;
             }
@@ -944,6 +963,7 @@ void Thermostat::register_mqtt_ha_config(uint8_t hc_num) {
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(summertemp), this->device_type(), "summertemp", F_(degrees), F_(icontemperature));
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(designtemp), this->device_type(), "designtemp", F_(degrees), F_(icontemperature));
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(offsettemp), this->device_type(), "offsettemp", F_(degrees), F_(icontemperature));
+        Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(minflowtemp), this->device_type(), "minflowtemp", F_(degrees), F_(icontemperature));
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(maxflowtemp), this->device_type(), "maxflowtemp", F_(degrees), F_(icontemperature));
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(roominfluence), this->device_type(), "roominfluence", F_(degrees), F_(icontemperature));
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(nofrosttemp), this->device_type(), "nofrosttemp", F_(degrees), F_(icontemperature));
@@ -964,6 +984,7 @@ void Thermostat::register_mqtt_ha_config(uint8_t hc_num) {
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(summertemp), this->device_type(), "summertemp", F_(degrees), F_(icontemperature));
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(nofrosttemp), this->device_type(), "nofrosttemp", F_(degrees), F_(icontemperature));
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(roominfluence), this->device_type(), "roominfluence", F_(degrees), F_(icontemperature));
+        Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(minflowtemp), this->device_type(), "minflowtemp", F_(degrees), F_(icontemperature));
         Mqtt::register_mqtt_ha_sensor(hc_name, nullptr, F_(maxflowtemp), this->device_type(), "maxflowtemp", F_(degrees), F_(icontemperature));
         break;
     case EMS_DEVICE_FLAG_JUNKERS:
@@ -1115,6 +1136,9 @@ std::string Thermostat::mode_tostring(uint8_t mode) {
     case HeatingCircuit::Mode::DESIGN:
         return read_flash_string(F("design"));
         break;
+    case HeatingCircuit::Mode::MINFLOW:
+        return read_flash_string(F("minflow"));
+        break;
     case HeatingCircuit::Mode::MAXFLOW:
         return read_flash_string(F("maxflow"));
         break;
@@ -1304,6 +1328,7 @@ void Thermostat::process_RC300Summer(std::shared_ptr<const Telegram> telegram) {
     } else {
         changed_ |= telegram->read_value(hc->designtemp, 5);
     }
+    changed_ |= telegram->read_value(hc->minflowtemp, 8);
 }
 
 // types 0x29B ff
@@ -1417,10 +1442,13 @@ void Thermostat::process_RC35Set(std::shared_ptr<const Telegram> telegram) {
     changed_ |= telegram->read_value(hc->summertemp, 22);     // is * 1
     changed_ |= telegram->read_value(hc->nofrosttemp, 23);    // is * 1
     changed_ |= telegram->read_value(hc->flowtempoffset, 24); // is * 1, only in mixed circuits
+    changed_ |= telegram->read_value(hc->minflowtemp, 16);
     if (hc->heatingtype == 3) {
         changed_ |= telegram->read_value(hc->designtemp, 36); // is * 1
+        changed_ |= telegram->read_value(hc->maxflowtemp, 35); // is * 1
     } else {
         changed_ |= telegram->read_value(hc->designtemp, 17); // is * 1
+        changed_ |= telegram->read_value(hc->maxflowtemp, 15); // is * 1
     }
 }
 
@@ -1656,6 +1684,19 @@ bool Thermostat::set_wwtemplow(const char * value, const int8_t id) {
     return true;
 }
 
+// Set ww onetime RC300, ems+
+bool Thermostat::set_wwonetime(const char * value, const int8_t id) {
+    bool b = false;
+    if (!Helpers::value2bool(value, b)) {
+        LOG_WARNING(F("Set warm water onetime: Invalid value"));
+        return false;
+    }
+    char s[7];
+    LOG_INFO(F("Setting warm water onetime to %s"), Helpers::render_boolean(s, b));
+    write_command(0x02F5, 11, b ? 0xFF : 0x00, 0x031D);
+    return true;
+}
+
 
 // sets the thermostat ww circulation working mode, where mode is a string
 bool Thermostat::set_wwcircmode(const char * value, const int8_t id) {
@@ -1986,11 +2027,14 @@ bool Thermostat::set_temperature(const float temperature, const std::string & mo
     if (mode_tostring(HeatingCircuit::Mode::DESIGN) == mode) {
         return set_temperature(temperature, HeatingCircuit::Mode::DESIGN, hc_num);
     }
+    if (mode_tostring(HeatingCircuit::Mode::MINFLOW) == mode) {
+        return set_temperature(temperature, HeatingCircuit::Mode::MINFLOW, hc_num);
+    }
     if (mode_tostring(HeatingCircuit::Mode::MAXFLOW) == mode) {
-        return set_temperature(temperature, HeatingCircuit::Mode::DESIGN, hc_num);
+        return set_temperature(temperature, HeatingCircuit::Mode::MAXFLOW, hc_num);
     }
     if (mode_tostring(HeatingCircuit::Mode::ROOMINFLUENCE) == mode) {
-        return set_temperature(temperature, HeatingCircuit::Mode::DESIGN, hc_num);
+        return set_temperature(temperature, HeatingCircuit::Mode::ROOMINFLUENCE, hc_num);
     }
 
     LOG_WARNING(F("Set temperature: Invalid mode"));
@@ -2055,6 +2099,12 @@ bool Thermostat::set_temperature(const float temperature, const uint8_t mode, co
             }
             factor = 1;
             break;
+        case HeatingCircuit::Mode::MINFLOW:
+            set_typeid      = summer_typeids[hc->hc_num() - 1];
+            validate_typeid = set_typeid;
+            offset = 8;
+            factor = 1;
+            break;
         case HeatingCircuit::Mode::MAXFLOW:
             set_typeid      = curve_typeids[hc->hc_num() - 1];
             validate_typeid = set_typeid;
@@ -2143,8 +2193,16 @@ bool Thermostat::set_temperature(const float temperature, const uint8_t mode, co
             offset = 4;
             factor = 1;
             break;
+        case HeatingCircuit::Mode::MINFLOW:
+            offset = 16;
+            factor = 1;
+            break;
         case HeatingCircuit::Mode::MAXFLOW:
-            offset = 15;
+            if (hc->heatingtype == 3) {
+                offset = 35;
+            } else {
+                offset = 15;
+            }
             factor = 1;
             break;
         default:
@@ -2310,6 +2368,10 @@ bool Thermostat::set_maxflowtemp(const char * value, const int8_t id) {
     return set_temperature_value(value, id, HeatingCircuit::Mode::MAXFLOW);
 }
 
+bool Thermostat::set_minflowtemp(const char * value, const int8_t id) {
+    return set_temperature_value(value, id, HeatingCircuit::Mode::MINFLOW);
+}
+
 bool Thermostat::set_roominfluence(const char * value, const int8_t id) {
     return set_temperature_value(value, id, HeatingCircuit::Mode::ROOMINFLUENCE);
 }
@@ -2338,10 +2400,12 @@ void Thermostat::add_commands() {
         register_mqtt_cmd(F("wwmode"), [&](const char * value, const int8_t id) { return set_wwmode(value, id); });
         register_mqtt_cmd(F("wwtemp"), [&](const char * value, const int8_t id) { return set_wwtemp(value, id); });
         register_mqtt_cmd(F("wwtemplow"), [&](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("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); });
@@ -2374,6 +2438,7 @@ void Thermostat::add_commands() {
         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); });
         break;
     case EMS_DEVICE_FLAG_JUNKERS:

src/devices/thermostat.h

@@ -65,6 +65,7 @@ class Thermostat : public EMSdevice {
         uint8_t summer_setmode    = EMS_VALUE_UINT_NOTSET;
         uint8_t roominfluence     = EMS_VALUE_UINT_NOTSET;
         uint8_t flowtempoffset    = EMS_VALUE_UINT_NOTSET;
+        uint8_t minflowtemp       = EMS_VALUE_UINT_NOTSET;
         uint8_t maxflowtemp       = EMS_VALUE_UINT_NOTSET;
 
         uint8_t hc_num() const {
@@ -87,7 +88,7 @@ class Thermostat : public EMSdevice {
         uint8_t get_mode(uint8_t flags) const;
         uint8_t get_mode_type(uint8_t flags) const;
 
-        enum Mode : uint8_t { UNKNOWN, OFF, MANUAL, AUTO, DAY, NIGHT, HEAT, NOFROST, ECO, HOLIDAY, COMFORT, OFFSET, DESIGN, SUMMER, FLOWOFFSET, MAXFLOW, ROOMINFLUENCE };
+        enum Mode : uint8_t { UNKNOWN, OFF, MANUAL, AUTO, DAY, NIGHT, HEAT, NOFROST, ECO, HOLIDAY, COMFORT, OFFSET, DESIGN, SUMMER, FLOWOFFSET, MINFLOW, MAXFLOW, ROOMINFLUENCE };
 
         // for sorting based on hc number
         friend inline bool operator<(const std::shared_ptr<HeatingCircuit> & lhs, const std::shared_ptr<HeatingCircuit> & rhs) {
@@ -311,12 +312,14 @@ class Thermostat : public EMSdevice {
     bool set_remotetemp(const char * value, const int8_t id);
     bool set_roominfluence(const char * value, const int8_t id);
     bool set_flowtempoffset(const char * value, const int8_t id);
+    bool set_minflowtemp(const char * value, const int8_t id);
     bool set_maxflowtemp(const char * value, const int8_t id);
 
     // set functions - these don't use the id/hc, the parameters are ignored
     bool set_wwmode(const char * value, const int8_t id);
     bool set_wwtemp(const char * value, const int8_t id);
     bool set_wwtemplow(const char * value, const int8_t id);
+    bool set_wwonetime(const char * value, const int8_t id);
     bool set_wwcircmode(const char * value, const int8_t id);
     bool set_datetime(const char * value, const int8_t id);
     bool set_minexttemp(const char * value, const int8_t id);

src/locale_EN.h

@@ -66,6 +66,7 @@ MAKE_PSTR_WORD(publish)
 MAKE_PSTR_WORD(bar)
 MAKE_PSTR_WORD(min)
 MAKE_PSTR_WORD(uA)
+MAKE_PSTR_WORD(timeout)
 
 // for commands
 MAKE_PSTR_WORD(call)
@@ -241,6 +242,8 @@ MAKE_PSTR(floordrytemp, "Floordrying temperature")
 MAKE_PSTR(wwmode, "Warm water mode")
 MAKE_PSTR(wwtemp, "Warm water high temperature")
 MAKE_PSTR(wwtemplow, "Warm water low temperature")
+MAKE_PSTR(wwextra1, "Warm water circuit 1 extra")
+MAKE_PSTR(wwextra2, "Warm water circuit 2 extra")
 MAKE_PSTR(wwcircmode, "Warm water circulation mode")
 
 // thermostat - per heating circuit
@@ -262,6 +265,7 @@ MAKE_PSTR(summertemp, "Summer temperature")
 MAKE_PSTR(summermode, "Summer mode")
 MAKE_PSTR(roominfluence, "Room influence")
 MAKE_PSTR(flowtempoffset, "Flow temperature offset")
+MAKE_PSTR(minflowtemp, "Min. flow temperature")
 MAKE_PSTR(maxflowtemp, "Max. flow temperature")
 MAKE_PSTR(mode, "Mode")
 MAKE_PSTR(modetype, "Mode type")

src/system.cpp

@@ -39,6 +39,11 @@ uint16_t    System::analog_         = 0;
 bool        System::analog_enabled_ = false;
 bool        System::syslog_enabled_ = false;
 std::string System::hostname_;
+int8_t      System::syslog_level_         = -1;
+uint32_t    System::syslog_mark_interval_ = 0;
+String      System::syslog_host_;
+
+
 
 // send on/off to a gpio pin
 // value: true = HIGH, false = LOW
@@ -120,6 +125,13 @@ void System::syslog_init() {
     });
 
 #ifndef EMSESP_STANDALONE
+    if (!syslog_enabled_) {
+        syslog_.log_level((uuid::log::Level)-1);
+        syslog_.mark_interval(0);
+        syslog_.destination((IPAddress)((uint32_t)0));
+        return;
+    }
+
     syslog_.start(); // syslog service re-start
 
     // configure syslog
@@ -155,9 +167,6 @@ void System::start() {
         Command::add(EMSdevice::DeviceType::SYSTEM, settings.ems_bus_id, F_(send), System::command_send);
         Command::add_with_json(EMSdevice::DeviceType::SYSTEM, F_(info), System::command_info);
         Command::add_with_json(EMSdevice::DeviceType::SYSTEM, F_(report), System::command_report);
-        if (settings.syslog_enabled) {
-            syslog_init(); // init SysLog
-        }
     });
 
 
@@ -172,8 +181,8 @@ void System::init() {
     EMSESP::webSettingsService.read([&](WebSettings & settings) {
         Helpers::bool_format(settings.bool_format);
         analog_enabled_ = settings.analog_enabled;
-        syslog_enabled_ = settings.syslog_enabled;
     });
+    syslog_init(); // init SysLog
 
     EMSESP::esp8266React.getWiFiSettingsService()->read([&](WiFiSettings & settings) { hostname(settings.hostname.c_str()); });
 

src/system.h

@@ -59,9 +59,9 @@ class System {
     static void    show_mem(const char * note);
     static void    set_led();
     static void    init();
+    static void    syslog_init();
 
     bool check_upgrade();
-    void syslog_init();
     void send_heartbeat();
 
     static std::string hostname() {
@@ -108,13 +108,13 @@ class System {
     static std::string hostname_;
 
     // settings
-    static bool    hide_led_;
+    static bool     hide_led_;
-    static bool    syslog_enabled_;
+    static bool     syslog_enabled_;
-    uint8_t        syslog_level_;
+    static int8_t   syslog_level_;
-    uint32_t       syslog_mark_interval_;
+    static uint32_t syslog_mark_interval_;
-    String         syslog_host_;
+    static String   syslog_host_;
-    static uint8_t led_gpio_;
+    static uint8_t  led_gpio_;
-    static bool    analog_enabled_;
+    static bool     analog_enabled_;
 };
 
 } // namespace emsesp