esphome 2024.10.3__py3-none-any.whl → 2024.11.0b1__py3-none-any.whl

esphome/components/online_image/online_image.cpp

@@ -215,16 +215,10 @@ void OnlineImage::draw_pixel_(int x, int y, Color color) {
     }
     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);
+      if (this->has_transparency())
+        this->buffer_[pos + 2] = color.w;
       break;
     }
     case ImageType::IMAGE_TYPE_RGBA: {

esphome/components/online_image/online_image.h

@@ -86,13 +86,9 @@ class OnlineImage : public PollingComponent,
   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_buffer_size_(int width, int height) const { return (this->get_bpp() * width + 7u) / 8u * height; }
 
-  int get_position_(int x, int y) const {
-    return ((x + y * this->buffer_width_) * image::image_type_to_bpp(this->type_)) / 8;
-  }
+  int get_position_(int x, int y) const { return (x + y * this->buffer_width_) * this->get_bpp() / 8; }
 
   ESPHOME_ALWAYS_INLINE bool auto_resize_() const { return this->fixed_width_ == 0 || this->fixed_height_ == 0; }
 

esphome/components/opentherm/__init__.py

@@ -1,9 +1,11 @@
 from typing import Any
 
-from esphome import pins
 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 . import const, schema, validate, generate
 
 CODEOWNERS = ["@olegtarasov"]
 MULTI_CONF = True
@@ -15,15 +17,15 @@ CONF_DHW_ENABLE = "dhw_enable"
 CONF_COOLING_ENABLE = "cooling_enable"
 CONF_OTC_ACTIVE = "otc_active"
 CONF_CH2_ACTIVE = "ch2_active"
+CONF_SUMMER_MODE_ACTIVE = "summer_mode_active"
+CONF_DHW_BLOCK = "dhw_block"
 CONF_SYNC_MODE = "sync_mode"
-
-opentherm_ns = cg.esphome_ns.namespace("opentherm")
-OpenthermHub = opentherm_ns.class_("OpenthermHub", cg.Component)
+CONF_OPENTHERM_VERSION = "opentherm_version"
 
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
-            cv.GenerateID(): cv.declare_id(OpenthermHub),
+            cv.GenerateID(): cv.declare_id(generate.OpenthermHub),
             cv.Required(CONF_IN_PIN): pins.internal_gpio_input_pin_schema,
             cv.Required(CONF_OUT_PIN): pins.internal_gpio_output_pin_schema,
             cv.Optional(CONF_CH_ENABLE, True): cv.boolean,
@@ -31,16 +33,23 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_COOLING_ENABLE, False): cv.boolean,
             cv.Optional(CONF_OTC_ACTIVE, False): cv.boolean,
             cv.Optional(CONF_CH2_ACTIVE, False): cv.boolean,
+            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,
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(
+        validate.create_entities_schema(
+            schema.INPUTS, (lambda _: cv.use_id(sensor.Sensor))
+        )
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266]),
 )
 
 
 async def to_code(config: dict[str, Any]) -> None:
-    # Create the hub, passing the two callbacks defined below
-    # Since the hub is used in the callbacks, we need to define it first
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
@@ -52,6 +61,23 @@ async def to_code(config: dict[str, Any]) -> None:
     cg.add(var.set_out_pin(out_pin))
 
     non_sensors = {CONF_ID, CONF_IN_PIN, CONF_OUT_PIN}
+    input_sensors = []
     for key, value in config.items():
-        if key not in non_sensors:
+        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)
+            )
+            input_sensors.append(key)
+        else:
             cg.add(getattr(var, f"set_{key}")(value))
+
+    if len(input_sensors) > 0:
+        generate.define_has_component(const.INPUT_SENSOR, input_sensors)
+        generate.define_message_handler(
+            const.INPUT_SENSOR, input_sensors, schema.INPUTS
+        )
+        generate.define_readers(const.INPUT_SENSOR, input_sensors)
+        generate.add_messages(var, input_sensors, schema.INPUTS)

