esphome 2024.12.3__py3-none-any.whl → 2025.2.0b1__py3-none-any.whl

esphome/components/online_image/jpeg_image.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "image_decoder.h"
+#include "esphome/core/defines.h"
+#ifdef USE_ONLINE_IMAGE_JPEG_SUPPORT
+#include <JPEGDEC.h>
+
+namespace esphome {
+namespace online_image {
+
+/**
+ * @brief Image decoder specialization for JPEG images.
+ */
+class JpegDecoder : public ImageDecoder {
+ public:
+  /**
+   * @brief Construct a new JPEG Decoder object.
+   *
+   * @param display The image to decode the stream into.
+   */
+  JpegDecoder(OnlineImage *image) : ImageDecoder(image) {}
+  ~JpegDecoder() override {}
+
+  int prepare(size_t download_size) override;
+  int HOT decode(uint8_t *buffer, size_t size) override;
+
+ protected:
+  JPEGDEC jpeg_{};
+};
+
+}  // namespace online_image
+}  // namespace esphome
+
+#endif  // USE_ONLINE_IMAGE_JPEG_SUPPORT

esphome/components/online_image/online_image.cpp

@@ -6,6 +6,12 @@ static const char *const TAG = "online_image";
 
 #include "image_decoder.h"
 
+#ifdef USE_ONLINE_IMAGE_BMP_SUPPORT
+#include "bmp_image.h"
+#endif
+#ifdef USE_ONLINE_IMAGE_JPEG_SUPPORT
+#include "jpeg_image.h"
+#endif
 #ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
 #include "png_image.h"
 #endif
@@ -25,10 +31,11 @@ inline bool is_color_on(const Color &color) {
 }
 
 OnlineImage::OnlineImage(const std::string &url, int width, int height, ImageFormat format, ImageType type,
-                         uint32_t download_buffer_size)
-    : Image(nullptr, 0, 0, type),
+                         image::Transparency transparency, uint32_t download_buffer_size)
+    : Image(nullptr, 0, 0, type, transparency),
       buffer_(nullptr),
       download_buffer_(download_buffer_size),
