esphome 2024.10.2__py3-none-any.whl → 2024.11.0__py3-none-any.whl

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

esphome/components/opentherm/input.py

@@ -0,0 +1,51 @@
+from typing import Any
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from . import schema, generate
+
+CONF_min_value = "min_value"
+CONF_max_value = "max_value"
+CONF_auto_min_value = "auto_min_value"
+CONF_auto_max_value = "auto_max_value"
+CONF_step = "step"
+
+OpenthermInput = generate.opentherm_ns.class_("OpenthermInput")
+
+
+def validate_min_value_less_than_max_value(conf):
+    if (
+        CONF_min_value in conf
+        and CONF_max_value in conf
+        and conf[CONF_min_value] > conf[CONF_max_value]
+    ):
+        raise cv.Invalid(f"{CONF_min_value} must be less than {CONF_max_value}")
+    return conf
+
+
+def input_schema(entity: schema.InputSchema) -> cv.Schema:
+    result = cv.Schema(
+        {
+            cv.Optional(CONF_min_value, entity.range[0]): cv.float_range(
+                entity.range[0], entity.range[1]
+            ),
+            cv.Optional(CONF_max_value, entity.range[1]): cv.float_range(
+                entity.range[0], entity.range[1]
+            ),
+        }
+    )
+    result = result.add_extra(validate_min_value_less_than_max_value)
+    result = result.extend({cv.Optional(CONF_step, False): cv.float_})
+    if entity.auto_min_value is not None:
+        result = result.extend({cv.Optional(CONF_auto_min_value, False): cv.boolean})
+    if entity.auto_max_value is not None:
+        result = result.extend({cv.Optional(CONF_auto_max_value, False): cv.boolean})
+
+    return result
+
+
+def generate_setters(entity: cg.MockObj, conf: dict[str, Any]) -> None:
+    generate.add_property_set(entity, CONF_min_value, conf)
+    generate.add_property_set(entity, CONF_max_value, conf)
+    generate.add_property_set(entity, CONF_auto_min_value, conf)
+    generate.add_property_set(entity, CONF_auto_max_value, conf)

esphome/components/opentherm/number/__init__.py

@@ -0,0 +1,74 @@
+from typing import Any
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import number
+from esphome.const import (
+    CONF_ID,
+    CONF_UNIT_OF_MEASUREMENT,
+    CONF_STEP,
+    CONF_INITIAL_VALUE,
+    CONF_RESTORE_VALUE,
+)
+from .. import const, schema, validate, input, generate
+
+DEPENDENCIES = [const.OPENTHERM]
+COMPONENT_TYPE = const.NUMBER
+
+OpenthermNumber = generate.opentherm_ns.class_(
+    "OpenthermNumber", number.Number, cg.Component, input.OpenthermInput
+)
+
+
+async def new_openthermnumber(config: dict[str, Any]) -> cg.Pvariable:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await number.register_number(
+        var,
+        config,
+        min_value=config[input.CONF_min_value],
+        max_value=config[input.CONF_max_value],
+        step=config[input.CONF_step],
+    )
+    input.generate_setters(var, config)
+
+    if CONF_INITIAL_VALUE in config:
+        cg.add(var.set_initial_value(config[CONF_INITIAL_VALUE]))
+    if CONF_RESTORE_VALUE in config:
+        cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
+
+    return var
+
+
+def get_entity_validation_schema(entity: schema.InputSchema) -> cv.Schema:
+    return (
+        number.NUMBER_SCHEMA.extend(
+            {
+                cv.GenerateID(): cv.declare_id(OpenthermNumber),
+                cv.Optional(
+                    CONF_UNIT_OF_MEASUREMENT, entity.unit_of_measurement
+                ): cv.string_strict,
+                cv.Optional(CONF_STEP, entity.step): cv.float_,
+                cv.Optional(CONF_INITIAL_VALUE): cv.float_,
+                cv.Optional(CONF_RESTORE_VALUE): cv.boolean,
+            }
+        )
+        .extend(input.input_schema(entity))
+        .extend(cv.COMPONENT_SCHEMA)
+    )
+
+
+CONFIG_SCHEMA = validate.create_component_schema(
+    schema.INPUTS, get_entity_validation_schema
+)
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    keys = await generate.component_to_code(
+        COMPONENT_TYPE,
+        schema.INPUTS,
+        OpenthermNumber,
+        generate.create_only_conf(new_openthermnumber),
+        config,
+    )
+    generate.define_readers(COMPONENT_TYPE, keys)

esphome/components/opentherm/number/number.cpp