esphome/components/opentherm/binary_sensor/__init__.py

@@ -0,0 +1,33 @@
+from typing import Any
+
+import esphome.config_validation as cv
+from esphome.components import binary_sensor
+from .. import const, schema, validate, generate
+
+DEPENDENCIES = [const.OPENTHERM]
+COMPONENT_TYPE = const.BINARY_SENSOR
+
+
+def get_entity_validation_schema(entity: schema.BinarySensorSchema) -> cv.Schema:
+    return binary_sensor.binary_sensor_schema(
+        device_class=(
+            entity.device_class
+            or binary_sensor._UNDEF  # pylint: disable=protected-access
+        ),
+        icon=(entity.icon or binary_sensor._UNDEF),  # pylint: disable=protected-access
+    )
+
+
+CONFIG_SCHEMA = validate.create_component_schema(
+    schema.BINARY_SENSORS, get_entity_validation_schema
+)
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    await generate.component_to_code(
+        COMPONENT_TYPE,
+        schema.BINARY_SENSORS,
+        binary_sensor.BinarySensor,
+        generate.create_only_conf(binary_sensor.new_binary_sensor),
+        config,
+    )

esphome/components/opentherm/const.py

@@ -0,0 +1,11 @@
+OPENTHERM = "opentherm"
+
+CONF_OPENTHERM_ID = "opentherm_id"
+CONF_DATA_TYPE = "data_type"
+
+SENSOR = "sensor"
+BINARY_SENSOR = "binary_sensor"
+SWITCH = "switch"
+NUMBER = "number"
+OUTPUT = "output"
+INPUT_SENSOR = "input_sensor"

esphome/components/opentherm/generate.py

