From f0ba8873caff4f00af8a8f79dc3d8e9d1d811afb Mon Sep 17 00:00:00 2001 From: j0ta29 Date: Sat, 26 Aug 2023 18:48:37 +0000 Subject: [PATCH] first working rework for text_sendor mode DAY_SCHEDULE_SYNCHRONIZED --- esphome/components/optolink/__init__.py | 1 - .../binary_sensor/optolink_binary_sensor.h | 6 +- .../optolink/number/optolink_number.cpp | 8 +- .../optolink/number/optolink_number.h | 7 +- esphome/components/optolink/optolink.cpp | 10 +- .../optolink/optolink_sensor_base.cpp | 269 +++++++++++------- .../optolink/optolink_sensor_base.h | 38 ++- .../optolink/select/optolink_select.cpp | 43 ++- .../optolink/select/optolink_select.h | 8 +- .../optolink/sensor/optolink_sensor.h | 7 +- .../optolink/switch/optolink_switch.cpp | 8 +- .../optolink/switch/optolink_switch.h | 6 +- .../optolink/text_sensor/__init__.py | 55 +++- .../optolink_device_info_sensor.cpp | 4 +- .../text_sensor/optolink_text_sensor.cpp | 150 ++++++++-- .../text_sensor/optolink_text_sensor.h | 12 +- 16 files changed, 429 insertions(+), 203 deletions(-) diff --git a/esphome/components/optolink/__init__.py b/esphome/components/optolink/__init__.py index d3e879868e..2b086db404 100644 --- a/esphome/components/optolink/__init__.py +++ b/esphome/components/optolink/__init__.py @@ -34,7 +34,6 @@ DeviceInfoSensor = optolink_ns.class_( "OptolinkDeviceInfoSensor", ts.TextSensor, cg.PollingComponent ) DEVICE_INFO_SENSOR_ID = "device_info_sensor_id" - CONF_OPTOLINK_ID = "optolink_id" SENSOR_BASE_SCHEMA = cv.Schema( { diff --git a/esphome/components/optolink/binary_sensor/optolink_binary_sensor.h b/esphome/components/optolink/binary_sensor/optolink_binary_sensor.h index b3565030f2..5284c37b6c 100644 --- a/esphome/components/optolink/binary_sensor/optolink_binary_sensor.h +++ b/esphome/components/optolink/binary_sensor/optolink_binary_sensor.h @@ -20,11 +20,11 @@ class OptolinkBinarySensor : public OptolinkSensorBase, } protected: - void setup() override { setup_datapoint_(); } + void setup() override { setup_datapoint(); } void update() override { optolink_->read_value(datapoint_); } - const StringRef &get_sensor_name() override { return get_name(); } - void value_changed(float state) override { publish_state(state); }; + const StringRef &get_component_name() override { return get_name(); } + void value_changed(uint8_t state) override { publish_state(state); }; }; } // namespace optolink } // namespace esphome diff --git a/esphome/components/optolink/number/optolink_number.cpp b/esphome/components/optolink/number/optolink_number.cpp index 97877a573a..676ca32b7c 100644 --- a/esphome/components/optolink/number/optolink_number.cpp +++ b/esphome/components/optolink/number/optolink_number.cpp @@ -9,11 +9,11 @@ namespace optolink { void OptolinkNumber::control(float value) { if (value > traits.get_max_value() || value < traits.get_min_value()) { - optolink_->set_error("datapoint value of number %s not in allowed range", get_sensor_name().c_str()); - ESP_LOGE("OptolinkNumber", "datapoint value of number %s not in allowed range", get_sensor_name().c_str()); + optolink_->set_error("datapoint value of number %s not in allowed range", get_component_name().c_str()); + ESP_LOGE("OptolinkNumber", "datapoint value of number %s not in allowed range", get_component_name().c_str()); } else { - ESP_LOGI("OptolinkNumber", "control of number %s to value %f", get_sensor_name().c_str(), value); - update_datapoint_(value); + ESP_LOGI("OptolinkNumber", "control of number %s to value %f", get_component_name().c_str(), value); + update_datapoint(value); publish_state(value); } }; diff --git a/esphome/components/optolink/number/optolink_number.h b/esphome/components/optolink/number/optolink_number.h index d12db821d3..097039878b 100644 --- a/esphome/components/optolink/number/optolink_number.h +++ b/esphome/components/optolink/number/optolink_number.h @@ -15,11 +15,14 @@ class OptolinkNumber : public OptolinkSensorBase, public esphome::number::Number OptolinkNumber(Optolink *optolink) : OptolinkSensorBase(optolink, true) {} protected: - void setup() override { setup_datapoint_(); } + void setup() override { setup_datapoint(); } void update() override { optolink_->read_value(datapoint_); } - const StringRef &get_sensor_name() override { return get_name(); } + const StringRef &get_component_name() override { return get_name(); } void value_changed(float state) override { publish_state(state); }; + void value_changed(uint8_t state) override { publish_state(state); }; + void value_changed(uint16_t state) override { publish_state(state); }; + void value_changed(uint32_t state) override { publish_state(state); }; void control(float value) override; }; diff --git a/esphome/components/optolink/optolink.cpp b/esphome/components/optolink/optolink.cpp index e5fe87d5d2..efe2c90b1f 100644 --- a/esphome/components/optolink/optolink.cpp +++ b/esphome/components/optolink/optolink.cpp @@ -15,10 +15,12 @@ VitoWiFiClass VitoWiFi; // this is not really a fallback but dedicated to namespace esphome { namespace optolink { +static const char *const TAG = "optolink"; + void Optolink::comm_() { - ESP_LOGD("Optolink", "enter _comm"); + ESP_LOGD(TAG, "enter _comm"); VitoWiFi.readAll(); - ESP_LOGD("Optolink", "exit _comm"); + ESP_LOGD(TAG, "exit _comm"); } void Optolink::setup() { @@ -52,7 +54,7 @@ void Optolink::set_error(const char *format, ...) { void Optolink::read_value(IDatapoint *datapoint) { if (datapoint != nullptr) { - ESP_LOGI("Optolink", " read value of datapoint %s", datapoint->getName()); + ESP_LOGI("Optolink", "requesting value of datapoint %s", datapoint->getName()); VitoWiFi.readDatapoint(*datapoint); } } @@ -61,7 +63,7 @@ void Optolink::write_value(IDatapoint *datapoint, DPValue dp_value) { if (datapoint != nullptr) { char buffer[64]; dp_value.getString(buffer, sizeof(buffer)); - ESP_LOGI("Optolink", " write value %s of datapoint %s", buffer, datapoint->getName()); + ESP_LOGI("Optolink", "sending value %s to datapoint %s", buffer, datapoint->getName()); VitoWiFi.writeDatapoint(*datapoint, dp_value); } } diff --git a/esphome/components/optolink/optolink_sensor_base.cpp b/esphome/components/optolink/optolink_sensor_base.cpp index abe2b48c4e..856a59d56e 100644 --- a/esphome/components/optolink/optolink_sensor_base.cpp +++ b/esphome/components/optolink/optolink_sensor_base.cpp @@ -6,148 +6,197 @@ namespace esphome { namespace optolink { -void OptolinkSensorBase::update_datapoint_(float value) { - if (!writeable_) { - optolink_->set_error("try to control not writable number %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "try to control not writable number %s", get_sensor_name().c_str()); - } else if (datapoint_ != nullptr) { - switch (bytes_) { - case 1: - switch (div_ratio_) { - case 1: - optolink_->write_value(datapoint_, DPValue((uint8_t) value)); - break; - case 10: - optolink_->write_value(datapoint_, DPValue((float) value)); - break; - default: - optolink_->set_error("Unknown byte/div_ratio combination for number %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "Unknown byte/div_ratio combination for number %s", - get_sensor_name().c_str()); - break; - } - break; - case 2: - switch (div_ratio_) { - case 1: - optolink_->write_value(datapoint_, DPValue((uint16_t) value)); - break; - case 10: - case 100: - optolink_->write_value(datapoint_, DPValue((float) value)); - break; - default: - optolink_->set_error("Unknown byte/div_ratio combination for number %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "Unknown byte/div_ratio combination for number %s", - get_sensor_name().c_str()); - break; - } - break; - case 4: - switch (div_ratio_) { - case 1: - optolink_->write_value(datapoint_, DPValue((uint32_t) value)); - break; - case 3600: - optolink_->write_value(datapoint_, DPValue((float) value)); - break; - default: - optolink_->set_error("Unknown byte/div_ratio combination for number %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "Unknown byte/div_ratio combination for number %s", - get_sensor_name().c_str()); - break; - } - break; - default: - optolink_->set_error("Unknown byte value for number %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "Unknown byte value for number %s", get_sensor_name().c_str()); - break; - } - } -} +static const char *const TAG = "optolink.sensor_base"; -void OptolinkSensorBase::setup_datapoint_() { - switch (bytes_) { +void OptolinkSensorBase::setup_datapoint() { + switch (div_ratio_) { + case 0: + datapoint_ = new Datapoint(get_component_name().c_str(), "optolink", address_, writeable_); + datapoint_->setLength(bytes_); + datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { + uint8_t buffer[bytes_]; + dp_value.getRaw(buffer); +#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_INFO + char print_buffer[bytes_ * 2 + 1]; + dp_value.getString(print_buffer, sizeof(print_buffer)); + ESP_LOGI(TAG, "recieved data for datapoint %s: %s", dp.getName(), print_buffer); +#endif + value_changed((uint8_t *) buffer, bytes_); + }); + break; case 1: - switch (div_ratio_) { + switch (bytes_) { case 1: - datapoint_ = new Datapoint(get_sensor_name().c_str(), "optolink", address_, writeable_); + datapoint_ = new Datapoint(get_component_name().c_str(), "optolink", address_, writeable_); datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { - ESP_LOGD("OptolinkSensorBase", "Datapoint %s - %s: %d", dp.getGroup(), dp.getName(), dp_value.getU8()); + ESP_LOGI(TAG, "recieved data for datapoint %s: %d", dp.getName(), dp_value.getU8()); value_changed(dp_value.getU8()); }); break; - case 10: - datapoint_ = new Datapoint(get_sensor_name().c_str(), "optolink", address_, writeable_); + case 2: + datapoint_ = new Datapoint(get_component_name().c_str(), "optolink", address_, writeable_); datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { - ESP_LOGD("OptolinkSensorBase", "Datapoint %s - %s: %f", dp.getGroup(), dp.getName(), dp_value.getFloat()); - value_changed(dp_value.getFloat()); - }); - break; - default: - optolink_->set_error("Unknown byte/div_ratio combination for sensor %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "Unknown byte/div_ratio combination for sensor %s", get_sensor_name().c_str()); - break; - } - break; - case 2: - switch (div_ratio_) { - case 1: - datapoint_ = new Datapoint(get_sensor_name().c_str(), "optolink", address_, writeable_); - datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { - ESP_LOGD("OptolinkSensorBase", "Datapoint %s - %s: %d", dp.getGroup(), dp.getName(), dp_value.getU16()); + ESP_LOGI(TAG, "recieved data for datapoint %s: %d", dp.getName(), dp_value.getU16()); value_changed(dp_value.getU16()); }); break; - case 10: - datapoint_ = new Datapoint(get_sensor_name().c_str(), "optolink", address_, writeable_); + case 4: + datapoint_ = new Datapoint(get_component_name().c_str(), "optolink", address_, writeable_); datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { - ESP_LOGD("OptolinkSensorBase", "Datapoint %s - %s: %f", dp.getGroup(), dp.getName(), dp_value.getFloat()); - value_changed(dp_value.getFloat()); - }); - break; - case 100: - datapoint_ = new Datapoint(get_sensor_name().c_str(), "optolink", address_, writeable_); - datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { - ESP_LOGD("OptolinkSensorBase", "Datapoint %s - %s: %f", dp.getGroup(), dp.getName(), dp_value.getFloat()); - value_changed(dp_value.getFloat()); + ESP_LOGI(TAG, "recieved data for datapoint %s: %d", dp.getName(), dp_value.getU32()); + value_changed((uint32_t) dp_value.getU32()); }); break; default: - optolink_->set_error("Unknown byte/div_ratio combination for sensor %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "Unknown byte/div_ratio combination for sensor %s", get_sensor_name().c_str()); - break; + unfitting_value_type(); } break; - case 4: - switch (div_ratio_) { + case 10: + switch (bytes_) { case 1: - datapoint_ = new Datapoint(get_sensor_name().c_str(), "optolink", address_, writeable_); + datapoint_ = new Datapoint(get_component_name().c_str(), "optolink", address_, writeable_); datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { - ESP_LOGD("OptolinkSensorBase", "Datapoint %s - %s: %d", dp.getGroup(), dp.getName(), dp_value.getU32()); - value_changed(dp_value.getU32()); + ESP_LOGI(TAG, "recieved data for datapoint %s: %f", dp.getName(), dp_value.getFloat()); + value_changed(dp_value.getFloat()); }); break; - case 3600: - datapoint_ = new Datapoint(get_sensor_name().c_str(), "optolink", address_, writeable_); + case 2: + datapoint_ = new Datapoint(get_component_name().c_str(), "optolink", address_, writeable_); datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { - ESP_LOGD("OptolinkSensorBase", "Datapoint %s - %s: %f", dp.getGroup(), dp.getName(), dp_value.getFloat()); + ESP_LOGI(TAG, "recieved data for datapoint %s: %f", dp.getName(), dp_value.getFloat()); value_changed(dp_value.getFloat()); }); break; default: - optolink_->set_error("Unknown byte/div_ratio combination for sensor %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "Unknown byte/div_ratio combination for sensor %s", get_sensor_name().c_str()); - break; + unfitting_value_type(); } break; - default: - optolink_->set_error("Unknown byte value for sensor %s", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSensorBase", "Unknown byte value for sensor %s", get_sensor_name().c_str()); + case 100: + switch (bytes_) { + case 2: + datapoint_ = new Datapoint(get_component_name().c_str(), "optolink", address_, writeable_); + datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { + ESP_LOGI(TAG, "recieved data for datapoint %s: %f", dp.getName(), dp_value.getFloat()); + value_changed(dp_value.getFloat()); + }); + break; + default: + unfitting_value_type(); + } break; + case 3600: + switch (bytes_) { + case 4: + datapoint_ = new Datapoint(get_component_name().c_str(), "optolink", address_, writeable_); + datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { + ESP_LOGI(TAG, "recieved data for datapoint %s: %f", dp.getName(), dp_value.getFloat()); + value_changed(dp_value.getFloat()); + }); + break; + } + default: + unfitting_value_type(); } } +void OptolinkSensorBase::value_changed(float value) { + ESP_LOGW(TAG, "unused value update by sensor %s", get_component_name().c_str()); +} + +void OptolinkSensorBase::value_changed(uint8_t value) { + ESP_LOGW(TAG, "unused value update by sensor %s", get_component_name().c_str()); +} + +void OptolinkSensorBase::value_changed(uint16_t value) { + ESP_LOGW(TAG, "unused value update by sensor %s", get_component_name().c_str()); +} + +void OptolinkSensorBase::value_changed(uint32_t value) { + ESP_LOGW(TAG, "unused value update by sensor %s", get_component_name().c_str()); +} + +void OptolinkSensorBase::value_changed(std::string value) { + ESP_LOGW(TAG, "unused value update by sensor %s", get_component_name().c_str()); +} + +void OptolinkSensorBase::value_changed(uint8_t *value, size_t length) { + ESP_LOGW(TAG, "unused value update by sensor %s", get_component_name().c_str()); +} + +void OptolinkSensorBase::update_datapoint(DPValue dp_value) { + if (!writeable_) { + optolink_->set_error("trying to control not writable datapoint %s", get_component_name().c_str()); + ESP_LOGE(TAG, "trying to control not writable datapoint %s", get_component_name().c_str()); + } else if (datapoint_ != nullptr) { +#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_INFO + char buffer[100]; + dp_value.getString(buffer, sizeof(buffer)); + ESP_LOGI(TAG, "updating datapoint %s value: %s", datapoint_->getName(), buffer); +#endif + optolink_->write_value(datapoint_, dp_value); + } +} + +void OptolinkSensorBase::update_datapoint(float value) { + if (div_ratio_ > 1) { + update_datapoint(DPValue(value)); + } else if (div_ratio_ == 1) { + switch (bytes_) { + case 1: + update_datapoint(DPValue((uint8_t) value)); + break; + case 2: + update_datapoint(DPValue((uint16_t) value)); + break; + case 4: + update_datapoint(DPValue((uint32_t) value)); + break; + default: + unfitting_value_type(); + break; + } + } else { + unfitting_value_type(); + } +} + +void OptolinkSensorBase::update_datapoint(uint8_t value) { + if (bytes_ == 1 && div_ratio_ == 1) { + update_datapoint(DPValue(value)); + } else { + unfitting_value_type(); + } +} + +void OptolinkSensorBase::update_datapoint(uint16_t value) { + if (bytes_ == 2 && div_ratio_ == 1) { + update_datapoint(DPValue(value)); + } else { + unfitting_value_type(); + } +} + +void OptolinkSensorBase::update_datapoint(uint32_t value) { + if (bytes_ == 4 && div_ratio_ == 1) { + update_datapoint(DPValue(value)); + } else { + unfitting_value_type(); + } +} + +void OptolinkSensorBase::update_datapoint(uint8_t *value, size_t length) { + if (bytes_ == length && div_ratio_ == 0) { + update_datapoint(DPValue(value, length)); + } else { + unfitting_value_type(); + } +} + +void OptolinkSensorBase::unfitting_value_type() { + optolink_->set_error("Unfitting byte/div_ratio combination for sensor/component %s", get_component_name().c_str()); + ESP_LOGE(TAG, "Unfitting byte/div_ratio combination for sensor/component %s", get_component_name().c_str()); +} + void conv2_100_F::encode(uint8_t *out, DPValue in) { int16_t tmp = floor((in.getFloat() * 100) + 0.5); out[1] = tmp >> 8; diff --git a/esphome/components/optolink/optolink_sensor_base.h b/esphome/components/optolink/optolink_sensor_base.h index 3c84de4d85..abb6b56967 100644 --- a/esphome/components/optolink/optolink_sensor_base.h +++ b/esphome/components/optolink/optolink_sensor_base.h @@ -12,17 +12,6 @@ namespace optolink { class Optolink; class OptolinkSensorBase { - protected: - Optolink *optolink_; - bool writeable_; - IDatapoint *datapoint_ = nullptr; - uint32_t address_; - int bytes_; - int div_ratio_ = 1; - - void setup_datapoint_(); - void update_datapoint_(float value); - public: OptolinkSensorBase(Optolink *optolink, bool writeable = false) { optolink_ = optolink; @@ -34,8 +23,31 @@ class OptolinkSensorBase { void set_div_ratio(int div_ratio) { div_ratio_ = div_ratio; } protected: - virtual const StringRef &get_sensor_name() = 0; - virtual void value_changed(float state) = 0; + Optolink *optolink_; + bool writeable_; + IDatapoint *datapoint_ = nullptr; + uint32_t address_; + size_t bytes_; + size_t div_ratio_ = 0; + + virtual const StringRef &get_component_name() = 0; + void setup_datapoint(); + virtual void value_changed(float value); + virtual void value_changed(uint8_t value); + virtual void value_changed(uint16_t value); + virtual void value_changed(uint32_t value); + virtual void value_changed(std::string value); + virtual void value_changed(uint8_t *value, size_t length); + void update_datapoint(float value); + void update_datapoint(uint8_t value); + void update_datapoint(uint16_t value); + void update_datapoint(uint32_t value); + void update_datapoint(uint8_t *value, size_t length); + + void unfitting_value_type(); + + private: + void update_datapoint(DPValue dp_value); }; // NOLINTNEXTLINE diff --git a/esphome/components/optolink/select/optolink_select.cpp b/esphome/components/optolink/select/optolink_select.cpp index 4bdf6201f1..68fb6140bd 100644 --- a/esphome/components/optolink/select/optolink_select.cpp +++ b/esphome/components/optolink/select/optolink_select.cpp @@ -10,34 +10,47 @@ namespace optolink { void OptolinkSelect::control(const std::string &value) { for (auto it = mapping_->begin(); it != mapping_->end(); ++it) { if (it->second == value) { - ESP_LOGI("OptolinkSelect", "control of select %s to value %s", get_sensor_name().c_str(), it->first.c_str()); - update_datapoint_(std::stof(it->first)); + ESP_LOGI("OptolinkSelect", "control of select %s to value %s", get_component_name().c_str(), it->first.c_str()); + update_datapoint(std::stof(it->first)); publish_state(it->second); break; } if (it == mapping_->end()) { - optolink_->set_error("unknown value %s of select %s", value.c_str(), get_sensor_name().c_str()); - ESP_LOGE("OptolinkSelect", "unknown value %s of select %s", value.c_str(), get_sensor_name().c_str()); + optolink_->set_error("unknown value %s of select %s", value.c_str(), get_component_name().c_str()); + ESP_LOGE("OptolinkSelect", "unknown value %s of select %s", value.c_str(), get_component_name().c_str()); } } }; -void OptolinkSelect::value_changed(float state) { - std::string key; - if (div_ratio_ == 1) { - key = std::to_string((int) state); - } else { - key = std::to_string(state); - } +void OptolinkSelect::value_changed(std::string key) { auto pos = mapping_->find(key); if (pos == mapping_->end()) { - optolink_->set_error("value %s not found in select %s", key.c_str(), get_sensor_name().c_str()); - ESP_LOGE("OptolinkSelect", "value %s not found in select %s", key.c_str(), get_sensor_name().c_str()); + optolink_->set_error("value %s not found in select %s", key.c_str(), get_component_name().c_str()); + ESP_LOGE("OptolinkSelect", "value %s not found in select %s", key.c_str(), get_component_name().c_str()); } else { publish_state(pos->second); } - //-----------------------------------------------publish_state(state); -}; +} + +void OptolinkSelect::value_changed(uint8_t state) { + std::string key = std::to_string(state); + value_changed(key); +} + +void OptolinkSelect::value_changed(uint16_t state) { + std::string key = std::to_string(state); + value_changed(key); +} + +void OptolinkSelect::value_changed(uint32_t state) { + std::string key = std::to_string(state); + value_changed(key); +} + +void OptolinkSelect::value_changed(float state) { + std::string key = std::to_string(state); + value_changed(key); +} } // namespace optolink } // namespace esphome diff --git a/esphome/components/optolink/select/optolink_select.h b/esphome/components/optolink/select/optolink_select.h index b7a5eab47e..20137b0d1d 100644 --- a/esphome/components/optolink/select/optolink_select.h +++ b/esphome/components/optolink/select/optolink_select.h @@ -25,10 +25,14 @@ class OptolinkSelect : public OptolinkSensorBase, public esphome::select::Select }; protected: - void setup() override { setup_datapoint_(); } + void setup() override { setup_datapoint(); } void update() override { optolink_->read_value(datapoint_); } - const StringRef &get_sensor_name() override { return get_name(); } + const StringRef &get_component_name() override { return get_name(); } + void value_changed(std::string state) override; + void value_changed(uint8_t state) override; + void value_changed(uint16_t state) override; + void value_changed(uint32_t state) override; void value_changed(float state) override; void control(const std::string &value) override; diff --git a/esphome/components/optolink/sensor/optolink_sensor.h b/esphome/components/optolink/sensor/optolink_sensor.h index f0a7da49ac..89474abcda 100644 --- a/esphome/components/optolink/sensor/optolink_sensor.h +++ b/esphome/components/optolink/sensor/optolink_sensor.h @@ -17,11 +17,14 @@ class OptolinkSensor : public OptolinkSensorBase, public esphome::sensor::Sensor } protected: - void setup() { setup_datapoint_(); } + void setup() { setup_datapoint(); } void update() override { optolink_->read_value(datapoint_); } - const StringRef &get_sensor_name() override { return get_name(); } + const StringRef &get_component_name() override { return get_name(); } void value_changed(float state) override { publish_state(state); }; + void value_changed(uint8_t state) override { publish_state(state); }; + void value_changed(uint16_t state) override { publish_state(state); }; + void value_changed(uint32_t state) override { publish_state(state); }; }; } // namespace optolink } // namespace esphome diff --git a/esphome/components/optolink/switch/optolink_switch.cpp b/esphome/components/optolink/switch/optolink_switch.cpp index 4b08e9bda0..b334398f53 100644 --- a/esphome/components/optolink/switch/optolink_switch.cpp +++ b/esphome/components/optolink/switch/optolink_switch.cpp @@ -9,11 +9,11 @@ namespace optolink { void OptolinkSwitch::write_state(bool value) { if (value != 0 && value != 1) { - optolink_->set_error("datapoint value of switch %s not 0 or 1", get_sensor_name().c_str()); - ESP_LOGE("OptolinkSwitch", "datapoint value of switch %s not 0 or 1", get_sensor_name().c_str()); + optolink_->set_error("datapoint value of switch %s not 0 or 1", get_component_name().c_str()); + ESP_LOGE("OptolinkSwitch", "datapoint value of switch %s not 0 or 1", get_component_name().c_str()); } else { - ESP_LOGI("OptolinkSwitch", "control of switch %s to value %d", get_sensor_name().c_str(), value); - update_datapoint_(value); + ESP_LOGI("OptolinkSwitch", "control of switch %s to value %d", get_component_name().c_str(), value); + update_datapoint((uint8_t) value); publish_state(value); } }; diff --git a/esphome/components/optolink/switch/optolink_switch.h b/esphome/components/optolink/switch/optolink_switch.h index e1a4ebfb80..6b5cffdf28 100644 --- a/esphome/components/optolink/switch/optolink_switch.h +++ b/esphome/components/optolink/switch/optolink_switch.h @@ -18,11 +18,11 @@ class OptolinkSwitch : public OptolinkSensorBase, public esphome::switch_::Switc } protected: - void setup() override { setup_datapoint_(); } + void setup() override { setup_datapoint(); } void update() override { optolink_->read_value(datapoint_); } - const StringRef &get_sensor_name() override { return get_name(); } - void value_changed(float state) override { publish_state(state); }; + const StringRef &get_component_name() override { return get_name(); } + void value_changed(uint8_t state) override { publish_state(state); }; void write_state(bool value) override; }; diff --git a/esphome/components/optolink/text_sensor/__init__.py b/esphome/components/optolink/text_sensor/__init__.py index aaad5837e4..56110527a6 100644 --- a/esphome/components/optolink/text_sensor/__init__.py +++ b/esphome/components/optolink/text_sensor/__init__.py @@ -5,22 +5,21 @@ from esphome.const import ( CONF_ADDRESS, CONF_BYTES, CONF_DIV_RATIO, + CONF_ENTITY_ID, CONF_ID, CONF_MODE, ) from .. import optolink_ns, CONF_OPTOLINK_ID, SENSOR_BASE_SCHEMA -OptolinkTextSensor = optolink_ns.class_( - "OptolinkTextSensor", text_sensor.TextSensor, cg.PollingComponent -) +DEPENDENCIES = ["api"] TextSensorMode = optolink_ns.enum("TextSensorMode") MODE = { "MAP": TextSensorMode.MAP, "RAW": TextSensorMode.RAW, "DAY_SCHEDULE": TextSensorMode.DAY_SCHEDULE, + "DAY_SCHEDULE_SYNCHRONIZED": TextSensorMode.DAY_SCHEDULE_SYNCHRONIZED, } - DAY_OF_WEEK = { "MONDAY": 0, "TUESDAY": 1, @@ -30,9 +29,12 @@ DAY_OF_WEEK = { "SATURDAY": 5, "SUNDAY": 6, } - CONF_DOW = "day_of_week" +OptolinkTextSensor = optolink_ns.class_( + "OptolinkTextSensor", text_sensor.TextSensor, cg.PollingComponent +) + def check_bytes(): def validator_(config): @@ -41,7 +43,9 @@ def check_bytes(): if bytes_needed and not bytes_defined: raise cv.Invalid(f"{CONF_BYTES} is required in mode MAP or RAW") if not bytes_needed and bytes_defined: - raise cv.Invalid(f"{CONF_BYTES} is not allowed in mode DAY_SCHEDULE") + raise cv.Invalid( + f"{CONF_BYTES} is not allowed in mode DAY_SCHEDULE and DAY_SCHEDULE_SYNCHRONIZED" + ) return config return validator_ @@ -49,10 +53,39 @@ def check_bytes(): def check_dow(): def validator_(config): - if config[CONF_MODE] == "DAY_SCHEDULE" and CONF_DOW not in config: + if ( + config[CONF_MODE] in ["DAY_SCHEDULE", "DAY_SCHEDULE_SYNCHRONIZED"] + and CONF_DOW not in config + ): raise cv.Invalid(f"{CONF_DOW} is required in mode DAY_SCHEDULE") - if config[CONF_MODE] != "DAY_SCHEDULE" and CONF_DOW in config: - raise cv.Invalid(f"{CONF_DOW} is only allowed in mode DAY_SCHEDULE") + if ( + config[CONF_MODE] not in ["DAY_SCHEDULE", "DAY_SCHEDULE_SYNCHRONIZED"] + and CONF_DOW in config + ): + raise cv.Invalid( + f"{CONF_DOW} is only allowed in mode DAY_SCHEDULE or DAY_SCHEDULE_SYNCHRONIZED" + ) + return config + + return validator_ + + +def check_entity_id(): + def validator_(config): + if ( + config[CONF_MODE] in ["DAY_SCHEDULE_SYNCHRONIZED"] + and CONF_ENTITY_ID not in config + ): + raise cv.Invalid( + f"{CONF_ENTITY_ID} is required in mode DAY_SCHEDULE_SYNCHRONIZED" + ) + if ( + config[CONF_MODE] not in ["DAY_SCHEDULE_SYNCHRONIZED"] + and CONF_ENTITY_ID in config + ): + raise cv.Invalid( + f"{CONF_ENTITY_ID} is only allowed in mode DAY_SCHEDULE_SYNCHRONIZED" + ) return config return validator_ @@ -65,11 +98,13 @@ CONFIG_SCHEMA = cv.All( cv.Optional(CONF_MODE, default="MAP"): cv.enum(MODE, upper=True), cv.Optional(CONF_BYTES): cv.int_range(min=1, max=9), cv.Optional(CONF_DOW): cv.enum(DAY_OF_WEEK, upper=True), + cv.Optional(CONF_ENTITY_ID): cv.entity_id, } ) .extend(SENSOR_BASE_SCHEMA), check_bytes(), check_dow(), + check_entity_id(), ) @@ -87,3 +122,5 @@ async def to_code(config): cg.add(var.set_bytes(config[CONF_BYTES])) if CONF_DOW in config: cg.add(var.set_day_of_week(config[CONF_DOW])) + if CONF_ENTITY_ID in config: + cg.add(var.set_entity_id(config[CONF_ENTITY_ID])) diff --git a/esphome/components/optolink/text_sensor/optolink_device_info_sensor.cpp b/esphome/components/optolink/text_sensor/optolink_device_info_sensor.cpp index 4ce4e19974..9de361841f 100644 --- a/esphome/components/optolink/text_sensor/optolink_device_info_sensor.cpp +++ b/esphome/components/optolink/text_sensor/optolink_device_info_sensor.cpp @@ -6,11 +6,13 @@ namespace esphome { namespace optolink { +static const char *const TAG = "optolink.text_sensor"; + void OptolinkDeviceInfoSensor::setup() { datapoint_ = new Datapoint(get_name().c_str(), "optolink", 0x00f8, false); datapoint_->setCallback([this](const IDatapoint &dp, DPValue dp_value) { uint32_t value = dp_value.getU32(); - ESP_LOGD("OptolinkTextSensor", "Datapoint %s - %s: %d", dp.getGroup(), dp.getName(), value); + ESP_LOGI(TAG, "recieved data for datapoint %s: %d", dp.getName(), value); uint8_t *bytes = (uint8_t *) &value; uint16_t tmp = esphome::byteswap(*((uint16_t *) bytes)); std::string geraetekennung = esphome::format_hex_pretty(&tmp, 1); diff --git a/esphome/components/optolink/text_sensor/optolink_text_sensor.cpp b/esphome/components/optolink/text_sensor/optolink_text_sensor.cpp index bbc18973cb..c65c2459d3 100644 --- a/esphome/components/optolink/text_sensor/optolink_text_sensor.cpp +++ b/esphome/components/optolink/text_sensor/optolink_text_sensor.cpp @@ -2,43 +2,139 @@ #include "optolink_text_sensor.h" #include "../optolink.h" +#include "esphome/components/api/api_server.h" #include "VitoWiFi.h" +#include +#include +#include namespace esphome { namespace optolink { +static const char *const TAG = "optolink.text_sensor"; + +struct Time { + int hours; + int minutes; +}; + +bool check_time_sequence(const Time &t1, const Time &t2) { + if (t2.hours > t1.hours || (t2.hours == t1.hours && t2.minutes >= t1.minutes)) { + return true; + } + return false; +} + +bool check_time_values(const Time &time) { + return (time.hours >= 0 && time.hours <= 23) && (time.minutes >= 0 && time.minutes <= 59); +} + +uint8_t *encode_time_string(std::string input) { + std::istringstream iss(input); + std::vector