+      download_buffer_initial_size_(download_buffer_size),
       format_(format),
       fixed_width_(width),
       fixed_height_(height) {
@@ -45,7 +52,7 @@ void OnlineImage::draw(int x, int y, display::Display *display, Color color_on,
 
 void OnlineImage::release() {
   if (this->buffer_) {
-    ESP_LOGD(TAG, "Deallocating old buffer...");
+    ESP_LOGV(TAG, "Deallocating old buffer...");
     this->allocator_.deallocate(this->buffer_, this->get_buffer_size_());
     this->data_start_ = nullptr;
     this->buffer_ = nullptr;
@@ -70,28 +77,19 @@ bool OnlineImage::resize_(int width_in, int height_in) {
   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);
+  size_t new_size = this->get_buffer_size_(width, height);
+  ESP_LOGD(TAG, "Allocating new buffer of %zu bytes", new_size);
   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);
+  if (this->buffer_ == nullptr) {
+    ESP_LOGE(TAG, "allocation of %zu bytes failed. Biggest block in heap: %zu Bytes", new_size,
+             this->allocator_.get_max_free_block_size());
     this->end_connection_();
     return false;
   }
+  this->buffer_width_ = width;
+  this->buffer_height_ = height;
+  this->width_ = width;
+  ESP_LOGV(TAG, "New size: (%d, %d)", width, height);
   return true;
 }
 
@@ -99,11 +97,38 @@ void OnlineImage::update() {
   if (this->decoder_) {
     ESP_LOGW(TAG, "Image already being updated.");
     return;
-  } else {
-    ESP_LOGI(TAG, "Updating image");
   }
+  ESP_LOGI(TAG, "Updating image %s", this->url_.c_str());
 
-  this->downloader_ = this->parent_->get(this->url_);
+  std::list<http_request::Header> headers = {};
+
+  http_request::Header accept_header;
+  accept_header.name = "Accept";
+  std::string accept_mime_type;
+  switch (this->format_) {
+#ifdef USE_ONLINE_IMAGE_BMP_SUPPORT
+    case ImageFormat::BMP:
+      accept_mime_type = "image/bmp";
+      break;
+#endif  // ONLINE_IMAGE_BMP_SUPPORT
+#ifdef USE_ONLINE_IMAGE_JPEG_SUPPORT
+    case ImageFormat::JPEG:
+      accept_mime_type = "image/jpeg";
+      break;
+#endif  // USE_ONLINE_IMAGE_JPEG_SUPPORT
+#ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
+    case ImageFormat::PNG:
+      accept_mime_type = "image/png";
+      break;
+#endif  // ONLINE_IMAGE_PNG_SUPPORT
+    default:
+      accept_mime_type = "image/*";
+  }
+  accept_header.value = accept_mime_type + ",*/*;q=0.8";
+
+  headers.push_back(accept_header);
+
+  this->downloader_ = this->parent_->get(this->url_, headers);
 
   if (this->downloader_ == nullptr) {
     ESP_LOGE(TAG, "Download failed.");
@@ -128,20 +153,39 @@ void OnlineImage::update() {
   ESP_LOGD(TAG, "Starting download");
   size_t total_size = this->downloader_->content_length;
 
+#ifdef USE_ONLINE_IMAGE_BMP_SUPPORT
+  if (this->format_ == ImageFormat::BMP) {
+    ESP_LOGD(TAG, "Allocating BMP decoder");
+    this->decoder_ = make_unique<BmpDecoder>(this);
+  }
+#endif  // ONLINE_IMAGE_BMP_SUPPORT
+#ifdef USE_ONLINE_IMAGE_JPEG_SUPPORT
+  if (this->format_ == ImageFormat::JPEG) {
+    ESP_LOGD(TAG, "Allocating JPEG decoder");
+    this->decoder_ = esphome::make_unique<JpegDecoder>(this);
+  }
+#endif  // USE_ONLINE_IMAGE_JPEG_SUPPORT
 #ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
   if (this->format_ == ImageFormat::PNG) {
-    this->decoder_ = esphome::make_unique<PngDecoder>(this);
+    ESP_LOGD(TAG, "Allocating PNG decoder");
+    this->decoder_ = make_unique<PngDecoder>(this);
   }
 #endif  // ONLINE_IMAGE_PNG_SUPPORT
 
   if (!this->decoder_) {
-    ESP_LOGE(TAG, "Could not instantiate decoder. Image format unsupported.");
+    ESP_LOGE(TAG, "Could not instantiate decoder. Image format unsupported: %d", this->format_);
     this->end_connection_();
     this->download_error_callback_.call();
     return;
   }
-  this->decoder_->prepare(total_size);
-  ESP_LOGI(TAG, "Downloading image");
+  auto prepare_result = this->decoder_->prepare(total_size);
+  if (prepare_result < 0) {
+    this->end_connection_();
+    this->download_error_callback_.call();
+    return;
+  }
+  ESP_LOGI(TAG, "Downloading image (Size: %d)", total_size);
+  this->start_time_ = ::time(nullptr);
 }
 
 void OnlineImage::loop() {
@@ -150,10 +194,12 @@ void OnlineImage::loop() {
     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_;
+    ESP_LOGD(TAG, "Image fully downloaded, read %zu bytes, width/height = %d/%d", this->downloader_->get_bytes_read(),
+             this->width_, this->height_);
+    ESP_LOGD(TAG, "Total time: %lds", ::time(nullptr) - this->start_time_);
     this->end_connection_();
     this->download_finished_callback_.call();
     return;
@@ -164,6 +210,10 @@ void OnlineImage::loop() {
   }
   size_t available = this->download_buffer_.free_capacity();
   if (available) {
+    // Some decoders need to fully download the image before downloading.
+    // In case of huge images, don't wait blocking until the whole image has been downloaded,
+    // use smaller chunks
+    available = std::min(available, this->download_buffer_initial_size_);
     auto len = this->downloader_->read(this->download_buffer_.append(), available);
     if (len > 0) {
       this->download_buffer_.write(len);
@@ -179,6 +229,19 @@ void OnlineImage::loop() {
   }
 }
 
+void OnlineImage::map_chroma_key(Color &color) {
+  if (this->transparency_ == image::TRANSPARENCY_CHROMA_KEY) {
+    if (color.g == 1 && color.r == 0 && color.b == 0) {
+      color.g = 0;
+    }
+    if (color.w < 0x80) {
+      color.r = 0;
+      color.g = this->type_ == ImageType::IMAGE_TYPE_RGB565 ? 4 : 1;
+      color.b = 0;
+    }
+  }
+}
+
 void OnlineImage::draw_pixel_(int x, int y, Color color) {
   if (!this->buffer_) {
     ESP_LOGE(TAG, "Buffer not allocated!");
@@ -192,57 +255,53 @@ void OnlineImage::draw_pixel_(int x, int y, Color color) {
   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));
+      pos = x + y * width_8;
+      auto bitno = 0x80 >> (pos % 8u);
+      pos /= 8u;
+      auto on = is_color_on(color);
+      if (this->has_transparency() && color.w < 0x80)
+        on = false;
+      if (on) {
+        this->buffer_[pos] |= bitno;
       } else {
-        this->buffer_[pos / 8u] &= ~(0x80 >> (pos % 8u));
+        this->buffer_[pos] &= ~bitno;
       }
       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 (this->transparency_ == image::TRANSPARENCY_CHROMA_KEY) {
         if (gray == 1) {
           gray = 0;
         }
         if (color.w < 0x80) {
           gray = 1;
         }
+      } else if (this->transparency_ == image::TRANSPARENCY_ALPHA_CHANNEL) {
+        if (color.w != 0xFF)
+          gray = color.w;
       }
       this->buffer_[pos] = gray;
       break;
     }
     case ImageType::IMAGE_TYPE_RGB565: {
+      this->map_chroma_key(color);
       uint16_t col565 = display::ColorUtil::color_to_565(color);
       this->buffer_[pos + 0] = static_cast<uint8_t>((col565 >> 8) & 0xFF);
       this->buffer_[pos + 1] = static_cast<uint8_t>(col565 & 0xFF);
-      if (this->has_transparency())
+      if (this->transparency_ == image::TRANSPARENCY_ALPHA_CHANNEL) {
         this->buffer_[pos + 2] = color.w;
+      }
       break;
     }
-    case ImageType::IMAGE_TYPE_RGBA: {
+    case ImageType::IMAGE_TYPE_RGB: {
+      this->map_chroma_key(color);
       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;
-        }
+      if (this->transparency_ == image::TRANSPARENCY_ALPHA_CHANNEL) {
+        this->buffer_[pos + 3] = color.w;
       }
-      this->buffer_[pos + 0] = color.r;
-      this->buffer_[pos + 1] = color.g;
-      this->buffer_[pos + 2] = color.b;
       break;
     }
   }

esphome/components/online_image/online_image.h

@@ -1,10 +1,10 @@
 #pragma once
 
+#include "esphome/components/http_request/http_request.h"
+#include "esphome/components/image/image.h"
 #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"
 
@@ -23,10 +23,12 @@ using t_http_codes = enum {
 enum ImageFormat {
   /** Automatically detect from MIME type. Not supported yet. */
   AUTO,
-  /** JPEG format. Not supported yet. */
+  /** JPEG format. */
   JPEG,
   /** PNG format. */
   PNG,
+  /** BMP format. */
+  BMP,
 };
 
 /**
@@ -48,12 +50,13 @@ class OnlineImage : public PollingComponent,
    * @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);
+              image::Transparency transparency, 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;
+  void map_chroma_key(Color &color);
 
   /** Set the URL to download the image from. */
   void set_url(const std::string &url) {
@@ -76,14 +79,20 @@ class OnlineImage : public PollingComponent,
    */
   void release();
 
+  /**
+   * Resize the download buffer
+   *
+   * @param size The new size for the download buffer.
+   */
+  size_t resize_download_buffer(size_t size) { return this->download_buffer_.resize(size); }
+
   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};
+  RAMAllocator<uint8_t> allocator_{};
 
   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 (this->get_bpp() * width + 7u) / 8u * height; }
@@ -117,6 +126,12 @@ class OnlineImage : public PollingComponent,
 
   uint8_t *buffer_;
   DownloadBuffer download_buffer_;
+  /**
+   * This is the *initial* size of the download buffer, not the current size.
+   * The download buffer can be resized at runtime; the download_buffer_initial_size_
+   * will *not* change even if the download buffer has been resized.
+   */
+  size_t download_buffer_initial_size_;
 
   const ImageFormat format_;
   image::Image *placeholder_{nullptr};
@@ -146,7 +161,9 @@ class OnlineImage : public PollingComponent,
    */
   int buffer_height_;
 
-  friend void ImageDecoder::set_size(int width, int height);
+  time_t start_time_;
+
+  friend bool ImageDecoder::set_size(int width, int height);
   friend void ImageDecoder::draw(int x, int y, int w, int h, const Color &color);
 };
 

esphome/components/online_image/png_image.cpp

@@ -2,7 +2,6 @@
 #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"
 
@@ -41,17 +40,22 @@ static void draw_callback(pngle_t *pngle, uint32_t x, uint32_t y, uint32_t w, ui
   decoder->draw(x, y, w, h, color);
 }
 
-void PngDecoder::prepare(uint32_t download_size) {
+int PngDecoder::prepare(size_t download_size) {
   ImageDecoder::prepare(download_size);
+  if (!this->pngle_) {
+    ESP_LOGE(TAG, "PNG decoder engine not initialized!");
+    return DECODE_ERROR_OUT_OF_MEMORY;
+  }
   pngle_set_user_data(this->pngle_, this);
   pngle_set_init_callback(this->pngle_, init_callback);
   pngle_set_draw_callback(this->pngle_, draw_callback);
+  return 0;
 }
 
 int HOT PngDecoder::decode(uint8_t *buffer, size_t size) {
   if (!this->pngle_) {
     ESP_LOGE(TAG, "PNG decoder engine not initialized!");
-    return -1;
+    return DECODE_ERROR_OUT_OF_MEMORY;
   }
   if (size < 256 && size < this->download_size_ - this->decoded_bytes_) {
     ESP_LOGD(TAG, "Waiting for data");

esphome/components/online_image/png_image.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "image_decoder.h"
+#include "esphome/core/defines.h"
 #ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
 #include <pngle.h>
 
@@ -20,7 +21,7 @@ class PngDecoder : public ImageDecoder {
   PngDecoder(OnlineImage *image) : ImageDecoder(image), pngle_(pngle_new()) {}
   ~PngDecoder() override { pngle_destroy(this->pngle_); }
 
-  void prepare(uint32_t download_size) override;
+  int prepare(size_t download_size) override;
   int HOT decode(uint8_t *buffer, size_t size) override;
 
  protected:

esphome/components/opentherm/__init__.py

@@ -1,10 +1,12 @@
 from typing import Any
 
+import logging
+from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
 from esphome.components import sensor
-from esphome.const import CONF_ID, PLATFORM_ESP32, PLATFORM_ESP8266
+from esphome.const import CONF_ID, PLATFORM_ESP32, PLATFORM_ESP8266, CONF_TRIGGER_ID
 from . import const, schema, validate, generate
 
 CODEOWNERS = ["@olegtarasov"]
@@ -20,7 +22,21 @@ CONF_CH2_ACTIVE = "ch2_active"
 CONF_SUMMER_MODE_ACTIVE = "summer_mode_active"
 CONF_DHW_BLOCK = "dhw_block"
 CONF_SYNC_MODE = "sync_mode"
-CONF_OPENTHERM_VERSION = "opentherm_version"
+CONF_OPENTHERM_VERSION = "opentherm_version"  # Deprecated, will be removed
+CONF_BEFORE_SEND = "before_send"
+CONF_BEFORE_PROCESS_RESPONSE = "before_process_response"
+
+# Triggers
+BeforeSendTrigger = generate.opentherm_ns.class_(
+    "BeforeSendTrigger",
+    automation.Trigger.template(generate.OpenthermData.operator("ref")),
+)
+BeforeProcessResponseTrigger = generate.opentherm_ns.class_(
+    "BeforeProcessResponseTrigger",
+    automation.Trigger.template(generate.OpenthermData.operator("ref")),
+)
+
+_LOGGER = logging.getLogger(__name__)
 
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
@@ -36,7 +52,19 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_SUMMER_MODE_ACTIVE, False): cv.boolean,
             cv.Optional(CONF_DHW_BLOCK, False): cv.boolean,
             cv.Optional(CONF_SYNC_MODE, False): cv.boolean,
-            cv.Optional(CONF_OPENTHERM_VERSION): cv.positive_float,
+            cv.Optional(CONF_OPENTHERM_VERSION): cv.positive_float,  # Deprecated
+            cv.Optional(CONF_BEFORE_SEND): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(BeforeSendTrigger),
+                }
+            ),
+            cv.Optional(CONF_BEFORE_PROCESS_RESPONSE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BeforeProcessResponseTrigger
+                    ),
+                }
+            ),
         }
     )
     .extend(
@@ -44,6 +72,11 @@ CONFIG_SCHEMA = cv.All(
             schema.INPUTS, (lambda _: cv.use_id(sensor.Sensor))
         )
     )
+    .extend(
+        validate.create_entities_schema(
+            schema.SETTINGS, (lambda s: s.validation_schema)
+        )
+    )
     .extend(cv.COMPONENT_SCHEMA),
     cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266]),
 )