@@ -0,0 +1,142 @@
+from collections.abc import Awaitable
+from typing import Any, Callable
+
+import esphome.codegen as cg
+from esphome.const import CONF_ID
+from . import const
+from .schema import TSchema
+
+opentherm_ns = cg.esphome_ns.namespace("opentherm")
+OpenthermHub = opentherm_ns.class_("OpenthermHub", cg.Component)
+
+
+def define_has_component(component_type: str, keys: list[str]) -> None:
+    cg.add_define(
+        f"OPENTHERM_{component_type.upper()}_LIST(F, sep)",
+        cg.RawExpression(
+            " sep ".join(map(lambda key: f"F({key}_{component_type.lower()})", keys))
+        ),
+    )
+    for key in keys:
+        cg.add_define(f"OPENTHERM_HAS_{component_type.upper()}_{key}")
+
+
+def define_message_handler(
+    component_type: str, keys: list[str], schemas: dict[str, TSchema]
+) -> None:
+    # The macros defined here should be able to generate things like this:
+    # // Parsing a message and publishing to sensors
+    # case MessageId::Message:
+    #     // Can have multiple sensors here, for example for a Status message with multiple flags
+    #     this->thing_binary_sensor->publish_state(parse_flag8_lb_0(response));
+    #     this->other_binary_sensor->publish_state(parse_flag8_lb_1(response));
+    #     break;
+    # // Building a message for a write request
+    # case MessageId::Message: {
+    #     unsigned int data = 0;
+    #     data = write_flag8_lb_0(some_input_switch->state, data); // Where input_sensor can also be a number/output/switch
+    #     data = write_u8_hb(some_number->state, data);
+    #     return opentherm_->build_request_(MessageType::WriteData, MessageId::Message, data);
+    # }
+
+    messages: dict[str, list[tuple[str, str]]] = {}
+    for key in keys:
+        msg = schemas[key].message
+        if msg not in messages:
+            messages[msg] = []
+        messages[msg].append((key, schemas[key].message_data))
+
+    cg.add_define(
+        f"OPENTHERM_{component_type.upper()}_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)",
+        cg.RawExpression(
+            " msg_sep ".join(
+                [
+                    f"MESSAGE({msg}) "
+                    + " entity_sep ".join(
+                        [
+                            f"ENTITY({key}_{component_type.lower()}, {msg_data})"
+                            for key, msg_data in keys
+                        ]
+                    )
+                    + " postscript"
+                    for msg, keys in messages.items()
+                ]
+            )
+        ),
+    )
+
+
+def define_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()}->state"),
+        )
+
+
+def add_messages(hub: cg.MockObj, keys: list[str], schemas: dict[str, TSchema]):
+    messages: set[tuple[str, bool]] = set()
+    for key in keys:
+        messages.add((schemas[key].message, schemas[key].keep_updated))
+    for msg, keep_updated in messages:
+        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))
+
+
+def add_property_set(var: cg.MockObj, config_key: str, config: dict[str, Any]) -> None:
+    if config_key in config:
+        cg.add(getattr(var, f"set_{config_key}")(config[config_key]))
+
+
+Create = Callable[[dict[str, Any], str, cg.MockObj], Awaitable[cg.Pvariable]]
+
+
+def create_only_conf(
+    create: Callable[[dict[str, Any]], Awaitable[cg.Pvariable]]
+) -> Create:
+    return lambda conf, _key, _hub: create(conf)
+
+
+async def component_to_code(
+    component_type: str,
+    schemas: dict[str, TSchema],
+    type: cg.MockObjClass,
+    create: Create,
+    config: dict[str, Any],
+) -> list[str]:
+    """Generate the code for each configured component in the schema of a component type.
+
+    Parameters:
+    - component_type: The type of component, e.g. "sensor" or "binary_sensor"
+    - schema_: The schema for that component type, a list of available components
+    - type: The type of the component, e.g. sensor.Sensor or OpenthermOutput
+    - create: A constructor function for the component, which receives the config,
+      the key and the hub and should asynchronously return the new component
+    - config: The configuration for this component type
+
+    Returns: The list of keys for the created components
+    """
+    cg.add_define(f"OPENTHERM_USE_{component_type.upper()}")
+
+    hub = await cg.get_variable(config[const.CONF_OPENTHERM_ID])
+
+    keys: list[str] = []
+    for key, conf in config.items():
+        if not isinstance(conf, dict):
+            continue
+        id = conf[CONF_ID]
+        if id and id.type == type:
+            entity = await create(conf, key, hub)
+            if const.CONF_DATA_TYPE in conf:
+                schemas[key].message_data = conf[const.CONF_DATA_TYPE]
+            cg.add(getattr(hub, f"set_{key}_{component_type.lower()}")(entity))
+            keys.append(key)
+
+    define_has_component(component_type, keys)
+    define_message_handler(component_type, keys, schemas)
+    add_messages(hub, keys, schemas)
+
+    return keys

esphome/components/opentherm/hub.cpp