@@ -0,0 +1,40 @@
+#include "number.h"
+
+namespace esphome {
+namespace opentherm {
+
+static const char *const TAG = "opentherm.number";
+
+void OpenthermNumber::control(float value) {
+  this->publish_state(value);
+
+  if (this->restore_value_)
+    this->pref_.save(&value);
+}
+
+void OpenthermNumber::setup() {
+  float value;
+  if (!this->restore_value_) {
+    value = this->initial_value_;
+  } else {
+    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    if (!this->pref_.load(&value)) {
+      if (!std::isnan(this->initial_value_)) {
+        value = this->initial_value_;
+      } else {
+        value = this->traits.get_min_value();
+      }
+    }
+  }
+  this->publish_state(value);
+}
+
+void OpenthermNumber::dump_config() {
+  LOG_NUMBER("", "OpenTherm Number", this);
+  ESP_LOGCONFIG(TAG, "  Restore value: %d", this->restore_value_);
+  ESP_LOGCONFIG(TAG, "  Initial value: %.2f", this->initial_value_);
+  ESP_LOGCONFIG(TAG, "  Current value: %.2f", this->state);
+}
+
+}  // namespace opentherm
+}  // namespace esphome

esphome/components/opentherm/number/number.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "esphome/core/preferences.h"
+#include "esphome/core/log.h"
+#include "esphome/components/opentherm/input.h"
+
+namespace esphome {
+namespace opentherm {
+
+// Just a simple number, which stores the number
+class OpenthermNumber : public number::Number, public Component, public OpenthermInput {
+ protected:
+  void control(float value) override;
+  void setup() override;
+  void dump_config() override;
+
+  float initial_value_{NAN};
+  bool restore_value_{false};
+
+  ESPPreferenceObject pref_;
+
+ public:
+  void set_min_value(float min_value) override { this->traits.set_min_value(min_value); }
+  void set_max_value(float max_value) override { this->traits.set_max_value(max_value); }
+  void set_initial_value(float initial_value) { initial_value_ = initial_value; }
+  void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
+};
+
+}  // namespace opentherm
+}  // namespace esphome

esphome/components/opentherm/opentherm.cpp

@@ -283,6 +283,9 @@ bool OpenTherm::init_esp32_timer_() {
     .clk_src = TIMER_SRC_CLK_DEFAULT,
 #endif
     .divider = 80,
+#if defined(SOC_TIMER_GROUP_SUPPORT_XTAL) && ESP_IDF_VERSION_MAJOR < 5
+    .clk_src = TIMER_SRC_CLK_APB
+#endif
   };
 
   esp_err_t result;
@@ -480,6 +483,8 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
     TO_STRING_MEMBER(EXHAUST_TEMP)
     TO_STRING_MEMBER(FAN_SPEED)
     TO_STRING_MEMBER(FLAME_CURRENT)
+    TO_STRING_MEMBER(ROOM_TEMP_CH2)
+    TO_STRING_MEMBER(REL_HUMIDITY)
     TO_STRING_MEMBER(DHW_BOUNDS)
     TO_STRING_MEMBER(CH_BOUNDS)
     TO_STRING_MEMBER(OTC_CURVE_BOUNDS)
@@ -489,14 +494,39 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
     TO_STRING_MEMBER(HVAC_STATUS)
     TO_STRING_MEMBER(REL_VENT_SETPOINT)
     TO_STRING_MEMBER(DEVICE_VENT)
+    TO_STRING_MEMBER(HVAC_VER_ID)
     TO_STRING_MEMBER(REL_VENTILATION)
     TO_STRING_MEMBER(REL_HUMID_EXHAUST)
+    TO_STRING_MEMBER(EXHAUST_CO2)
     TO_STRING_MEMBER(SUPPLY_INLET_TEMP)
     TO_STRING_MEMBER(SUPPLY_OUTLET_TEMP)
     TO_STRING_MEMBER(EXHAUST_INLET_TEMP)
     TO_STRING_MEMBER(EXHAUST_OUTLET_TEMP)
+    TO_STRING_MEMBER(EXHAUST_FAN_SPEED)
+    TO_STRING_MEMBER(SUPPLY_FAN_SPEED)
+    TO_STRING_MEMBER(REMOTE_VENTILATION_PARAM)
     TO_STRING_MEMBER(NOM_REL_VENTILATION)
+    TO_STRING_MEMBER(HVAC_NUM_TSP)
+    TO_STRING_MEMBER(HVAC_IDX_TSP)
+    TO_STRING_MEMBER(HVAC_FHB_SIZE)
+    TO_STRING_MEMBER(HVAC_FHB_IDX)
+    TO_STRING_MEMBER(RF_SIGNAL)
+    TO_STRING_MEMBER(DHW_MODE)
     TO_STRING_MEMBER(OVERRIDE_FUNC)