@@ -60,18 +93,33 @@ async def to_code(config: dict[str, Any]) -> None:
     out_pin = await cg.gpio_pin_expression(config[CONF_OUT_PIN])
     cg.add(var.set_out_pin(out_pin))
 
-    non_sensors = {CONF_ID, CONF_IN_PIN, CONF_OUT_PIN}
+    non_sensors = {
+        CONF_ID,
+        CONF_IN_PIN,
+        CONF_OUT_PIN,
+        CONF_BEFORE_SEND,
+        CONF_BEFORE_PROCESS_RESPONSE,
+    }
     input_sensors = []
+    settings = []
     for key, value in config.items():
         if key in non_sensors:
             continue
         if key in schema.INPUTS:
             input_sensor = await cg.get_variable(value)
-            cg.add(
-                getattr(var, f"set_{key}_{const.INPUT_SENSOR.lower()}")(input_sensor)
-            )
+            cg.add(getattr(var, f"set_{key}_{const.INPUT_SENSOR}")(input_sensor))
             input_sensors.append(key)
+        elif key in schema.SETTINGS:
+            if value == schema.SETTINGS[key].default_value:
+                continue
+            cg.add(getattr(var, f"set_{key}_{const.SETTING}")(value))
+            settings.append(key)
         else:
+            if key == CONF_OPENTHERM_VERSION:
+                _LOGGER.warning(
+                    "opentherm_version is deprecated and will be removed in esphome 2025.2.0\n"
+                    "Please change to 'opentherm_version_controller'."
+                )
             cg.add(getattr(var, f"set_{key}")(value))
 
     if len(input_sensors) > 0:
