esphome 2024.7.2__py3-none-any.whl → 2024.8.0__py3-none-any.whl

esphome/components/online_image/online_image.cpp

@@ -0,0 +1,283 @@
+#include "online_image.h"
+
+#include "esphome/core/log.h"
+
+static const char *const TAG = "online_image";
+
+#include "image_decoder.h"
+
+#ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
+#include "png_image.h"
+#endif
+
+namespace esphome {
+namespace online_image {
+
+using image::ImageType;
+
+inline bool is_color_on(const Color &color) {
+  // This produces the most accurate monochrome conversion, but is slightly slower.
+  //  return (0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b) > 127;
+
+  // Approximation using fast integer computations; produces acceptable results
+  // Equivalent to 0.25 * R + 0.5 * G + 0.25 * B
+  return ((color.r >> 2) + (color.g >> 1) + (color.b >> 2)) & 0x80;
+}
+
+OnlineImage::OnlineImage(const std::string &url, int width, int height, ImageFormat format, ImageType type,
+                         uint32_t download_buffer_size)
+    : Image(nullptr, 0, 0, type),
+      buffer_(nullptr),
+      download_buffer_(download_buffer_size),
+      format_(format),
+      fixed_width_(width),
+      fixed_height_(height) {
+  this->set_url(url);
+}
+
+void OnlineImage::draw(int x, int y, display::Display *display, Color color_on, Color color_off) {
+  if (this->data_start_) {
+    Image::draw(x, y, display, color_on, color_off);
+  } else if (this->placeholder_) {
+    this->placeholder_->draw(x, y, display, color_on, color_off);
+  }
+}
+
+void OnlineImage::release() {
+  if (this->buffer_) {
+    ESP_LOGD(TAG, "Deallocating old buffer...");
+    this->allocator_.deallocate(this->buffer_, this->get_buffer_size_());
+    this->data_start_ = nullptr;
+    this->buffer_ = nullptr;
+    this->width_ = 0;
+    this->height_ = 0;
+    this->buffer_width_ = 0;
+    this->buffer_height_ = 0;
+    this->end_connection_();
+  }
+}
+
+bool OnlineImage::resize_(int width_in, int height_in) {
+  int width = this->fixed_width_;
+  int height = this->fixed_height_;
+  if (this->auto_resize_()) {
+    width = width_in;
+    height = height_in;
+    if (this->width_ != width && this->height_ != height) {
+      this->release();
+    }
+  }
+  if (this->buffer_) {
+    return false;
+  }
+  auto new_size = this->get_buffer_size_(width, height);
+  ESP_LOGD(TAG, "Allocating new buffer of %d Bytes...", new_size);
+  delay_microseconds_safe(2000);
+  this->buffer_ = this->allocator_.allocate(new_size);
+  if (this->buffer_) {
+    this->buffer_width_ = width;
+    this->buffer_height_ = height;
+    this->width_ = width;
+    ESP_LOGD(TAG, "New size: (%d, %d)", width, height);
+  } else {
+#if defined(USE_ESP8266)
+    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+    int max_block = ESP.getMaxFreeBlockSize();
+#elif defined(USE_ESP32)
+    int max_block = heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL);
+#else
+    int max_block = -1;
+#endif
+    ESP_LOGE(TAG, "allocation failed. Biggest block in heap: %d Bytes", max_block);
+    this->end_connection_();
+    return false;
+  }
+  return true;
+}
+
+void OnlineImage::update() {
+  if (this->decoder_) {
+    ESP_LOGW(TAG, "Image already being updated.");
+    return;
+  } else {
+    ESP_LOGI(TAG, "Updating image");
+  }
+
+  this->downloader_ = this->parent_->get(this->url_);
+
+  if (this->downloader_ == nullptr) {
+    ESP_LOGE(TAG, "Download failed.");
+    this->end_connection_();
+    this->download_error_callback_.call();
+    return;
+  }
+
+  int http_code = this->downloader_->status_code;
+  if (http_code == HTTP_CODE_NOT_MODIFIED) {
+    // Image hasn't changed on server. Skip download.
+    this->end_connection_();
+    return;
+  }
+  if (http_code != HTTP_CODE_OK) {
+    ESP_LOGE(TAG, "HTTP result: %d", http_code);
+    this->end_connection_();
+    this->download_error_callback_.call();
+    return;
+  }
+
+  ESP_LOGD(TAG, "Starting download");
+  size_t total_size = this->downloader_->content_length;
+
+#ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
+  if (this->format_ == ImageFormat::PNG) {
+    this->decoder_ = esphome::make_unique<PngDecoder>(this);
+  }
+#endif  // ONLINE_IMAGE_PNG_SUPPORT
+
+  if (!this->decoder_) {
+    ESP_LOGE(TAG, "Could not instantiate decoder. Image format unsupported.");
+    this->end_connection_();
+    this->download_error_callback_.call();
+    return;
+  }
+  this->decoder_->prepare(total_size);
+  ESP_LOGI(TAG, "Downloading image");
+}
+
+void OnlineImage::loop() {
+  if (!this->decoder_) {
+    // Not decoding at the moment => nothing to do.
+    return;
+  }
+  if (!this->downloader_ || this->decoder_->is_finished()) {
+    ESP_LOGD(TAG, "Image fully downloaded");
+    this->data_start_ = buffer_;
+    this->width_ = buffer_width_;
+    this->height_ = buffer_height_;
+    this->end_connection_();
+    this->download_finished_callback_.call();
+    return;
+  }
+  if (this->downloader_ == nullptr) {
+    ESP_LOGE(TAG, "Downloader not instantiated; cannot download");
+    return;
+  }
+  size_t available = this->download_buffer_.free_capacity();
+  if (available) {
+    auto len = this->downloader_->read(this->download_buffer_.append(), available);
+    if (len > 0) {
+      this->download_buffer_.write(len);
+      auto fed = this->decoder_->decode(this->download_buffer_.data(), this->download_buffer_.unread());
+      if (fed < 0) {
+        ESP_LOGE(TAG, "Error when decoding image.");
+        this->end_connection_();
+        this->download_error_callback_.call();
+        return;
+      }
+      this->download_buffer_.read(fed);
+    }
+  }
+}
+
+void OnlineImage::draw_pixel_(int x, int y, Color color) {
+  if (!this->buffer_) {
+    ESP_LOGE(TAG, "Buffer not allocated!");
+    return;
+  }
+  if (x < 0 || y < 0 || x >= this->buffer_width_ || y >= this->buffer_height_) {
+    ESP_LOGE(TAG, "Tried to paint a pixel (%d,%d) outside the image!", x, y);
+    return;
+  }
+  uint32_t pos = this->get_position_(x, y);
+  switch (this->type_) {
+    case ImageType::IMAGE_TYPE_BINARY: {
+      const uint32_t width_8 = ((this->width_ + 7u) / 8u) * 8u;
+      const uint32_t pos = x + y * width_8;
+      if ((this->has_transparency() && color.w > 127) || is_color_on(color)) {
+        this->buffer_[pos / 8u] |= (0x80 >> (pos % 8u));
+      } else {
+        this->buffer_[pos / 8u] &= ~(0x80 >> (pos % 8u));
+      }
+      break;
+    }
+    case ImageType::IMAGE_TYPE_GRAYSCALE: {
+      uint8_t gray = static_cast<uint8_t>(0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b);
+      if (this->has_transparency()) {
+        if (gray == 1) {
+          gray = 0;
+        }
+        if (color.w < 0x80) {
+          gray = 1;
+        }
+      }
+      this->buffer_[pos] = gray;
+      break;
+    }
+    case ImageType::IMAGE_TYPE_RGB565: {
+      uint16_t col565 = display::ColorUtil::color_to_565(color);
+      if (this->has_transparency()) {
+        if (col565 == 0x0020) {
+          col565 = 0;
+        }
+        if (color.w < 0x80) {
+          col565 = 0x0020;
+        }
+      }
+      this->buffer_[pos + 0] = static_cast<uint8_t>((col565 >> 8) & 0xFF);
+      this->buffer_[pos + 1] = static_cast<uint8_t>(col565 & 0xFF);
+      break;
+    }
+    case ImageType::IMAGE_TYPE_RGBA: {
+      this->buffer_[pos + 0] = color.r;
+      this->buffer_[pos + 1] = color.g;
+      this->buffer_[pos + 2] = color.b;
+      this->buffer_[pos + 3] = color.w;
+      break;
+    }
+    case ImageType::IMAGE_TYPE_RGB24:
+    default: {
+      if (this->has_transparency()) {
+        if (color.b == 1 && color.r == 0 && color.g == 0) {
+          color.b = 0;
+        }
+        if (color.w < 0x80) {
+          color.r = 0;
+          color.g = 0;
+          color.b = 1;
+        }
+      }
+      this->buffer_[pos + 0] = color.r;
+      this->buffer_[pos + 1] = color.g;
+      this->buffer_[pos + 2] = color.b;
+      break;
+    }
+  }
+}
+
+void OnlineImage::end_connection_() {
+  if (this->downloader_) {
+    this->downloader_->end();
+    this->downloader_ = nullptr;
+  }
+  this->decoder_.reset();
+  this->download_buffer_.reset();
+}
+
+bool OnlineImage::validate_url_(const std::string &url) {
+  if ((url.length() < 8) || (url.find("http") != 0) || (url.find("://") == std::string::npos)) {
+    ESP_LOGE(TAG, "URL is invalid and/or must be prefixed with 'http://' or 'https://'");
+    return false;
+  }
+  return true;
+}
+
+void OnlineImage::add_on_finished_callback(std::function<void()> &&callback) {
+  this->download_finished_callback_.add(std::move(callback));
+}
+
+void OnlineImage::add_on_error_callback(std::function<void()> &&callback) {
+  this->download_error_callback_.add(std::move(callback));
+}
+
+}  // namespace online_image
+}  // namespace esphome

