From 7d0ed2246a2aa556ad9210c2a2293b069ad62b85 Mon Sep 17 00:00:00 2001 From: proddy Date: Sun, 2 May 2021 08:32:52 +0200 Subject: [PATCH] auto formatting --- .clang-format | 2 +- src/WebDevicesService.cpp | 14 +- src/WebSettingsService.cpp | 3 +- src/WebStatusService.cpp | 4 +- src/command.cpp | 6 +- src/console.cpp | 493 +++++++++++++++++++++---------------- src/dallassensor.cpp | 18 +- src/devices/boiler.cpp | 93 ++++--- src/devices/solar.cpp | 3 +- src/devices/thermostat.cpp | 109 ++++++-- src/devices/thermostat.h | 4 +- src/emsdevice.cpp | 39 ++- src/emsdevice.h | 25 +- src/emsesp.h | 7 +- src/helpers.cpp | 3 +- src/locale_EN.h | 11 +- src/mqtt.cpp | 45 +++- src/mqtt.h | 7 +- src/system.cpp | 1 - src/telegram.cpp | 51 ++-- src/telegram.h | 17 +- src/uart/emsuart_esp32.cpp | 9 +- 22 files changed, 646 insertions(+), 318 deletions(-) diff --git a/.clang-format b/.clang-format index 2f5e3b42b..e84ce1c3c 100644 --- a/.clang-format +++ b/.clang-format @@ -2,7 +2,7 @@ Language: Cpp BasedOnStyle: LLVM UseTab: Never IndentWidth: 4 -ColumnLimit: 220 +ColumnLimit: 160 TabWidth: 4 #BreakBeforeBraces: Custom BraceWrapping: diff --git a/src/WebDevicesService.cpp b/src/WebDevicesService.cpp index 5db6fcd50..e16d50b8d 100644 --- a/src/WebDevicesService.cpp +++ b/src/WebDevicesService.cpp @@ -23,10 +23,16 @@ namespace emsesp { using namespace std::placeholders; // for `_1` etc WebDevicesService::WebDevicesService(AsyncWebServer * server, SecurityManager * securityManager) - : _device_dataHandler(DEVICE_DATA_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebDevicesService::device_data, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) - , _writevalue_dataHandler(WRITE_VALUE_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebDevicesService::write_value, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) { - server->on(EMSESP_DEVICES_SERVICE_PATH, HTTP_GET, securityManager->wrapRequest(std::bind(&WebDevicesService::all_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED)); - server->on(SCAN_DEVICES_SERVICE_PATH, HTTP_GET, securityManager->wrapRequest(std::bind(&WebDevicesService::scan_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED)); + : _device_dataHandler(DEVICE_DATA_SERVICE_PATH, + securityManager->wrapCallback(std::bind(&WebDevicesService::device_data, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) + , _writevalue_dataHandler(WRITE_VALUE_SERVICE_PATH, + securityManager->wrapCallback(std::bind(&WebDevicesService::write_value, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) { + server->on(EMSESP_DEVICES_SERVICE_PATH, + HTTP_GET, + securityManager->wrapRequest(std::bind(&WebDevicesService::all_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED)); + server->on(SCAN_DEVICES_SERVICE_PATH, + HTTP_GET, + securityManager->wrapRequest(std::bind(&WebDevicesService::scan_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED)); _device_dataHandler.setMethod(HTTP_POST); _device_dataHandler.setMaxContentLength(256); diff --git a/src/WebSettingsService.cpp b/src/WebSettingsService.cpp index 8836c3740..f1a4d2396 100644 --- a/src/WebSettingsService.cpp +++ b/src/WebSettingsService.cpp @@ -27,7 +27,8 @@ using namespace std::placeholders; // for `_1` etc WebSettingsService::WebSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager) : _httpEndpoint(WebSettings::read, WebSettings::update, this, server, EMSESP_SETTINGS_SERVICE_PATH, securityManager) , _fsPersistence(WebSettings::read, WebSettings::update, this, fs, EMSESP_SETTINGS_FILE) - , _boardProfileHandler(EMSESP_BOARD_PROFILE_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebSettingsService::board_profile, this, _1, _2), AuthenticationPredicates::IS_ADMIN)) { + , _boardProfileHandler(EMSESP_BOARD_PROFILE_SERVICE_PATH, + securityManager->wrapCallback(std::bind(&WebSettingsService::board_profile, this, _1, _2), AuthenticationPredicates::IS_ADMIN)) { _boardProfileHandler.setMethod(HTTP_POST); _boardProfileHandler.setMaxContentLength(256); server->addHandler(&_boardProfileHandler); diff --git a/src/WebStatusService.cpp b/src/WebStatusService.cpp index f0d418c2e..c7e972582 100644 --- a/src/WebStatusService.cpp +++ b/src/WebStatusService.cpp @@ -24,7 +24,9 @@ namespace emsesp { WebStatusService::WebStatusService(AsyncWebServer * server, SecurityManager * securityManager) { // rest endpoint for web page - server->on(EMSESP_STATUS_SERVICE_PATH, HTTP_GET, securityManager->wrapRequest(std::bind(&WebStatusService::webStatusService, this, _1), AuthenticationPredicates::IS_AUTHENTICATED)); + server->on(EMSESP_STATUS_SERVICE_PATH, + HTTP_GET, + securityManager->wrapRequest(std::bind(&WebStatusService::webStatusService, this, _1), AuthenticationPredicates::IS_AUTHENTICATED)); WiFi.onEvent(std::bind(&WebStatusService::WiFiEvent, this, _1, _2)); } diff --git a/src/command.cpp b/src/command.cpp index 4abdd4d64..ca0c376d4 100644 --- a/src/command.cpp +++ b/src/command.cpp @@ -95,6 +95,7 @@ bool Command::call(const uint8_t device_type, const char * cmd, const char * val } } +// set the id if there are prefixes char * Command::check_command(char * out, const char * cmd, int8_t & id) { // convert cmd to lowercase strlcpy(out, cmd, 20); @@ -102,7 +103,7 @@ char * Command::check_command(char * out, const char * cmd, int8_t & id) { *p = tolower(*p); } - //scan for prefix hc. + // scan for prefix hc. for (uint8_t i = DeviceValueTAG::TAG_HC1; i <= DeviceValueTAG::TAG_HC4; i++) { if ((strncmp(out, EMSdevice::tag_to_string(i).c_str(), 3) == 0) && (strlen(out) > 4)) { strcpy(out, &out[4]); @@ -111,7 +112,7 @@ char * Command::check_command(char * out, const char * cmd, int8_t & id) { } } - //scan for prefix wwc. + // scan for prefix wwc. for (uint8_t i = DeviceValueTAG::TAG_WWC1; i <= DeviceValueTAG::TAG_WWC4; i++) { if ((strncmp(out, EMSdevice::tag_to_string(i).c_str(), 4) == 0) && (strlen(out) > 5)) { strcpy(out, &out[5]); @@ -123,7 +124,6 @@ char * Command::check_command(char * out, const char * cmd, int8_t & id) { return out; } - // add a command to the list, which does not return json void Command::add(const uint8_t device_type, const __FlashStringHelper * cmd, cmdfunction_p cb, uint8_t flag) { // if the command already exists for that device type don't add it diff --git a/src/console.cpp b/src/console.cpp index 033cf49e3..0df126eb2 100644 --- a/src/console.cpp +++ b/src/console.cpp @@ -36,7 +36,9 @@ static std::shared_ptr shell; std::vector EMSESPStreamConsole::ptys_; #ifndef EMSESP_STANDALONE -uuid::telnet::TelnetService telnet_([](Stream & stream, const IPAddress & addr, uint16_t port) -> std::shared_ptr { return std::make_shared(stream, addr, port); }); +uuid::telnet::TelnetService telnet_([](Stream & stream, const IPAddress & addr, uint16_t port) -> std::shared_ptr { + return std::make_shared(stream, addr, port); +}); #endif EMSESPShell::EMSESPShell() @@ -102,30 +104,42 @@ void EMSESPShell::add_console_commands() { // just in case, remove everything commands->remove_all_commands(); - commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - shell.printfln(F("%s%sEMS-ESP version %s%s"), COLOR_BRIGHT_GREEN, COLOR_BOLD_ON, EMSESP_APP_VERSION, COLOR_RESET); - shell.println(); - EMSESP::show_device_values(shell); - EMSESP::show_sensor_values(shell); - }); + commands->add_command(ShellContext::MAIN, + CommandFlags::USER, + flash_string_vector{F_(show)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { + shell.printfln(F("%s%sEMS-ESP version %s%s"), COLOR_BRIGHT_GREEN, COLOR_BOLD_ON, EMSESP_APP_VERSION, COLOR_RESET); + shell.println(); + EMSESP::show_device_values(shell); + EMSESP::show_sensor_values(shell); + }); - commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show), F_(devices)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - EMSESP::show_devices(shell); - }); + commands->add_command(ShellContext::MAIN, + CommandFlags::USER, + flash_string_vector{F_(show), F_(devices)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { EMSESP::show_devices(shell); }); - commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show), F_(ems)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { EMSESP::show_ems(shell); }); + commands->add_command(ShellContext::MAIN, + CommandFlags::USER, + flash_string_vector{F_(show), F_(ems)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { EMSESP::show_ems(shell); }); - commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show), F_(values)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - EMSESP::show_device_values(shell); - }); + commands->add_command(ShellContext::MAIN, + CommandFlags::USER, + flash_string_vector{F_(show), F_(values)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { EMSESP::show_device_values(shell); }); - commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show), F_(mqtt)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { Mqtt::show_mqtt(shell); }); + commands->add_command(ShellContext::MAIN, + CommandFlags::USER, + flash_string_vector{F_(show), F_(mqtt)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { Mqtt::show_mqtt(shell); }); - commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(show), F_(commands)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - Command::show_all(shell); - }); + commands->add_command(ShellContext::MAIN, + CommandFlags::USER, + flash_string_vector{F_(show), F_(commands)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { Command::show_all(shell); }); commands->add_command( ShellContext::MAIN, @@ -157,62 +171,75 @@ void EMSESPShell::add_console_commands() { }; }); - commands->add_command(ShellContext::MAIN, CommandFlags::ADMIN, flash_string_vector{F_(set), F_(tx_mode)}, flash_string_vector{F_(n_mandatory)}, [](Shell & shell, const std::vector & arguments) { - uint8_t tx_mode = std::strtol(arguments[0].c_str(), nullptr, 10); - // save the tx_mode - EMSESP::webSettingsService.update( - [&](WebSettings & settings) { - settings.tx_mode = tx_mode; - shell.printfln(F_(tx_mode_fmt), settings.tx_mode); - return StateUpdateResult::CHANGED; - }, - "local"); - }); + commands->add_command(ShellContext::MAIN, + CommandFlags::ADMIN, + flash_string_vector{F_(set), F_(tx_mode)}, + flash_string_vector{F_(n_mandatory)}, + [](Shell & shell, const std::vector & arguments) { + uint8_t tx_mode = std::strtol(arguments[0].c_str(), nullptr, 10); + // save the tx_mode + EMSESP::webSettingsService.update( + [&](WebSettings & settings) { + settings.tx_mode = tx_mode; + shell.printfln(F_(tx_mode_fmt), settings.tx_mode); + return StateUpdateResult::CHANGED; + }, + "local"); + }); - commands->add_command(ShellContext::MAIN, CommandFlags::ADMIN, flash_string_vector{F_(scan), F_(devices)}, flash_string_vector{F_(deep_optional)}, [](Shell & shell, const std::vector & arguments) { - if (arguments.size() == 0) { - EMSESP::scan_devices(); - } else { - shell.printfln(F("Performing a deep scan...")); - EMSESP::clear_all_devices(); - std::vector Device_Ids; + commands->add_command(ShellContext::MAIN, + CommandFlags::ADMIN, + flash_string_vector{F_(scan), F_(devices)}, + flash_string_vector{F_(deep_optional)}, + [](Shell & shell, const std::vector & arguments) { + if (arguments.size() == 0) { + EMSESP::scan_devices(); + } else { + shell.printfln(F("Performing a deep scan...")); + EMSESP::clear_all_devices(); + std::vector Device_Ids; - Device_Ids.push_back(0x08); // Boilers - 0x08 - Device_Ids.push_back(0x38); // HeatPump - 0x38 - Device_Ids.push_back(0x30); // Solar Module - 0x30 - Device_Ids.push_back(0x09); // Controllers - 0x09 - Device_Ids.push_back(0x02); // Connect - 0x02 - Device_Ids.push_back(0x48); // Gateway - 0x48 - Device_Ids.push_back(0x20); // Mixer Devices - 0x20 - Device_Ids.push_back(0x21); // Mixer Devices - 0x21 - Device_Ids.push_back(0x22); // Mixer Devices - 0x22 - Device_Ids.push_back(0x23); // Mixer Devices - 0x23 - Device_Ids.push_back(0x28); // Mixer Devices WW- 0x28 - Device_Ids.push_back(0x29); // Mixer Devices WW- 0x29 - Device_Ids.push_back(0x10); // Thermostats - 0x10 - Device_Ids.push_back(0x17); // Thermostats - 0x17 - Device_Ids.push_back(0x18); // Thermostat remote - 0x18 - Device_Ids.push_back(0x19); // Thermostat remote - 0x19 - Device_Ids.push_back(0x1A); // Thermostat remote - 0x1A - Device_Ids.push_back(0x1B); // Thermostat remote - 0x1B - Device_Ids.push_back(0x11); // Switches - 0x11 + Device_Ids.push_back(0x08); // Boilers - 0x08 + Device_Ids.push_back(0x38); // HeatPump - 0x38 + Device_Ids.push_back(0x30); // Solar Module - 0x30 + Device_Ids.push_back(0x09); // Controllers - 0x09 + Device_Ids.push_back(0x02); // Connect - 0x02 + Device_Ids.push_back(0x48); // Gateway - 0x48 + Device_Ids.push_back(0x20); // Mixer Devices - 0x20 + Device_Ids.push_back(0x21); // Mixer Devices - 0x21 + Device_Ids.push_back(0x22); // Mixer Devices - 0x22 + Device_Ids.push_back(0x23); // Mixer Devices - 0x23 + Device_Ids.push_back(0x28); // Mixer Devices WW- 0x28 + Device_Ids.push_back(0x29); // Mixer Devices WW- 0x29 + Device_Ids.push_back(0x10); // Thermostats - 0x10 + Device_Ids.push_back(0x17); // Thermostats - 0x17 + Device_Ids.push_back(0x18); // Thermostat remote - 0x18 + Device_Ids.push_back(0x19); // Thermostat remote - 0x19 + Device_Ids.push_back(0x1A); // Thermostat remote - 0x1A + Device_Ids.push_back(0x1B); // Thermostat remote - 0x1B + Device_Ids.push_back(0x11); // Switches - 0x11 - // send the read command with Version command - for (const uint8_t device_id : Device_Ids) { - EMSESP::send_read_request(EMSdevice::EMS_TYPE_VERSION, device_id); - } - } - }); + // send the read command with Version command + for (const uint8_t device_id : Device_Ids) { + EMSESP::send_read_request(EMSdevice::EMS_TYPE_VERSION, device_id); + } + } + }); - commands->add_command(ShellContext::MAIN, CommandFlags::USER, flash_string_vector{F_(set)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - EMSESP::webSettingsService.read([&](WebSettings & settings) { - shell.printfln(F_(tx_mode_fmt), settings.tx_mode); - shell.printfln(F_(bus_id_fmt), settings.ems_bus_id); - char buffer[4]; - shell.printfln(F_(master_thermostat_fmt), settings.master_thermostat == 0 ? uuid::read_flash_string(F_(auto)).c_str() : Helpers::hextoa(buffer, settings.master_thermostat)); - shell.printfln(F_(board_profile_fmt), settings.board_profile.c_str()); - }); - }); + commands->add_command(ShellContext::MAIN, + CommandFlags::USER, + flash_string_vector{F_(set)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { + EMSESP::webSettingsService.read([&](WebSettings & settings) { + shell.printfln(F_(tx_mode_fmt), settings.tx_mode); + shell.printfln(F_(bus_id_fmt), settings.ems_bus_id); + char buffer[4]; + shell.printfln(F_(master_thermostat_fmt), + settings.master_thermostat == 0 ? uuid::read_flash_string(F_(auto)).c_str() + : Helpers::hextoa(buffer, settings.master_thermostat)); + shell.printfln(F_(board_profile_fmt), settings.board_profile.c_str()); + }); + }); commands->add_command(ShellContext::MAIN, CommandFlags::ADMIN, @@ -245,18 +272,23 @@ void EMSESPShell::add_console_commands() { settings.master_thermostat = value; EMSESP::actual_master_thermostat(value); // set the internal value too char buffer[5]; - shell.printfln(F_(master_thermostat_fmt), !value ? uuid::read_flash_string(F_(auto)).c_str() : Helpers::hextoa(buffer, value)); + shell.printfln(F_(master_thermostat_fmt), + !value ? uuid::read_flash_string(F_(auto)).c_str() : Helpers::hextoa(buffer, value)); return StateUpdateResult::CHANGED; }, "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 & arguments) { - uint16_t value = Helpers::atoint(arguments.front().c_str()); - telnet_.initial_idle_timeout(value * 60); - shell.printfln(F("Telnet timeout set to %d minutes"), value); - }); + 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 & arguments) { + uint16_t value = Helpers::atoint(arguments.front().c_str()); + telnet_.initial_idle_timeout(value * 60); + shell.printfln(F("Telnet timeout set to %d minutes"), value); + }); #endif commands->add_command(ShellContext::MAIN, @@ -444,27 +476,37 @@ void Console::enter_custom_context(Shell & shell, unsigned int context) { // each custom context has the common commands like log, help, exit, su etc void Console::load_standard_commands(unsigned int context) { #if defined(EMSESP_DEBUG) - EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F("test")}, flash_string_vector{F_(name_optional)}, [](Shell & shell, const std::vector & arguments) { - if (arguments.size() == 0) { - Test::run_test(shell, "default"); - } else { - Test::run_test(shell, arguments.front()); - } - }); + EMSESPShell::commands->add_command(context, + CommandFlags::USER, + flash_string_vector{F("test")}, + flash_string_vector{F_(name_optional)}, + [](Shell & shell, const std::vector & arguments) { + if (arguments.size() == 0) { + Test::run_test(shell, "default"); + } else { + Test::run_test(shell, arguments.front()); + } + }); #endif #if defined(EMSESP_STANDALONE) - EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F("t")}, [](Shell & shell, const std::vector & arguments) { Test::run_test(shell, "default"); }); + EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F("t")}, [](Shell & shell, const std::vector & arguments) { + Test::run_test(shell, "default"); + }); #endif #if defined(EMSESP_DEBUG) - EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(debug)}, flash_string_vector{F_(name_optional)}, [](Shell & shell, const std::vector & arguments) { - if (arguments.size() == 0) { - Test::debug(shell, "default"); - } else { - Test::debug(shell, arguments.front()); - } - }); + EMSESPShell::commands->add_command(context, + CommandFlags::USER, + flash_string_vector{F_(debug)}, + flash_string_vector{F_(name_optional)}, + [](Shell & shell, const std::vector & arguments) { + if (arguments.size() == 0) { + Test::debug(shell, "default"); + } else { + Test::debug(shell, arguments.front()); + } + }); #endif EMSESPShell::commands->add_command( @@ -493,44 +535,55 @@ void Console::load_standard_commands(unsigned int context) { } shell.printfln(F_(log_level_fmt), uuid::log::format_level_lowercase(shell.log_level())); }, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> std::vector { return uuid::log::levels_lowercase(); }); + [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) -> std::vector { + return uuid::log::levels_lowercase(); + }); - EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(help)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - shell.print_all_available_commands(); - }); + EMSESPShell::commands->add_command(context, + CommandFlags::USER, + flash_string_vector{F_(help)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { + shell.print_all_available_commands(); + }); - EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(exit)}, [=](Shell & shell, const std::vector & arguments __attribute__((unused))) { - shell.stop(); - // shell.exit_context(); - }); + EMSESPShell::commands->add_command(context, + CommandFlags::USER, + flash_string_vector{F_(exit)}, + [=](Shell & shell, const std::vector & arguments __attribute__((unused))) { + shell.stop(); + // shell.exit_context(); + }); - EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(su)}, [=](Shell & shell, const std::vector & arguments __attribute__((unused))) { - auto become_admin = [](Shell & shell) { - shell.logger().log(LogLevel::NOTICE, LogFacility::AUTH, F("su session opened on console")); - shell.add_flags(CommandFlags::ADMIN); - }; + EMSESPShell::commands->add_command(context, + CommandFlags::USER, + flash_string_vector{F_(su)}, + [=](Shell & shell, const std::vector & arguments __attribute__((unused))) { + auto become_admin = [](Shell & shell) { + shell.logger().log(LogLevel::NOTICE, LogFacility::AUTH, F("su session opened on console")); + shell.add_flags(CommandFlags::ADMIN); + }; - if (shell.has_flags(CommandFlags::LOCAL)) { - become_admin(shell); - } else { - shell.enter_password(F_(password_prompt), [=](Shell & shell, bool completed, const std::string & password) { - if (completed) { - uint64_t now = uuid::get_uptime_ms(); + if (shell.has_flags(CommandFlags::LOCAL)) { + become_admin(shell); + } else { + shell.enter_password(F_(password_prompt), [=](Shell & shell, bool completed, const std::string & password) { + if (completed) { + uint64_t now = uuid::get_uptime_ms(); - EMSESP::esp8266React.getSecuritySettingsService()->read([&](SecuritySettings & securitySettings) { - if (securitySettings.jwtSecret.equals(password.c_str())) { - become_admin(shell); - } else { - shell.delay_until(now + INVALID_PASSWORD_DELAY_MS, [](Shell & shell) { - shell.logger().log(LogLevel::NOTICE, LogFacility::AUTH, F("Invalid su password on console")); - shell.println(F("su: incorrect password")); - }); - } - }); - } - }); - } - }); + EMSESP::esp8266React.getSecuritySettingsService()->read([&](SecuritySettings & securitySettings) { + if (securitySettings.jwtSecret.equals(password.c_str())) { + become_admin(shell); + } else { + shell.delay_until(now + INVALID_PASSWORD_DELAY_MS, [](Shell & shell) { + shell.logger().log(LogLevel::NOTICE, LogFacility::AUTH, F("Invalid su password on console")); + shell.println(F("su: incorrect password")); + }); + } + }); + } + }); + } + }); } // console commands to add @@ -538,53 +591,67 @@ void Console::load_system_commands(unsigned int context) { EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, flash_string_vector{F_(restart)}, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) { EMSESP::system_.restart(); }); + [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) { + EMSESP::system_.restart(); + }); EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, flash_string_vector{F_(wifi), F_(reconnect)}, - [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) { EMSESP::system_.wifi_reconnect(); }); + [](Shell & shell __attribute__((unused)), const std::vector & arguments __attribute__((unused))) { + EMSESP::system_.wifi_reconnect(); + }); - EMSESPShell::commands->add_command(ShellContext::MAIN, CommandFlags::ADMIN, flash_string_vector{F_(format)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - shell.enter_password(F_(password_prompt), [=](Shell & shell, bool completed, const std::string & password) { - if (completed) { - EMSESP::esp8266React.getSecuritySettingsService()->read([&](SecuritySettings & securitySettings) { - if (securitySettings.jwtSecret.equals(password.c_str())) { - EMSESP::system_.format(shell); - } else { - shell.println(F("incorrect password")); - } - }); - } - }); - }); + EMSESPShell::commands->add_command(ShellContext::MAIN, + CommandFlags::ADMIN, + flash_string_vector{F_(format)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { + shell.enter_password(F_(password_prompt), [=](Shell & shell, bool completed, const std::string & password) { + if (completed) { + EMSESP::esp8266React.getSecuritySettingsService()->read([&](SecuritySettings & securitySettings) { + if (securitySettings.jwtSecret.equals(password.c_str())) { + EMSESP::system_.format(shell); + } else { + shell.println(F("incorrect password")); + } + }); + } + }); + }); - EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, flash_string_vector{F_(passwd)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - shell.enter_password(F_(new_password_prompt1), [](Shell & shell, bool completed, const std::string & password1) { - if (completed) { - shell.enter_password(F_(new_password_prompt2), [password1](Shell & shell, bool completed, const std::string & password2) { - if (completed) { - if (password1 == password2) { - EMSESP::esp8266React.getSecuritySettingsService()->update( - [&](SecuritySettings & securitySettings) { - securitySettings.jwtSecret = password2.c_str(); - return StateUpdateResult::CHANGED; - }, - "local"); - shell.println(F("su password updated")); - } else { - shell.println(F("Passwords do not match")); - } - } - }); - } - }); - }); + EMSESPShell::commands->add_command(context, + CommandFlags::ADMIN, + flash_string_vector{F_(passwd)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { + shell.enter_password(F_(new_password_prompt1), [](Shell & shell, bool completed, const std::string & password1) { + if (completed) { + shell.enter_password(F_(new_password_prompt2), + [password1](Shell & shell, bool completed, const std::string & password2) { + if (completed) { + if (password1 == password2) { + EMSESP::esp8266React.getSecuritySettingsService()->update( + [&](SecuritySettings & securitySettings) { + securitySettings.jwtSecret = password2.c_str(); + return StateUpdateResult::CHANGED; + }, + "local"); + shell.println(F("su password updated")); + } else { + shell.println(F("Passwords do not match")); + } + } + }); + } + }); + }); - EMSESPShell::commands->add_command(context, CommandFlags::USER, flash_string_vector{F_(show), F_(system)}, [=](Shell & shell, const std::vector & arguments __attribute__((unused))) { - EMSESP::system_.show_system(shell); - shell.println(); - }); + EMSESPShell::commands->add_command(context, + CommandFlags::USER, + flash_string_vector{F_(show), F_(system)}, + [=](Shell & shell, const std::vector & arguments __attribute__((unused))) { + EMSESP::system_.show_system(shell); + shell.println(); + }); EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, @@ -614,55 +681,63 @@ void Console::load_system_commands(unsigned int context) { shell.println("Use `wifi reconnect` to save and apply the new settings"); }); - EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, flash_string_vector{F_(set), F_(wifi), F_(password)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - shell.enter_password(F_(new_password_prompt1), [](Shell & shell, bool completed, const std::string & password1) { - if (completed) { - shell.enter_password(F_(new_password_prompt2), [password1](Shell & shell, bool completed, const std::string & password2) { - if (completed) { - if (password1 == password2) { - EMSESP::esp8266React.getNetworkSettingsService()->updateWithoutPropagation([&](NetworkSettings & networkSettings) { - networkSettings.password = password2.c_str(); - return StateUpdateResult::CHANGED; - }); - shell.println("Use `wifi reconnect` to save and apply the new settings"); - } else { - shell.println(F("Passwords do not match")); - } - } - }); - } - }); - }); - EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, - flash_string_vector{F_(set), F_(board_profile)}, - flash_string_vector{F_(name_mandatory)}, - [](Shell & shell, const std::vector & arguments) { - std::vector data; // led, dallas, rx, tx, button - std::string board_profile = Helpers::toUpper(arguments.front()); - if (!EMSESP::system_.load_board_profile(data, board_profile)) { - shell.println(F("Invalid board profile (S32, E32, MH-ET, NODEMCU, OLIMEX, TLK110, LAN8720, CUSTOM)")); - return; - } - EMSESP::webSettingsService.update( - [&](WebSettings & settings) { - settings.board_profile = board_profile.c_str(); - settings.led_gpio = data[0]; - settings.dallas_gpio = data[1]; - settings.rx_gpio = data[2]; - settings.tx_gpio = data[3]; - settings.pbutton_gpio = data[4]; - return StateUpdateResult::CHANGED; - }, - "local"); - shell.printfln("Loaded board profile %s (%d,%d,%d,%d,%d)", board_profile.c_str(), data[0], data[1], data[2], data[3], data[4]); - EMSESP::system_.network_init(true); + flash_string_vector{F_(set), F_(wifi), F_(password)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { + shell.enter_password(F_(new_password_prompt1), [](Shell & shell, bool completed, const std::string & password1) { + if (completed) { + shell.enter_password(F_(new_password_prompt2), + [password1](Shell & shell, bool completed, const std::string & password2) { + if (completed) { + if (password1 == password2) { + EMSESP::esp8266React.getNetworkSettingsService()->updateWithoutPropagation( + [&](NetworkSettings & networkSettings) { + networkSettings.password = password2.c_str(); + return StateUpdateResult::CHANGED; + }); + shell.println("Use `wifi reconnect` to save and apply the new settings"); + } else { + shell.println(F("Passwords do not match")); + } + } + }); + } + }); }); - EMSESPShell::commands->add_command(context, CommandFlags::ADMIN, flash_string_vector{F_(show), F_(users)}, [](Shell & shell, const std::vector & arguments __attribute__((unused))) { - EMSESP::system_.show_users(shell); - }); + EMSESPShell::commands + ->add_command(context, + CommandFlags::ADMIN, + flash_string_vector{F_(set), F_(board_profile)}, + flash_string_vector{F_(name_mandatory)}, + [](Shell & shell, const std::vector & arguments) { + std::vector data; // led, dallas, rx, tx, button + std::string board_profile = Helpers::toUpper(arguments.front()); + if (!EMSESP::system_.load_board_profile(data, board_profile)) { + shell.println(F("Invalid board profile (S32, E32, MH-ET, NODEMCU, OLIMEX, TLK110, LAN8720, CUSTOM)")); + return; + } + EMSESP::webSettingsService.update( + [&](WebSettings & settings) { + settings.board_profile = board_profile.c_str(); + settings.led_gpio = data[0]; + settings.dallas_gpio = data[1]; + settings.rx_gpio = data[2]; + settings.tx_gpio = data[3]; + settings.pbutton_gpio = data[4]; + return StateUpdateResult::CHANGED; + }, + "local"); + shell.printfln("Loaded board profile %s (%d,%d,%d,%d,%d)", board_profile.c_str(), data[0], data[1], data[2], data[3], data[4]); + EMSESP::system_.network_init(true); + }); + EMSESPShell::commands->add_command(context, + CommandFlags::ADMIN, + flash_string_vector{F_(show), F_(users)}, + [](Shell & shell, const std::vector & arguments __attribute__((unused))) { + EMSESP::system_.show_users(shell); + }); } /* diff --git a/src/dallassensor.cpp b/src/dallassensor.cpp index a1dd07fb9..76d8e571f 100644 --- a/src/dallassensor.cpp +++ b/src/dallassensor.cpp @@ -41,7 +41,9 @@ void DallasSensor::start() { bus_.begin(dallas_gpio_); #endif // API call - Command::add_with_json(EMSdevice::DeviceType::DALLASSENSOR, F_(info), [&](const char * value, const int8_t id, JsonObject & json) { return command_info(value, id, json); }); + Command::add_with_json(EMSdevice::DeviceType::DALLASSENSOR, F_(info), [&](const char * value, const int8_t id, JsonObject & json) { + return command_info(value, id, json); + }); } } @@ -270,11 +272,13 @@ const std::vector DallasSensor::sensors() const { // skip crc from id. DallasSensor::Sensor::Sensor(const uint8_t addr[]) - : id_(((uint64_t)addr[0] << 48) | ((uint64_t)addr[1] << 40) | ((uint64_t)addr[2] << 32) | ((uint64_t)addr[3] << 24) | ((uint64_t)addr[4] << 16) | ((uint64_t)addr[5] << 8) | ((uint64_t)addr[6])) { + : id_(((uint64_t)addr[0] << 48) | ((uint64_t)addr[1] << 40) | ((uint64_t)addr[2] << 32) | ((uint64_t)addr[3] << 24) | ((uint64_t)addr[4] << 16) + | ((uint64_t)addr[5] << 8) | ((uint64_t)addr[6])) { } uint64_t DallasSensor::get_id(const uint8_t addr[]) { - return (((uint64_t)addr[0] << 48) | ((uint64_t)addr[1] << 40) | ((uint64_t)addr[2] << 32) | ((uint64_t)addr[3] << 24) | ((uint64_t)addr[4] << 16) | ((uint64_t)addr[5] << 8) | ((uint64_t)addr[6])); + return (((uint64_t)addr[0] << 48) | ((uint64_t)addr[1] << 40) | ((uint64_t)addr[2] << 32) | ((uint64_t)addr[3] << 24) | ((uint64_t)addr[4] << 16) + | ((uint64_t)addr[5] << 8) | ((uint64_t)addr[6])); } uint64_t DallasSensor::Sensor::id() const { @@ -283,7 +287,13 @@ uint64_t DallasSensor::Sensor::id() const { std::string DallasSensor::Sensor::to_string() const { std::string str(20, '\0'); - snprintf_P(&str[0], str.capacity() + 1, PSTR("%02X-%04X-%04X-%04X"), (unsigned int)(id_ >> 48) & 0xFF, (unsigned int)(id_ >> 32) & 0xFFFF, (unsigned int)(id_ >> 16) & 0xFFFF, (unsigned int)(id_)&0xFFFF); + snprintf_P(&str[0], + str.capacity() + 1, + PSTR("%02X-%04X-%04X-%04X"), + (unsigned int)(id_ >> 48) & 0xFF, + (unsigned int)(id_ >> 32) & 0xFFFF, + (unsigned int)(id_ >> 16) & 0xFFFF, + (unsigned int)(id_)&0xFFFF); return str; } diff --git a/src/devices/boiler.cpp b/src/devices/boiler.cpp index eb637977e..5eb577a3a 100644 --- a/src/devices/boiler.cpp +++ b/src/devices/boiler.cpp @@ -85,7 +85,8 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_telegram_type(0x48F, F("HpOutdoor"), false, MAKE_PF_CB(process_HpOutdoor)); } // MQTT commands for boiler topic - register_device_value(TAG_BOILER_DATA, &dummybool_, DeviceValueType::BOOL, nullptr, FL_(wwtapactivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_tapwarmwater_activated)); + register_device_value( + TAG_BOILER_DATA, &dummybool_, DeviceValueType::BOOL, nullptr, FL_(wwtapactivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_tapwarmwater_activated)); register_device_value(TAG_BOILER_DATA, &dummy8u_, DeviceValueType::ENUM, FL_(enum_reset), FL_(reset), DeviceValueUOM::NONE, MAKE_CF_CB(set_reset)); // add values @@ -113,7 +114,8 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_BOILER_DATA, &heatingPump_, DeviceValueType::BOOL, nullptr, FL_(heatingPump), DeviceValueUOM::PUMP); 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(TAG_BOILER_DATA, &heatingActivated_, DeviceValueType::BOOL, nullptr, FL_(heatingActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_heating_activated)); + register_device_value( + TAG_BOILER_DATA, &heatingActivated_, DeviceValueType::BOOL, nullptr, FL_(heatingActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_heating_activated)); register_device_value(TAG_BOILER_DATA, &heatingTemp_, DeviceValueType::UINT, nullptr, FL_(heatingTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_heating_temp)); register_device_value(TAG_BOILER_DATA, &pumpModMax_, DeviceValueType::UINT, nullptr, FL_(pumpModMax), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_max_pump)); register_device_value(TAG_BOILER_DATA, &pumpModMin_, DeviceValueType::UINT, nullptr, FL_(pumpModMin), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_min_pump)); @@ -135,7 +137,13 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_BOILER_DATA, &serviceCodeNumber_, DeviceValueType::USHORT, nullptr, FL_(serviceCodeNumber), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &maintenanceMessage_, DeviceValueType::TEXT, nullptr, FL_(maintenanceMessage), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &maintenanceDate_, DeviceValueType::TEXT, nullptr, FL_(maintenanceDate), DeviceValueUOM::NONE); - register_device_value(TAG_BOILER_DATA, &maintenanceType_, DeviceValueType::ENUM, FL_(enum_off_time_date), FL_(maintenanceType), DeviceValueUOM::NONE, MAKE_CF_CB(set_maintenance)); + register_device_value(TAG_BOILER_DATA, + &maintenanceType_, + DeviceValueType::ENUM, + FL_(enum_off_time_date), + FL_(maintenanceType), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_maintenance)); register_device_value(TAG_BOILER_DATA, &maintenanceTime_, DeviceValueType::USHORT, nullptr, FL_(maintenanceTime), DeviceValueUOM::HOURS); // heatpump info if (model() == EMS_DEVICE_FLAG_HEATPUMP) { @@ -175,20 +183,37 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_DEVICE_DATA_WW, &wWSelTemp_, DeviceValueType::UINT, nullptr, FL_(wWSelTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_DEVICE_DATA_WW, &wWSetTemp_, DeviceValueType::UINT, nullptr, FL_(wWSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_warmwater_temp)); register_device_value(TAG_DEVICE_DATA_WW, &wWType_, DeviceValueType::ENUM, FL_(enum_flow), FL_(wWType), DeviceValueUOM::NONE); - register_device_value(TAG_DEVICE_DATA_WW, &wWComfort_, DeviceValueType::ENUM, FL_(enum_comfort), FL_(wWComfort), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_mode)); - register_device_value(TAG_DEVICE_DATA_WW, &wWFlowTempOffset_, DeviceValueType::UINT, nullptr, FL_(wWFlowTempOffset), DeviceValueUOM::NONE, MAKE_CF_CB(set_wWFlowTempOffset)); - register_device_value(TAG_DEVICE_DATA_WW, &wWMaxPower_, DeviceValueType::UINT, nullptr, FL_(wWMaxPower), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_warmwater_maxpower)); - register_device_value(TAG_DEVICE_DATA_WW, &wWCircPump_, DeviceValueType::BOOL, nullptr, FL_(wWCircPump), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_circulation_pump)); + register_device_value( + TAG_DEVICE_DATA_WW, &wWComfort_, DeviceValueType::ENUM, FL_(enum_comfort), FL_(wWComfort), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_mode)); + register_device_value( + TAG_DEVICE_DATA_WW, &wWFlowTempOffset_, DeviceValueType::UINT, nullptr, FL_(wWFlowTempOffset), DeviceValueUOM::NONE, MAKE_CF_CB(set_wWFlowTempOffset)); + register_device_value( + TAG_DEVICE_DATA_WW, &wWMaxPower_, DeviceValueType::UINT, nullptr, FL_(wWMaxPower), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_warmwater_maxpower)); + register_device_value( + TAG_DEVICE_DATA_WW, &wWCircPump_, DeviceValueType::BOOL, nullptr, FL_(wWCircPump), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_circulation_pump)); register_device_value(TAG_DEVICE_DATA_WW, &wWChargeType_, DeviceValueType::BOOL, FL_(enum_charge), FL_(wWChargeType), DeviceValueUOM::NONE); - register_device_value(TAG_DEVICE_DATA_WW, &wWDisinfectionTemp_, DeviceValueType::UINT, nullptr, FL_(wWDisinfectionTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_disinfect_temp)); - register_device_value(TAG_DEVICE_DATA_WW, &wWCircMode_, DeviceValueType::ENUM, FL_(enum_freq), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_circulation_mode)); + register_device_value(TAG_DEVICE_DATA_WW, + &wWDisinfectionTemp_, + DeviceValueType::UINT, + nullptr, + FL_(wWDisinfectionTemp), + DeviceValueUOM::DEGREES, + MAKE_CF_CB(set_disinfect_temp)); + register_device_value(TAG_DEVICE_DATA_WW, + &wWCircMode_, + DeviceValueType::ENUM, + FL_(enum_freq), + FL_(wWCircMode), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_warmwater_circulation_mode)); register_device_value(TAG_DEVICE_DATA_WW, &wWCirc_, DeviceValueType::BOOL, nullptr, FL_(wWCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_circulation)); register_device_value(TAG_DEVICE_DATA_WW, &wWCurTemp_, DeviceValueType::USHORT, FL_(div10), FL_(wWCurTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_DEVICE_DATA_WW, &wWCurTemp2_, DeviceValueType::USHORT, FL_(div10), FL_(wWCurTemp2), DeviceValueUOM::DEGREES); register_device_value(TAG_DEVICE_DATA_WW, &wWCurFlow_, DeviceValueType::UINT, FL_(div10), FL_(wWCurFlow), DeviceValueUOM::LMIN); register_device_value(TAG_DEVICE_DATA_WW, &wWStorageTemp1_, DeviceValueType::USHORT, FL_(div10), FL_(wWStorageTemp1), DeviceValueUOM::DEGREES); register_device_value(TAG_DEVICE_DATA_WW, &wWStorageTemp2_, DeviceValueType::USHORT, FL_(div10), FL_(wWStorageTemp2), DeviceValueUOM::DEGREES); - register_device_value(TAG_DEVICE_DATA_WW, &wWActivated_, DeviceValueType::BOOL, nullptr, FL_(wWActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_activated)); + register_device_value( + TAG_DEVICE_DATA_WW, &wWActivated_, DeviceValueType::BOOL, nullptr, FL_(wWActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_activated)); register_device_value(TAG_DEVICE_DATA_WW, &wWOneTime_, DeviceValueType::BOOL, nullptr, FL_(wWOneTime), DeviceValueUOM::NONE, MAKE_CF_CB(set_warmwater_onetime)); register_device_value(TAG_DEVICE_DATA_WW, &wWDisinfecting_, DeviceValueType::BOOL, nullptr, FL_(wWDisinfecting), DeviceValueUOM::NONE); register_device_value(TAG_DEVICE_DATA_WW, &wWCharging_, DeviceValueType::BOOL, nullptr, FL_(wWCharging), DeviceValueUOM::NONE); @@ -204,10 +229,14 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_DEVICE_DATA_WW, &wWWorkM_, DeviceValueType::TIME, nullptr, FL_(wWWorkM), 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) + 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 @@ -231,7 +260,8 @@ bool Boiler::publish_ha_config() { char topic[Mqtt::MQTT_TOPIC_MAX_SIZE]; snprintf_P(topic, sizeof(topic), PSTR("sensor/%s/boiler/config"), Mqtt::base().c_str()); - Mqtt::publish_ha(topic, doc.as()); // publish the config payload with retain flag + Mqtt::publish_ha(topic, + doc.as()); // publish the config payload with retain flag return true; } @@ -288,7 +318,8 @@ void Boiler::process_UBAParameterWW(std::shared_ptr telegram) { has_update(telegram->read_value(wWCircPump_, 6)); // 0xFF means on has_update(telegram->read_value(wWCircMode_, 7)); // 1=1x3min 6=6x3min 7=continuous has_update(telegram->read_value(wWDisinfectionTemp_, 8)); - has_update(telegram->read_value(wWChargeType_, 10)); // 0 = charge pump, 0xff = 3-way valve + has_update(telegram->read_value(wWChargeType_, + 10)); // 0 = charge pump, 0xff = 3-way valve telegram->read_value(wWComfort_, 9); if (wWComfort_ == 0x00) { @@ -319,8 +350,9 @@ void Boiler::process_UBAMonitorFast(std::shared_ptr telegram) { // warm water storage sensors (if present) // wWStorageTemp2 is also used by some brands as the boiler temperature - see https://github.com/emsesp/EMS-ESP/issues/206 - has_update(telegram->read_value(wWStorageTemp1_, 9)); // 0x8300 if not available - has_update(telegram->read_value(wWStorageTemp2_, 11)); // 0x8000 if not available - this is boiler temp + has_update(telegram->read_value(wWStorageTemp1_, 9)); // 0x8300 if not available + has_update(telegram->read_value(wWStorageTemp2_, + 11)); // 0x8000 if not available - this is boiler temp has_update(telegram->read_value(retTemp_, 13)); has_update(telegram->read_value(flameCurr_, 15)); @@ -456,7 +488,8 @@ void Boiler::process_UBAMonitorSlow(std::shared_ptr telegram) { has_update(telegram->read_value(outdoorTemp_, 0)); has_update(telegram->read_value(boilTemp_, 2)); has_update(telegram->read_value(exhaustTemp_, 4)); - has_update(telegram->read_value(switchTemp_, 25)); // only if there is a mixer module present + has_update(telegram->read_value(switchTemp_, + 25)); // only if there is a mixer module present has_update(telegram->read_value(heatingPumpMod_, 9)); has_update(telegram->read_value(burnStarts_, 10, 3)); // force to 3 bytes has_update(telegram->read_value(burnWorkMin_, 13, 3)); // force to 3 bytes @@ -515,7 +548,8 @@ void Boiler::process_UBAParametersPlus(std::shared_ptr telegram) void Boiler::process_UBAParameterWWPlus(std::shared_ptr telegram) { has_update(telegram->read_value(wWActivated_, 5)); // 0x01 means on has_update(telegram->read_value(wWCircPump_, 10)); // 0x01 means yes - has_update(telegram->read_value(wWCircMode_, 11)); // 1=1x3min... 6=6x3min, 7=continuous + has_update(telegram->read_value(wWCircMode_, + 11)); // 1=1x3min... 6=6x3min, 7=continuous // has_update(telegram->read_value(wWDisinfectTemp_, 12)); // settings, status in E9 // has_update(telegram->read_value(wWSelTemp_, 6)); // settings, status in E9 } @@ -588,13 +622,12 @@ void Boiler::process_UBAEnergySupplied(std::shared_ptr telegram) } // Heatpump power - type 0x48D -void Boiler::process_HpPower(std::shared_ptr telegram){ +void Boiler::process_HpPower(std::shared_ptr telegram) { has_update(telegram->read_value(hpPower_, 11)); - } // Heatpump outdoor unit - type 0x48F -void Boiler::process_HpOutdoor(std::shared_ptr telegram){ +void Boiler::process_HpOutdoor(std::shared_ptr telegram) { has_update(telegram->read_value(hpTc0_, 6)); has_update(telegram->read_value(hpTc1_, 4)); has_update(telegram->read_value(hpTc3_, 2)); @@ -625,7 +658,8 @@ void Boiler::process_UBAOutdoorTemp(std::shared_ptr telegram) { // UBASetPoint 0x1A void Boiler::process_UBASetPoints(std::shared_ptr telegram) { - has_update(telegram->read_value(setFlowTemp_, 0)); // boiler set temp from thermostat + has_update(telegram->read_value(setFlowTemp_, + 0)); // boiler set temp from thermostat has_update(telegram->read_value(setBurnPow_, 1)); // max json power in % has_update(telegram->read_value(wWSetPumpPower_, 2)); // ww pump speed/power? } @@ -727,8 +761,9 @@ bool Boiler::set_warmwater_temp(const char * value, const int8_t id) { write_command(EMS_TYPE_UBAParameterWWPlus, 6, v, EMS_TYPE_UBAParameterWWPlus); } else { // some boiler have it in 0x33, some in 0x35 - write_command(EMS_TYPE_UBAFlags, 3, v, 0x34); // for i9000, see #397 - write_command(EMS_TYPE_UBAParameterWW, 2, v, EMS_TYPE_UBAParameterWW); // read seltemp back + write_command(EMS_TYPE_UBAFlags, 3, v, 0x34); // for i9000, see #397 + write_command(EMS_TYPE_UBAParameterWW, 2, v, + EMS_TYPE_UBAParameterWW); // read seltemp back } return true; @@ -1074,7 +1109,8 @@ bool Boiler::set_warmwater_onetime(const char * value, const int8_t id) { LOG_INFO(F("Setting warm water OneTime loading %s"), v ? "on" : "off"); if (get_toggle_fetch(EMS_TYPE_UBAParameterWWPlus)) { - write_command(EMS_TYPE_UBAFlags, 0, (v ? 0x22 : 0x02), 0xE9); // not sure if this is in flags + write_command(EMS_TYPE_UBAFlags, 0, (v ? 0x22 : 0x02), + 0xE9); // not sure if this is in flags } else { write_command(EMS_TYPE_UBAFlags, 0, (v ? 0x22 : 0x02), 0x34); } @@ -1093,7 +1129,8 @@ bool Boiler::set_warmwater_circulation(const char * value, const int8_t id) { LOG_INFO(F("Setting warm water circulation %s"), v ? "on" : "off"); if (get_toggle_fetch(EMS_TYPE_UBAParameterWWPlus)) { - write_command(EMS_TYPE_UBAFlags, 1, (v ? 0x22 : 0x02), 0xE9); // not sure if this is in flags + write_command(EMS_TYPE_UBAFlags, 1, (v ? 0x22 : 0x02), + 0xE9); // not sure if this is in flags } else { write_command(EMS_TYPE_UBAFlags, 1, (v ? 0x22 : 0x02), 0x34); } diff --git a/src/devices/solar.cpp b/src/devices/solar.cpp index ce0fe1284..c724b8c54 100644 --- a/src/devices/solar.cpp +++ b/src/devices/solar.cpp @@ -81,7 +81,8 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s 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, &tankBottomMaxTemp_, DeviceValueType::UINT, nullptr, FL_(tankMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_SM100TankBottomMaxTemp)); + register_device_value( + TAG_NONE, &tankBottomMaxTemp_, DeviceValueType::UINT, nullptr, FL_(tankMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_SM100TankBottomMaxTemp)); register_device_value(TAG_NONE, &solarPumpModulation_, DeviceValueType::UINT, nullptr, FL_(solarPumpModulation), DeviceValueUOM::PERCENT); register_device_value(TAG_NONE, &cylinderPumpModulation_, DeviceValueType::UINT, nullptr, FL_(cylinderPumpModulation), DeviceValueUOM::PERCENT); diff --git a/src/devices/thermostat.cpp b/src/devices/thermostat.cpp index 44ed9246e..80fe8af51 100644 --- a/src/devices/thermostat.cpp +++ b/src/devices/thermostat.cpp @@ -38,7 +38,8 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i // or if its the master thermostat we defined // see https://github.com/emsesp/EMS-ESP/issues/362#issuecomment-629628161 if ((master_thermostat == device_id) - || ((master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT) && (device_id < 0x19) && ((actual_master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT) || (device_id < actual_master_thermostat)))) { + || ((master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT) && (device_id < 0x19) + && ((actual_master_thermostat == EMSESP_DEFAULT_MASTER_THERMOSTAT) || (device_id < actual_master_thermostat)))) { EMSESP::actual_master_thermostat(device_id); actual_master_thermostat = device_id; reserve_telgram_functions(25); // reserve some space for the telegram registries, to avoid memory fragmentation @@ -960,7 +961,7 @@ void Thermostat::process_RC35Set(std::shared_ptr telegram) { has_update(telegram->read_value(hc->control, 26)); // 0-off, 1-RC20 (remote), 2-RC35 has_update(telegram->read_value(hc->controlmode, 33)); // 0-outdoortemp, 1-roomtemp has_update(telegram->read_value(hc->tempautotemp, 37)); - has_update(telegram->read_value(hc->noreducetemp, 38)); // outdoor temperature for no reduce + has_update(telegram->read_value(hc->noreducetemp, 38)); // outdoor temperature for no reduce has_update(telegram->read_value(hc->minflowtemp, 16)); if (hc->heatingtype == 3) { has_update(telegram->read_value(hc->designtemp, 36)); // is * 1 @@ -1970,7 +1971,10 @@ bool Thermostat::set_temperature(const float temperature, const uint8_t mode, co // if we know what to send and to where, go and do it if (offset != -1) { char s[10]; - LOG_INFO(F("Setting thermostat temperature to %s for heating circuit %d, mode %s"), Helpers::render_value(s, temperature, 2), hc->hc_num(), mode_tostring(mode).c_str()); + LOG_INFO(F("Setting thermostat temperature to %s for heating circuit %d, mode %s"), + Helpers::render_value(s, temperature, 2), + hc->hc_num(), + mode_tostring(mode).c_str()); // add the write command to the Tx queue. value is *2 // post validate is the corresponding monitor or set type IDs as they can differ per model @@ -2084,11 +2088,19 @@ void Thermostat::register_device_values() { register_device_value(TAG_THERMOSTAT_DATA, &floordrystatus_, DeviceValueType::ENUM, FL_(enum_floordrystatus), FL_(floordrystatus), DeviceValueUOM::NONE); register_device_value(TAG_THERMOSTAT_DATA, &dampedoutdoortemp2_, DeviceValueType::SHORT, FL_(div10), FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES); register_device_value(TAG_THERMOSTAT_DATA, &floordrytemp_, DeviceValueType::UINT, nullptr, FL_(floordrytemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType), FL_(ibaBuildingType), DeviceValueUOM::NONE, MAKE_CF_CB(set_building)); + register_device_value(TAG_THERMOSTAT_DATA, + &ibaBuildingType_, + DeviceValueType::ENUM, + FL_(enum_ibaBuildingType), + FL_(ibaBuildingType), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_building)); register_device_value(TAG_DEVICE_DATA_WW, &wwSetTemp_, DeviceValueType::UINT, nullptr, FL_(wwSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemp)); register_device_value(TAG_DEVICE_DATA_WW, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode)); - register_device_value(TAG_DEVICE_DATA_WW, &wwSetTempLow_, DeviceValueType::UINT, nullptr, FL_(wwSetTempLow), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemplow)); - register_device_value(TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode)); + register_device_value( + TAG_DEVICE_DATA_WW, &wwSetTempLow_, DeviceValueType::UINT, nullptr, FL_(wwSetTempLow), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemplow)); + register_device_value( + TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode)); register_device_value(TAG_DEVICE_DATA_WW, &wwExtra1_, DeviceValueType::UINT, nullptr, FL_(wwExtra1), DeviceValueUOM::DEGREES); register_device_value(TAG_DEVICE_DATA_WW, &wwExtra2_, DeviceValueType::UINT, nullptr, FL_(wwExtra2), DeviceValueUOM::DEGREES); break; @@ -2100,24 +2112,67 @@ void Thermostat::register_device_values() { register_device_value(TAG_THERMOSTAT_DATA, &dateTime_, DeviceValueType::TEXT, nullptr, FL_(dateTime), DeviceValueUOM::NONE); // can't set datetime register_device_value(TAG_THERMOSTAT_DATA, &ibaMainDisplay_, DeviceValueType::ENUM, FL_(enum_ibaMainDisplay), FL_(ibaMainDisplay), DeviceValueUOM::NONE); register_device_value(TAG_THERMOSTAT_DATA, &ibaLanguage_, DeviceValueType::ENUM, FL_(enum_ibaLanguage), FL_(ibaLanguage), DeviceValueUOM::NONE); - register_device_value(TAG_THERMOSTAT_DATA, &ibaClockOffset_, DeviceValueType::UINT, nullptr, FL_(ibaClockOffset), DeviceValueUOM::NONE); // offset (in sec) to clock, 0xff=-1s, 0x02=2s - register_device_value(TAG_THERMOSTAT_DATA, &ibaCalIntTemperature_, DeviceValueType::INT, FL_(div2), FL_(ibaCalIntTemperature), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_calinttemp)); - register_device_value(TAG_THERMOSTAT_DATA, &ibaMinExtTemperature_, DeviceValueType::INT, nullptr, FL_(ibaMinExtTemperature), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minexttemp)); + register_device_value(TAG_THERMOSTAT_DATA, + &ibaClockOffset_, + DeviceValueType::UINT, + nullptr, + FL_(ibaClockOffset), + DeviceValueUOM::NONE); // offset (in sec) to clock, 0xff=-1s, 0x02=2s + register_device_value(TAG_THERMOSTAT_DATA, + &ibaCalIntTemperature_, + DeviceValueType::INT, + FL_(div2), + FL_(ibaCalIntTemperature), + DeviceValueUOM::DEGREES, + MAKE_CF_CB(set_calinttemp)); + register_device_value(TAG_THERMOSTAT_DATA, + &ibaMinExtTemperature_, + DeviceValueType::INT, + nullptr, + FL_(ibaMinExtTemperature), + DeviceValueUOM::DEGREES, + MAKE_CF_CB(set_minexttemp)); register_device_value(TAG_THERMOSTAT_DATA, &dampedoutdoortemp_, DeviceValueType::INT, nullptr, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType2), FL_(ibaBuildingType), DeviceValueUOM::NONE, MAKE_CF_CB(set_building)); + register_device_value(TAG_THERMOSTAT_DATA, + &ibaBuildingType_, + DeviceValueType::ENUM, + FL_(enum_ibaBuildingType2), + FL_(ibaBuildingType), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_building)); register_device_value(TAG_DEVICE_DATA_WW, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode2), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode)); - register_device_value(TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode)); + register_device_value( + TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode)); break; case EMS_DEVICE_FLAG_RC35: register_device_value(TAG_THERMOSTAT_DATA, &dateTime_, DeviceValueType::TEXT, nullptr, FL_(dateTime), DeviceValueUOM::NONE, MAKE_CF_CB(set_datetime)); - register_device_value(TAG_THERMOSTAT_DATA, &ibaCalIntTemperature_, DeviceValueType::INT, FL_(div2), FL_(ibaCalIntTemperature), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_calinttemp)); - register_device_value(TAG_THERMOSTAT_DATA, &ibaMinExtTemperature_, DeviceValueType::INT, nullptr, FL_(ibaMinExtTemperature), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minexttemp)); + register_device_value(TAG_THERMOSTAT_DATA, + &ibaCalIntTemperature_, + DeviceValueType::INT, + FL_(div2), + FL_(ibaCalIntTemperature), + DeviceValueUOM::DEGREES, + MAKE_CF_CB(set_calinttemp)); + register_device_value(TAG_THERMOSTAT_DATA, + &ibaMinExtTemperature_, + DeviceValueType::INT, + nullptr, + FL_(ibaMinExtTemperature), + DeviceValueUOM::DEGREES, + MAKE_CF_CB(set_minexttemp)); register_device_value(TAG_THERMOSTAT_DATA, &tempsensor1_, DeviceValueType::USHORT, FL_(div10), FL_(tempsensor1), DeviceValueUOM::DEGREES); register_device_value(TAG_THERMOSTAT_DATA, &tempsensor2_, DeviceValueType::USHORT, FL_(div10), FL_(tempsensor2), DeviceValueUOM::DEGREES); register_device_value(TAG_THERMOSTAT_DATA, &dampedoutdoortemp_, DeviceValueType::INT, nullptr, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType2), FL_(ibaBuildingType), DeviceValueUOM::NONE, MAKE_CF_CB(set_building)); + register_device_value(TAG_THERMOSTAT_DATA, + &ibaBuildingType_, + DeviceValueType::ENUM, + FL_(enum_ibaBuildingType2), + FL_(ibaBuildingType), + DeviceValueUOM::NONE, + MAKE_CF_CB(set_building)); register_device_value(TAG_DEVICE_DATA_WW, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode2), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode)); - register_device_value(TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode)); + register_device_value( + TAG_DEVICE_DATA_WW, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcircmode)); break; case EMS_DEVICE_FLAG_JUNKERS: register_device_value(TAG_THERMOSTAT_DATA, &dateTime_, DeviceValueType::TEXT, nullptr, FL_(dateTime), DeviceValueUOM::NONE, MAKE_CF_CB(set_datetime)); @@ -2128,7 +2183,7 @@ void Thermostat::register_device_values() { } // registers the values for a heating circuit -void Thermostat::register_device_values_hc(std::shared_ptr hc) { +void Thermostat::register_device_values_hc(std::shared_ptr hc) { uint8_t model = hc->get_model(); // heating circuit @@ -2151,8 +2206,17 @@ void Thermostat::register_device_values_hc(std::shared_ptrsetpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(setpoint_roomTemp), DeviceValueUOM::DEGREES); } else { - register_device_value(tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(setpoint_roomTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_temp), 5, 29); - register_device_value(tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(temp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_temp), 5, 29); + register_device_value(tag, + &hc->setpoint_roomTemp, + DeviceValueType::SHORT, + setpoint_temp_divider, + FL_(setpoint_roomTemp), + DeviceValueUOM::DEGREES, + MAKE_CF_CB(set_temp), + 5, + 29); + register_device_value( + tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(temp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_temp), 5, 29); } register_device_value(tag, &hc->curr_roomTemp, DeviceValueType::SHORT, curr_temp_divider, FL_(curr_roomTemp), DeviceValueUOM::DEGREES); @@ -2195,9 +2259,11 @@ void Thermostat::register_device_values_hc(std::shared_ptrnofrosttemp, DeviceValueType::INT, nullptr, FL_(nofrosttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nofrosttemp)); register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT, nullptr, FL_(targetflowtemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE); - register_device_value(tag, &hc->summer_setmode, DeviceValueType::ENUM, FL_(enum_summermode), FL_(summermode), DeviceValueUOM::NONE, MAKE_CF_CB(set_summermode)); + register_device_value( + tag, &hc->summer_setmode, DeviceValueType::ENUM, FL_(enum_summermode), FL_(summermode), DeviceValueUOM::NONE, MAKE_CF_CB(set_summermode)); register_device_value(tag, &hc->summermode, DeviceValueType::BOOL, nullptr, FL_(summermode), DeviceValueUOM::NONE); - register_device_value(tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode)); + register_device_value( + tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode)); register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program)); register_device_value(tag, &hc->tempautotemp, DeviceValueType::UINT, FL_(div2), FL_(tempautotemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_tempautotemp)); break; @@ -2231,7 +2297,8 @@ void Thermostat::register_device_values_hc(std::shared_ptrflowtempoffset, DeviceValueType::UINT, nullptr, FL_(flowtempoffset), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flowtempoffset)); register_device_value(tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE); register_device_value(tag, &hc->reducemode, DeviceValueType::ENUM, FL_(enum_reducemode), FL_(reducemode), DeviceValueUOM::NONE, MAKE_CF_CB(set_reducemode)); - register_device_value(tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode2), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode)); + register_device_value( + tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode2), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode)); register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control), FL_(control), DeviceValueUOM::NONE, MAKE_CF_CB(set_control)); register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program)); register_device_value(tag, &hc->pause, DeviceValueType::UINT, nullptr, FL_(pause), DeviceValueUOM::HOURS, MAKE_CF_CB(set_pause)); diff --git a/src/devices/thermostat.h b/src/devices/thermostat.h index c8ef0bd0b..b3059decf 100644 --- a/src/devices/thermostat.h +++ b/src/devices/thermostat.h @@ -147,7 +147,7 @@ class Thermostat : public EMSdevice { char dummychar_[5]; // for commands with no output // Installation parameters - uint8_t ibaMainDisplay_; // display on Thermostat: 0 int temp, 1 int setpoint, 2 ext temp, 3 burner temp, 4 ww temp, 5 functioning mode, 6 time, 7 data, 9 smoke temp + uint8_t ibaMainDisplay_; // display on Thermostat: 0 int temp, 1 int setpoint, 2 ext temp, 3 burner temp, 4 ww temp, 5 functioning mode, 6 time, 7 data, 9 smoke temp uint8_t ibaLanguage_; // language on Thermostat: 0 german, 1 dutch, 2 french, 3 italian int8_t ibaCalIntTemperature_; // offset int. temperature sensor, by * 0.1 Kelvin (-5.0 to 5.0K) int8_t ibaMinExtTemperature_; // min ext temp for heating curve, in deg., 0xF6=-10, 0x0 = 0, 0xFF=-1 @@ -254,7 +254,7 @@ class Thermostat : public EMSdevice { std::shared_ptr heating_circuit(const uint8_t hc_num); void register_mqtt_ha_config_hc(uint8_t hc_num); - void register_device_values_hc(std::shared_ptr hc); + 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 40b0bd627..eb7f1fa9b 100644 --- a/src/emsdevice.cpp +++ b/src/emsdevice.cpp @@ -298,7 +298,14 @@ std::string EMSdevice::to_string() const { if (brand_ == Brand::NO_BRAND) { snprintf_P(&str[0], str.capacity() + 1, PSTR("%s (DeviceID:0x%02X, ProductID:%d, Version:%s)"), name_.c_str(), device_id_, product_id_, version_.c_str()); } else { - snprintf_P(&str[0], str.capacity() + 1, PSTR("%s %s (DeviceID:0x%02X ProductID:%d, Version:%s)"), brand_to_string().c_str(), name_.c_str(), device_id_, product_id_, version_.c_str()); + snprintf_P(&str[0], + str.capacity() + 1, + PSTR("%s %s (DeviceID:0x%02X ProductID:%d, Version:%s)"), + brand_to_string().c_str(), + name_.c_str(), + device_id_, + product_id_, + version_.c_str()); } return str; @@ -470,7 +477,15 @@ void EMSdevice::register_device_value(uint8_t tag, devicevalues_.emplace_back(device_type_, tag, value_p, type, options, options_size, short_name, full_name, uom, 0, has_cmd, min, max); } -void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, cmdfunction_p f, int32_t min, uint32_t max) { +void EMSdevice::register_device_value(uint8_t tag, + void * value_p, + uint8_t type, + const __FlashStringHelper * const * options, + const __FlashStringHelper * const * name, + uint8_t uom, + cmdfunction_p f, + int32_t min, + uint32_t max) { register_device_value(tag, value_p, type, options, name[0], name[1], uom, (f != nullptr), min, max); if (f != nullptr) { if (tag >= TAG_HC1 && tag <= TAG_HC4) { @@ -481,7 +496,13 @@ void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, } } -void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, cmdfunction_p f) { +void EMSdevice::register_device_value(uint8_t tag, + void * value_p, + uint8_t type, + const __FlashStringHelper * const * options, + const __FlashStringHelper * const * name, + uint8_t uom, + cmdfunction_p f) { register_device_value(tag, value_p, type, options, name, uom, f, 0, 0); } @@ -489,7 +510,12 @@ void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, // register_device_value(tag, value_p, type, options, name, uom, nullptr, min, max); // } -void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom) { +void EMSdevice::register_device_value(uint8_t tag, + void * value_p, + uint8_t type, + const __FlashStringHelper * const * options, + const __FlashStringHelper * const * name, + uint8_t uom) { register_device_value(tag, value_p, type, options, name, uom, nullptr, 0, 0); } @@ -657,7 +683,7 @@ bool EMSdevice::get_value_info(JsonObject & root, const char * cmd, const int8_t const char * max = "max"; const char * value = "value"; - json["name"] = dv.short_name; + json["name"] = dv.short_name; if (!tag_to_mqtt(dv.tag).empty()) { json["circuit"] = tag_to_mqtt(dv.tag); } @@ -811,7 +837,8 @@ bool EMSdevice::generate_values_json(JsonObject & root, const uint8_t tag_filter // only show if tag is either empty (TAG_NONE) or matches a value // and don't show if full_name is empty unless we're outputing for mqtt payloads // for nested we use all values, dont show command only (have_cmd and no fulname) - if (((nested) || tag_filter == DeviceValueTAG::TAG_NONE || (tag_filter == dv.tag)) && (dv.full_name != nullptr || !console) && !(dv.full_name == nullptr && dv.has_cmd)) { + if (((nested) || tag_filter == DeviceValueTAG::TAG_NONE || (tag_filter == dv.tag)) && (dv.full_name != nullptr || !console) + && !(dv.full_name == nullptr && dv.has_cmd)) { // we have a tag if it matches the filter given, and that the tag name is not empty/"" bool have_tag = ((dv.tag != tag_filter) && !tag_to_string(dv.tag).empty()); diff --git a/src/emsdevice.h b/src/emsdevice.h index 06d54d7fd..06ffc2c80 100644 --- a/src/emsdevice.h +++ b/src/emsdevice.h @@ -232,9 +232,28 @@ class EMSdevice { bool has_cmd, int32_t min, uint32_t max); - void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, cmdfunction_p f, int32_t min, uint32_t max); - void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, cmdfunction_p f); - void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom); + void register_device_value(uint8_t tag, + void * value_p, + uint8_t type, + const __FlashStringHelper * const * options, + const __FlashStringHelper * const * name, + uint8_t uom, + cmdfunction_p f, + int32_t min, + uint32_t max); + void register_device_value(uint8_t tag, + void * value_p, + uint8_t type, + const __FlashStringHelper * const * options, + const __FlashStringHelper * const * name, + uint8_t uom, + cmdfunction_p f); + void register_device_value(uint8_t tag, + void * value_p, + uint8_t type, + const __FlashStringHelper * const * options, + const __FlashStringHelper * const * name, + uint8_t uom); // void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, int32_t min, uint32_t max); void write_command(const uint16_t type_id, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validate_typeid); diff --git a/src/emsesp.h b/src/emsesp.h index b49872c4d..6d1e4ac05 100644 --- a/src/emsesp.h +++ b/src/emsesp.h @@ -93,7 +93,12 @@ class EMSESP { static std::string pretty_telegram(std::shared_ptr telegram); static void send_read_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset = 0, const uint8_t length = 0); - static void send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validate_typeid); + static void send_write_request(const uint16_t type_id, + const uint8_t dest, + const uint8_t offset, + uint8_t * message_data, + const uint8_t message_length, + const uint16_t validate_typeid); static void send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, const uint8_t value); static void send_write_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset, const uint8_t value, const uint16_t validate_typeid); diff --git a/src/helpers.cpp b/src/helpers.cpp index 24dc075bc..1474fe9a3 100644 --- a/src/helpers.cpp +++ b/src/helpers.cpp @@ -478,7 +478,8 @@ bool Helpers::value2enum(const char * v, uint8_t & value, const __FlashStringHel std::string str = toLower(v); for (value = 0; strs[value]; value++) { std::string str1 = toLower(uuid::read_flash_string(strs[value])); - if ((str1 == uuid::read_flash_string(F_(off)) && str == "false") || (str1 == uuid::read_flash_string(F_(on)) && str == "true") || (str == str1) || (v[0] == ('0' + value) && v[1] == '\0')) { + if ((str1 == uuid::read_flash_string(F_(off)) && str == "false") || (str1 == uuid::read_flash_string(F_(on)) && str == "true") || (str == str1) + || (v[0] == ('0' + value) && v[1] == '\0')) { return true; } } diff --git a/src/locale_EN.h b/src/locale_EN.h index 7b6a36eda..f6ec5713e 100644 --- a/src/locale_EN.h +++ b/src/locale_EN.h @@ -283,7 +283,16 @@ MAKE_PSTR(functioning_mode, "functioning mode") MAKE_PSTR(smoke_temperature, "smoke temperature") // thermostat lists -MAKE_PSTR_LIST(enum_ibaMainDisplay, F_(internal_temperature), F_(internal_setpoint), F_(external_temperature), F_(burner_temperature), F_(ww_temperature), F_(functioning_mode), F_(time), F_(date), F_(smoke_temperature)) +MAKE_PSTR_LIST(enum_ibaMainDisplay, + F_(internal_temperature), + F_(internal_setpoint), + F_(external_temperature), + F_(burner_temperature), + F_(ww_temperature), + F_(functioning_mode), + F_(time), + F_(date), + F_(smoke_temperature)) MAKE_PSTR_LIST(enum_ibaLanguage, F_(german), F_(dutch), F_(french), F_(italian)) MAKE_PSTR_LIST(enum_floordrystatus, F_(off), F_(start), F_(heat), F_(hold), F_(cool), F_(end)) MAKE_PSTR_LIST(enum_ibaBuildingType, F_(blank), F_(light), F_(medium), F_(heavy)) // RC300 diff --git a/src/mqtt.cpp b/src/mqtt.cpp index b701929b1..3b0df514e 100644 --- a/src/mqtt.cpp +++ b/src/mqtt.cpp @@ -228,12 +228,27 @@ void Mqtt::show_mqtt(uuid::console::Shell & shell) { } for (const auto & cf : Command::commands()) { if (subscribe_format_ == 2 && cf.flag_ == MqttSubFlag::FLAG_HC) { - shell.printfln(F(" %s/%s/hc1/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str()); - shell.printfln(F(" %s/%s/hc2/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str()); - shell.printfln(F(" %s/%s/hc3/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str()); - shell.printfln(F(" %s/%s/hc4/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str()); + shell.printfln(F(" %s/%s/hc1/%s"), + mqtt_base_.c_str(), + EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), + uuid::read_flash_string(cf.cmd_).c_str()); + shell.printfln(F(" %s/%s/hc2/%s"), + mqtt_base_.c_str(), + EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), + uuid::read_flash_string(cf.cmd_).c_str()); + shell.printfln(F(" %s/%s/hc3/%s"), + mqtt_base_.c_str(), + EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), + uuid::read_flash_string(cf.cmd_).c_str()); + shell.printfln(F(" %s/%s/hc4/%s"), + mqtt_base_.c_str(), + EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), + uuid::read_flash_string(cf.cmd_).c_str()); } else if (subscribe_format_ && cf.flag_ != MqttSubFlag::FLAG_NOSUB) { - shell.printfln(F(" %s/%s/%s"), mqtt_base_.c_str(), EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), uuid::read_flash_string(cf.cmd_).c_str()); + shell.printfln(F(" %s/%s/%s"), + mqtt_base_.c_str(), + EMSdevice::device_type_2_device_name(cf.device_type_).c_str(), + uuid::read_flash_string(cf.cmd_).c_str()); } } shell.println(); @@ -265,7 +280,12 @@ void Mqtt::show_mqtt(uuid::console::Shell & shell) { shell.printfln(F(" [%02d] (Pub) topic=%s payload=%s (pid %d)"), message.id_, topic, content->payload.c_str(), message.packet_id_); } } else { - shell.printfln(F(" [%02d] (Pub) topic=%s payload=%s (pid %d, retry #%d)"), message.id_, topic, content->payload.c_str(), message.packet_id_, message.retry_count_); + shell.printfln(F(" [%02d] (Pub) topic=%s payload=%s (pid %d, retry #%d)"), + message.id_, + topic, + content->payload.c_str(), + message.packet_id_, + message.retry_count_); } } else { // Subscribe messages @@ -400,7 +420,10 @@ void Mqtt::on_message(const char * fulltopic, const char * payload, size_t len) // print all the topics related to a specific device type void Mqtt::show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_type) { - if (std::count_if(mqtt_subfunctions_.cbegin(), mqtt_subfunctions_.cend(), [=](MQTTSubFunction const & mqtt_subfunction) { return device_type == mqtt_subfunction.device_type_; }) == 0) { + if (std::count_if(mqtt_subfunctions_.cbegin(), + mqtt_subfunctions_.cend(), + [=](MQTTSubFunction const & mqtt_subfunction) { return device_type == mqtt_subfunction.device_type_; }) + == 0) { return; } @@ -851,7 +874,13 @@ void Mqtt::process_queue() { // else try and publish it uint16_t packet_id = mqttClient_->publish(topic, mqtt_qos_, message->retain, message->payload.c_str(), message->payload.size(), false, mqtt_message.id_); - LOG_DEBUG(F("Publishing topic %s (#%02d, retain=%d, try#%d, size %d, pid %d)"), topic, mqtt_message.id_, message->retain, mqtt_message.retry_count_ + 1, message->payload.size(), packet_id); + LOG_DEBUG(F("Publishing topic %s (#%02d, retain=%d, try#%d, size %d, pid %d)"), + topic, + mqtt_message.id_, + message->retain, + mqtt_message.retry_count_ + 1, + message->payload.size(), + packet_id); if (packet_id == 0) { // it failed. if we retried n times, give up. remove from queue diff --git a/src/mqtt.h b/src/mqtt.h index c45aded12..fde421eab 100644 --- a/src/mqtt.h +++ b/src/mqtt.h @@ -106,7 +106,12 @@ class Mqtt { static void publish_ha(const std::string & topic, const JsonObject & payload); static void publish_ha(const __FlashStringHelper * topic, const JsonObject & payload); - static void publish_mqtt_ha_sensor(uint8_t type, uint8_t tag, const __FlashStringHelper * name, const uint8_t device_type, const __FlashStringHelper * entity, const uint8_t uom = 0); + static void publish_mqtt_ha_sensor(uint8_t type, + uint8_t tag, + const __FlashStringHelper * name, + const uint8_t device_type, + const __FlashStringHelper * entity, + const uint8_t uom = 0); static void register_command(const uint8_t device_type, const __FlashStringHelper * cmd, cmdfunction_p cb, uint8_t tag = 0); static void show_topic_handlers(uuid::console::Shell & shell, const uint8_t device_type); diff --git a/src/system.cpp b/src/system.cpp index c0ea30677..8a6aa203b 100644 --- a/src/system.cpp +++ b/src/system.cpp @@ -860,7 +860,6 @@ bool System::command_settings(const char * value, const int8_t id, JsonObject & // export status information including some basic settings // e.g. http://ems-esp/api?device=system&cmd=info bool System::command_info(const char * value, const int8_t id, JsonObject & json) { - if (id == 0) { return EMSESP::system_.heartbeat_json(json); } diff --git a/src/telegram.cpp b/src/telegram.cpp index 113cbdfd0..97e61284e 100644 --- a/src/telegram.cpp +++ b/src/telegram.cpp @@ -22,15 +22,19 @@ namespace emsesp { // CRC lookup table with poly 12 for faster checking -const uint8_t ems_crc_table[] = {0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2A, 0x2C, 0x2E, 0x30, 0x32, 0x34, 0x36, 0x38, - 0x3A, 0x3C, 0x3E, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4A, 0x4C, 0x4E, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5A, 0x5C, 0x5E, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6A, 0x6C, 0x6E, 0x70, 0x72, - 0x74, 0x76, 0x78, 0x7A, 0x7C, 0x7E, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8A, 0x8C, 0x8E, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E, 0xA0, 0xA2, 0xA4, 0xA6, 0xA8, 0xAA, 0xAC, - 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC, 0xBE, 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE, 0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE, 0xE0, 0xE2, 0xE4, 0xE6, - 0xE8, 0xEA, 0xEC, 0xEE, 0xF0, 0xF2, 0xF4, 0xF6, 0xF8, 0xFA, 0xFC, 0xFE, 0x19, 0x1B, 0x1D, 0x1F, 0x11, 0x13, 0x15, 0x17, 0x09, 0x0B, 0x0D, 0x0F, 0x01, 0x03, 0x05, 0x07, 0x39, - 0x3B, 0x3D, 0x3F, 0x31, 0x33, 0x35, 0x37, 0x29, 0x2B, 0x2D, 0x2F, 0x21, 0x23, 0x25, 0x27, 0x59, 0x5B, 0x5D, 0x5F, 0x51, 0x53, 0x55, 0x57, 0x49, 0x4B, 0x4D, 0x4F, 0x41, 0x43, - 0x45, 0x47, 0x79, 0x7B, 0x7D, 0x7F, 0x71, 0x73, 0x75, 0x77, 0x69, 0x6B, 0x6D, 0x6F, 0x61, 0x63, 0x65, 0x67, 0x99, 0x9B, 0x9D, 0x9F, 0x91, 0x93, 0x95, 0x97, 0x89, 0x8B, 0x8D, - 0x8F, 0x81, 0x83, 0x85, 0x87, 0xB9, 0xBB, 0xBD, 0xBF, 0xB1, 0xB3, 0xB5, 0xB7, 0xA9, 0xAB, 0xAD, 0xAF, 0xA1, 0xA3, 0xA5, 0xA7, 0xD9, 0xDB, 0xDD, 0xDF, 0xD1, 0xD3, 0xD5, 0xD7, - 0xC9, 0xCB, 0xCD, 0xCF, 0xC1, 0xC3, 0xC5, 0xC7, 0xF9, 0xFB, 0xFD, 0xFF, 0xF1, 0xF3, 0xF5, 0xF7, 0xE9, 0xEB, 0xED, 0xEF, 0xE1, 0xE3, 0xE5, 0xE7}; +const uint8_t ems_crc_table[] = {0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24, 0x26, + 0x28, 0x2A, 0x2C, 0x2E, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, 0x3E, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4A, 0x4C, 0x4E, + 0x50, 0x52, 0x54, 0x56, 0x58, 0x5A, 0x5C, 0x5E, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6A, 0x6C, 0x6E, 0x70, 0x72, 0x74, 0x76, + 0x78, 0x7A, 0x7C, 0x7E, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8A, 0x8C, 0x8E, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E, + 0xA0, 0xA2, 0xA4, 0xA6, 0xA8, 0xAA, 0xAC, 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC, 0xBE, 0xC0, 0xC2, 0xC4, 0xC6, + 0xC8, 0xCA, 0xCC, 0xCE, 0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE, 0xE0, 0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE, + 0xF0, 0xF2, 0xF4, 0xF6, 0xF8, 0xFA, 0xFC, 0xFE, 0x19, 0x1B, 0x1D, 0x1F, 0x11, 0x13, 0x15, 0x17, 0x09, 0x0B, 0x0D, 0x0F, + 0x01, 0x03, 0x05, 0x07, 0x39, 0x3B, 0x3D, 0x3F, 0x31, 0x33, 0x35, 0x37, 0x29, 0x2B, 0x2D, 0x2F, 0x21, 0x23, 0x25, 0x27, + 0x59, 0x5B, 0x5D, 0x5F, 0x51, 0x53, 0x55, 0x57, 0x49, 0x4B, 0x4D, 0x4F, 0x41, 0x43, 0x45, 0x47, 0x79, 0x7B, 0x7D, 0x7F, + 0x71, 0x73, 0x75, 0x77, 0x69, 0x6B, 0x6D, 0x6F, 0x61, 0x63, 0x65, 0x67, 0x99, 0x9B, 0x9D, 0x9F, 0x91, 0x93, 0x95, 0x97, + 0x89, 0x8B, 0x8D, 0x8F, 0x81, 0x83, 0x85, 0x87, 0xB9, 0xBB, 0xBD, 0xBF, 0xB1, 0xB3, 0xB5, 0xB7, 0xA9, 0xAB, 0xAD, 0xAF, + 0xA1, 0xA3, 0xA5, 0xA7, 0xD9, 0xDB, 0xDD, 0xDF, 0xD1, 0xD3, 0xD5, 0xD7, 0xC9, 0xCB, 0xCD, 0xCF, 0xC1, 0xC3, 0xC5, 0xC7, + 0xF9, 0xFB, 0xFD, 0xFF, 0xF1, 0xF3, 0xF5, 0xF7, 0xE9, 0xEB, 0xED, 0xEF, 0xE1, 0xE3, 0xE5, 0xE7}; uint32_t EMSbus::last_bus_activity_ = 0; // timestamp of last time a valid Rx came in bool EMSbus::bus_connected_ = false; // start assuming the bus hasn't been connected @@ -55,7 +59,13 @@ uint8_t EMSbus::calculate_crc(const uint8_t * data, const uint8_t length) { // creates a telegram object // stores header in separate member objects and the rest in the message_data block -Telegram::Telegram(const uint8_t operation, const uint8_t src, const uint8_t dest, const uint16_t type_id, const uint8_t offset, const uint8_t * data, const uint8_t message_length) +Telegram::Telegram(const uint8_t operation, + const uint8_t src, + const uint8_t dest, + const uint16_t type_id, + const uint8_t offset, + const uint8_t * data, + const uint8_t message_length) : operation(operation) , src(src) , dest(dest) @@ -192,7 +202,8 @@ void RxService::add(uint8_t * data, uint8_t length) { // if we're watching and "raw" print out actual telegram as bytes to the console if (EMSESP::watch() == EMSESP::Watch::WATCH_RAW) { uint16_t trace_watch_id = EMSESP::watch_id(); - if ((trace_watch_id == WATCH_ID_NONE) || (type_id == trace_watch_id) || ((trace_watch_id < 0x80) && ((src == trace_watch_id) || (dest == trace_watch_id)))) { + if ((trace_watch_id == WATCH_ID_NONE) || (type_id == trace_watch_id) + || ((trace_watch_id < 0x80) && ((src == trace_watch_id) || (dest == trace_watch_id)))) { LOG_NOTICE(F("Rx: %s"), Helpers::data_to_hex(data, length).c_str()); } else if (EMSESP::trace_raw()) { LOG_TRACE(F("Rx: %s"), Helpers::data_to_hex(data, length).c_str()); @@ -349,7 +360,10 @@ void TxService::send_telegram(const QueuedTxTelegram & tx_telegram) { length++; // add one since we want to now include the CRC - LOG_DEBUG(F("Sending %s Tx [#%d], telegram: %s"), (telegram->operation == Telegram::Operation::TX_WRITE) ? F("write") : F("read"), tx_telegram.id_, Helpers::data_to_hex(telegram_raw, length).c_str()); + LOG_DEBUG(F("Sending %s Tx [#%d], telegram: %s"), + (telegram->operation == Telegram::Operation::TX_WRITE) ? F("write") : F("read"), + tx_telegram.id_, + Helpers::data_to_hex(telegram_raw, length).c_str()); set_post_send_query(tx_telegram.validateid_); // send the telegram to the UART Tx @@ -389,7 +403,14 @@ void TxService::send_telegram(const uint8_t * data, const uint8_t length) { } */ -void TxService::add(const uint8_t operation, const uint8_t dest, const uint16_t type_id, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validateid, const bool front) { +void TxService::add(const uint8_t operation, + const uint8_t dest, + const uint16_t type_id, + const uint8_t offset, + uint8_t * message_data, + const uint8_t message_length, + const uint16_t validateid, + const bool front) { auto telegram = std::make_shared(operation, ems_bus_id(), dest, type_id, offset, message_data, message_length); #ifdef EMSESP_DEBUG @@ -546,7 +567,9 @@ void TxService::retry_tx(const uint8_t operation, const uint8_t * data, const ui reset_retry_count(); // give up increment_telegram_fail_count(); // another Tx fail - LOG_ERROR(F("Last Tx %s operation failed after %d retries. Ignoring request."), (operation == Telegram::Operation::TX_WRITE) ? F("Write") : F("Read"), MAXIMUM_TX_RETRIES); + LOG_ERROR(F("Last Tx %s operation failed after %d retries. Ignoring request."), + (operation == Telegram::Operation::TX_WRITE) ? F("Write") : F("Read"), + MAXIMUM_TX_RETRIES); return; } diff --git a/src/telegram.h b/src/telegram.h index b10f52a2e..7891a1090 100644 --- a/src/telegram.h +++ b/src/telegram.h @@ -55,7 +55,13 @@ namespace emsesp { class Telegram { public: - Telegram(const uint8_t operation, const uint8_t src, const uint8_t dest, const uint16_t type_id, const uint8_t offset, const uint8_t * message_data, const uint8_t message_length); + Telegram(const uint8_t operation, + const uint8_t src, + const uint8_t dest, + const uint16_t type_id, + const uint8_t offset, + const uint8_t * message_data, + const uint8_t message_length); ~Telegram() = default; const uint8_t operation; // is Operation mode @@ -262,7 +268,14 @@ class TxService : public EMSbus { void start(); void send(); - void add(const uint8_t operation, const uint8_t dest, const uint16_t type_id, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validateid, const bool front = false); + void add(const uint8_t operation, + const uint8_t dest, + const uint16_t type_id, + const uint8_t offset, + uint8_t * message_data, + const uint8_t message_length, + const uint16_t validateid, + const bool front = false); void add(const uint8_t operation, const uint8_t * data, const uint8_t length, const uint16_t validateid, const bool front = false); void read_request(const uint16_t type_id, const uint8_t dest, const uint8_t offset = 0, const uint8_t length = 0); void send_raw(const char * telegram_data); diff --git a/src/uart/emsuart_esp32.cpp b/src/uart/emsuart_esp32.cpp index 63cc8a9fa..df80308d9 100644 --- a/src/uart/emsuart_esp32.cpp +++ b/src/uart/emsuart_esp32.cpp @@ -102,10 +102,10 @@ void EMSuart::start(const uint8_t tx_mode, const uint8_t rx_gpio, const uint8_t uart_param_config(EMSUART_UART, &uart_config); uart_set_pin(EMSUART_UART, tx_gpio, rx_gpio, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); - EMS_UART.int_ena.val = 0; // disable all intr. - EMS_UART.int_clr.val = 0xFFFFFFFF; // clear all intr. flags - EMS_UART.idle_conf.tx_brk_num = 10; // breaklength 10 bit - drop_next_rx_ = true; + EMS_UART.int_ena.val = 0; // disable all intr. + EMS_UART.int_clr.val = 0xFFFFFFFF; // clear all intr. flags + EMS_UART.idle_conf.tx_brk_num = 10; // breaklength 10 bit + drop_next_rx_ = true; // EMS_UART.idle_conf.rx_idle_thrhd = 256; // EMS_UART.auto_baud.glitch_filt = 192; #if (EMSUART_UART != UART_NUM_2) @@ -140,7 +140,6 @@ void EMSuart::restart() { EMS_UART.int_ena.brk_det = 1; // activate only break EMS_UART.conf0.txd_brk = (tx_mode_ == EMS_TXMODE_HW) ? 1 : 0; portEXIT_CRITICAL(&mux_); - } /*