+    TO_STRING_MEMBER(SOLAR_MODE_FLAGS)
+    TO_STRING_MEMBER(SOLAR_ASF)
+    TO_STRING_MEMBER(SOLAR_VERSION_ID)
+    TO_STRING_MEMBER(SOLAR_PRODUCT_ID)
+    TO_STRING_MEMBER(SOLAR_NUM_TSP)
+    TO_STRING_MEMBER(SOLAR_IDX_TSP)
+    TO_STRING_MEMBER(SOLAR_FHB_SIZE)
+    TO_STRING_MEMBER(SOLAR_FHB_IDX)
+    TO_STRING_MEMBER(SOLAR_STARTS)
+    TO_STRING_MEMBER(SOLAR_HOURS)
+    TO_STRING_MEMBER(SOLAR_ENERGY)
+    TO_STRING_MEMBER(SOLAR_TOTAL_ENERGY)
+    TO_STRING_MEMBER(FAILED_BURNER_STARTS)
+    TO_STRING_MEMBER(BURNER_FLAME_LOW)
     TO_STRING_MEMBER(OEM_DIAGNOSTIC)
     TO_STRING_MEMBER(BURNER_STARTS)
     TO_STRING_MEMBER(CH_PUMP_STARTS)

esphome/components/opentherm/opentherm.h