esphome/components/online_image/online_image.h

@@ -0,0 +1,195 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/http_request/http_request.h"
+#include "esphome/components/image/image.h"
+
+#include "image_decoder.h"
+
+namespace esphome {
+namespace online_image {
+
+using t_http_codes = enum {
+  HTTP_CODE_OK = 200,
+  HTTP_CODE_NOT_MODIFIED = 304,
+  HTTP_CODE_NOT_FOUND = 404,
+};
+
+/**
+ * @brief Format that the image is encoded with.
+ */
+enum ImageFormat {
+  /** Automatically detect from MIME type. Not supported yet. */
+  AUTO,
+  /** JPEG format. Not supported yet. */
+  JPEG,
+  /** PNG format. */
+  PNG,
+};
+
+/**
+ * @brief Download an image from a given URL, and decode it using the specified decoder.
+ * The image will then be stored in a buffer, so that it can be re-displayed without the
+ * need to re-download or re-decode.
+ */
+class OnlineImage : public PollingComponent,
+                    public image::Image,
+                    public Parented<esphome::http_request::HttpRequestComponent> {
+ public:
+  /**
+   * @brief Construct a new OnlineImage object.
+   *
+   * @param url URL to download the image from.
+   * @param width Desired width of the target image area.
+   * @param height Desired height of the target image area.
+   * @param format Format that the image is encoded in (@see ImageFormat).
+   * @param buffer_size Size of the buffer used to download the image.
+   */
+  OnlineImage(const std::string &url, int width, int height, ImageFormat format, image::ImageType type,
+              uint32_t buffer_size);
+
+  void draw(int x, int y, display::Display *display, Color color_on, Color color_off) override;
+
+  void update() override;
+  void loop() override;
+
+  /** Set the URL to download the image from. */
+  void set_url(const std::string &url) {
+    if (this->validate_url_(url)) {
+      this->url_ = url;
+    }
+  }
+
+  /**
+   * @brief Set the image that needs to be shown as long as the downloaded image
+   *  is not available.
+   *
+   * @param placeholder Pointer to the (@link Image) to show as placeholder.
+   */
+  void set_placeholder(image::Image *placeholder) { this->placeholder_ = placeholder; }
+
+  /**
+   * Release the buffer storing the image. The image will need to be downloaded again
+   * to be able to be displayed.
+   */
+  void release();
+
+  void add_on_finished_callback(std::function<void()> &&callback);
+  void add_on_error_callback(std::function<void()> &&callback);
+
+ protected:
+  bool validate_url_(const std::string &url);
+
+  using Allocator = ExternalRAMAllocator<uint8_t>;
+  Allocator allocator_{Allocator::Flags::ALLOW_FAILURE};
+
+  uint32_t get_buffer_size_() const { return get_buffer_size_(this->buffer_width_, this->buffer_height_); }
+  int get_buffer_size_(int width, int height) const {
+    return std::ceil(image::image_type_to_bpp(this->type_) * width * height / 8.0);
+  }
+
+  int get_position_(int x, int y) const {
+    return ((x + y * this->buffer_width_) * image::image_type_to_bpp(this->type_)) / 8;
+  }
+
+  ESPHOME_ALWAYS_INLINE bool auto_resize_() const { return this->fixed_width_ == 0 || this->fixed_height_ == 0; }
+
+  bool resize_(int width, int height);
+
+  /**
+   * @brief Draw a pixel into the buffer.
+   *
+   * This is used by the decoder to fill the buffer that will later be displayed
+   * by the `draw` method. This will internally convert the supplied 32 bit RGBA
+   * color into the requested image storage format.
+   *
+   * @param x Horizontal pixel position.
+   * @param y Vertical pixel position.
+   * @param color 32 bit color to put into the pixel.
+   */
+  void draw_pixel_(int x, int y, Color color);
+
+  void end_connection_();
+
+  CallbackManager<void()> download_finished_callback_{};
+  CallbackManager<void()> download_error_callback_{};
+
+  std::shared_ptr<http_request::HttpContainer> downloader_{nullptr};
+  std::unique_ptr<ImageDecoder> decoder_{nullptr};
+
+  uint8_t *buffer_;
+  DownloadBuffer download_buffer_;
+
+  const ImageFormat format_;
+  image::Image *placeholder_{nullptr};
+
+  std::string url_{""};
+
+  /** width requested on configuration, or 0 if non specified. */
+  const int fixed_width_;
+  /** height requested on configuration, or 0 if non specified. */
+  const int fixed_height_;
+  /**
+   * Actual width of the current image. If fixed_width_ is specified,
+   * this will be equal to it; otherwise it will be set once the decoding
+   * starts and the original size is known.
+   * This needs to be separate from "BaseImage::get_width()" because the latter
+   * must return 0 until the image has been decoded (to avoid showing partially
+   * decoded images).
+   */
+  int buffer_width_;
+  /**
+   * Actual height of the current image. If fixed_height_ is specified,
+   * this will be equal to it; otherwise it will be set once the decoding
+   * starts and the original size is known.
+   * This needs to be separate from "BaseImage::get_height()" because the latter
+   * must return 0 until the image has been decoded (to avoid showing partially
+   * decoded images).
+   */
+  int buffer_height_;
+
+  friend void ImageDecoder::set_size(int width, int height);
+  friend void ImageDecoder::draw(int x, int y, int w, int h, const Color &color);
+};
+
+template<typename... Ts> class OnlineImageSetUrlAction : public Action<Ts...> {
+ public:
+  OnlineImageSetUrlAction(OnlineImage *parent) : parent_(parent) {}
+  TEMPLATABLE_VALUE(const char *, url)
+  void play(Ts... x) override {
+    this->parent_->set_url(this->url_.value(x...));
+    this->parent_->update();
+  }
+
+ protected:
+  OnlineImage *parent_;
+};
+
+template<typename... Ts> class OnlineImageReleaseAction : public Action<Ts...> {
+ public:
+  OnlineImageReleaseAction(OnlineImage *parent) : parent_(parent) {}
+  TEMPLATABLE_VALUE(const char *, url)
+  void play(Ts... x) override { this->parent_->release(); }
+
+ protected:
+  OnlineImage *parent_;
+};
+
+class DownloadFinishedTrigger : public Trigger<> {
+ public:
+  explicit DownloadFinishedTrigger(OnlineImage *parent) {
+    parent->add_on_finished_callback([this]() { this->trigger(); });
+  }
+};
+
+class DownloadErrorTrigger : public Trigger<> {
+ public:
+  explicit DownloadErrorTrigger(OnlineImage *parent) {
+    parent->add_on_error_callback([this]() { this->trigger(); });
+  }
+};
+
+}  // namespace online_image
+}  // namespace esphome