@@ -81,3 +129,21 @@ async def to_code(config: dict[str, Any]) -> None:
         )
         generate.define_readers(const.INPUT_SENSOR, input_sensors)
         generate.add_messages(var, input_sensors, schema.INPUTS)
+
+    if len(settings) > 0:
+        generate.define_has_settings(settings, schema.SETTINGS)
+        generate.define_message_handler(const.SETTING, settings, schema.SETTINGS)
+        generate.define_setting_readers(const.SETTING, settings)
+        generate.add_messages(var, settings, schema.SETTINGS)
+
+    for conf in config.get(CONF_BEFORE_SEND, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(generate.OpenthermData.operator("ref"), "x")], conf
+        )
+
+    for conf in config.get(CONF_BEFORE_PROCESS_RESPONSE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(generate.OpenthermData.operator("ref"), "x")], conf
+        )

esphome/components/opentherm/automation.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "hub.h"
+#include "opentherm.h"
+
+namespace esphome {
+namespace opentherm {
+
+class BeforeSendTrigger : public Trigger<OpenthermData &> {
+ public:
+  BeforeSendTrigger(OpenthermHub *hub) {
+    hub->add_on_before_send_callback([this](OpenthermData &x) { this->trigger(x); });
+  }
+};
+
+class BeforeProcessResponseTrigger : public Trigger<OpenthermData &> {
+ public:
+  BeforeProcessResponseTrigger(OpenthermHub *hub) {
+    hub->add_on_before_process_response_callback([this](OpenthermData &x) { this->trigger(x); });
+  }
+};
+
+}  // namespace opentherm
+}  // namespace esphome