@@ -7,50 +7,147 @@ namespace esphome {
 namespace opentherm {
 
 static const char *const TAG = "opentherm";
-
-OpenthermData OpenthermHub::build_request_(MessageId request_id) {
+namespace message_data {
+bool parse_flag8_lb_0(OpenthermData &data) { return read_bit(data.valueLB, 0); }
+bool parse_flag8_lb_1(OpenthermData &data) { return read_bit(data.valueLB, 1); }
+bool parse_flag8_lb_2(OpenthermData &data) { return read_bit(data.valueLB, 2); }
+bool parse_flag8_lb_3(OpenthermData &data) { return read_bit(data.valueLB, 3); }
+bool parse_flag8_lb_4(OpenthermData &data) { return read_bit(data.valueLB, 4); }
+bool parse_flag8_lb_5(OpenthermData &data) { return read_bit(data.valueLB, 5); }
+bool parse_flag8_lb_6(OpenthermData &data) { return read_bit(data.valueLB, 6); }
+bool parse_flag8_lb_7(OpenthermData &data) { return read_bit(data.valueLB, 7); }
+bool parse_flag8_hb_0(OpenthermData &data) { return read_bit(data.valueHB, 0); }
+bool parse_flag8_hb_1(OpenthermData &data) { return read_bit(data.valueHB, 1); }
+bool parse_flag8_hb_2(OpenthermData &data) { return read_bit(data.valueHB, 2); }
+bool parse_flag8_hb_3(OpenthermData &data) { return read_bit(data.valueHB, 3); }
+bool parse_flag8_hb_4(OpenthermData &data) { return read_bit(data.valueHB, 4); }
+bool parse_flag8_hb_5(OpenthermData &data) { return read_bit(data.valueHB, 5); }
+bool parse_flag8_hb_6(OpenthermData &data) { return read_bit(data.valueHB, 6); }
+bool parse_flag8_hb_7(OpenthermData &data) { return read_bit(data.valueHB, 7); }
+uint8_t parse_u8_lb(OpenthermData &data) { return data.valueLB; }
+uint8_t parse_u8_hb(OpenthermData &data) { return data.valueHB; }
+int8_t parse_s8_lb(OpenthermData &data) { return (int8_t) data.valueLB; }
+int8_t parse_s8_hb(OpenthermData &data) { return (int8_t) data.valueHB; }
+uint16_t parse_u16(OpenthermData &data) { return data.u16(); }
+uint16_t parse_u8_lb_60(OpenthermData &data) { return data.valueLB * 60; }
+uint16_t parse_u8_hb_60(OpenthermData &data) { return data.valueHB * 60; }
+int16_t parse_s16(OpenthermData &data) { return data.s16(); }
+float parse_f88(OpenthermData &data) { return data.f88(); }
+
+void write_flag8_lb_0(const bool value, OpenthermData &data) { data.valueLB = write_bit(data.valueLB, 0, value); }
+void write_flag8_lb_1(const bool value, OpenthermData &data) { data.valueLB = write_bit(data.valueLB, 1, value); }
+void write_flag8_lb_2(const bool value, OpenthermData &data) { data.valueLB = write_bit(data.valueLB, 2, value); }
+void write_flag8_lb_3(const bool value, OpenthermData &data) { data.valueLB = write_bit(data.valueLB, 3, value); }
+void write_flag8_lb_4(const bool value, OpenthermData &data) { data.valueLB = write_bit(data.valueLB, 4, value); }
+void write_flag8_lb_5(const bool value, OpenthermData &data) { data.valueLB = write_bit(data.valueLB, 5, value); }
+void write_flag8_lb_6(const bool value, OpenthermData &data) { data.valueLB = write_bit(data.valueLB, 6, value); }
+void write_flag8_lb_7(const bool value, OpenthermData &data) { data.valueLB = write_bit(data.valueLB, 7, value); }
+void write_flag8_hb_0(const bool value, OpenthermData &data) { data.valueHB = write_bit(data.valueHB, 0, value); }
+void write_flag8_hb_1(const bool value, OpenthermData &data) { data.valueHB = write_bit(data.valueHB, 1, value); }
+void write_flag8_hb_2(const bool value, OpenthermData &data) { data.valueHB = write_bit(data.valueHB, 2, value); }
+void write_flag8_hb_3(const bool value, OpenthermData &data) { data.valueHB = write_bit(data.valueHB, 3, value); }
+void write_flag8_hb_4(const bool value, OpenthermData &data) { data.valueHB = write_bit(data.valueHB, 4, value); }
+void write_flag8_hb_5(const bool value, OpenthermData &data) { data.valueHB = write_bit(data.valueHB, 5, value); }
+void write_flag8_hb_6(const bool value, OpenthermData &data) { data.valueHB = write_bit(data.valueHB, 6, value); }
+void write_flag8_hb_7(const bool value, OpenthermData &data) { data.valueHB = write_bit(data.valueHB, 7, value); }
+void write_u8_lb(const uint8_t value, OpenthermData &data) { data.valueLB = value; }
+void write_u8_hb(const uint8_t value, OpenthermData &data) { data.valueHB = value; }
+void write_s8_lb(const int8_t value, OpenthermData &data) { data.valueLB = (uint8_t) value; }
+void write_s8_hb(const int8_t value, OpenthermData &data) { data.valueHB = (uint8_t) value; }
+void write_u16(const uint16_t value, OpenthermData &data) { data.u16(value); }
+void write_s16(const int16_t value, OpenthermData &data) { data.s16(value); }
+void write_f88(const float value, OpenthermData &data) { data.f88(value); }
+
+}  // namespace message_data
+
+OpenthermData OpenthermHub::build_request_(MessageId request_id) const {
   OpenthermData data;
   data.type = 0;
   data.id = 0;
   data.valueHB = 0;
   data.valueLB = 0;
 
-  // First, handle the status request. This requires special logic, because we
-  // wouldn't want to inadvertently disable domestic hot water, for example.
-  // It is also included in the macro-generated code below, but that will
-  // never be executed, because we short-circuit it here.
+  // We need this special logic for STATUS message because we have two options for specifying boiler modes:
+  // with static config values in the hub, or with separate switches.
   if (request_id == MessageId::STATUS) {
-    bool const ch_enabled = this->ch_enable;
-    bool dhw_enabled = this->dhw_enable;
-    bool cooling_enabled = this->cooling_enable;
-    bool otc_enabled = this->otc_active;
-    bool ch2_enabled = this->ch2_active;
+    // NOLINTBEGIN
+    bool const ch_enabled = this->ch_enable && OPENTHERM_READ_ch_enable && OPENTHERM_READ_t_set > 0.0;
+    bool const dhw_enabled = this->dhw_enable && OPENTHERM_READ_dhw_enable;
+    bool const cooling_enabled =
+        this->cooling_enable && OPENTHERM_READ_cooling_enable && OPENTHERM_READ_cooling_control > 0.0;
+    bool const otc_enabled = this->otc_active && OPENTHERM_READ_otc_active;
+    bool const ch2_enabled = this->ch2_active && OPENTHERM_READ_ch2_active && OPENTHERM_READ_t_set_ch2 > 0.0;
+    bool const summer_mode_is_active = this->summer_mode_active && OPENTHERM_READ_summer_mode_active;
+    bool const dhw_blocked = this->dhw_block && OPENTHERM_READ_dhw_block;
+    // NOLINTEND
 
     data.type = MessageType::READ_DATA;
     data.id = MessageId::STATUS;
-    data.valueHB = ch_enabled | (dhw_enabled << 1) | (cooling_enabled << 2) | (otc_enabled << 3) | (ch2_enabled << 4);
+    data.valueHB = ch_enabled | (dhw_enabled << 1) | (cooling_enabled << 2) | (otc_enabled << 3) | (ch2_enabled << 4) |
+                   (summer_mode_is_active << 5) | (dhw_blocked << 6);
+
+    return data;
+  }
+
+  // Another special case is OpenTherm version number which is configured at hub level as a constant
+  if (request_id == MessageId::OT_VERSION_CONTROLLER) {
+    data.type = MessageType::WRITE_DATA;
+    data.id = MessageId::OT_VERSION_CONTROLLER;
+    data.f88(this->opentherm_version_);
+
+    return data;
+  }
 
 // Disable incomplete switch statement warnings, because the cases in each
 // switch are generated based on the configured sensors and inputs.
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch"
 
-    // TODO: This is a placeholder for an auto-generated switch statement which builds request structure based on
-    // which sensors are enabled in config.
+  // Next, we start with the write requests from switches and other inputs,
+  // because we would want to write that data if it is available, rather than
+  // request a read for that type (in the case that both read and write are
+  // supported).
+  switch (request_id) {
+    OPENTHERM_SWITCH_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_WRITE_MESSAGE, OPENTHERM_MESSAGE_WRITE_ENTITY, ,
+                                      OPENTHERM_MESSAGE_WRITE_POSTSCRIPT, )
+    OPENTHERM_NUMBER_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_WRITE_MESSAGE, OPENTHERM_MESSAGE_WRITE_ENTITY, ,
+                                      OPENTHERM_MESSAGE_WRITE_POSTSCRIPT, )
+    OPENTHERM_OUTPUT_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_WRITE_MESSAGE, OPENTHERM_MESSAGE_WRITE_ENTITY, ,
+                                      OPENTHERM_MESSAGE_WRITE_POSTSCRIPT, )
+    OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_WRITE_MESSAGE, OPENTHERM_MESSAGE_WRITE_ENTITY, ,
+                                            OPENTHERM_MESSAGE_WRITE_POSTSCRIPT, )
+  }
 