esphome/components/online_image/png_image.cpp

@@ -0,0 +1,68 @@
+#include "png_image.h"
+#ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
+
+#include "esphome/components/display/display_buffer.h"
+#include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+static const char *const TAG = "online_image.png";
+
+namespace esphome {
+namespace online_image {
+
+/**
+ * @brief Callback method that will be called by the PNGLE engine when the basic
+ * data of the image is received (i.e. width and height);
+ *
+ * @param pngle The PNGLE object, including the context data.
+ * @param w The width of the image.
+ * @param h The height of the image.
+ */
+static void init_callback(pngle_t *pngle, uint32_t w, uint32_t h) {
+  PngDecoder *decoder = (PngDecoder *) pngle_get_user_data(pngle);
+  decoder->set_size(w, h);
+}
+
+/**
+ * @brief Callback method that will be called by the PNGLE engine when a chunk
+ * of the image is decoded.
+ *
+ * @param pngle The PNGLE object, including the context data.
+ * @param x The X coordinate to draw the rectangle on.
+ * @param y The Y coordinate to draw the rectangle on.
+ * @param w The width of the rectangle to draw.
+ * @param h The height of the rectangle to draw.
+ * @param rgba The color to paint the rectangle in.
+ */
+static void draw_callback(pngle_t *pngle, uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint8_t rgba[4]) {
+  PngDecoder *decoder = (PngDecoder *) pngle_get_user_data(pngle);
+  Color color(rgba[0], rgba[1], rgba[2], rgba[3]);
+  decoder->draw(x, y, w, h, color);
+}
+
+void PngDecoder::prepare(uint32_t download_size) {
+  ImageDecoder::prepare(download_size);
+  pngle_set_user_data(this->pngle_, this);
+  pngle_set_init_callback(this->pngle_, init_callback);
+  pngle_set_draw_callback(this->pngle_, draw_callback);
+}
+
+int HOT PngDecoder::decode(uint8_t *buffer, size_t size) {
+  if (size < 256 && size < this->download_size_ - this->decoded_bytes_) {
+    ESP_LOGD(TAG, "Waiting for data");
+    return 0;
+  }
+  auto fed = pngle_feed(this->pngle_, buffer, size);
+  if (fed < 0) {
+    ESP_LOGE(TAG, "Error decoding image: %s", pngle_error(this->pngle_));
+  } else {
+    this->decoded_bytes_ += fed;
+  }
+  return fed;
+}
+
+}  // namespace online_image
+}  // namespace esphome
+
+#endif  // USE_ONLINE_IMAGE_PNG_SUPPORT