esphome/components/opentherm/const.py

@@ -9,3 +9,4 @@ SWITCH = "switch"
 NUMBER = "number"
 OUTPUT = "output"
 INPUT_SENSOR = "input_sensor"
+SETTING = "setting"

esphome/components/opentherm/generate.py

@@ -1,13 +1,14 @@
 from collections.abc import Awaitable
-from typing import Any, Callable
+from typing import Any, Callable, Optional
 
 import esphome.codegen as cg
 from esphome.const import CONF_ID
 from . import const
-from .schema import TSchema
+from .schema import TSchema, SettingSchema
 
 opentherm_ns = cg.esphome_ns.namespace("opentherm")
 OpenthermHub = opentherm_ns.class_("OpenthermHub", cg.Component)
+OpenthermData = opentherm_ns.class_("OpenthermData")
 
 
 def define_has_component(component_type: str, keys: list[str]) -> None:
@@ -21,6 +22,24 @@ def define_has_component(component_type: str, keys: list[str]) -> None:
         cg.add_define(f"OPENTHERM_HAS_{component_type.upper()}_{key}")
 
 
+# We need a separate set of macros for settings because there are different backing field types we need to take
+# into account
+def define_has_settings(keys: list[str], schemas: dict[str, SettingSchema]) -> None:
+    cg.add_define(
+        "OPENTHERM_SETTING_LIST(F, sep)",
+        cg.RawExpression(
+            " sep ".join(
+                map(
+                    lambda key: f"F({schemas[key].backing_type}, {key}_setting, {schemas[key].default_value})",
+                    keys,
+                )
+            )
+        ),
+    )
+    for key in keys:
+        cg.add_define(f"OPENTHERM_HAS_SETTING_{key}")
+
+
 def define_message_handler(
     component_type: str, keys: list[str], schemas: dict[str, TSchema]
 ) -> None:
