esphome 2024.6.6__py3-none-any.whl → 2024.7.0b1__py3-none-any.whl

esphome/components/cover/cover.h

@@ -129,13 +129,13 @@ class Cover : public EntityBase, public EntityBase_DeviceClass {
    *
    * This is a legacy method and may be removed later, please use `.make_call()` instead.
    */
-  ESPDEPRECATED("open() is deprecated, use make_call().set_command_open() instead.", "2021.9")
+  ESPDEPRECATED("open() is deprecated, use make_call().set_command_open().perform() instead.", "2021.9")
   void open();
   /** Close the cover.
    *
    * This is a legacy method and may be removed later, please use `.make_call()` instead.
    */
-  ESPDEPRECATED("close() is deprecated, use make_call().set_command_close() instead.", "2021.9")
+  ESPDEPRECATED("close() is deprecated, use make_call().set_command_close().perform() instead.", "2021.9")
   void close();
   /** Stop the cover.
    *

esphome/components/esp32_camera/__init__.py

@@ -17,7 +17,7 @@ from esphome.const import (
     CONF_VSYNC_PIN,
 )
 from esphome.core import CORE
-from esphome.components.esp32 import add_idf_sdkconfig_option
+from esphome.components.esp32 import add_idf_component
 from esphome.cpp_helpers import setup_entity
 
 DEPENDENCIES = ["esp32"]
@@ -290,8 +290,11 @@ async def to_code(config):
     cg.add_define("USE_ESP32_CAMERA")
 
     if CORE.using_esp_idf:
-        cg.add_library("espressif/esp32-camera", "1.0.0")
-        add_idf_sdkconfig_option("CONFIG_RTCIO_SUPPORT_RTC_GPIO_DESC", True)
+        add_idf_component(
+            name="esp32-camera",
+            repo="https://github.com/espressif/esp32-camera.git",
+            ref="v2.0.9",
+        )
 
     for conf in config.get(CONF_ON_STREAM_START, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)

esphome/components/ethernet/ethernet_component.cpp

@@ -65,7 +65,8 @@ void EthernetComponent::setup() {
       .intr_flags = 0,
   };
 
-#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3) || \
+    defined(USE_ESP32_VARIANT_ESP32C6)
   auto host = SPI2_HOST;
 #else
   auto host = SPI3_HOST;
@@ -631,7 +632,7 @@ void EthernetComponent::write_phy_register_(esp_eth_mac_t *mac, PHYRegister regi
   ESPHL_ERROR_CHECK(err, "Writing PHY Register failed");
 
   if (this->type_ == ETHERNET_TYPE_RTL8201 && register_data.page) {
-    ESP_LOGD(TAG, "Select PHY Register Page 0x%02" PRIX32, 0x0);
+    ESP_LOGD(TAG, "Select PHY Register Page 0x00");
     err = mac->write_phy_reg(mac, this->phy_addr_, eth_phy_psr_reg_addr, 0x0);
     ESPHL_ERROR_CHECK(err, "Select PHY Register Page 0 failed");
   }

esphome/components/font/__init__.py

@@ -17,7 +17,6 @@ from esphome.helpers import (
     cpp_string_escape,
 )
 from esphome.const import (
-    __version__,
     CONF_FAMILY,
     CONF_FILE,
     CONF_GLYPHS,
@@ -185,31 +184,6 @@ def get_font_path(value, type) -> Path:
     return None
 
 
-def download_content(url: str, path: Path) -> None:
-    if not external_files.has_remote_file_changed(url, path):
-        _LOGGER.debug("Remote file has not changed %s", url)
-        return
-
-    _LOGGER.debug(
-        "Remote file has changed, downloading from %s to %s",
-        url,
-        path,
-    )
-
-    try:
-        req = requests.get(
-            url,
-            timeout=external_files.NETWORK_TIMEOUT,
-            headers={"User-agent": f"ESPHome/{__version__} (https://esphome.io)"},
-        )
-        req.raise_for_status()
-    except requests.exceptions.RequestException as e:
-        raise cv.Invalid(f"Could not download from {url}: {e}")
-
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_bytes(req.content)
-
-
 def download_gfont(value):
     name = (
         f"{value[CONF_FAMILY]}:ital,wght@{int(value[CONF_ITALIC])},{value[CONF_WEIGHT]}"
@@ -236,7 +210,7 @@ def download_gfont(value):
     ttf_url = match.group(1)
     _LOGGER.debug("download_gfont: ttf_url=%s", ttf_url)
 
-    download_content(ttf_url, path)
+    external_files.download_content(ttf_url, path)
     return value
 
 
@@ -244,7 +218,7 @@ def download_web_font(value):
     url = value[CONF_URL]
     path = get_font_path(value, TYPE_WEB)
 
-    download_content(url, path)
+    external_files.download_content(url, path)
     _LOGGER.debug("download_web_font: path=%s", path)
     return value
 

esphome/components/haier/binary_sensor/__init__.py

@@ -56,7 +56,7 @@ SENSOR_TYPES = {
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_HAIER_ID): cv.use_id(HonClimate),
+        cv.GenerateID(CONF_HAIER_ID): cv.use_id(HonClimate),
     }
 ).extend({cv.Optional(type): schema for type, schema in SENSOR_TYPES.items()})
 
@@ -64,8 +64,8 @@ CONFIG_SCHEMA = cv.Schema(
 async def to_code(config):
     paren = await cg.get_variable(config[CONF_HAIER_ID])
 
-    for type, _ in SENSOR_TYPES.items():
-        if conf := config.get(type):
+    for type_ in SENSOR_TYPES:
+        if conf := config.get(type_):
             sens = await binary_sensor.new_binary_sensor(conf)
-            binary_sensor_type = getattr(BinarySensorTypeEnum, type.upper())
+            binary_sensor_type = getattr(BinarySensorTypeEnum, type_.upper())
             cg.add(paren.set_sub_binary_sensor(binary_sensor_type, sens))

esphome/components/haier/button/__init__.py

@@ -21,7 +21,7 @@ ICON_SPRAY_BOTTLE = "mdi:spray-bottle"
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_HAIER_ID): cv.use_id(HonClimate),
+        cv.GenerateID(CONF_HAIER_ID): cv.use_id(HonClimate),
         cv.Optional(CONF_SELF_CLEANING): button.button_schema(
             SelfCleaningButton,
             icon=ICON_SPRAY_BOTTLE,

esphome/components/haier/climate.py

@@ -38,6 +38,9 @@ PROTOCOL_MAX_TEMPERATURE = 30.0
 PROTOCOL_TARGET_TEMPERATURE_STEP = 1.0
 PROTOCOL_CURRENT_TEMPERATURE_STEP = 0.5
 PROTOCOL_CONTROL_PACKET_SIZE = 10
+PROTOCOL_MIN_SENSORS_PACKET_SIZE = 18
+PROTOCOL_DEFAULT_SENSORS_PACKET_SIZE = 22
+PROTOCOL_STATUS_MESSAGE_HEADER_SIZE = 0
 
 CODEOWNERS = ["@paveldn"]
 DEPENDENCIES = ["climate", "uart"]
@@ -48,6 +51,9 @@ CONF_CONTROL_PACKET_SIZE = "control_packet_size"
 CONF_HORIZONTAL_AIRFLOW = "horizontal_airflow"
 CONF_ON_ALARM_START = "on_alarm_start"
 CONF_ON_ALARM_END = "on_alarm_end"
+CONF_ON_STATUS_MESSAGE = "on_status_message"
+CONF_SENSORS_PACKET_SIZE = "sensors_packet_size"
+CONF_STATUS_MESSAGE_HEADER_SIZE = "status_message_header_size"
 CONF_VERTICAL_AIRFLOW = "vertical_airflow"
 CONF_WIFI_SIGNAL = "wifi_signal"
 
@@ -129,6 +135,11 @@ HaierAlarmEndTrigger = haier_ns.class_(
     automation.Trigger.template(cg.uint8, cg.const_char_ptr),
 )
 
+StatusMessageTrigger = haier_ns.class_(
+    "StatusMessageTrigger",
+    automation.Trigger.template(cg.const_char_ptr, cg.size_t),
+)
+
 
 def validate_visual(config):
     if CONF_VISUAL in config:
@@ -183,7 +194,6 @@ BASE_CONFIG_SCHEMA = (
             cv.Optional(
                 CONF_SUPPORTED_SWING_MODES,
                 default=[
-                    "OFF",
                     "VERTICAL",
                     "HORIZONTAL",
                     "BOTH",
@@ -194,6 +204,11 @@ BASE_CONFIG_SCHEMA = (
             cv.Optional(
                 CONF_ANSWER_TIMEOUT,
             ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_ON_STATUS_MESSAGE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StatusMessageTrigger),
+                }
+            ),
         }
     )
     .extend(uart.UART_DEVICE_SCHEMA)
@@ -211,7 +226,7 @@ CONFIG_SCHEMA = cv.All(
                     ): cv.boolean,
                     cv.Optional(
                         CONF_SUPPORTED_PRESETS,
-                        default=list(["BOOST", "COMFORT"]),  # No AWAY by default
+                        default=["BOOST", "COMFORT"],  # No AWAY by default
                     ): cv.ensure_list(
                         cv.enum(SUPPORTED_CLIMATE_PRESETS_SMARTAIR2_OPTIONS, upper=True)
                     ),
@@ -229,9 +244,17 @@ CONFIG_SCHEMA = cv.All(
                     cv.Optional(
                         CONF_CONTROL_PACKET_SIZE, default=PROTOCOL_CONTROL_PACKET_SIZE
                     ): cv.int_range(min=PROTOCOL_CONTROL_PACKET_SIZE, max=50),
+                    cv.Optional(
+                        CONF_SENSORS_PACKET_SIZE,
+                        default=PROTOCOL_DEFAULT_SENSORS_PACKET_SIZE,
+                    ): cv.int_range(min=PROTOCOL_MIN_SENSORS_PACKET_SIZE, max=50),
+                    cv.Optional(
+                        CONF_STATUS_MESSAGE_HEADER_SIZE,
+                        default=PROTOCOL_STATUS_MESSAGE_HEADER_SIZE,
+                    ): cv.int_range(min=PROTOCOL_STATUS_MESSAGE_HEADER_SIZE),
                     cv.Optional(
                         CONF_SUPPORTED_PRESETS,
-                        default=list(["BOOST", "ECO", "SLEEP"]),  # No AWAY by default
+                        default=["BOOST", "ECO", "SLEEP"],  # No AWAY by default
                     ): cv.ensure_list(
                         cv.enum(SUPPORTED_CLIMATE_PRESETS_HON_OPTIONS, upper=True)
                     ),
@@ -427,11 +450,7 @@ def _final_validate(config):
             "No logger component found, logging for Haier protocol is disabled"
         )
         cg.add_build_flag("-DHAIER_LOG_LEVEL=0")
-    if (
-        (CONF_WIFI_SIGNAL in config)
-        and (config[CONF_WIFI_SIGNAL])
-        and CONF_WIFI not in full_config
-    ):
+    if config.get(CONF_WIFI_SIGNAL) and CONF_WIFI not in full_config:
         raise cv.Invalid(
             f"No WiFi configured, if you want to use haier climate without WiFi add {CONF_WIFI_SIGNAL}: false to climate configuration"
         )
@@ -473,6 +492,16 @@ async def to_code(config):
                 config[CONF_CONTROL_PACKET_SIZE] - PROTOCOL_CONTROL_PACKET_SIZE
             )
         )
+    if CONF_SENSORS_PACKET_SIZE in config:
+        cg.add(
+            var.set_extra_sensors_packet_bytes_size(
+                config[CONF_SENSORS_PACKET_SIZE] - PROTOCOL_MIN_SENSORS_PACKET_SIZE
+            )
+        )
+    if CONF_STATUS_MESSAGE_HEADER_SIZE in config:
+        cg.add(
+            var.set_status_message_header_size(config[CONF_STATUS_MESSAGE_HEADER_SIZE])
+        )
     for conf in config.get(CONF_ON_ALARM_START, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(
@@ -483,5 +512,10 @@ async def to_code(config):
         await automation.build_automation(
             trigger, [(cg.uint8, "code"), (cg.const_char_ptr, "message")], conf
         )
+    for conf in config.get(CONF_ON_STATUS_MESSAGE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(cg.const_char_ptr, "data"), (cg.size_t, "data_size")], conf
+        )
     # https://github.com/paveldn/HaierProtocol
-    cg.add_library("pavlodn/HaierProtocol", "0.9.28")
+    cg.add_library("pavlodn/HaierProtocol", "0.9.31")

esphome/components/haier/haier_base.cpp

@@ -186,6 +186,10 @@ void HaierClimateBase::send_custom_command(const haier_protocol::HaierMessage &m
   this->action_request_ = PendingAction({ActionRequest::SEND_CUSTOM_COMMAND, message});
 }
 
+void HaierClimateBase::add_status_message_callback(std::function<void(const char *, size_t)> &&callback) {
+  this->status_message_callback_.add(std::move(callback));
+}
+
 haier_protocol::HandlerError HaierClimateBase::answer_preprocess_(
     haier_protocol::FrameType request_message_type, haier_protocol::FrameType expected_request_message_type,
     haier_protocol::FrameType answer_message_type, haier_protocol::FrameType expected_answer_message_type,

esphome/components/haier/haier_base.h

@@ -4,6 +4,7 @@
 #include <set>
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/uart/uart.h"
+#include "esphome/core/automation.h"
 // HaierProtocol
 #include <protocol/haier_protocol.h>
 
@@ -56,6 +57,7 @@ class HaierClimateBase : public esphome::Component,
   void set_answer_timeout(uint32_t timeout);
   void set_send_wifi(bool send_wifi);
   void send_custom_command(const haier_protocol::HaierMessage &message);
+  void add_status_message_callback(std::function<void(const char *, size_t)> &&callback);
 
  protected:
   enum class ProtocolPhases {
@@ -140,11 +142,19 @@ class HaierClimateBase : public esphome::Component,
   esphome::climate::ClimateTraits traits_;
   HvacSettings current_hvac_settings_;
   HvacSettings next_hvac_settings_;
-  std::unique_ptr<uint8_t[]> last_status_message_;
+  std::unique_ptr<uint8_t[]> last_status_message_{nullptr};
   std::chrono::steady_clock::time_point last_request_timestamp_;       // For interval between messages
   std::chrono::steady_clock::time_point last_valid_status_timestamp_;  // For protocol timeout
   std::chrono::steady_clock::time_point last_status_request_;          // To request AC status
   std::chrono::steady_clock::time_point last_signal_request_;          // To send WiFI signal level
+  CallbackManager<void(const char *, size_t)> status_message_callback_{};
+};
+
+class StatusMessageTrigger : public Trigger<const char *, size_t> {
+ public:
+  explicit StatusMessageTrigger(HaierClimateBase *parent) {
+    parent->add_status_message_callback([this](const char *data, size_t data_size) { this->trigger(data, data_size); });
+  }
 };
 
 }  // namespace haier

esphome/components/haier/hon_climate.cpp

@@ -18,12 +18,13 @@ constexpr int PROTOCOL_OUTDOOR_TEMPERATURE_OFFSET = -64;
 constexpr uint8_t CONTROL_MESSAGE_RETRIES = 5;
 constexpr std::chrono::milliseconds CONTROL_MESSAGE_RETRIES_INTERVAL = std::chrono::milliseconds(500);
 constexpr size_t ALARM_STATUS_REQUEST_INTERVAL_MS = 600000;
+const uint8_t ONE_BUF[] = {0x00, 0x01};
+const uint8_t ZERO_BUF[] = {0x00, 0x00};
 
 HonClimate::HonClimate()
     : cleaning_status_(CleaningState::NO_CLEANING), got_valid_outdoor_temp_(false), active_alarms_{0x00, 0x00, 0x00,
                                                                                                    0x00, 0x00, 0x00,
                                                                                                    0x00, 0x00} {
-  last_status_message_ = std::unique_ptr<uint8_t[]>(new uint8_t[sizeof(hon_protocol::HaierPacketControl)]);
   this->fan_mode_speed_ = (uint8_t) hon_protocol::FanMode::FAN_MID;
   this->other_modes_fan_speed_ = (uint8_t) hon_protocol::FanMode::FAN_AUTO;
 }
@@ -169,11 +170,18 @@ haier_protocol::HandlerError HonClimate::status_handler_(haier_protocol::FrameTy
       this->action_request_.reset();
       this->force_send_control_ = false;
     } else {
-      if (data_size >= sizeof(hon_protocol::HaierPacketControl) + 2) {
-        memcpy(this->last_status_message_.get(), data + 2, sizeof(hon_protocol::HaierPacketControl));
+      if (!this->last_status_message_) {
+        this->real_control_packet_size_ = sizeof(hon_protocol::HaierPacketControl) + this->extra_control_packet_bytes_;
+        this->real_sensors_packet_size_ = sizeof(hon_protocol::HaierPacketSensors) + this->extra_sensors_packet_bytes_;
+        this->last_status_message_.reset();
+        this->last_status_message_ = std::unique_ptr<uint8_t[]>(new uint8_t[this->real_control_packet_size_]);
+      };
+      if (data_size >= this->real_control_packet_size_ + 2) {
+        memcpy(this->last_status_message_.get(), data + 2 + this->status_message_header_size_,
+               this->real_control_packet_size_);
+        this->status_message_callback_.call((const char *) data, data_size);
       } else {
-        ESP_LOGW(TAG, "Status packet too small: %d (should be >= %d)", data_size,
-                 sizeof(hon_protocol::HaierPacketControl));
+        ESP_LOGW(TAG, "Status packet too small: %d (should be >= %d)", data_size, this->real_control_packet_size_);
       }
       switch (this->protocol_phase_) {
         case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
@@ -479,8 +487,8 @@ void HonClimate::initialization() {
 }
 
 haier_protocol::HaierMessage HonClimate::get_control_message() {
-  uint8_t control_out_buffer[sizeof(hon_protocol::HaierPacketControl)];
-  memcpy(control_out_buffer, this->last_status_message_.get(), sizeof(hon_protocol::HaierPacketControl));
+  uint8_t control_out_buffer[haier_protocol::MAX_FRAME_SIZE];
+  memcpy(control_out_buffer, this->last_status_message_.get(), this->real_control_packet_size_);
   hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
   control_out_buffer[4] = 0;  // This byte should be cleared before setting values
   bool has_hvac_settings = false;
@@ -636,7 +644,7 @@ haier_protocol::HaierMessage HonClimate::get_control_message() {
   out_data->health_mode = this->health_mode_ ? 1 : 0;
   return haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
                                       (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
-                                      control_out_buffer, sizeof(hon_protocol::HaierPacketControl));
+                                      control_out_buffer, this->real_control_packet_size_);
 }
 
 void HonClimate::process_alarm_message_(const uint8_t *packet, uint8_t size, bool check_new) {
@@ -758,15 +766,17 @@ void HonClimate::update_sub_text_sensor_(SubTextSensorType type, const std::stri
 #endif  // USE_TEXT_SENSOR
 
 haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *packet_buffer, uint8_t size) {
-  size_t expected_size = 2 + sizeof(hon_protocol::HaierPacketControl) + sizeof(hon_protocol::HaierPacketSensors) +
-                         this->extra_control_packet_bytes_;
-  if (size < expected_size)
+  size_t expected_size =
+      2 + this->status_message_header_size_ + this->real_control_packet_size_ + this->real_sensors_packet_size_;
+  if (size < expected_size) {
+    ESP_LOGW(TAG, "Unexpected message size %d (expexted >= %d)", size, expected_size);
     return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
+  }
   uint16_t subtype = (((uint16_t) packet_buffer[0]) << 8) + packet_buffer[1];
-  if ((subtype == 0x7D01) && (size >= expected_size + 4 + sizeof(hon_protocol::HaierPacketBigData))) {
+  if ((subtype == 0x7D01) && (size >= expected_size + sizeof(hon_protocol::HaierPacketBigData))) {
     // Got BigData packet
     const hon_protocol::HaierPacketBigData *bd_packet =
-        (const hon_protocol::HaierPacketBigData *) (&packet_buffer[expected_size + 4]);
+        (const hon_protocol::HaierPacketBigData *) (&packet_buffer[expected_size]);
 #ifdef USE_SENSOR
     this->update_sub_sensor_(SubSensorType::INDOOR_COIL_TEMPERATURE, bd_packet->indoor_coil_temperature / 2.0 - 20);
     this->update_sub_sensor_(SubSensorType::OUTDOOR_COIL_TEMPERATURE, bd_packet->outdoor_coil_temperature - 64);
@@ -795,9 +805,9 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
     hon_protocol::HaierPacketControl control;
     hon_protocol::HaierPacketSensors sensors;
   } packet;
-  memcpy(&packet.control, packet_buffer + 2, sizeof(hon_protocol::HaierPacketControl));
-  memcpy(&packet.sensors,
-         packet_buffer + 2 + sizeof(hon_protocol::HaierPacketControl) + this->extra_control_packet_bytes_,
+  memcpy(&packet.control, packet_buffer + 2 + this->status_message_header_size_,
+         sizeof(hon_protocol::HaierPacketControl));
+  memcpy(&packet.sensors, packet_buffer + 2 + this->status_message_header_size_ + this->real_control_packet_size_,
          sizeof(hon_protocol::HaierPacketSensors));
   if (packet.sensors.error_status != 0) {
     ESP_LOGW(TAG, "HVAC error, code=0x%02X", packet.sensors.error_status);
@@ -996,8 +1006,6 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
 }
 
 void HonClimate::fill_control_messages_queue_() {
-  static uint8_t one_buf[] = {0x00, 0x01};
-  static uint8_t zero_buf[] = {0x00, 0x00};
   if (!this->current_hvac_settings_.valid && !this->force_send_control_)
     return;
   this->clear_control_messages_queue_();
@@ -1009,7 +1017,7 @@ void HonClimate::fill_control_messages_queue_() {
         haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
                                      (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                          (uint8_t) hon_protocol::DataParameters::BEEPER_STATUS,
-                                     this->beeper_status_ ? zero_buf : one_buf, 2));
+                                     this->beeper_status_ ? ZERO_BUF : ONE_BUF, 2));
   }
   // Health mode
   {
@@ -1017,7 +1025,7 @@ void HonClimate::fill_control_messages_queue_() {
         haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
                                      (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                          (uint8_t) hon_protocol::DataParameters::HEALTH_MODE,
-                                     this->health_mode_ ? one_buf : zero_buf, 2));
+                                     this->health_mode_ ? ONE_BUF : ZERO_BUF, 2));
   }
   // Climate mode
   bool new_power = this->mode != CLIMATE_MODE_OFF;
@@ -1092,7 +1100,7 @@ void HonClimate::fill_control_messages_queue_() {
         haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
                                      (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
                                          (uint8_t) hon_protocol::DataParameters::AC_POWER,
-                                     new_power ? one_buf : zero_buf, 2));
+                                     new_power ? ONE_BUF : ZERO_BUF, 2));
   }
   // CLimate preset
   {
@@ -1165,6 +1173,35 @@ void HonClimate::fill_control_messages_queue_() {
                                          (uint8_t) hon_protocol::DataParameters::SET_POINT,
                                      buffer, 2));
   }
+  // Vertical swing mode
+  if (climate_control.swing_mode.has_value()) {
+    uint8_t vertical_swing_buf[] = {0x00, (uint8_t) hon_protocol::VerticalSwingMode::AUTO};
+    uint8_t horizontal_swing_buf[] = {0x00, (uint8_t) hon_protocol::HorizontalSwingMode::AUTO};
+    switch (climate_control.swing_mode.value()) {
+      case CLIMATE_SWING_OFF:
+        horizontal_swing_buf[1] = (uint8_t) this->settings_.last_horizontal_swing;
+        vertical_swing_buf[1] = (uint8_t) this->settings_.last_vertiacal_swing;
+        break;
+      case CLIMATE_SWING_VERTICAL:
+        horizontal_swing_buf[1] = (uint8_t) this->settings_.last_horizontal_swing;
+        break;
+      case CLIMATE_SWING_HORIZONTAL:
+        vertical_swing_buf[1] = (uint8_t) this->settings_.last_vertiacal_swing;
+        break;
+      case CLIMATE_SWING_BOTH:
+        break;
+    }
+    this->control_messages_queue_.push(
+        haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
+                                     (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
+                                         (uint8_t) hon_protocol::DataParameters::HORIZONTAL_SWING_MODE,
+                                     horizontal_swing_buf, 2));
+    this->control_messages_queue_.push(
+        haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
+                                     (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
+                                         (uint8_t) hon_protocol::DataParameters::VERTICAL_SWING_MODE,
+                                     vertical_swing_buf, 2));
+  }
   // Fan mode
   if (climate_control.fan_mode.has_value()) {
     switch (climate_control.fan_mode.value()) {
@@ -1202,40 +1239,56 @@ void HonClimate::clear_control_messages_queue_() {
 
 bool HonClimate::prepare_pending_action() {
   switch (this->action_request_.value().action) {
-    case ActionRequest::START_SELF_CLEAN: {
-      uint8_t control_out_buffer[sizeof(hon_protocol::HaierPacketControl)];
-      memcpy(control_out_buffer, this->last_status_message_.get(), sizeof(hon_protocol::HaierPacketControl));
-      hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
-      out_data->self_cleaning_status = 1;
-      out_data->steri_clean = 0;
-      out_data->set_point = 0x06;
-      out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::CENTER;
-      out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::CENTER;
-      out_data->ac_power = 1;
-      out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
-      out_data->light_status = 0;
-      this->action_request_.value().message = haier_protocol::HaierMessage(
-          haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
-          control_out_buffer, sizeof(hon_protocol::HaierPacketControl));
-    }
-      return true;
-    case ActionRequest::START_STERI_CLEAN: {
-      uint8_t control_out_buffer[sizeof(hon_protocol::HaierPacketControl)];
-      memcpy(control_out_buffer, this->last_status_message_.get(), sizeof(hon_protocol::HaierPacketControl));
-      hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
-      out_data->self_cleaning_status = 0;
-      out_data->steri_clean = 1;
-      out_data->set_point = 0x06;
-      out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::CENTER;
-      out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::CENTER;
-      out_data->ac_power = 1;
-      out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
-      out_data->light_status = 0;
-      this->action_request_.value().message = haier_protocol::HaierMessage(
-          haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
-          control_out_buffer, sizeof(hon_protocol::HaierPacketControl));
-    }
-      return true;
+    case ActionRequest::START_SELF_CLEAN:
+      if (this->control_method_ == HonControlMethod::SET_GROUP_PARAMETERS) {
+        uint8_t control_out_buffer[haier_protocol::MAX_FRAME_SIZE];
+        memcpy(control_out_buffer, this->last_status_message_.get(), this->real_control_packet_size_);
+        hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
+        out_data->self_cleaning_status = 1;
+        out_data->steri_clean = 0;
+        out_data->set_point = 0x06;
+        out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::CENTER;
+        out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::CENTER;
+        out_data->ac_power = 1;
+        out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
+        out_data->light_status = 0;
+        this->action_request_.value().message = haier_protocol::HaierMessage(
+            haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
+            control_out_buffer, this->real_control_packet_size_);
+        return true;
+      } else if (this->control_method_ == HonControlMethod::SET_SINGLE_PARAMETER) {
+        this->action_request_.value().message =
+            haier_protocol::HaierMessage(haier_protocol::FrameType::CONTROL,
+                                         (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
+                                             (uint8_t) hon_protocol::DataParameters::SELF_CLEANING,
+                                         ONE_BUF, 2);
+        return true;
+      } else {
+        this->action_request_.reset();
+        return false;
+      }
+    case ActionRequest::START_STERI_CLEAN:
+      if (this->control_method_ == HonControlMethod::SET_GROUP_PARAMETERS) {
+        uint8_t control_out_buffer[haier_protocol::MAX_FRAME_SIZE];
+        memcpy(control_out_buffer, this->last_status_message_.get(), this->real_control_packet_size_);
+        hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
+        out_data->self_cleaning_status = 0;
+        out_data->steri_clean = 1;
+        out_data->set_point = 0x06;
+        out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::CENTER;
+        out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::CENTER;
+        out_data->ac_power = 1;
+        out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
+        out_data->light_status = 0;
+        this->action_request_.value().message = haier_protocol::HaierMessage(
+            haier_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
+            control_out_buffer, this->real_control_packet_size_);
+        return true;
+      } else {
+        // No Steri clean support (yet?) in SET_SINGLE_PARAMETER
+        this->action_request_.reset();
+        return false;
+      }
     default:
       return HaierClimateBase::prepare_pending_action();
   }
@@ -1251,6 +1304,7 @@ void HonClimate::process_protocol_reset() {
 #endif  // USE_SENSOR
   this->got_valid_outdoor_temp_ = false;
   this->hvac_hardware_info_.reset();
+  this->last_status_message_.reset(nullptr);
 }
 
 bool HonClimate::should_get_big_data_() {

esphome/components/haier/hon_climate.h

@@ -104,6 +104,8 @@ class HonClimate : public HaierClimateBase {
   void start_self_cleaning();
   void start_steri_cleaning();
   void set_extra_control_packet_bytes_size(size_t size) { this->extra_control_packet_bytes_ = size; };
+  void set_extra_sensors_packet_bytes_size(size_t size) { this->extra_sensors_packet_bytes_ = size; };
+  void set_status_message_header_size(size_t size) { this->status_message_header_size_ = size; };
   void set_control_method(HonControlMethod method) { this->control_method_ = method; };
   void add_alarm_start_callback(std::function<void(uint8_t, const char *)> &&callback);
   void add_alarm_end_callback(std::function<void(uint8_t, const char *)> &&callback);
@@ -158,7 +160,11 @@ class HonClimate : public HaierClimateBase {
   esphome::optional<hon_protocol::HorizontalSwingMode> pending_horizontal_direction_{};
   esphome::optional<HardwareInfo> hvac_hardware_info_{};
   uint8_t active_alarms_[8];
-  int extra_control_packet_bytes_;
+  int extra_control_packet_bytes_{0};
+  int extra_sensors_packet_bytes_{4};
+  int status_message_header_size_{0};
+  int real_control_packet_size_{sizeof(hon_protocol::HaierPacketControl)};
+  int real_sensors_packet_size_{sizeof(hon_protocol::HaierPacketSensors) + 4};
   HonControlMethod control_method_;
   std::queue<haier_protocol::HaierMessage> control_messages_queue_;
   CallbackManager<void(uint8_t, const char *)> alarm_start_callback_{};

esphome/components/haier/hon_packet.h

@@ -41,15 +41,20 @@ enum class ConditioningMode : uint8_t {
 enum class DataParameters : uint8_t {
   AC_POWER = 0x01,
   SET_POINT = 0x02,
+  VERTICAL_SWING_MODE = 0x03,
   AC_MODE = 0x04,
   FAN_MODE = 0x05,
   USE_FAHRENHEIT = 0x07,
+  DISPLAY_STATUS = 0x09,
   TEN_DEGREE = 0x0A,
   HEALTH_MODE = 0x0B,
+  HORIZONTAL_SWING_MODE = 0x0C,
+  SELF_CLEANING = 0x0D,
   BEEPER_STATUS = 0x16,
   LOCK_REMOTE = 0x17,
   QUIET_MODE = 0x19,
   FAST_MODE = 0x1A,
+  SLEEP_MODE = 0x1B,
 };
 
 enum class SpecialMode : uint8_t { NONE = 0x00, ELDERLY = 0x01, CHILDREN = 0x02, PREGNANT = 0x03 };

esphome/components/haier/sensor/__init__.py

@@ -137,16 +137,16 @@ SENSOR_TYPES = {
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_HAIER_ID): cv.use_id(HonClimate),
+        cv.GenerateID(CONF_HAIER_ID): cv.use_id(HonClimate),
     }
-).extend({cv.Optional(type): schema for type, schema in SENSOR_TYPES.items()})
+).extend({cv.Optional(type_): schema for type_, schema in SENSOR_TYPES.items()})
 
 
 async def to_code(config):
     paren = await cg.get_variable(config[CONF_HAIER_ID])
 
-    for type, _ in SENSOR_TYPES.items():
-        if conf := config.get(type):
+    for type_ in SENSOR_TYPES:
+        if conf := config.get(type_):
             sens = await sensor.new_sensor(conf)
-            sensor_type = getattr(SensorTypeEnum, type.upper())
+            sensor_type = getattr(SensorTypeEnum, type_.upper())
             cg.add(paren.set_sub_sensor(sensor_type, sens))