esphome/components/online_image/png_image.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "image_decoder.h"
+#ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
+#include <pngle.h>
+
+namespace esphome {
+namespace online_image {
+
+/**
+ * @brief Image decoder specialization for PNG images.
+ */
+class PngDecoder : public ImageDecoder {
+ public:
+  /**
+   * @brief Construct a new PNG Decoder object.
+   *
+   * @param display The image to decode the stream into.
+   */
+  PngDecoder(OnlineImage *image) : ImageDecoder(image), pngle_(pngle_new()) {}
+  ~PngDecoder() override { pngle_destroy(this->pngle_); }
+
+  void prepare(uint32_t download_size) override;
+  int HOT decode(uint8_t *buffer, size_t size) override;
+
+ protected:
+  pngle_t *pngle_;
+};
+
+}  // namespace online_image
+}  // namespace esphome
+
+#endif  // USE_ONLINE_IMAGE_PNG_SUPPORT

esphome/components/ota/__init__.py

@@ -1,10 +1,15 @@
+from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome import automation
+from esphome.const import (
+    CONF_ESPHOME,
+    CONF_ON_ERROR,
+    CONF_OTA,
+    CONF_PLATFORM,
+    CONF_TRIGGER_ID,
+)
 from esphome.core import CORE, coroutine_with_priority
 
-from esphome.const import CONF_ESPHOME, CONF_OTA, CONF_PLATFORM, CONF_TRIGGER_ID
-
 CODEOWNERS = ["@esphome/core"]
 AUTO_LOAD = ["md5", "safe_mode"]
 
@@ -13,7 +18,6 @@ IS_PLATFORM_COMPONENT = True
 CONF_ON_ABORT = "on_abort"
 CONF_ON_BEGIN = "on_begin"
 CONF_ON_END = "on_end"
-CONF_ON_ERROR = "on_error"
 CONF_ON_PROGRESS = "on_progress"
 CONF_ON_STATE_CHANGE = "on_state_change"
 

esphome/components/pid/pid_climate.h

@@ -44,6 +44,8 @@ class PIDClimate : public climate::Climate, public Component {
   float get_kp() { return controller_.kp_; }
   float get_ki() { return controller_.ki_; }
   float get_kd() { return controller_.kd_; }
+  float get_min_integral() { return controller_.min_integral_; }
+  float get_max_integral() { return controller_.max_integral_; }
   float get_proportional_term() const { return controller_.proportional_term_; }
   float get_integral_term() const { return controller_.integral_term_; }
   float get_derivative_term() const { return controller_.derivative_term_; }

esphome/components/pmwcs3/pmwcs3.cpp

@@ -72,43 +72,44 @@ void PMWCS3Component::dump_config() {
   LOG_SENSOR("  ", "vwc", this->vwc_sensor_);
 }
 void PMWCS3Component::read_data_() {
-  uint8_t data[8];
-  float e25, ec, temperature, vwc;
-
   /////// Super important !!!! first activate reading PMWCS3_REG_READ_START (if not, return always the same values) ////
-
   if (!this->write_bytes(PMWCS3_REG_READ_START, nullptr, 0)) {
     this->status_set_warning();
     ESP_LOGVV(TAG, "Failed to write into REG_READ_START register !!!");
     return;
   }
-  // NOLINT  delay(100);
 
-  if (!this->read_bytes(PMWCS3_REG_GET_DATA, (uint8_t *) &data, 8)) {
-    ESP_LOGVV(TAG, "Error reading PMWCS3_REG_GET_DATA registers");
-    this->mark_failed();
-    return;
-  }
-  if (this->e25_sensor_ != nullptr) {
-    e25 = ((data[1] << 8) | data[0]) / 100.0;
-    this->e25_sensor_->publish_state(e25);
-    ESP_LOGVV(TAG, "e25: data[0]=%d, data[1]=%d, result=%f", data[0], data[1], e25);
-  }
-  if (this->ec_sensor_ != nullptr) {
-    ec = ((data[3] << 8) | data[2]) / 10.0;
-    this->ec_sensor_->publish_state(ec);
-    ESP_LOGVV(TAG, "ec: data[2]=%d, data[3]=%d, result=%f", data[2], data[3], ec);
-  }
-  if (this->temperature_sensor_ != nullptr) {
-    temperature = ((data[5] << 8) | data[4]) / 100.0;
-    this->temperature_sensor_->publish_state(temperature);
-    ESP_LOGVV(TAG, "temp: data[4]=%d, data[5]=%d, result=%f", data[4], data[5], temperature);
-  }
-  if (this->vwc_sensor_ != nullptr) {
-    vwc = ((data[7] << 8) | data[6]) / 10.0;
-    this->vwc_sensor_->publish_state(vwc);
-    ESP_LOGVV(TAG, "vwc: data[6]=%d, data[7]=%d, result=%f", data[6], data[7], vwc);
-  }
+  // Wait for the sensor to be ready.
+  // 80ms empirically determined (conservative).
+  this->set_timeout(80, [this] {
+    uint8_t data[8];
+    float e25, ec, temperature, vwc;
+    if (!this->read_bytes(PMWCS3_REG_GET_DATA, (uint8_t *) &data, 8)) {
+      ESP_LOGVV(TAG, "Error reading PMWCS3_REG_GET_DATA registers");
+      this->mark_failed();
+      return;
+    }
+    if (this->e25_sensor_ != nullptr) {
+      e25 = ((data[1] << 8) | data[0]) / 100.0;
+      this->e25_sensor_->publish_state(e25);
+      ESP_LOGVV(TAG, "e25: data[0]=%d, data[1]=%d, result=%f", data[0], data[1], e25);
+    }
+    if (this->ec_sensor_ != nullptr) {
+      ec = ((data[3] << 8) | data[2]) / 10.0;
+      this->ec_sensor_->publish_state(ec);
+      ESP_LOGVV(TAG, "ec: data[2]=%d, data[3]=%d, result=%f", data[2], data[3], ec);
+    }
+    if (this->temperature_sensor_ != nullptr) {
+      temperature = ((data[5] << 8) | data[4]) / 100.0;
+      this->temperature_sensor_->publish_state(temperature);
+      ESP_LOGVV(TAG, "temp: data[4]=%d, data[5]=%d, result=%f", data[4], data[5], temperature);
+    }
+    if (this->vwc_sensor_ != nullptr) {
+      vwc = ((data[7] << 8) | data[6]) / 10.0;
+      this->vwc_sensor_->publish_state(vwc);
+      ESP_LOGVV(TAG, "vwc: data[6]=%d, data[7]=%d, result=%f", data[6], data[7], vwc);
+    }
+  });
 }
 
 }  // namespace pmwcs3