@@ -74,16 +93,30 @@ def define_readers(component_type: str, keys: list[str]) -> None:
         )
 
 
+def define_setting_readers(component_type: str, keys: list[str]) -> None:
+    for key in keys:
+        cg.add_define(
+            f"OPENTHERM_READ_{key}",
+            cg.RawExpression(f"this->{key}_{component_type.lower()}"),
+        )
+
+
 def add_messages(hub: cg.MockObj, keys: list[str], schemas: dict[str, TSchema]):
-    messages: set[tuple[str, bool]] = set()
+    messages: dict[str, tuple[bool, Optional[int]]] = {}
     for key in keys:
-        messages.add((schemas[key].message, schemas[key].keep_updated))
-    for msg, keep_updated in messages:
+        messages[schemas[key].message] = (
+            schemas[key].keep_updated,
+            schemas[key].order if hasattr(schemas[key], "order") else None,
+        )
+    for msg, (keep_updated, order) in messages.items():
         msg_expr = cg.RawExpression(f"esphome::opentherm::MessageId::{msg}")
         if keep_updated:
             cg.add(hub.add_repeating_message(msg_expr))
         else:
-            cg.add(hub.add_initial_message(msg_expr))
+            if order is not None:
+                cg.add(hub.add_initial_message(msg_expr, order))
+            else:
+                cg.add(hub.add_initial_message(msg_expr))
 
 
 def add_property_set(var: cg.MockObj, config_key: str, config: dict[str, Any]) -> None: