esphome 2024.12.4__py3-none-any.whl → 2025.2.0__py3-none-any.whl

esphome/components/opentherm/opentherm.cpp

@@ -52,7 +52,9 @@ bool OpenTherm::initialize() {
   OpenTherm::instance = this;
 #endif
   this->in_pin_->pin_mode(gpio::FLAG_INPUT);
+  this->in_pin_->setup();
   this->out_pin_->pin_mode(gpio::FLAG_OUTPUT);
+  this->out_pin_->setup();
   this->out_pin_->digital_write(true);
 
 #if defined(ESP32) || defined(USE_ESP_IDF)
@@ -182,7 +184,7 @@ bool IRAM_ATTR OpenTherm::timer_isr(OpenTherm *arg) {
       }
       arg->capture_ = 1;  // reset counter
     } else if (arg->capture_ > 0xFF) {
-      // no change for too long, invalid mancheter encoding
+      // no change for too long, invalid manchester encoding
       arg->mode_ = OperationMode::ERROR_PROTOCOL;
       arg->error_type_ = ProtocolErrorType::NO_CHANGE_TOO_LONG;
       arg->stop_timer_();
@@ -312,21 +314,31 @@ bool OpenTherm::init_esp32_timer_() {
 }
 
 void IRAM_ATTR OpenTherm::start_esp32_timer_(uint64_t alarm_value) {
-  esp_err_t result;
+  // We will report timer errors outside of interrupt handler
+  this->timer_error_ = ESP_OK;
+  this->timer_error_type_ = TimerErrorType::NO_TIMER_ERROR;
 
-  result = timer_set_alarm_value(this->timer_group_, this->timer_idx_, alarm_value);
-  if (result != ESP_OK) {
-    const auto *error = esp_err_to_name(result);
-    ESP_LOGE(TAG, "Failed to set alarm value. Error: %s", error);
+  this->timer_error_ = timer_set_alarm_value(this->timer_group_, this->timer_idx_, alarm_value);
+  if (this->timer_error_ != ESP_OK) {
+    this->timer_error_type_ = TimerErrorType::SET_ALARM_VALUE_ERROR;
     return;
   }
+  this->timer_error_ = timer_start(this->timer_group_, this->timer_idx_);
+  if (this->timer_error_ != ESP_OK) {
+    this->timer_error_type_ = TimerErrorType::TIMER_START_ERROR;
+  }
+}
 
-  result = timer_start(this->timer_group_, this->timer_idx_);
-  if (result != ESP_OK) {
-    const auto *error = esp_err_to_name(result);
-    ESP_LOGE(TAG, "Failed to start the timer. Error: %s", error);
+void OpenTherm::report_and_reset_timer_error() {
+  if (this->timer_error_ == ESP_OK) {
     return;
   }
+
+  ESP_LOGE(TAG, "Error occured while manipulating timer (%s): %s", this->timer_error_to_str(this->timer_error_type_),
+           esp_err_to_name(this->timer_error_));
+
+  this->timer_error_ = ESP_OK;
+  this->timer_error_type_ = NO_TIMER_ERROR;
 }
 
 // 5 kHz timer_
@@ -343,21 +355,18 @@ void IRAM_ATTR OpenTherm::start_write_timer_() {
 
 void IRAM_ATTR OpenTherm::stop_timer_() {
   InterruptLock const lock;
+  // We will report timer errors outside of interrupt handler
+  this->timer_error_ = ESP_OK;
+  this->timer_error_type_ = TimerErrorType::NO_TIMER_ERROR;
 
-  esp_err_t result;
-
-  result = timer_pause(this->timer_group_, this->timer_idx_);
-  if (result != ESP_OK) {
-    const auto *error = esp_err_to_name(result);
-    ESP_LOGE(TAG, "Failed to pause the timer. Error: %s", error);
+  this->timer_error_ = timer_pause(this->timer_group_, this->timer_idx_);
+  if (this->timer_error_ != ESP_OK) {
+    this->timer_error_type_ = TimerErrorType::TIMER_PAUSE_ERROR;
     return;
   }
-
-  result = timer_set_counter_value(this->timer_group_, this->timer_idx_, 0);
-  if (result != ESP_OK) {
-    const auto *error = esp_err_to_name(result);
-    ESP_LOGE(TAG, "Failed to set timer counter to 0 after pausing. Error: %s", error);
-    return;
+  this->timer_error_ = timer_set_counter_value(this->timer_group_, this->timer_idx_, 0);
+  if (this->timer_error_ != ESP_OK) {
+    this->timer_error_type_ = TimerErrorType::SET_COUNTER_VALUE_ERROR;
   }
 }
 
@@ -386,6 +395,9 @@ void IRAM_ATTR OpenTherm::stop_timer_() {
   timer1_detachInterrupt();
 }
 
+// There is nothing to report on ESP8266
+void OpenTherm::report_and_reset_timer_error() {}
+
 #endif  // END ESP8266
 
 // https://stackoverflow.com/questions/21617970/how-to-check-if-value-has-even-parity-of-bits-or-odd
@@ -412,11 +424,12 @@ const char *OpenTherm::operation_mode_to_str(OperationMode mode) {
     TO_STRING_MEMBER(SENT)
     TO_STRING_MEMBER(ERROR_PROTOCOL)
     TO_STRING_MEMBER(ERROR_TIMEOUT)
+    TO_STRING_MEMBER(ERROR_TIMER)
     default:
       return "<INVALID>";
   }
 }
-const char *OpenTherm::protocol_error_to_to_str(ProtocolErrorType error_type) {
+const char *OpenTherm::protocol_error_to_str(ProtocolErrorType error_type) {
   switch (error_type) {
     TO_STRING_MEMBER(NO_ERROR)
     TO_STRING_MEMBER(NO_TRANSITION)
@@ -427,6 +440,17 @@ const char *OpenTherm::protocol_error_to_to_str(ProtocolErrorType error_type) {
       return "<INVALID>";
   }
 }
+const char *OpenTherm::timer_error_to_str(TimerErrorType error_type) {
+  switch (error_type) {
+    TO_STRING_MEMBER(NO_TIMER_ERROR)
+    TO_STRING_MEMBER(SET_ALARM_VALUE_ERROR)
+    TO_STRING_MEMBER(TIMER_START_ERROR)
+    TO_STRING_MEMBER(TIMER_PAUSE_ERROR)
+    TO_STRING_MEMBER(SET_COUNTER_VALUE_ERROR)
+    default:
+      return "<INVALID>";
+  }
+}
 const char *OpenTherm::message_type_to_str(MessageType message_type) {
   switch (message_type) {
     TO_STRING_MEMBER(READ_DATA)

esphome/components/opentherm/opentherm.h

@@ -36,11 +36,12 @@ enum OperationMode {
   READ = 2,      // reading 32-bit data frame
   RECEIVED = 3,  // data frame received with valid start and stop bit
 
-  WRITE = 4,  // writing data with timer_
+  WRITE = 4,  // writing data to output
   SENT = 5,   // all data written to output
 
-  ERROR_PROTOCOL = 8,  // manchester protocol data transfer error
-  ERROR_TIMEOUT = 9    // read timeout
+  ERROR_PROTOCOL = 8,  // protocol error, can happed only during READ
+  ERROR_TIMEOUT = 9,   // timeout while waiting for response from device, only during LISTEN
+  ERROR_TIMER = 10     // error operating the ESP32 timer
 };
 
 enum ProtocolErrorType {
@@ -51,6 +52,14 @@ enum ProtocolErrorType {
   NO_CHANGE_TOO_LONG = 4,  // No level change for too much timer ticks
 };
 
+enum TimerErrorType {
+  NO_TIMER_ERROR = 0,           // No error
+  SET_ALARM_VALUE_ERROR = 1,    // No transition in the middle of the bit
+  TIMER_START_ERROR = 2,        // Stop bit wasn't present when expected
+  TIMER_PAUSE_ERROR = 3,        // Parity check didn't pass
+  SET_COUNTER_VALUE_ERROR = 4,  // No level change for too much timer ticks
+};
+
 enum MessageType {
   READ_DATA = 0,
   READ_ACK = 4,
@@ -299,7 +308,9 @@ class OpenTherm {
    *
    * @return true if last listen() or send() operation ends up with an error.
    */
-  bool is_error() { return mode_ == OperationMode::ERROR_TIMEOUT || mode_ == OperationMode::ERROR_PROTOCOL; }
+  bool is_error() {
+    return mode_ == OperationMode::ERROR_TIMEOUT || mode_ == OperationMode::ERROR_PROTOCOL || mode_ == ERROR_TIMER;
+  }
 
   /**
    * Indicates whether last listen() or send() operation ends up with a *timeout* error
@@ -313,14 +324,22 @@ class OpenTherm {
    */
   bool is_protocol_error() { return mode_ == OperationMode::ERROR_PROTOCOL; }
 
+  /**
+   * Indicates whether start_esp32_timer_() or stop_timer_() had an error. Only relevant when used on ESP32.
+   * @return true if there was an error.
+   */
+  bool is_timer_error() { return mode_ == OperationMode::ERROR_TIMER; }
+
   bool is_active() { return mode_ == LISTEN || mode_ == READ || mode_ == WRITE; }
 
   OperationMode get_mode() { return mode_; }
 
   void debug_data(OpenthermData &data);
   void debug_error(OpenThermError &error) const;
+  void report_and_reset_timer_error();
 
-  const char *protocol_error_to_to_str(ProtocolErrorType error_type);
+  const char *protocol_error_to_str(ProtocolErrorType error_type);
+  const char *timer_error_to_str(TimerErrorType error_type);
   const char *message_type_to_str(MessageType message_type);
   const char *operation_mode_to_str(OperationMode mode);
   const char *message_id_to_str(MessageId id);
@@ -349,10 +368,12 @@ class OpenTherm {
   uint32_t data_;
   uint8_t bit_pos_;
   int32_t timeout_counter_;  // <0 no timeout
-
   int32_t device_timeout_;
 
 #if defined(ESP32) || defined(USE_ESP_IDF)
+  esp_err_t timer_error_ = ESP_OK;
+  TimerErrorType timer_error_type_ = TimerErrorType::NO_TIMER_ERROR;
+
   bool init_esp32_timer_();
   void start_esp32_timer_(uint64_t alarm_value);
 #endif

esphome/components/opentherm/opentherm_macros.h

@@ -28,6 +28,9 @@ namespace opentherm {
 #ifndef OPENTHERM_INPUT_SENSOR_LIST
 #define OPENTHERM_INPUT_SENSOR_LIST(F, sep)
 #endif
+#ifndef OPENTHERM_SETTING_LIST
+#define OPENTHERM_SETTING_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;
@@ -36,6 +39,7 @@ namespace opentherm {
 #define OPENTHERM_DECLARE_NUMBER(entity) OpenthermNumber *entity;
 #define OPENTHERM_DECLARE_OUTPUT(entity) OpenthermOutput *entity;
 #define OPENTHERM_DECLARE_INPUT_SENSOR(entity) sensor::Sensor *entity;
+#define OPENTHERM_DECLARE_SETTING(type, entity, def) type entity = def;
 
 // Setter macros
 #define OPENTHERM_SET_SENSOR(entity) \
@@ -56,6 +60,9 @@ namespace opentherm {
 #define OPENTHERM_SET_INPUT_SENSOR(entity) \
   void set_##entity(sensor::Sensor *sensor) { this->entity = sensor; }
 
+#define OPENTHERM_SET_SETTING(type, entity, def) \
+  void set_##entity(type value) { this->entity = value; }
+
 // ===== hub.cpp macros =====
 
 // *_MESSAGE_HANDLERS are generated in defines.h and look like this:
@@ -85,6 +92,9 @@ namespace opentherm {
 #ifndef OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS
 #define OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
 #endif
+#ifndef OPENTHERM_SETTING_MESSAGE_HANDLERS
+#define OPENTHERM_SETTING_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
 
 // Write data request builders
 #define OPENTHERM_MESSAGE_WRITE_MESSAGE(msg) \
@@ -92,6 +102,7 @@ namespace opentherm {
     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_SETTING(key, msg_data) message_data::write_##msg_data(this->key, data);
 #define OPENTHERM_MESSAGE_WRITE_POSTSCRIPT \
   return data; \
   }

esphome/components/opentherm/schema.py

@@ -2,8 +2,9 @@
 # inputs of the OpenTherm component.
 
 from dataclasses import dataclass
-from typing import Optional, TypeVar
+from typing import Optional, TypeVar, Any
 
+import esphome.config_validation as cv
 from esphome.const import (
     UNIT_CELSIUS,
     UNIT_EMPTY,
@@ -64,6 +65,7 @@ class SensorSchema(EntitySchema):
     icon: Optional[str] = None
     device_class: Optional[str] = None
     disabled_by_default: bool = False
+    order: Optional[int] = None
 
 
 SENSORS: dict[str, SensorSchema] = {
@@ -399,6 +401,7 @@ SENSORS: dict[str, SensorSchema] = {
         message="OT_VERSION_DEVICE",
         keep_updated=False,
         message_data="f88",
+        order=2,
     ),
     "device_type": SensorSchema(
         description="Device product type",
@@ -409,6 +412,7 @@ SENSORS: dict[str, SensorSchema] = {
         message="VERSION_DEVICE",
         keep_updated=False,
         message_data="u8_hb",
+        order=0,
     ),
     "device_version": SensorSchema(
         description="Device product version",
@@ -419,6 +423,7 @@ SENSORS: dict[str, SensorSchema] = {
         message="VERSION_DEVICE",
         keep_updated=False,
         message_data="u8_lb",
+        order=0,
     ),
     "device_id": SensorSchema(
         description="Device ID code",
@@ -429,6 +434,7 @@ SENSORS: dict[str, SensorSchema] = {
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="u8_lb",
+        order=4,
     ),
     "otc_hc_ratio_ub": SensorSchema(
         description="OTC heat curve ratio upper bound",
@@ -457,6 +463,7 @@ SENSORS: dict[str, SensorSchema] = {
 class BinarySensorSchema(EntitySchema):
     icon: Optional[str] = None
     device_class: Optional[str] = None
+    order: Optional[int] = None
 
 
 BINARY_SENSORS: dict[str, BinarySensorSchema] = {
@@ -525,48 +532,56 @@ BINARY_SENSORS: dict[str, BinarySensorSchema] = {
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_0",
+        order=4,
     ),
     "control_type_on_off": BinarySensorSchema(
         description="Configuration: Control type is on/off",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_1",
+        order=4,
     ),
     "cooling_supported": BinarySensorSchema(
         description="Configuration: Cooling supported",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_2",
+        order=4,
     ),
     "dhw_storage_tank": BinarySensorSchema(
         description="Configuration: DHW storage tank",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_3",
+        order=4,
     ),
     "controller_pump_control_allowed": BinarySensorSchema(
         description="Configuration: Controller pump control allowed",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_4",
+        order=4,
     ),
     "ch2_present": BinarySensorSchema(
         description="Configuration: CH2 present",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_5",
+        order=4,
     ),
     "water_filling": BinarySensorSchema(
         description="Configuration: Remote water filling",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_6",
+        order=4,
     ),
     "heat_mode": BinarySensorSchema(
         description="Configuration: Heating or cooling",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_7",
+        order=4,
     ),
     "dhw_setpoint_transfer_enabled": BinarySensorSchema(
         description="Remote boiler parameters: DHW setpoint transfer enabled",
@@ -812,3 +827,65 @@ INPUTS: dict[str, InputSchema] = {
         auto_max_value=AutoConfigure(message="OTC_CURVE_BOUNDS", message_data="u8_hb"),
     ),
 }
+
+
+@dataclass
+class SettingSchema(EntitySchema):
+    backing_type: str
+    validation_schema: cv.Schema
+    default_value: Any
+    order: Optional[int] = None
+
+
+SETTINGS: dict[str, SettingSchema] = {
+    "controller_product_type": SettingSchema(
+        description="Controller product type",
+        message="VERSION_CONTROLLER",
+        keep_updated=False,
+        message_data="u8_hb",
+        backing_type="uint8_t",
+        validation_schema=cv.int_range(min=0, max=255),
+        default_value=0,
+        order=1,
+    ),
+    "controller_product_version": SettingSchema(
+        description="Controller product version",
+        message="VERSION_CONTROLLER",
+        keep_updated=False,
+        message_data="u8_lb",
+        backing_type="uint8_t",
+        validation_schema=cv.int_range(min=0, max=255),
+        default_value=0,
+        order=1,
+    ),
+    "opentherm_version_controller": SettingSchema(
+        description="Version of OpenTherm implemented by controller",
+        message="OT_VERSION_CONTROLLER",
+        keep_updated=False,
+        message_data="f88",
+        backing_type="float",
+        validation_schema=cv.positive_float,
+        default_value=0,
+        order=3,
+    ),
+    "controller_configuration": SettingSchema(
+        description="Controller configuration",
+        message="CONTROLLER_CONFIG",
+        keep_updated=False,
+        message_data="u8_hb",
+        backing_type="uint8_t",
+        validation_schema=cv.int_range(min=0, max=255),
+        default_value=0,
+        order=5,
+    ),
+    "controller_id": SettingSchema(
+        description="Controller ID code",
+        message="CONTROLLER_CONFIG",
+        keep_updated=False,
+        message_data="u8_lb",
+        backing_type="uint8_t",
+        validation_schema=cv.int_range(min=0, max=255),
+        default_value=0,
+        order=5,
+    ),
+}

esphome/components/opentherm/validate.py

@@ -9,12 +9,17 @@ from .schema import TSchema
 
 
 def create_entities_schema(
-    entities: dict[str, schema.EntitySchema],
+    entities: dict[str, TSchema],
     get_entity_validation_schema: Callable[[TSchema], cv.Schema],
 ) -> Schema:
     entity_schema = {}
     for key, entity in entities.items():
-        entity_schema[cv.Optional(key)] = get_entity_validation_schema(entity)
+        schema_key = (
+            cv.Optional(key, entity.default_value)
+            if hasattr(entity, "default_value")
+            else cv.Optional(key)
+        )
+        entity_schema[schema_key] = get_entity_validation_schema(entity)
     return cv.Schema(entity_schema)
 
 

esphome/components/pca6416a/pca6416a.h

@@ -52,6 +52,8 @@ class PCA6416AGPIOPin : public GPIOPin {
   void set_inverted(bool inverted) { inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { flags_ = flags; }
 
+  gpio::Flags get_flags() const override { return this->flags_; }
+
  protected:
   PCA6416AComponent *parent_;
   uint8_t pin_;

esphome/components/pca9554/pca9554.h

@@ -65,6 +65,8 @@ class PCA9554GPIOPin : public GPIOPin {
   void set_inverted(bool inverted) { inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { flags_ = flags; }
 
+  gpio::Flags get_flags() const override { return this->flags_; }
+
  protected:
   PCA9554Component *parent_;
   uint8_t pin_;

esphome/components/pcf8574/pcf8574.h

@@ -54,6 +54,8 @@ class PCF8574GPIOPin : public GPIOPin {
   void set_inverted(bool inverted) { inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { flags_ = flags; }
 
+  gpio::Flags get_flags() const override { return this->flags_; }
+
  protected:
   PCF8574Component *parent_;
   uint8_t pin_;

esphome/components/preferences/__init__.py

@@ -1,6 +1,6 @@
-from esphome.const import CONF_ID
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.const import CONF_ID
 
 CODEOWNERS = ["@esphome/core"]
 
@@ -11,9 +11,7 @@ CONF_FLASH_WRITE_INTERVAL = "flash_write_interval"
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(IntervalSyncer),
-        cv.Optional(
-            CONF_FLASH_WRITE_INTERVAL, default="60s"
-        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_FLASH_WRITE_INTERVAL, default="60s"): cv.update_interval,
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/preferences/syncer.h

@@ -8,15 +8,22 @@ namespace preferences {
 
 class IntervalSyncer : public Component {
  public:
-  void set_write_interval(uint32_t write_interval) { write_interval_ = write_interval; }
+  void set_write_interval(uint32_t write_interval) { this->write_interval_ = write_interval; }
   void setup() override {
-    set_interval(write_interval_, []() { global_preferences->sync(); });
+    if (this->write_interval_ != 0) {
+      set_interval(this->write_interval_, []() { global_preferences->sync(); });
+    }
+  }
+  void loop() override {
+    if (this->write_interval_ == 0) {
+      global_preferences->sync();
+    }
   }
   void on_shutdown() override { global_preferences->sync(); }
   float get_setup_priority() const override { return setup_priority::BUS; }
 
  protected:
-  uint32_t write_interval_;
+  uint32_t write_interval_{60000};
 };
 
 }  // namespace preferences