@@ -20,7 +20,6 @@
 namespace esphome {
 namespace opentherm {
 
-// TODO: Account for immutable semantics change in hub.cpp when doing later installments of OpenTherm PR
 template<class T> constexpr T read_bit(T value, uint8_t bit) { return (value >> bit) & 0x01; }
 
 template<class T> constexpr T set_bit(T value, uint8_t bit) { return value |= (1UL << bit); }
@@ -28,7 +27,7 @@ template<class T> constexpr T set_bit(T value, uint8_t bit) { return value |= (1
 template<class T> constexpr T clear_bit(T value, uint8_t bit) { return value &= ~(1UL << bit); }
 
 template<class T> constexpr T write_bit(T value, uint8_t bit, uint8_t bit_value) {
-  return bit_value ? setBit(value, bit) : clearBit(value, bit);
+  return bit_value ? set_bit(value, bit) : clear_bit(value, bit);
 }
 
 enum OperationMode {
@@ -100,6 +99,8 @@ enum MessageId {
   EXHAUST_TEMP = 33,
   FAN_SPEED = 35,
   FLAME_CURRENT = 36,
+  ROOM_TEMP_CH2 = 37,
+  REL_HUMIDITY = 38,
   DHW_BOUNDS = 48,
   CH_BOUNDS = 49,
   OTC_CURVE_BOUNDS = 50,
@@ -111,15 +112,46 @@ enum MessageId {
   HVAC_STATUS = 70,
   REL_VENT_SETPOINT = 71,
   DEVICE_VENT = 74,
+  HVAC_VER_ID = 75,
   REL_VENTILATION = 77,
   REL_HUMID_EXHAUST = 78,
+  EXHAUST_CO2 = 79,
   SUPPLY_INLET_TEMP = 80,
   SUPPLY_OUTLET_TEMP = 81,
   EXHAUST_INLET_TEMP = 82,
   EXHAUST_OUTLET_TEMP = 83,
+  EXHAUST_FAN_SPEED = 84,
+  SUPPLY_FAN_SPEED = 85,
+  REMOTE_VENTILATION_PARAM = 86,
   NOM_REL_VENTILATION = 87,
+  HVAC_NUM_TSP = 88,
+  HVAC_IDX_TSP = 89,
+  HVAC_FHB_SIZE = 90,
+  HVAC_FHB_IDX = 91,
 
+  RF_SIGNAL = 98,
+  DHW_MODE = 99,
   OVERRIDE_FUNC = 100,
+
+  // Solar Specific Message IDs
+  SOLAR_MODE_FLAGS = 101,  // hb0-2 Controller storage mode
+                           // lb0   Device fault
+                           // lb1-3 Device mode status
+                           // lb4-5 Device status
+  SOLAR_ASF = 102,
+  SOLAR_VERSION_ID = 103,
+  SOLAR_PRODUCT_ID = 104,
+  SOLAR_NUM_TSP = 105,
+  SOLAR_IDX_TSP = 106,
+  SOLAR_FHB_SIZE = 107,
+  SOLAR_FHB_IDX = 108,
+  SOLAR_STARTS = 109,
+  SOLAR_HOURS = 110,
+  SOLAR_ENERGY = 111,
+  SOLAR_TOTAL_ENERGY = 112,
+
+  FAILED_BURNER_STARTS = 113,
+  BURNER_FLAME_LOW = 114,
   OEM_DIAGNOSTIC = 115,
   BURNER_STARTS = 116,
   CH_PUMP_STARTS = 117,

esphome/components/opentherm/opentherm_macros.h

@@ -0,0 +1,151 @@
+#pragma once
+namespace esphome {
+namespace opentherm {
+
+// ===== hub.h macros =====
+
+// *_LIST macros will be generated in defines.h if at least one sensor from each platform is used.
+// These lists will look like this:
+// #define OPENTHERM_BINARY_SENSOR_LIST(F, sep) F(sensor_1) sep F(sensor_2)
+// These lists will be used in hub.h to define sensor fields (passing macros like OPENTHERM_DECLARE_SENSOR as F)
+// and setters (passing macros like OPENTHERM_SET_SENSOR as F) (see below)
+// In order for things not to break, we define empty lists here in case some platforms are not used in config.
+#ifndef OPENTHERM_SENSOR_LIST
+#define OPENTHERM_SENSOR_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_BINARY_SENSOR_LIST
+#define OPENTHERM_BINARY_SENSOR_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_SWITCH_LIST
+#define OPENTHERM_SWITCH_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_NUMBER_LIST
+#define OPENTHERM_NUMBER_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_OUTPUT_LIST
+#define OPENTHERM_OUTPUT_LIST(F, sep)
+#endif
+#ifndef OPENTHERM_INPUT_SENSOR_LIST
+#define OPENTHERM_INPUT_SENSOR_LIST(F, sep)
+#endif
+
+// Use macros to create fields for every entity specified in the ESPHome configuration
+#define OPENTHERM_DECLARE_SENSOR(entity) sensor::Sensor *entity;
+#define OPENTHERM_DECLARE_BINARY_SENSOR(entity) binary_sensor::BinarySensor *entity;
+#define OPENTHERM_DECLARE_SWITCH(entity) OpenthermSwitch *entity;
+#define OPENTHERM_DECLARE_NUMBER(entity) OpenthermNumber *entity;
+#define OPENTHERM_DECLARE_OUTPUT(entity) OpenthermOutput *entity;
+#define OPENTHERM_DECLARE_INPUT_SENSOR(entity) sensor::Sensor *entity;
+
+// Setter macros
+#define OPENTHERM_SET_SENSOR(entity) \
+  void set_##entity(sensor::Sensor *sensor) { this->entity = sensor; }
+
+#define OPENTHERM_SET_BINARY_SENSOR(entity) \
+  void set_##entity(binary_sensor::BinarySensor *binary_sensor) { this->entity = binary_sensor; }
+
+#define OPENTHERM_SET_SWITCH(entity) \
+  void set_##entity(OpenthermSwitch *sw) { this->entity = sw; }
+
+#define OPENTHERM_SET_NUMBER(entity) \
+  void set_##entity(OpenthermNumber *number) { this->entity = number; }
+
+#define OPENTHERM_SET_OUTPUT(entity) \
+  void set_##entity(OpenthermOutput *output) { this->entity = output; }
+
+#define OPENTHERM_SET_INPUT_SENSOR(entity) \
+  void set_##entity(sensor::Sensor *sensor) { this->entity = sensor; }
+
+// ===== hub.cpp macros =====
+
+// *_MESSAGE_HANDLERS are generated in defines.h and look like this:
+// OPENTHERM_NUMBER_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep) MESSAGE(COOLING_CONTROL)
+// ENTITY(cooling_control_number, f88) postscript msg_sep They contain placeholders for message part and entities parts,
+// since one message can contain multiple entities. MESSAGE part is substituted with OPENTHERM_MESSAGE_WRITE_MESSAGE,
+// OPENTHERM_MESSAGE_READ_MESSAGE or OPENTHERM_MESSAGE_RESPONSE_MESSAGE. ENTITY part is substituted with
+// OPENTHERM_MESSAGE_WRITE_ENTITY or OPENTHERM_MESSAGE_RESPONSE_ENTITY. OPENTHERM_IGNORE is used for sensor read
+// requests since no data needs to be sent or processed, just the data id.
+
+// In order for things not to break, we define empty lists here in case some platforms are not used in config.
+#ifndef OPENTHERM_SENSOR_MESSAGE_HANDLERS
+#define OPENTHERM_SENSOR_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_BINARY_SENSOR_MESSAGE_HANDLERS
+#define OPENTHERM_BINARY_SENSOR_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_SWITCH_MESSAGE_HANDLERS
+#define OPENTHERM_SWITCH_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_NUMBER_MESSAGE_HANDLERS
+#define OPENTHERM_NUMBER_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_OUTPUT_MESSAGE_HANDLERS
+#define OPENTHERM_OUTPUT_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+#ifndef OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS
+#define OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
+
+// Write data request builders
+#define OPENTHERM_MESSAGE_WRITE_MESSAGE(msg) \
+  case MessageId::msg: { \
+    data.type = MessageType::WRITE_DATA; \
+    data.id = request_id;
+#define OPENTHERM_MESSAGE_WRITE_ENTITY(key, msg_data) message_data::write_##msg_data(this->key->state, data);
+#define OPENTHERM_MESSAGE_WRITE_POSTSCRIPT \
+  return data; \
+  }
+
+// Read data request builder
+#define OPENTHERM_MESSAGE_READ_MESSAGE(msg) \
+  case MessageId::msg: \
+    data.type = MessageType::READ_DATA; \
+    data.id = request_id; \
+    return data;
+
+// Data processing builders
+#define OPENTHERM_MESSAGE_RESPONSE_MESSAGE(msg) case MessageId::msg:
+#define OPENTHERM_MESSAGE_RESPONSE_ENTITY(key, msg_data) this->key->publish_state(message_data::parse_##msg_data(data));
+#define OPENTHERM_MESSAGE_RESPONSE_POSTSCRIPT break;
+
+#define OPENTHERM_IGNORE(x, y)
+
+// Default macros for STATUS entities
+#ifndef OPENTHERM_READ_ch_enable
+#define OPENTHERM_READ_ch_enable true
+#endif
+#ifndef OPENTHERM_READ_dhw_enable
+#define OPENTHERM_READ_dhw_enable true
+#endif
+#ifndef OPENTHERM_READ_t_set
+#define OPENTHERM_READ_t_set 0.0
+#endif
+#ifndef OPENTHERM_READ_cooling_enable
+#define OPENTHERM_READ_cooling_enable false
+#endif
+#ifndef OPENTHERM_READ_cooling_control
+#define OPENTHERM_READ_cooling_control 0.0
+#endif
+#ifndef OPENTHERM_READ_otc_active
+#define OPENTHERM_READ_otc_active false
+#endif
+#ifndef OPENTHERM_READ_ch2_active
+#define OPENTHERM_READ_ch2_active false
+#endif
+#ifndef OPENTHERM_READ_t_set_ch2
+#define OPENTHERM_READ_t_set_ch2 0.0
+#endif
+#ifndef OPENTHERM_READ_summer_mode_active
+#define OPENTHERM_READ_summer_mode_active false
+#endif
+#ifndef OPENTHERM_READ_dhw_block
+#define OPENTHERM_READ_dhw_block false
+#endif
+
+// These macros utilize the structure of *_LIST macros in order
+#define ID(x) x
+#define SHOW_INNER(x) #x
+#define SHOW(x) SHOW_INNER(x)
+
+}  // namespace opentherm
+}  // namespace esphome

esphome/components/opentherm/output/__init__.py

@@ -0,0 +1,47 @@
+from typing import Any
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import output
+from esphome.const import CONF_ID
+from .. import const, schema, validate, input, generate
+
+DEPENDENCIES = [const.OPENTHERM]
+COMPONENT_TYPE = const.OUTPUT
+
+OpenthermOutput = generate.opentherm_ns.class_(
+    "OpenthermOutput", output.FloatOutput, cg.Component, input.OpenthermInput
+)
+
+
+async def new_openthermoutput(
+    config: dict[str, Any], key: str, _hub: cg.MockObj
+) -> cg.Pvariable:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await output.register_output(var, config)
+    cg.add(getattr(var, "set_id")(cg.RawExpression(f'"{key}_{config[CONF_ID]}"')))
+    input.generate_setters(var, config)
+    return var
+
+
+def get_entity_validation_schema(entity: schema.InputSchema) -> cv.Schema:
+    return (
+        output.FLOAT_OUTPUT_SCHEMA.extend(
+            {cv.GenerateID(): cv.declare_id(OpenthermOutput)}
+        )
+        .extend(input.input_schema(entity))
+        .extend(cv.COMPONENT_SCHEMA)
+    )
+
+
+CONFIG_SCHEMA = validate.create_component_schema(
+    schema.INPUTS, get_entity_validation_schema
+)
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    keys = await generate.component_to_code(
+        COMPONENT_TYPE, schema.INPUTS, OpenthermOutput, new_openthermoutput, config
+    )
+    generate.define_readers(COMPONENT_TYPE, keys)