+  // Finally, handle the simple read requests, which only change with the message id.
+  switch (request_id) { OPENTHERM_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_READ_MESSAGE, OPENTHERM_IGNORE, , , ) }
+  switch (request_id) {
+    OPENTHERM_BINARY_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_READ_MESSAGE, OPENTHERM_IGNORE, , , )
+  }
 #pragma GCC diagnostic pop
 
-    return data;
-  }
-  return OpenthermData();
+  // And if we get here, a message was requested which somehow wasn't handled.
+  // This shouldn't happen due to the way the defines are configured, so we
+  // log an error and just return a 0 message.
+  ESP_LOGE(TAG, "Tried to create a request with unknown id %d. This should never happen, so please open an issue.",
+           request_id);
+  return {};
 }
 
-OpenthermHub::OpenthermHub() : Component() {}
+OpenthermHub::OpenthermHub() : Component(), in_pin_{}, out_pin_{} {}
 
 void OpenthermHub::process_response(OpenthermData &data) {
   ESP_LOGD(TAG, "Received OpenTherm response with id %d (%s)", data.id,
            this->opentherm_->message_id_to_str((MessageId) data.id));
   ESP_LOGD(TAG, "%s", this->opentherm_->debug_data(data).c_str());
+
+  switch (data.id) {
+    OPENTHERM_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_RESPONSE_MESSAGE, OPENTHERM_MESSAGE_RESPONSE_ENTITY, ,
+                                      OPENTHERM_MESSAGE_RESPONSE_POSTSCRIPT, )
+  }
+  switch (data.id) {
+    OPENTHERM_BINARY_SENSOR_MESSAGE_HANDLERS(OPENTHERM_MESSAGE_RESPONSE_MESSAGE, OPENTHERM_MESSAGE_RESPONSE_ENTITY, ,
+                                             OPENTHERM_MESSAGE_RESPONSE_POSTSCRIPT, )
+  }
 }
 
 void OpenthermHub::setup() {
@@ -67,6 +164,13 @@ void OpenthermHub::setup() {
   // good practice anyway.
   this->add_repeating_message(MessageId::STATUS);
 
+  // Also ensure that we start communication with the STATUS message
+  this->initial_messages_.insert(this->initial_messages_.begin(), MessageId::STATUS);
+
+  if (this->opentherm_version_ > 0.0f) {
+    this->initial_messages_.insert(this->initial_messages_.begin(), MessageId::OT_VERSION_CONTROLLER);
+  }
+
   this->current_message_iterator_ = this->initial_messages_.begin();
 }
 
@@ -254,22 +358,24 @@ void OpenthermHub::handle_timeout_error_() {
   this->stop_opentherm_();
 }
 
-#define ID(x) x
-#define SHOW2(x) #x
-#define SHOW(x) SHOW2(x)
-
 void OpenthermHub::dump_config() {
   ESP_LOGCONFIG(TAG, "OpenTherm:");
   LOG_PIN("  In: ", this->in_pin_);
   LOG_PIN("  Out: ", this->out_pin_);
   ESP_LOGCONFIG(TAG, "  Sync mode: %d", this->sync_mode_);
+  ESP_LOGCONFIG(TAG, "  Sensors: %s", SHOW(OPENTHERM_SENSOR_LIST(ID, )));
+  ESP_LOGCONFIG(TAG, "  Binary sensors: %s", SHOW(OPENTHERM_BINARY_SENSOR_LIST(ID, )));
+  ESP_LOGCONFIG(TAG, "  Switches: %s", SHOW(OPENTHERM_SWITCH_LIST(ID, )));
+  ESP_LOGCONFIG(TAG, "  Input sensors: %s", SHOW(OPENTHERM_INPUT_SENSOR_LIST(ID, )));
+  ESP_LOGCONFIG(TAG, "  Outputs: %s", SHOW(OPENTHERM_OUTPUT_LIST(ID, )));
+  ESP_LOGCONFIG(TAG, "  Numbers: %s", SHOW(OPENTHERM_NUMBER_LIST(ID, )));
   ESP_LOGCONFIG(TAG, "  Initial requests:");
   for (auto type : this->initial_messages_) {
-    ESP_LOGCONFIG(TAG, "  - %d", type);
+    ESP_LOGCONFIG(TAG, "  - %d (%s)", type, this->opentherm_->message_id_to_str((type)));
   }
   ESP_LOGCONFIG(TAG, "  Repeating requests:");
   for (auto type : this->repeating_messages_) {
-    ESP_LOGCONFIG(TAG, "  - %d", type);
+    ESP_LOGCONFIG(TAG, "  - %d (%s)", type, this->opentherm_->message_id_to_str((type)));
   }
 }
 

esphome/components/opentherm/hub.h

@@ -4,14 +4,37 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/component.h"
 #include "esphome/core/log.h"
+#include <vector>
 
 #include "opentherm.h"
 
+#ifdef OPENTHERM_USE_SENSOR
+#include "esphome/components/sensor/sensor.h"
+#endif
+
+#ifdef OPENTHERM_USE_BINARY_SENSOR
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
+
+#ifdef OPENTHERM_USE_SWITCH
+#include "esphome/components/opentherm/switch/switch.h"
+#endif
+
+#ifdef OPENTHERM_USE_OUTPUT
+#include "esphome/components/opentherm/output/output.h"
+#endif
+
+#ifdef OPENTHERM_USE_NUMBER
+#include "esphome/components/opentherm/number/number.h"
+#endif
+
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
 #include <functional>
 
+#include "opentherm_macros.h"
+
 namespace esphome {
 namespace opentherm {
 
@@ -23,15 +46,27 @@ class OpenthermHub : public Component {
   // The OpenTherm interface
   std::unique_ptr<OpenTherm> opentherm_;
 
+  OPENTHERM_SENSOR_LIST(OPENTHERM_DECLARE_SENSOR, )
+
+  OPENTHERM_BINARY_SENSOR_LIST(OPENTHERM_DECLARE_BINARY_SENSOR, )
+
+  OPENTHERM_SWITCH_LIST(OPENTHERM_DECLARE_SWITCH, )
+
+  OPENTHERM_NUMBER_LIST(OPENTHERM_DECLARE_NUMBER, )
+
+  OPENTHERM_OUTPUT_LIST(OPENTHERM_DECLARE_OUTPUT, )
+
+  OPENTHERM_INPUT_SENSOR_LIST(OPENTHERM_DECLARE_INPUT_SENSOR, )
+
   // The set of initial messages to send on starting communication with the boiler
-  std::unordered_set<MessageId> initial_messages_;
+  std::vector<MessageId> initial_messages_;
   // and the repeating messages which are sent repeatedly to update various sensors
   // and boiler parameters (like the setpoint).
-  std::unordered_set<MessageId> repeating_messages_;
+  std::vector<MessageId> repeating_messages_;
   // Indicates if we are still working on the initial requests or not
   bool sending_initial_ = true;
   // Index for the current request in one of the _requests sets.
-  std::unordered_set<MessageId>::const_iterator current_message_iterator_;
+  std::vector<MessageId>::const_iterator current_message_iterator_;
 
   uint32_t last_conversation_start_ = 0;
   uint32_t last_conversation_end_ = 0;
@@ -43,8 +78,10 @@ class OpenthermHub : public Component {
   // Very likely to happen while using Dallas temperature sensors.
   bool sync_mode_ = false;
 
+  float opentherm_version_ = 0.0f;
+
   // Create OpenTherm messages based on the message id
-  OpenthermData build_request_(MessageId request_id);
+  OpenthermData build_request_(MessageId request_id) const;
   void handle_protocol_write_error_();
   void handle_protocol_read_error_();
   void handle_timeout_error_();
@@ -78,17 +115,30 @@ class OpenthermHub : public Component {
   void set_in_pin(InternalGPIOPin *in_pin) { this->in_pin_ = in_pin; }
   void set_out_pin(InternalGPIOPin *out_pin) { this->out_pin_ = out_pin; }
 
-  // Add a request to the set of initial requests
-  void add_initial_message(MessageId message_id) { this->initial_messages_.insert(message_id); }
+  OPENTHERM_SENSOR_LIST(OPENTHERM_SET_SENSOR, )
+
+  OPENTHERM_BINARY_SENSOR_LIST(OPENTHERM_SET_BINARY_SENSOR, )
+
+  OPENTHERM_SWITCH_LIST(OPENTHERM_SET_SWITCH, )
+
+  OPENTHERM_NUMBER_LIST(OPENTHERM_SET_NUMBER, )
+
+  OPENTHERM_OUTPUT_LIST(OPENTHERM_SET_OUTPUT, )
+
+  OPENTHERM_INPUT_SENSOR_LIST(OPENTHERM_SET_INPUT_SENSOR, )
+
+  // Add a request to the vector of initial requests
+  void add_initial_message(MessageId message_id) { this->initial_messages_.push_back(message_id); }
   // Add a request to the set of repeating requests. Note that a large number of repeating
   // requests will slow down communication with the boiler. Each request may take up to 1 second,
   // so with all sensors enabled, it may take about half a minute before a change in setpoint
   // will be processed.
-  void add_repeating_message(MessageId message_id) { this->repeating_messages_.insert(message_id); }
+  void add_repeating_message(MessageId message_id) { this->repeating_messages_.push_back(message_id); }
 
-  // There are five status variables, which can either be set as a simple variable,
+  // There are seven status variables, which can either be set as a simple variable,
   // or using a switch. ch_enable and dhw_enable default to true, the others to false.
-  bool ch_enable = true, dhw_enable = true, cooling_enable = false, otc_active = false, ch2_active = false;
+  bool ch_enable = true, dhw_enable = true, cooling_enable = false, otc_active = false, ch2_active = false,
+       summer_mode_active = false, dhw_block = false;
 
   // Setters for the status variables
   void set_ch_enable(bool value) { this->ch_enable = value; }
@@ -96,7 +146,10 @@ class OpenthermHub : public Component {
   void set_cooling_enable(bool value) { this->cooling_enable = value; }
   void set_otc_active(bool value) { this->otc_active = value; }
   void set_ch2_active(bool value) { this->ch2_active = value; }
+  void set_summer_mode_active(bool value) { this->summer_mode_active = value; }
+  void set_dhw_block(bool value) { this->dhw_block = value; }
   void set_sync_mode(bool sync_mode) { this->sync_mode_ = sync_mode; }
+  void set_opentherm_version(float value) { this->opentherm_version_ = value; }
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 

esphome/components/opentherm/input.h

@@ -0,0 +1,18 @@
+#pragma once
+
+namespace esphome {
+namespace opentherm {
+
+class OpenthermInput {
+ public:
+  bool auto_min_value, auto_max_value;
+
+  virtual void set_min_value(float min_value) = 0;
+  virtual void set_max_value(float max_value) = 0;
+
+  virtual void set_auto_min_value(bool auto_min_value) { this->auto_min_value = auto_min_value; }
+  virtual void set_auto_max_value(bool auto_max_value) { this->auto_max_value = auto_max_value; }
+};
+
+}  // namespace opentherm
+}  // namespace esphome