Merge pull request #5273 from esphome/bump-2023.8.1

2023.8.1
Bump version to 2023.8.1
2025-08-10 20:29:24 +00:00 · 2023-08-18 09:09:07 +12:00 · 2023-08-18 08:12:42 +12:00 · 2023-08-18 08:12:42 +12:00 · 2023-08-18 08:12:42 +12:00 · 2023-08-17 16:00:56 +12:00
64 changed files with 2118 additions and 586 deletions
--- a/2
+++ b/2
@@ -144,7 +144,7 @@ esphome/components/key_collector/* @ssieb
 esphome/components/key_provider/* @ssieb
 esphome/components/kuntze/* @ssieb
 esphome/components/lcd_menu/* @numo68
-esphome/components/ld2410/* @sebcaps
+esphome/components/ld2410/* @regevbr @sebcaps
 esphome/components/ledc/* @OttoWinter
 esphome/components/light/* @esphome/core
 esphome/components/lilygo_t5_47/touchscreen/* @jesserockz
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -35,7 +35,8 @@ RUN \
          python3-dev=3.9.2-3 \
          zlib1g-dev=1:1.2.11.dfsg-2+deb11u2 \
          libjpeg-dev=1:2.0.6-4 \
-          libcairo2=1.16.0-5; \
+          libcairo2=1.16.0-5 \
+          libfreetype-dev=2.10.4+dfsg-1+deb11u1; \
    fi; \
    rm -rf \
        /tmp/* \
--- a/esphome/components/haier/climate.py
+++ b/esphome/components/haier/climate.py
@@ -14,7 +14,10 @@ from esphome.const import (
    CONF_MIN_TEMPERATURE,
    CONF_PROTOCOL,
    CONF_SUPPORTED_MODES,
+    CONF_SUPPORTED_PRESETS,
    CONF_SUPPORTED_SWING_MODES,
+    CONF_TARGET_TEMPERATURE,
+    CONF_TEMPERATURE_STEP,
    CONF_VISUAL,
    CONF_WIFI,
    DEVICE_CLASS_TEMPERATURE,
@@ -23,25 +26,29 @@ from esphome.const import (
    UNIT_CELSIUS,
 )
 from esphome.components.climate import (
-    ClimateSwingMode,
    ClimateMode,
+    ClimatePreset,
+    ClimateSwingMode,
+    CONF_CURRENT_TEMPERATURE,
 )

 _LOGGER = logging.getLogger(__name__)

 PROTOCOL_MIN_TEMPERATURE = 16.0
 PROTOCOL_MAX_TEMPERATURE = 30.0
-PROTOCOL_TEMPERATURE_STEP = 1.0
+PROTOCOL_TARGET_TEMPERATURE_STEP = 1.0
+PROTOCOL_CURRENT_TEMPERATURE_STEP = 0.5

 CODEOWNERS = ["@paveldn"]
 AUTO_LOAD = ["sensor"]
 DEPENDENCIES = ["climate", "uart"]
 CONF_WIFI_SIGNAL = "wifi_signal"
+CONF_ANSWER_TIMEOUT = "answer_timeout"
+CONF_DISPLAY = "display"
 CONF_OUTDOOR_TEMPERATURE = "outdoor_temperature"
 CONF_VERTICAL_AIRFLOW = "vertical_airflow"
 CONF_HORIZONTAL_AIRFLOW = "horizontal_airflow"

-
 PROTOCOL_HON = "HON"
 PROTOCOL_SMARTAIR2 = "SMARTAIR2"
 PROTOCOLS_SUPPORTED = [PROTOCOL_HON, PROTOCOL_SMARTAIR2]
@@ -82,13 +89,24 @@ SUPPORTED_SWING_MODES_OPTIONS = {

 SUPPORTED_CLIMATE_MODES_OPTIONS = {
    "OFF": ClimateMode.CLIMATE_MODE_OFF,  # always available
-    "AUTO": ClimateMode.CLIMATE_MODE_AUTO,  # always available
+    "HEAT_COOL": ClimateMode.CLIMATE_MODE_HEAT_COOL,  # always available
    "COOL": ClimateMode.CLIMATE_MODE_COOL,
    "HEAT": ClimateMode.CLIMATE_MODE_HEAT,
    "DRY": ClimateMode.CLIMATE_MODE_DRY,
    "FAN_ONLY": ClimateMode.CLIMATE_MODE_FAN_ONLY,
 }

+SUPPORTED_CLIMATE_PRESETS_SMARTAIR2_OPTIONS = {
+    "BOOST": ClimatePreset.CLIMATE_PRESET_BOOST,
+    "COMFORT": ClimatePreset.CLIMATE_PRESET_COMFORT,
+}
+
+SUPPORTED_CLIMATE_PRESETS_HON_OPTIONS = {
+    "ECO": ClimatePreset.CLIMATE_PRESET_ECO,
+    "BOOST": ClimatePreset.CLIMATE_PRESET_BOOST,
+    "SLEEP": ClimatePreset.CLIMATE_PRESET_SLEEP,
+}
+

 def validate_visual(config):
    if CONF_VISUAL in config:
@@ -109,10 +127,29 @@ def validate_visual(config):
                )
        else:
            config[CONF_VISUAL][CONF_MAX_TEMPERATURE] = PROTOCOL_MAX_TEMPERATURE
+        if CONF_TEMPERATURE_STEP in visual_config:
+            temp_step = config[CONF_VISUAL][CONF_TEMPERATURE_STEP][
+                CONF_TARGET_TEMPERATURE
+            ]
+            if ((int)(temp_step * 2)) / 2 != temp_step:
+                raise cv.Invalid(
+                    f"Configured visual temperature step {temp_step} is wrong, it should be a multiple of 0.5"
+                )
+        else:
+            config[CONF_VISUAL][CONF_TEMPERATURE_STEP] = (
+                {
+                    CONF_TARGET_TEMPERATURE: PROTOCOL_TARGET_TEMPERATURE_STEP,
+                    CONF_CURRENT_TEMPERATURE: PROTOCOL_CURRENT_TEMPERATURE_STEP,
+                },
+            )
    else:
        config[CONF_VISUAL] = {
            CONF_MIN_TEMPERATURE: PROTOCOL_MIN_TEMPERATURE,
            CONF_MAX_TEMPERATURE: PROTOCOL_MAX_TEMPERATURE,
+            CONF_TEMPERATURE_STEP: {
+                CONF_TARGET_TEMPERATURE: PROTOCOL_TARGET_TEMPERATURE_STEP,
+                CONF_CURRENT_TEMPERATURE: PROTOCOL_CURRENT_TEMPERATURE_STEP,
+            },
        }
    return config

@@ -132,6 +169,11 @@ BASE_CONFIG_SCHEMA = (
                    "BOTH",
                ],
            ): cv.ensure_list(cv.enum(SUPPORTED_SWING_MODES_OPTIONS, upper=True)),
+            cv.Optional(CONF_WIFI_SIGNAL, default=False): cv.boolean,
+            cv.Optional(CONF_DISPLAY): cv.boolean,
+            cv.Optional(
+                CONF_ANSWER_TIMEOUT,
+            ): cv.positive_time_period_milliseconds,
        }
    )
    .extend(uart.UART_DEVICE_SCHEMA)
@@ -144,13 +186,26 @@ CONFIG_SCHEMA = cv.All(
            PROTOCOL_SMARTAIR2: BASE_CONFIG_SCHEMA.extend(
                {
                    cv.GenerateID(): cv.declare_id(Smartair2Climate),
+                    cv.Optional(
+                        CONF_SUPPORTED_PRESETS,
+                        default=list(
+                            SUPPORTED_CLIMATE_PRESETS_SMARTAIR2_OPTIONS.keys()
+                        ),
+                    ): cv.ensure_list(
+                        cv.enum(SUPPORTED_CLIMATE_PRESETS_SMARTAIR2_OPTIONS, upper=True)
+                    ),
                }
            ),
            PROTOCOL_HON: BASE_CONFIG_SCHEMA.extend(
                {
                    cv.GenerateID(): cv.declare_id(HonClimate),
-                    cv.Optional(CONF_WIFI_SIGNAL, default=True): cv.boolean,
                    cv.Optional(CONF_BEEPER, default=True): cv.boolean,
+                    cv.Optional(
+                        CONF_SUPPORTED_PRESETS,
+                        default=list(SUPPORTED_CLIMATE_PRESETS_HON_OPTIONS.keys()),
+                    ): cv.ensure_list(
+                        cv.enum(SUPPORTED_CLIMATE_PRESETS_HON_OPTIONS, upper=True)
+                    ),
                    cv.Optional(CONF_OUTDOOR_TEMPERATURE): sensor.sensor_schema(
                        unit_of_measurement=UNIT_CELSIUS,
                        icon=ICON_THERMOMETER,
@@ -354,10 +409,11 @@ async def to_code(config):
    await uart.register_uart_device(var, config)
    await climate.register_climate(var, config)

-    if (CONF_WIFI_SIGNAL in config) and (config[CONF_WIFI_SIGNAL]):
-        cg.add(var.set_send_wifi(config[CONF_WIFI_SIGNAL]))
+    cg.add(var.set_send_wifi(config[CONF_WIFI_SIGNAL]))
    if CONF_BEEPER in config:
        cg.add(var.set_beeper_state(config[CONF_BEEPER]))
+    if CONF_DISPLAY in config:
+        cg.add(var.set_display_state(config[CONF_DISPLAY]))
    if CONF_OUTDOOR_TEMPERATURE in config:
        sens = await sensor.new_sensor(config[CONF_OUTDOOR_TEMPERATURE])
        cg.add(var.set_outdoor_temperature_sensor(sens))
@@ -365,5 +421,9 @@ async def to_code(config):
        cg.add(var.set_supported_modes(config[CONF_SUPPORTED_MODES]))
    if CONF_SUPPORTED_SWING_MODES in config:
        cg.add(var.set_supported_swing_modes(config[CONF_SUPPORTED_SWING_MODES]))
+    if CONF_SUPPORTED_PRESETS in config:
+        cg.add(var.set_supported_presets(config[CONF_SUPPORTED_PRESETS]))
+    if CONF_ANSWER_TIMEOUT in config:
+        cg.add(var.set_answer_timeout(config[CONF_ANSWER_TIMEOUT]))
    # https://github.com/paveldn/HaierProtocol
-    cg.add_library("pavlodn/HaierProtocol", "0.9.18")
+    cg.add_library("pavlodn/HaierProtocol", "0.9.20")
--- a/esphome/components/haier/haier_base.cpp
+++ b/esphome/components/haier/haier_base.cpp
@@ -2,6 +2,9 @@
 #include <string>
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/uart/uart.h"
+#ifdef USE_WIFI
+#include "esphome/components/wifi/wifi_component.h"
+#endif
 #include "haier_base.h"

 using namespace esphome::climate;
@@ -24,14 +27,15 @@ constexpr size_t NO_COMMAND = 0xFF;  // Indicate that there is no command suppli
 const char *HaierClimateBase::phase_to_string_(ProtocolPhases phase) {
  static const char *phase_names[] = {
      "SENDING_INIT_1",
-      "WAITING_ANSWER_INIT_1",
+      "WAITING_INIT_1_ANSWER",
      "SENDING_INIT_2",
-      "WAITING_ANSWER_INIT_2",
+      "WAITING_INIT_2_ANSWER",
      "SENDING_FIRST_STATUS_REQUEST",
      "WAITING_FIRST_STATUS_ANSWER",
      "SENDING_ALARM_STATUS_REQUEST",
      "WAITING_ALARM_STATUS_ANSWER",
      "IDLE",
+      "UNKNOWN",
      "SENDING_STATUS_REQUEST",
      "WAITING_STATUS_ANSWER",
      "SENDING_UPDATE_SIGNAL_REQUEST",
@@ -63,11 +67,12 @@ HaierClimateBase::HaierClimateBase()
      forced_publish_(false),
      forced_request_status_(false),
      first_control_attempt_(false),
-      reset_protocol_request_(false) {
+      reset_protocol_request_(false),
+      send_wifi_signal_(true) {
  this->traits_ = climate::ClimateTraits();
  this->traits_.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_COOL, climate::CLIMATE_MODE_HEAT,
                                     climate::CLIMATE_MODE_FAN_ONLY, climate::CLIMATE_MODE_DRY,
-                                     climate::CLIMATE_MODE_AUTO});
+                                     climate::CLIMATE_MODE_HEAT_COOL});
  this->traits_.set_supported_fan_modes(
      {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH});
  this->traits_.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH,
@@ -77,7 +82,7 @@ HaierClimateBase::HaierClimateBase()

 HaierClimateBase::~HaierClimateBase() {}

-void HaierClimateBase::set_phase_(ProtocolPhases phase) {
+void HaierClimateBase::set_phase(ProtocolPhases phase) {
  if (this->protocol_phase_ != phase) {
 #if (HAIER_LOG_LEVEL > 4)
    ESP_LOGV(TAG, "Phase transition: %s => %s", phase_to_string_(this->protocol_phase_), phase_to_string_(phase));
@@ -109,10 +114,27 @@ bool HaierClimateBase::is_control_message_interval_exceeded_(std::chrono::steady
  return this->check_timeout_(now, this->last_request_timestamp_, CONTROL_MESSAGES_INTERVAL_MS);
 }

-bool HaierClimateBase::is_protocol_initialisation_interval_exceded_(std::chrono::steady_clock::time_point now) {
+bool HaierClimateBase::is_protocol_initialisation_interval_exceeded_(std::chrono::steady_clock::time_point now) {
  return this->check_timeout_(now, this->last_request_timestamp_, PROTOCOL_INITIALIZATION_INTERVAL);
 }

+#ifdef USE_WIFI
+haier_protocol::HaierMessage HaierClimateBase::get_wifi_signal_message_(uint8_t message_type) {
+  static uint8_t wifi_status_data[4] = {0x00, 0x00, 0x00, 0x00};
+  if (wifi::global_wifi_component->is_connected()) {
+    wifi_status_data[1] = 0;
+    int8_t rssi = wifi::global_wifi_component->wifi_rssi();
+    wifi_status_data[3] = uint8_t((128 + rssi) / 1.28f);
+    ESP_LOGD(TAG, "WiFi signal is: %ddBm => %d%%", rssi, wifi_status_data[3]);
+  } else {
+    ESP_LOGD(TAG, "WiFi is not connected");
+    wifi_status_data[1] = 1;
+    wifi_status_data[3] = 0;
+  }
+  return haier_protocol::HaierMessage(message_type, wifi_status_data, sizeof(wifi_status_data));
+}
+#endif
+
 bool HaierClimateBase::get_display_state() const { return this->display_status_; }

 void HaierClimateBase::set_display_state(bool state) {
@@ -136,18 +158,31 @@ void HaierClimateBase::send_power_on_command() { this->action_request_ = ActionR
 void HaierClimateBase::send_power_off_command() { this->action_request_ = ActionRequest::TURN_POWER_OFF; }

 void HaierClimateBase::toggle_power() { this->action_request_ = ActionRequest::TOGGLE_POWER; }
+
 void HaierClimateBase::set_supported_swing_modes(const std::set<climate::ClimateSwingMode> &modes) {
  this->traits_.set_supported_swing_modes(modes);
-  this->traits_.add_supported_swing_mode(climate::CLIMATE_SWING_OFF);       // Always available
-  this->traits_.add_supported_swing_mode(climate::CLIMATE_SWING_VERTICAL);  // Always available
+  if (!modes.empty())
+    this->traits_.add_supported_swing_mode(climate::CLIMATE_SWING_OFF);
+}
+
+void HaierClimateBase::set_answer_timeout(uint32_t timeout) {
+  this->answer_timeout_ = std::chrono::milliseconds(timeout);
 }

 void HaierClimateBase::set_supported_modes(const std::set<climate::ClimateMode> &modes) {
  this->traits_.set_supported_modes(modes);
-  this->traits_.add_supported_mode(climate::CLIMATE_MODE_OFF);   // Always available
-  this->traits_.add_supported_mode(climate::CLIMATE_MODE_AUTO);  // Always available
+  this->traits_.add_supported_mode(climate::CLIMATE_MODE_OFF);        // Always available
+  this->traits_.add_supported_mode(climate::CLIMATE_MODE_HEAT_COOL);  // Always available
 }

+void HaierClimateBase::set_supported_presets(const std::set<climate::ClimatePreset> &presets) {
+  this->traits_.set_supported_presets(presets);
+  if (!presets.empty())
+    this->traits_.add_supported_preset(climate::CLIMATE_PRESET_NONE);
+}
+
+void HaierClimateBase::set_send_wifi(bool send_wifi) { this->send_wifi_signal_ = send_wifi; }
+
 haier_protocol::HandlerError HaierClimateBase::answer_preprocess_(uint8_t request_message_type,
                                                                  uint8_t expected_request_message_type,
                                                                  uint8_t answer_message_type,
@@ -155,9 +190,9 @@ haier_protocol::HandlerError HaierClimateBase::answer_preprocess_(uint8_t reques
                                                                  ProtocolPhases expected_phase) {
  haier_protocol::HandlerError result = haier_protocol::HandlerError::HANDLER_OK;
  if ((expected_request_message_type != NO_COMMAND) && (request_message_type != expected_request_message_type))
-    result = haier_protocol::HandlerError::UNSUPORTED_MESSAGE;
+    result = haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
  if ((expected_answer_message_type != NO_COMMAND) && (answer_message_type != expected_answer_message_type))
-    result = haier_protocol::HandlerError::UNSUPORTED_MESSAGE;
+    result = haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
  if ((expected_phase != ProtocolPhases::UNKNOWN) && (expected_phase != this->protocol_phase_))
    result = haier_protocol::HandlerError::UNEXPECTED_MESSAGE;
  if (is_message_invalid(answer_message_type))
@@ -172,9 +207,9 @@ haier_protocol::HandlerError HaierClimateBase::timeout_default_handler_(uint8_t
  ESP_LOGW(TAG, "Answer timeout for command %02X, phase %d", request_type, (int) this->protocol_phase_);
 #endif
  if (this->protocol_phase_ > ProtocolPhases::IDLE) {
-    this->set_phase_(ProtocolPhases::IDLE);
+    this->set_phase(ProtocolPhases::IDLE);
  } else {
-    this->set_phase_(ProtocolPhases::SENDING_INIT_1);
+    this->set_phase(ProtocolPhases::SENDING_INIT_1);
  }
  return haier_protocol::HandlerError::HANDLER_OK;
 }
@@ -183,8 +218,8 @@ void HaierClimateBase::setup() {
  ESP_LOGI(TAG, "Haier initialization...");
  // Set timestamp here to give AC time to boot
  this->last_request_timestamp_ = std::chrono::steady_clock::now();
-  this->set_phase_(ProtocolPhases::SENDING_INIT_1);
-  this->set_answers_handlers();
+  this->set_phase(ProtocolPhases::SENDING_INIT_1);
+  this->set_handlers();
  this->haier_protocol_.set_default_timeout_handler(
      std::bind(&esphome::haier::HaierClimateBase::timeout_default_handler_, this, std::placeholders::_1));
 }
@@ -212,7 +247,7 @@ void HaierClimateBase::loop() {
      this->set_force_send_control_(false);
      if (this->hvac_settings_.valid)
        this->hvac_settings_.reset();
-      this->set_phase_(ProtocolPhases::SENDING_INIT_1);
+      this->set_phase(ProtocolPhases::SENDING_INIT_1);
      return;
    } else {
      // No need to reset protocol if we didn't pass initialization phase
@@ -229,7 +264,7 @@ void HaierClimateBase::loop() {
      this->process_pending_action();
    } else if (this->hvac_settings_.valid || this->force_send_control_) {
      ESP_LOGV(TAG, "Control packet is pending...");
-      this->set_phase_(ProtocolPhases::SENDING_CONTROL);
+      this->set_phase(ProtocolPhases::SENDING_CONTROL);
    }
  }
  this->process_phase(now);
@@ -243,10 +278,10 @@ void HaierClimateBase::process_pending_action() {
  }
  switch (request) {
    case ActionRequest::TURN_POWER_ON:
-      this->set_phase_(ProtocolPhases::SENDING_POWER_ON_COMMAND);
+      this->set_phase(ProtocolPhases::SENDING_POWER_ON_COMMAND);
      break;
    case ActionRequest::TURN_POWER_OFF:
-      this->set_phase_(ProtocolPhases::SENDING_POWER_OFF_COMMAND);
+      this->set_phase(ProtocolPhases::SENDING_POWER_OFF_COMMAND);
      break;
    case ActionRequest::TOGGLE_POWER:
    case ActionRequest::NO_ACTION:
@@ -303,7 +338,11 @@ void HaierClimateBase::set_force_send_control_(bool status) {
 }

 void HaierClimateBase::send_message_(const haier_protocol::HaierMessage &command, bool use_crc) {
-  this->haier_protocol_.send_message(command, use_crc);
+  if (this->answer_timeout_.has_value()) {
+    this->haier_protocol_.send_message(command, use_crc, this->answer_timeout_.value());
+  } else {
+    this->haier_protocol_.send_message(command, use_crc);
+  }
  this->last_request_timestamp_ = std::chrono::steady_clock::now();
 }

--- a/esphome/components/haier/haier_base.h
+++ b/esphome/components/haier/haier_base.h
@@ -44,6 +44,7 @@ class HaierClimateBase : public esphome::Component,
  void reset_protocol() { this->reset_protocol_request_ = true; };
  void set_supported_modes(const std::set<esphome::climate::ClimateMode> &modes);
  void set_supported_swing_modes(const std::set<esphome::climate::ClimateSwingMode> &modes);
+  void set_supported_presets(const std::set<esphome::climate::ClimatePreset> &presets);
  size_t available() noexcept override { return esphome::uart::UARTDevice::available(); };
  size_t read_array(uint8_t *data, size_t len) noexcept override {
    return esphome::uart::UARTDevice::read_array(data, len) ? len : 0;
@@ -52,39 +53,41 @@ class HaierClimateBase : public esphome::Component,
    esphome::uart::UARTDevice::write_array(data, len);
  };
  bool can_send_message() const { return haier_protocol_.get_outgoing_queue_size() == 0; };
+  void set_answer_timeout(uint32_t timeout);
+  void set_send_wifi(bool send_wifi);

 protected:
  enum class ProtocolPhases {
    UNKNOWN = -1,
    // INITIALIZATION
    SENDING_INIT_1 = 0,
-    WAITING_ANSWER_INIT_1 = 1,
+    WAITING_INIT_1_ANSWER = 1,
    SENDING_INIT_2 = 2,
-    WAITING_ANSWER_INIT_2 = 3,
+    WAITING_INIT_2_ANSWER = 3,
    SENDING_FIRST_STATUS_REQUEST = 4,
    WAITING_FIRST_STATUS_ANSWER = 5,
    SENDING_ALARM_STATUS_REQUEST = 6,
    WAITING_ALARM_STATUS_ANSWER = 7,
    // FUNCTIONAL STATE
    IDLE = 8,
-    SENDING_STATUS_REQUEST = 9,
-    WAITING_STATUS_ANSWER = 10,
-    SENDING_UPDATE_SIGNAL_REQUEST = 11,
-    WAITING_UPDATE_SIGNAL_ANSWER = 12,
-    SENDING_SIGNAL_LEVEL = 13,
-    WAITING_SIGNAL_LEVEL_ANSWER = 14,
-    SENDING_CONTROL = 15,
-    WAITING_CONTROL_ANSWER = 16,
-    SENDING_POWER_ON_COMMAND = 17,
-    WAITING_POWER_ON_ANSWER = 18,
-    SENDING_POWER_OFF_COMMAND = 19,
-    WAITING_POWER_OFF_ANSWER = 20,
+    SENDING_STATUS_REQUEST = 10,
+    WAITING_STATUS_ANSWER = 11,
+    SENDING_UPDATE_SIGNAL_REQUEST = 12,
+    WAITING_UPDATE_SIGNAL_ANSWER = 13,
+    SENDING_SIGNAL_LEVEL = 14,
+    WAITING_SIGNAL_LEVEL_ANSWER = 15,
+    SENDING_CONTROL = 16,
+    WAITING_CONTROL_ANSWER = 17,
+    SENDING_POWER_ON_COMMAND = 18,
+    WAITING_POWER_ON_ANSWER = 19,
+    SENDING_POWER_OFF_COMMAND = 20,
+    WAITING_POWER_OFF_ANSWER = 21,
    NUM_PROTOCOL_PHASES
  };
 #if (HAIER_LOG_LEVEL > 4)
  const char *phase_to_string_(ProtocolPhases phase);
 #endif
-  virtual void set_answers_handlers() = 0;
+  virtual void set_handlers() = 0;
  virtual void process_phase(std::chrono::steady_clock::time_point now) = 0;
  virtual haier_protocol::HaierMessage get_control_message() = 0;
  virtual bool is_message_invalid(uint8_t message_type) = 0;
@@ -99,14 +102,17 @@ class HaierClimateBase : public esphome::Component,
  // Helper functions
  void set_force_send_control_(bool status);
  void send_message_(const haier_protocol::HaierMessage &command, bool use_crc);
-  void set_phase_(ProtocolPhases phase);
+  virtual void set_phase(ProtocolPhases phase);
  bool check_timeout_(std::chrono::steady_clock::time_point now, std::chrono::steady_clock::time_point tpoint,
                      size_t timeout);
  bool is_message_interval_exceeded_(std::chrono::steady_clock::time_point now);
  bool is_status_request_interval_exceeded_(std::chrono::steady_clock::time_point now);
  bool is_control_message_timeout_exceeded_(std::chrono::steady_clock::time_point now);
  bool is_control_message_interval_exceeded_(std::chrono::steady_clock::time_point now);
-  bool is_protocol_initialisation_interval_exceded_(std::chrono::steady_clock::time_point now);
+  bool is_protocol_initialisation_interval_exceeded_(std::chrono::steady_clock::time_point now);
+#ifdef USE_WIFI
+  haier_protocol::HaierMessage get_wifi_signal_message_(uint8_t message_type);
+#endif

  struct HvacSettings {
    esphome::optional<esphome::climate::ClimateMode> mode;
@@ -136,6 +142,9 @@ class HaierClimateBase : public esphome::Component,
  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 control_request_timestamp_;    // To send control message
+  optional<std::chrono::milliseconds> answer_timeout_;                 // Message answer timeout
+  bool send_wifi_signal_;
+  std::chrono::steady_clock::time_point last_signal_request_;  // To send WiFI signal level
 };

 }  // namespace haier
--- a/esphome/components/haier/hon_climate.cpp
+++ b/esphome/components/haier/hon_climate.cpp
@@ -2,9 +2,6 @@
 #include <string>
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/uart/uart.h"
-#ifdef USE_WIFI
-#include "esphome/components/wifi/wifi_component.h"
-#endif
 #include "hon_climate.h"
 #include "hon_packet.h"

@@ -58,14 +55,7 @@ HonClimate::HonClimate()
      hvac_functions_{false, false, false, false, false},
      use_crc_(hvac_functions_[2]),
      active_alarms_{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-      outdoor_sensor_(nullptr),
-      send_wifi_signal_(true) {
-  this->traits_.set_supported_presets({
-      climate::CLIMATE_PRESET_NONE,
-      climate::CLIMATE_PRESET_ECO,
-      climate::CLIMATE_PRESET_BOOST,
-      climate::CLIMATE_PRESET_SLEEP,
-  });
+      outdoor_sensor_(nullptr) {
  this->fan_mode_speed_ = (uint8_t) hon_protocol::FanMode::FAN_MID;
  this->other_modes_fan_speed_ = (uint8_t) hon_protocol::FanMode::FAN_AUTO;
 }
@@ -121,17 +111,22 @@ void HonClimate::start_steri_cleaning() {
  }
 }

-void HonClimate::set_send_wifi(bool send_wifi) { this->send_wifi_signal_ = send_wifi; }
-
 haier_protocol::HandlerError HonClimate::get_device_version_answer_handler_(uint8_t request_type, uint8_t message_type,
                                                                            const uint8_t *data, size_t data_size) {
+  // Should check this before preprocess
+  if (message_type == (uint8_t) hon_protocol::FrameType::INVALID) {
+    ESP_LOGW(TAG, "It looks like your ESPHome Haier climate configuration is wrong. You should use the smartAir2 "
+                  "protocol instead of hOn");
+    this->set_phase(ProtocolPhases::SENDING_INIT_1);
+    return haier_protocol::HandlerError::INVALID_ANSWER;
+  }
  haier_protocol::HandlerError result = this->answer_preprocess_(
      request_type, (uint8_t) hon_protocol::FrameType::GET_DEVICE_VERSION, message_type,
-      (uint8_t) hon_protocol::FrameType::GET_DEVICE_VERSION_RESPONSE, ProtocolPhases::WAITING_ANSWER_INIT_1);
+      (uint8_t) hon_protocol::FrameType::GET_DEVICE_VERSION_RESPONSE, ProtocolPhases::WAITING_INIT_1_ANSWER);
  if (result == haier_protocol::HandlerError::HANDLER_OK) {
    if (data_size < sizeof(hon_protocol::DeviceVersionAnswer)) {
      // Wrong structure
-      this->set_phase_(ProtocolPhases::SENDING_INIT_1);
+      this->set_phase(ProtocolPhases::SENDING_INIT_1);
      return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
    }
    // All OK
@@ -152,11 +147,11 @@ haier_protocol::HandlerError HonClimate::get_device_version_answer_handler_(uint
    this->hvac_functions_[3] = (answr->functions[1] & 0x08) != 0;  // multiple AC support
    this->hvac_functions_[4] = (answr->functions[1] & 0x20) != 0;  // roles support
    this->hvac_hardware_info_available_ = true;
-    this->set_phase_(ProtocolPhases::SENDING_INIT_2);
+    this->set_phase(ProtocolPhases::SENDING_INIT_2);
    return result;
  } else {
-    this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                     : ProtocolPhases::SENDING_INIT_1);
+    this->set_phase((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
+                                                                    : ProtocolPhases::SENDING_INIT_1);
    return result;
  }
 }
@@ -165,13 +160,13 @@ haier_protocol::HandlerError HonClimate::get_device_id_answer_handler_(uint8_t r
                                                                       const uint8_t *data, size_t data_size) {
  haier_protocol::HandlerError result = this->answer_preprocess_(
      request_type, (uint8_t) hon_protocol::FrameType::GET_DEVICE_ID, message_type,
-      (uint8_t) hon_protocol::FrameType::GET_DEVICE_ID_RESPONSE, ProtocolPhases::WAITING_ANSWER_INIT_2);
+      (uint8_t) hon_protocol::FrameType::GET_DEVICE_ID_RESPONSE, ProtocolPhases::WAITING_INIT_2_ANSWER);
  if (result == haier_protocol::HandlerError::HANDLER_OK) {
-    this->set_phase_(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
+    this->set_phase(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
    return result;
  } else {
-    this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                     : ProtocolPhases::SENDING_INIT_1);
+    this->set_phase((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
+                                                                    : ProtocolPhases::SENDING_INIT_1);
    return result;
  }
 }
@@ -185,8 +180,8 @@ haier_protocol::HandlerError HonClimate::status_handler_(uint8_t request_type, u
    result = this->process_status_message_(data, data_size);
    if (result != haier_protocol::HandlerError::HANDLER_OK) {
      ESP_LOGW(TAG, "Error %d while parsing Status packet", (int) result);
-      this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                       : ProtocolPhases::SENDING_INIT_1);
+      this->set_phase((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
+                                                                      : ProtocolPhases::SENDING_INIT_1);
    } else {
      if (data_size >= sizeof(hon_protocol::HaierPacketControl) + 2) {
        memcpy(this->last_status_message_.get(), data + 2, sizeof(hon_protocol::HaierPacketControl));
@@ -196,13 +191,13 @@ haier_protocol::HandlerError HonClimate::status_handler_(uint8_t request_type, u
      }
      if (this->protocol_phase_ == ProtocolPhases::WAITING_FIRST_STATUS_ANSWER) {
        ESP_LOGI(TAG, "First HVAC status received");
-        this->set_phase_(ProtocolPhases::SENDING_ALARM_STATUS_REQUEST);
+        this->set_phase(ProtocolPhases::SENDING_ALARM_STATUS_REQUEST);
      } else if ((this->protocol_phase_ == ProtocolPhases::WAITING_STATUS_ANSWER) ||
                 (this->protocol_phase_ == ProtocolPhases::WAITING_POWER_ON_ANSWER) ||
                 (this->protocol_phase_ == ProtocolPhases::WAITING_POWER_OFF_ANSWER)) {
-        this->set_phase_(ProtocolPhases::IDLE);
+        this->set_phase(ProtocolPhases::IDLE);
      } else if (this->protocol_phase_ == ProtocolPhases::WAITING_CONTROL_ANSWER) {
-        this->set_phase_(ProtocolPhases::IDLE);
+        this->set_phase(ProtocolPhases::IDLE);
        this->set_force_send_control_(false);
        if (this->hvac_settings_.valid)
          this->hvac_settings_.reset();
@@ -210,8 +205,8 @@ haier_protocol::HandlerError HonClimate::status_handler_(uint8_t request_type, u
    }
    return result;
  } else {
-    this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                     : ProtocolPhases::SENDING_INIT_1);
+    this->set_phase((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
+                                                                    : ProtocolPhases::SENDING_INIT_1);
    return result;
  }
 }
@@ -225,10 +220,10 @@ haier_protocol::HandlerError HonClimate::get_management_information_answer_handl
                               message_type, (uint8_t) hon_protocol::FrameType::GET_MANAGEMENT_INFORMATION_RESPONSE,
                               ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER);
  if (result == haier_protocol::HandlerError::HANDLER_OK) {
-    this->set_phase_(ProtocolPhases::SENDING_SIGNAL_LEVEL);
+    this->set_phase(ProtocolPhases::SENDING_SIGNAL_LEVEL);
    return result;
  } else {
-    this->set_phase_(ProtocolPhases::IDLE);
+    this->set_phase(ProtocolPhases::IDLE);
    return result;
  }
 }
@@ -239,7 +234,7 @@ haier_protocol::HandlerError HonClimate::report_network_status_answer_handler_(u
  haier_protocol::HandlerError result =
      this->answer_preprocess_(request_type, (uint8_t) hon_protocol::FrameType::REPORT_NETWORK_STATUS, message_type,
                               (uint8_t) hon_protocol::FrameType::CONFIRM, ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER);
-  this->set_phase_(ProtocolPhases::IDLE);
+  this->set_phase(ProtocolPhases::IDLE);
  return result;
 }

@@ -248,24 +243,24 @@ haier_protocol::HandlerError HonClimate::get_alarm_status_answer_handler_(uint8_
  if (request_type == (uint8_t) hon_protocol::FrameType::GET_ALARM_STATUS) {
    if (message_type != (uint8_t) hon_protocol::FrameType::GET_ALARM_STATUS_RESPONSE) {
      // Unexpected answer to request
-      this->set_phase_(ProtocolPhases::IDLE);
-      return haier_protocol::HandlerError::UNSUPORTED_MESSAGE;
+      this->set_phase(ProtocolPhases::IDLE);
+      return haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
    }
    if (this->protocol_phase_ != ProtocolPhases::WAITING_ALARM_STATUS_ANSWER) {
      // Don't expect this answer now
-      this->set_phase_(ProtocolPhases::IDLE);
+      this->set_phase(ProtocolPhases::IDLE);
      return haier_protocol::HandlerError::UNEXPECTED_MESSAGE;
    }
    memcpy(this->active_alarms_, data + 2, 8);
-    this->set_phase_(ProtocolPhases::IDLE);
+    this->set_phase(ProtocolPhases::IDLE);
    return haier_protocol::HandlerError::HANDLER_OK;
  } else {
-    this->set_phase_(ProtocolPhases::IDLE);
-    return haier_protocol::HandlerError::UNSUPORTED_MESSAGE;
+    this->set_phase(ProtocolPhases::IDLE);
+    return haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
  }
 }

-void HonClimate::set_answers_handlers() {
+void HonClimate::set_handlers() {
  // Set handlers
  this->haier_protocol_.set_answer_handler(
      (uint8_t) (hon_protocol::FrameType::GET_DEVICE_VERSION),
@@ -311,7 +306,7 @@ void HonClimate::dump_config() {
 void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
  switch (this->protocol_phase_) {
    case ProtocolPhases::SENDING_INIT_1:
-      if (this->can_send_message() && this->is_protocol_initialisation_interval_exceded_(now)) {
+      if (this->can_send_message() && this->is_protocol_initialisation_interval_exceeded_(now)) {
        this->hvac_hardware_info_available_ = false;
        // Indicate device capabilities:
        // bit 0 - if 1 module support interactive mode
@@ -323,24 +318,24 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
        static const haier_protocol::HaierMessage DEVICE_VERSION_REQUEST(
            (uint8_t) hon_protocol::FrameType::GET_DEVICE_VERSION, module_capabilities, sizeof(module_capabilities));
        this->send_message_(DEVICE_VERSION_REQUEST, this->use_crc_);
-        this->set_phase_(ProtocolPhases::WAITING_ANSWER_INIT_1);
+        this->set_phase(ProtocolPhases::WAITING_INIT_1_ANSWER);
      }
      break;
    case ProtocolPhases::SENDING_INIT_2:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
        static const haier_protocol::HaierMessage DEVICEID_REQUEST((uint8_t) hon_protocol::FrameType::GET_DEVICE_ID);
        this->send_message_(DEVICEID_REQUEST, this->use_crc_);
-        this->set_phase_(ProtocolPhases::WAITING_ANSWER_INIT_2);
+        this->set_phase(ProtocolPhases::WAITING_INIT_2_ANSWER);
      }
      break;
    case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
    case ProtocolPhases::SENDING_STATUS_REQUEST:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
        static const haier_protocol::HaierMessage STATUS_REQUEST(
-            (uint8_t) hon_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcomandsControl::GET_USER_DATA);
+            (uint8_t) hon_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcommandsControl::GET_USER_DATA);
        this->send_message_(STATUS_REQUEST, this->use_crc_);
        this->last_status_request_ = now;
-        this->set_phase_((ProtocolPhases) ((uint8_t) this->protocol_phase_ + 1));
+        this->set_phase((ProtocolPhases) ((uint8_t) this->protocol_phase_ + 1));
      }
      break;
 #ifdef USE_WIFI
@@ -350,26 +345,14 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
            (uint8_t) hon_protocol::FrameType::GET_MANAGEMENT_INFORMATION);
        this->send_message_(UPDATE_SIGNAL_REQUEST, this->use_crc_);
        this->last_signal_request_ = now;
-        this->set_phase_(ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER);
+        this->set_phase(ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER);
      }
      break;
    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        static uint8_t wifi_status_data[4] = {0x00, 0x00, 0x00, 0x00};
-        if (wifi::global_wifi_component->is_connected()) {
-          wifi_status_data[1] = 0;
-          int8_t rssi = wifi::global_wifi_component->wifi_rssi();
-          wifi_status_data[3] = uint8_t((128 + rssi) / 1.28f);
-          ESP_LOGD(TAG, "WiFi signal is: %ddBm => %d%%", rssi, wifi_status_data[3]);
-        } else {
-          ESP_LOGD(TAG, "WiFi is not connected");
-          wifi_status_data[1] = 1;
-          wifi_status_data[3] = 0;
-        }
-        haier_protocol::HaierMessage wifi_status_request((uint8_t) hon_protocol::FrameType::REPORT_NETWORK_STATUS,
-                                                         wifi_status_data, sizeof(wifi_status_data));
-        this->send_message_(wifi_status_request, this->use_crc_);
-        this->set_phase_(ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER);
+        this->send_message_(this->get_wifi_signal_message_((uint8_t) hon_protocol::FrameType::REPORT_NETWORK_STATUS),
+                            this->use_crc_);
+        this->set_phase(ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER);
      }
      break;
    case ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER:
@@ -380,7 +363,7 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
    case ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER:
    case ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER:
-      this->set_phase_(ProtocolPhases::IDLE);
+      this->set_phase(ProtocolPhases::IDLE);
      break;
 #endif
    case ProtocolPhases::SENDING_ALARM_STATUS_REQUEST:
@@ -388,7 +371,7 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
        static const haier_protocol::HaierMessage ALARM_STATUS_REQUEST(
            (uint8_t) hon_protocol::FrameType::GET_ALARM_STATUS);
        this->send_message_(ALARM_STATUS_REQUEST, this->use_crc_);
-        this->set_phase_(ProtocolPhases::WAITING_ALARM_STATUS_ANSWER);
+        this->set_phase(ProtocolPhases::WAITING_ALARM_STATUS_ANSWER);
      }
      break;
    case ProtocolPhases::SENDING_CONTROL:
@@ -403,12 +386,12 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
          this->hvac_settings_.reset();
        this->forced_request_status_ = true;
        this->forced_publish_ = true;
-        this->set_phase_(ProtocolPhases::IDLE);
+        this->set_phase(ProtocolPhases::IDLE);
      } else if (this->can_send_message() && this->is_control_message_interval_exceeded_(now)) {
        haier_protocol::HaierMessage control_message = get_control_message();
        this->send_message_(control_message, this->use_crc_);
        ESP_LOGI(TAG, "Control packet sent");
-        this->set_phase_(ProtocolPhases::WAITING_CONTROL_ANSWER);
+        this->set_phase(ProtocolPhases::WAITING_CONTROL_ANSWER);
      }
      break;
    case ProtocolPhases::SENDING_POWER_ON_COMMAND:
@@ -418,17 +401,17 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
        if (this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND)
          pwr_cmd_buf[1] = 0x01;
        haier_protocol::HaierMessage power_cmd((uint8_t) hon_protocol::FrameType::CONTROL,
-                                               ((uint16_t) hon_protocol::SubcomandsControl::SET_SINGLE_PARAMETER) + 1,
+                                               ((uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER) + 1,
                                               pwr_cmd_buf, sizeof(pwr_cmd_buf));
        this->send_message_(power_cmd, this->use_crc_);
-        this->set_phase_(this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND
-                             ? ProtocolPhases::WAITING_POWER_ON_ANSWER
-                             : ProtocolPhases::WAITING_POWER_OFF_ANSWER);
+        this->set_phase(this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND
+                            ? ProtocolPhases::WAITING_POWER_ON_ANSWER
+                            : ProtocolPhases::WAITING_POWER_OFF_ANSWER);
      }
      break;

-    case ProtocolPhases::WAITING_ANSWER_INIT_1:
-    case ProtocolPhases::WAITING_ANSWER_INIT_2:
+    case ProtocolPhases::WAITING_INIT_1_ANSWER:
+    case ProtocolPhases::WAITING_INIT_2_ANSWER:
    case ProtocolPhases::WAITING_FIRST_STATUS_ANSWER:
    case ProtocolPhases::WAITING_ALARM_STATUS_ANSWER:
    case ProtocolPhases::WAITING_STATUS_ANSWER:
@@ -438,14 +421,14 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
      break;
    case ProtocolPhases::IDLE: {
      if (this->forced_request_status_ || this->is_status_request_interval_exceeded_(now)) {
-        this->set_phase_(ProtocolPhases::SENDING_STATUS_REQUEST);
+        this->set_phase(ProtocolPhases::SENDING_STATUS_REQUEST);
        this->forced_request_status_ = false;
      }
 #ifdef USE_WIFI
      else if (this->send_wifi_signal_ &&
               (std::chrono::duration_cast<std::chrono::milliseconds>(now - this->last_signal_request_).count() >
                SIGNAL_LEVEL_UPDATE_INTERVAL_MS))
-        this->set_phase_(ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST);
+        this->set_phase(ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST);
 #endif
    } break;
    default:
@@ -456,7 +439,7 @@ void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
 #else
      ESP_LOGE(TAG, "Wrong protocol handler state: %d, resetting communication", (int) this->protocol_phase_);
 #endif
-      this->set_phase_(ProtocolPhases::SENDING_INIT_1);
+      this->set_phase(ProtocolPhases::SENDING_INIT_1);
      break;
  }
 }
@@ -475,7 +458,7 @@ haier_protocol::HaierMessage HonClimate::get_control_message() {
        case CLIMATE_MODE_OFF:
          out_data->ac_power = 0;
          break;
-        case CLIMATE_MODE_AUTO:
+        case CLIMATE_MODE_HEAT_COOL:
          out_data->ac_power = 1;
          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::AUTO;
          out_data->fan_mode = this->other_modes_fan_speed_;
@@ -551,11 +534,12 @@ haier_protocol::HaierMessage HonClimate::get_control_message() {
      }
    }
    if (climate_control.target_temperature.has_value()) {
-      out_data->set_point =
-          climate_control.target_temperature.value() - 16;  // set the temperature at our offset, subtract 16.
+      float target_temp = climate_control.target_temperature.value();
+      out_data->set_point = ((int) target_temp) - 16;  // set the temperature at our offset, subtract 16.
+      out_data->half_degree = (target_temp - ((int) target_temp) >= 0.49) ? 1 : 0;
    }
    if (out_data->ac_power == 0) {
-      // If AC is off - no presets alowed
+      // If AC is off - no presets allowed
      out_data->quiet_mode = 0;
      out_data->fast_mode = 0;
      out_data->sleep_mode = 0;
@@ -631,7 +615,7 @@ haier_protocol::HaierMessage HonClimate::get_control_message() {
      break;
  }
  return haier_protocol::HaierMessage((uint8_t) hon_protocol::FrameType::CONTROL,
-                                      (uint16_t) hon_protocol::SubcomandsControl::SET_GROUP_PARAMETERS,
+                                      (uint16_t) hon_protocol::SubcommandsControl::SET_GROUP_PARAMETERS,
                                      control_out_buffer, sizeof(hon_protocol::HaierPacketControl));
 }

@@ -669,7 +653,7 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
  {
    // Target temperature
    float old_target_temperature = this->target_temperature;
-    this->target_temperature = packet.control.set_point + 16.0f;
+    this->target_temperature = packet.control.set_point + 16.0f + ((packet.control.half_degree == 1) ? 0.5f : 0.0f);
    should_publish = should_publish || (old_target_temperature != this->target_temperature);
  }
  {
@@ -747,7 +731,7 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
    if (new_cleaning != this->cleaning_status_) {
      ESP_LOGD(TAG, "Cleaning status change: %d => %d", (uint8_t) this->cleaning_status_, (uint8_t) new_cleaning);
      if (new_cleaning == CleaningState::NO_CLEANING) {
-        // Turnuin AC off after cleaning
+        // Turning AC off after cleaning
        this->action_request_ = ActionRequest::TURN_POWER_OFF;
      }
      this->cleaning_status_ = new_cleaning;
@@ -774,7 +758,7 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
          this->mode = CLIMATE_MODE_FAN_ONLY;
          break;
        case (uint8_t) hon_protocol::ConditioningMode::AUTO:
-          this->mode = CLIMATE_MODE_AUTO;
+          this->mode = CLIMATE_MODE_HEAT_COOL;
          break;
      }
    }
@@ -837,7 +821,7 @@ void HonClimate::process_pending_action() {
    case ActionRequest::START_SELF_CLEAN:
    case ActionRequest::START_STERI_CLEAN:
      // Will reset action with control message sending
-      this->set_phase_(ProtocolPhases::SENDING_CONTROL);
+      this->set_phase(ProtocolPhases::SENDING_CONTROL);
      break;
    default:
      HaierClimateBase::process_pending_action();
--- a/esphome/components/haier/hon_climate.h
+++ b/esphome/components/haier/hon_climate.h
@@ -48,10 +48,9 @@ class HonClimate : public HaierClimateBase {
  CleaningState get_cleaning_status() const;
  void start_self_cleaning();
  void start_steri_cleaning();
-  void set_send_wifi(bool send_wifi);

 protected:
-  void set_answers_handlers() override;
+  void set_handlers() override;
  void process_phase(std::chrono::steady_clock::time_point now) override;
  haier_protocol::HaierMessage get_control_message() override;
  bool is_message_invalid(uint8_t message_type) override;
@@ -87,8 +86,6 @@ class HonClimate : public HaierClimateBase {
  bool &use_crc_;
  uint8_t active_alarms_[8];
  esphome::sensor::Sensor *outdoor_sensor_;
-  bool send_wifi_signal_;
-  std::chrono::steady_clock::time_point last_signal_request_;  // To send WiFI signal level
 };

 }  // namespace haier
--- a/esphome/components/haier/hon_packet.h
+++ b/esphome/components/haier/hon_packet.h
@@ -53,12 +53,12 @@ struct HaierPacketControl {
  // 13
  uint8_t : 8;
  // 14
-  uint8_t ten_degree : 1;          // 10 degree status
-  uint8_t display_status : 1;      // If 0 disables AC's display
-  uint8_t half_degree : 1;         // Use half degree
-  uint8_t intelegence_status : 1;  // Intelligence status
-  uint8_t pmv_status : 1;          // Comfort/PMV status
-  uint8_t use_fahrenheit : 1;      // Use Fahrenheit instead of Celsius
+  uint8_t ten_degree : 1;           // 10 degree status
+  uint8_t display_status : 1;       // If 0 disables AC's display
+  uint8_t half_degree : 1;          // Use half degree
+  uint8_t intelligence_status : 1;  // Intelligence status
+  uint8_t pmv_status : 1;           // Comfort/PMV status
+  uint8_t use_fahrenheit : 1;       // Use Fahrenheit instead of Celsius
  uint8_t : 1;
  uint8_t steri_clean : 1;
  // 15
@@ -153,7 +153,7 @@ enum class FrameType : uint8_t {
                   // <-> device, required)
  REPORT = 0x06,   // Report frame (module <-> device, interactive, required)
  STOP_FAULT_ALARM = 0x09,             // Stop fault alarm frame (module -> device, interactive, required)
-  SYSTEM_DOWNLIK = 0x11,               // System downlink frame (module -> device, optional)
+  SYSTEM_DOWNLINK = 0x11,              // System downlink frame (module -> device, optional)
  DEVICE_UPLINK = 0x12,                // Device uplink frame (module <- device , interactive, optional)
  SYSTEM_QUERY = 0x13,                 // System query frame (module -> device, optional)
  SYSTEM_QUERY_RESPONSE = 0x14,        // System query response frame (module <- device , optional)
@@ -210,7 +210,7 @@ enum class FrameType : uint8_t {
  WAKE_UP = 0xFE,  // Request to wake up (module <-> device, optional)
 };

-enum class SubcomandsControl : uint16_t {
+enum class SubcommandsControl : uint16_t {
  GET_PARAMETERS = 0x4C01,  // Request specific parameters (packet content: parameter ID1 + parameter ID2 + ...)
  GET_USER_DATA = 0x4D01,   // Request all user data from device (packet content: None)
  GET_BIG_DATA = 0x4DFE,    // Request big data information from device (packet content: None)
--- a/esphome/components/haier/smartair2_climate.cpp
+++ b/esphome/components/haier/smartair2_climate.cpp
@@ -11,15 +11,10 @@ namespace esphome {
 namespace haier {

 static const char *const TAG = "haier.climate";
+constexpr size_t SIGNAL_LEVEL_UPDATE_INTERVAL_MS = 10000;

 Smartair2Climate::Smartair2Climate()
-    : last_status_message_(new uint8_t[sizeof(smartair2_protocol::HaierPacketControl)]) {
-  this->traits_.set_supported_presets({
-      climate::CLIMATE_PRESET_NONE,
-      climate::CLIMATE_PRESET_BOOST,
-      climate::CLIMATE_PRESET_COMFORT,
-  });
-}
+    : last_status_message_(new uint8_t[sizeof(smartair2_protocol::HaierPacketControl)]), timeouts_counter_(0) {}

 haier_protocol::HandlerError Smartair2Climate::status_handler_(uint8_t request_type, uint8_t message_type,
                                                               const uint8_t *data, size_t data_size) {
@@ -30,8 +25,8 @@ haier_protocol::HandlerError Smartair2Climate::status_handler_(uint8_t request_t
    result = this->process_status_message_(data, data_size);
    if (result != haier_protocol::HandlerError::HANDLER_OK) {
      ESP_LOGW(TAG, "Error %d while parsing Status packet", (int) result);
-      this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                       : ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
+      this->set_phase((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
+                                                                      : ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
    } else {
      if (data_size >= sizeof(smartair2_protocol::HaierPacketControl) + 2) {
        memcpy(this->last_status_message_.get(), data + 2, sizeof(smartair2_protocol::HaierPacketControl));
@@ -41,11 +36,11 @@ haier_protocol::HandlerError Smartair2Climate::status_handler_(uint8_t request_t
      }
      if (this->protocol_phase_ == ProtocolPhases::WAITING_FIRST_STATUS_ANSWER) {
        ESP_LOGI(TAG, "First HVAC status received");
-        this->set_phase_(ProtocolPhases::IDLE);
+        this->set_phase(ProtocolPhases::IDLE);
      } else if (this->protocol_phase_ == ProtocolPhases::WAITING_STATUS_ANSWER) {
-        this->set_phase_(ProtocolPhases::IDLE);
+        this->set_phase(ProtocolPhases::IDLE);
      } else if (this->protocol_phase_ == ProtocolPhases::WAITING_CONTROL_ANSWER) {
-        this->set_phase_(ProtocolPhases::IDLE);
+        this->set_phase(ProtocolPhases::IDLE);
        this->set_force_send_control_(false);
        if (this->hvac_settings_.valid)
          this->hvac_settings_.reset();
@@ -53,17 +48,82 @@ haier_protocol::HandlerError Smartair2Climate::status_handler_(uint8_t request_t
    }
    return result;
  } else {
-    this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                     : ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
+    this->set_phase((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
+                                                                    : ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
    return result;
  }
 }

-void Smartair2Climate::set_answers_handlers() {
+haier_protocol::HandlerError Smartair2Climate::get_device_version_answer_handler_(uint8_t request_type,
+                                                                                  uint8_t message_type,
+                                                                                  const uint8_t *data,
+                                                                                  size_t data_size) {
+  if (request_type != (uint8_t) smartair2_protocol::FrameType::GET_DEVICE_VERSION)
+    return haier_protocol::HandlerError::UNSUPPORTED_MESSAGE;
+  if (ProtocolPhases::WAITING_INIT_1_ANSWER != this->protocol_phase_)
+    return haier_protocol::HandlerError::UNEXPECTED_MESSAGE;
+  // Invalid packet is expected answer
+  if ((message_type == (uint8_t) smartair2_protocol::FrameType::GET_DEVICE_VERSION_RESPONSE) && (data_size >= 39) &&
+      ((data[37] & 0x04) != 0)) {
+    ESP_LOGW(TAG, "It looks like your ESPHome Haier climate configuration is wrong. You should use the hOn protocol "
+                  "instead of smartAir2");
+  }
+  this->set_phase(ProtocolPhases::SENDING_INIT_2);
+  return haier_protocol::HandlerError::HANDLER_OK;
+}
+
+haier_protocol::HandlerError Smartair2Climate::report_network_status_answer_handler_(uint8_t request_type,
+                                                                                     uint8_t message_type,
+                                                                                     const uint8_t *data,
+                                                                                     size_t data_size) {
+  haier_protocol::HandlerError result = this->answer_preprocess_(
+      request_type, (uint8_t) smartair2_protocol::FrameType::REPORT_NETWORK_STATUS, message_type,
+      (uint8_t) smartair2_protocol::FrameType::CONFIRM, ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER);
+  this->set_phase(ProtocolPhases::IDLE);
+  return result;
+}
+
+haier_protocol::HandlerError Smartair2Climate::initial_messages_timeout_handler_(uint8_t message_type) {
+  if (this->protocol_phase_ >= ProtocolPhases::IDLE)
+    return HaierClimateBase::timeout_default_handler_(message_type);
+  this->timeouts_counter_++;
+  ESP_LOGI(TAG, "Answer timeout for command %02X, phase %d, timeout counter %d", message_type,
+           (int) this->protocol_phase_, this->timeouts_counter_);
+  if (this->timeouts_counter_ >= 3) {
+    ProtocolPhases new_phase = (ProtocolPhases) ((int) this->protocol_phase_ + 1);
+    if (new_phase >= ProtocolPhases::SENDING_ALARM_STATUS_REQUEST)
+      new_phase = ProtocolPhases::SENDING_INIT_1;
+    this->set_phase(new_phase);
+  } else {
+    // Returning to the previous state to try again
+    this->set_phase((ProtocolPhases) ((int) this->protocol_phase_ - 1));
+  }
+  return haier_protocol::HandlerError::HANDLER_OK;
+}
+
+void Smartair2Climate::set_handlers() {
+  // Set handlers
+  this->haier_protocol_.set_answer_handler(
+      (uint8_t) (smartair2_protocol::FrameType::GET_DEVICE_VERSION),
+      std::bind(&Smartair2Climate::get_device_version_answer_handler_, this, std::placeholders::_1,
+                std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
  this->haier_protocol_.set_answer_handler(
      (uint8_t) (smartair2_protocol::FrameType::CONTROL),
      std::bind(&Smartair2Climate::status_handler_, this, std::placeholders::_1, std::placeholders::_2,
                std::placeholders::_3, std::placeholders::_4));
+  this->haier_protocol_.set_answer_handler(
+      (uint8_t) (smartair2_protocol::FrameType::REPORT_NETWORK_STATUS),
+      std::bind(&Smartair2Climate::report_network_status_answer_handler_, this, std::placeholders::_1,
+                std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
+  this->haier_protocol_.set_timeout_handler(
+      (uint8_t) (smartair2_protocol::FrameType::GET_DEVICE_ID),
+      std::bind(&Smartair2Climate::initial_messages_timeout_handler_, this, std::placeholders::_1));
+  this->haier_protocol_.set_timeout_handler(
+      (uint8_t) (smartair2_protocol::FrameType::GET_DEVICE_VERSION),
+      std::bind(&Smartair2Climate::initial_messages_timeout_handler_, this, std::placeholders::_1));
+  this->haier_protocol_.set_timeout_handler(
+      (uint8_t) (smartair2_protocol::FrameType::CONTROL),
+      std::bind(&Smartair2Climate::initial_messages_timeout_handler_, this, std::placeholders::_1));
 }

 void Smartair2Climate::dump_config() {
@@ -74,39 +134,62 @@ void Smartair2Climate::dump_config() {
 void Smartair2Climate::process_phase(std::chrono::steady_clock::time_point now) {
  switch (this->protocol_phase_) {
    case ProtocolPhases::SENDING_INIT_1:
-      this->set_phase_(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
-      break;
-    case ProtocolPhases::WAITING_ANSWER_INIT_1:
-    case ProtocolPhases::SENDING_INIT_2:
-    case ProtocolPhases::WAITING_ANSWER_INIT_2:
-    case ProtocolPhases::SENDING_ALARM_STATUS_REQUEST:
-    case ProtocolPhases::WAITING_ALARM_STATUS_ANSWER:
-      this->set_phase_(ProtocolPhases::SENDING_INIT_1);
-      break;
-    case ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST:
-    case ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER:
-    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
-    case ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER:
-      this->set_phase_(ProtocolPhases::IDLE);
-      break;
-    case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
-      if (this->can_send_message() && this->is_protocol_initialisation_interval_exceded_(now)) {
-        static const haier_protocol::HaierMessage STATUS_REQUEST((uint8_t) smartair2_protocol::FrameType::CONTROL,
-                                                                 0x4D01);
-        this->send_message_(STATUS_REQUEST, false);
-        this->last_status_request_ = now;
-        this->set_phase_(ProtocolPhases::WAITING_FIRST_STATUS_ANSWER);
+      if (this->can_send_message() &&
+          (((this->timeouts_counter_ == 0) && (this->is_protocol_initialisation_interval_exceeded_(now))) ||
+           ((this->timeouts_counter_ > 0) && (this->is_message_interval_exceeded_(now))))) {
+        // Indicate device capabilities:
+        // bit 0 - if 1 module support interactive mode
+        // bit 1 - if 1 module support controller-device mode
+        // bit 2 - if 1 module support crc
+        // bit 3 - if 1 module support multiple devices
+        // bit 4..bit 15 - not used
+        uint8_t module_capabilities[2] = {0b00000000, 0b00000111};
+        static const haier_protocol::HaierMessage DEVICE_VERSION_REQUEST(
+            (uint8_t) smartair2_protocol::FrameType::GET_DEVICE_VERSION, module_capabilities,
+            sizeof(module_capabilities));
+        this->send_message_(DEVICE_VERSION_REQUEST, false);
+        this->set_phase(ProtocolPhases::WAITING_INIT_1_ANSWER);
      }
      break;
+    case ProtocolPhases::SENDING_INIT_2:
+    case ProtocolPhases::WAITING_INIT_2_ANSWER:
+      this->set_phase(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
+      break;
+    case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
    case ProtocolPhases::SENDING_STATUS_REQUEST:
      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
        static const haier_protocol::HaierMessage STATUS_REQUEST((uint8_t) smartair2_protocol::FrameType::CONTROL,
                                                                 0x4D01);
        this->send_message_(STATUS_REQUEST, false);
        this->last_status_request_ = now;
-        this->set_phase_(ProtocolPhases::WAITING_STATUS_ANSWER);
+        this->set_phase((ProtocolPhases) ((uint8_t) this->protocol_phase_ + 1));
      }
      break;
+#ifdef USE_WIFI
+    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
+      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
+        this->send_message_(
+            this->get_wifi_signal_message_((uint8_t) smartair2_protocol::FrameType::REPORT_NETWORK_STATUS), false);
+        this->last_signal_request_ = now;
+        this->set_phase(ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER);
+      }
+      break;
+    case ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER:
+      break;
+#else
+    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
+    case ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER:
+      this->set_phase(ProtocolPhases::IDLE);
+      break;
+#endif
+    case ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST:
+    case ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER:
+      this->set_phase(ProtocolPhases::SENDING_SIGNAL_LEVEL);
+      break;
+    case ProtocolPhases::SENDING_ALARM_STATUS_REQUEST:
+    case ProtocolPhases::WAITING_ALARM_STATUS_ANSWER:
+      this->set_phase(ProtocolPhases::SENDING_INIT_1);
+      break;
    case ProtocolPhases::SENDING_CONTROL:
      if (this->first_control_attempt_) {
        this->control_request_timestamp_ = now;
@@ -119,14 +202,14 @@ void Smartair2Climate::process_phase(std::chrono::steady_clock::time_point now)
          this->hvac_settings_.reset();
        this->forced_request_status_ = true;
        this->forced_publish_ = true;
-        this->set_phase_(ProtocolPhases::IDLE);
+        this->set_phase(ProtocolPhases::IDLE);
      } else if (this->can_send_message() && this->is_control_message_interval_exceeded_(
                                                 now))  // Using CONTROL_MESSAGES_INTERVAL_MS to speedup requests
      {
        haier_protocol::HaierMessage control_message = get_control_message();
        this->send_message_(control_message, false);
        ESP_LOGI(TAG, "Control packet sent");
-        this->set_phase_(ProtocolPhases::WAITING_CONTROL_ANSWER);
+        this->set_phase(ProtocolPhases::WAITING_CONTROL_ANSWER);
      }
      break;
    case ProtocolPhases::SENDING_POWER_ON_COMMAND:
@@ -136,11 +219,12 @@ void Smartair2Climate::process_phase(std::chrono::steady_clock::time_point now)
            (uint8_t) smartair2_protocol::FrameType::CONTROL,
            this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND ? 0x4D02 : 0x4D03);
        this->send_message_(power_cmd, false);
-        this->set_phase_(this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND
-                             ? ProtocolPhases::WAITING_POWER_ON_ANSWER
-                             : ProtocolPhases::WAITING_POWER_OFF_ANSWER);
+        this->set_phase(this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND
+                            ? ProtocolPhases::WAITING_POWER_ON_ANSWER
+                            : ProtocolPhases::WAITING_POWER_OFF_ANSWER);
      }
      break;
+    case ProtocolPhases::WAITING_INIT_1_ANSWER:
    case ProtocolPhases::WAITING_FIRST_STATUS_ANSWER:
    case ProtocolPhases::WAITING_STATUS_ANSWER:
    case ProtocolPhases::WAITING_CONTROL_ANSWER:
@@ -149,14 +233,25 @@ void Smartair2Climate::process_phase(std::chrono::steady_clock::time_point now)
      break;
    case ProtocolPhases::IDLE: {
      if (this->forced_request_status_ || this->is_status_request_interval_exceeded_(now)) {
-        this->set_phase_(ProtocolPhases::SENDING_STATUS_REQUEST);
+        this->set_phase(ProtocolPhases::SENDING_STATUS_REQUEST);
        this->forced_request_status_ = false;
      }
+#ifdef USE_WIFI
+      else if (this->send_wifi_signal_ &&
+               (std::chrono::duration_cast<std::chrono::milliseconds>(now - this->last_signal_request_).count() >
+                SIGNAL_LEVEL_UPDATE_INTERVAL_MS))
+        this->set_phase(ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST);
+#endif
    } break;
    default:
      // Shouldn't get here
+#if (HAIER_LOG_LEVEL > 4)
+      ESP_LOGE(TAG, "Wrong protocol handler state: %s (%d), resetting communication",
+               phase_to_string_(this->protocol_phase_), (int) this->protocol_phase_);
+#else
      ESP_LOGE(TAG, "Wrong protocol handler state: %d, resetting communication", (int) this->protocol_phase_);
-      this->set_phase_(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
+#endif
+      this->set_phase(ProtocolPhases::SENDING_INIT_1);
      break;
  }
 }
@@ -175,7 +270,7 @@ haier_protocol::HaierMessage Smartair2Climate::get_control_message() {
          out_data->ac_power = 0;
          break;

-        case CLIMATE_MODE_AUTO:
+        case CLIMATE_MODE_HEAT_COOL:
          out_data->ac_power = 1;
          out_data->ac_mode = (uint8_t) smartair2_protocol::ConditioningMode::AUTO;
          out_data->fan_mode = this->other_modes_fan_speed_;
@@ -256,11 +351,12 @@ haier_protocol::HaierMessage Smartair2Climate::get_control_message() {
      }
    }
    if (climate_control.target_temperature.has_value()) {
-      out_data->set_point =
-          climate_control.target_temperature.value() - 16;  // set the temperature at our offset, subtract 16.
+      float target_temp = climate_control.target_temperature.value();
+      out_data->set_point = target_temp - 16;  // set the temperature with offset 16
+      out_data->half_degree = (target_temp - ((int) target_temp) >= 0.49) ? 1 : 0;
    }
    if (out_data->ac_power == 0) {
-      // If AC is off - no presets alowed
+      // If AC is off - no presets allowed
      out_data->turbo_mode = 0;
      out_data->quiet_mode = 0;
    } else if (climate_control.preset.has_value()) {
@@ -312,7 +408,7 @@ haier_protocol::HandlerError Smartair2Climate::process_status_message_(const uin
  {
    // Target temperature
    float old_target_temperature = this->target_temperature;
-    this->target_temperature = packet.control.set_point + 16.0f;
+    this->target_temperature = packet.control.set_point + 16.0f + ((packet.control.half_degree == 1) ? 0.5f : 0.0f);
    should_publish = should_publish || (old_target_temperature != this->target_temperature);
  }
  {
@@ -333,7 +429,7 @@ haier_protocol::HandlerError Smartair2Climate::process_status_message_(const uin
    }
    switch (packet.control.fan_mode) {
      case (uint8_t) smartair2_protocol::FanMode::FAN_AUTO:
-        // Somtimes AC reports in fan only mode that fan speed is auto
+        // Sometimes AC reports in fan only mode that fan speed is auto
        // but never accept this value back
        if (packet.control.ac_mode != (uint8_t) smartair2_protocol::ConditioningMode::FAN) {
          this->fan_mode = CLIMATE_FAN_AUTO;
@@ -391,7 +487,7 @@ haier_protocol::HandlerError Smartair2Climate::process_status_message_(const uin
          this->mode = CLIMATE_MODE_FAN_ONLY;
          break;
        case (uint8_t) smartair2_protocol::ConditioningMode::AUTO:
-          this->mode = CLIMATE_MODE_AUTO;
+          this->mode = CLIMATE_MODE_HEAT_COOL;
          break;
      }
    }
@@ -453,5 +549,15 @@ bool Smartair2Climate::is_message_invalid(uint8_t message_type) {
  return message_type == (uint8_t) smartair2_protocol::FrameType::INVALID;
 }

+void Smartair2Climate::set_phase(HaierClimateBase::ProtocolPhases phase) {
+  int old_phase = (int) this->protocol_phase_;
+  int new_phase = (int) phase;
+  int min_p = std::min(old_phase, new_phase);
+  int max_p = std::max(old_phase, new_phase);
+  if ((min_p % 2 != 0) || (max_p - min_p > 1))
+    this->timeouts_counter_ = 0;
+  HaierClimateBase::set_phase(phase);
+}
+
 }  // namespace haier
 }  // namespace esphome
--- a/esphome/components/haier/smartair2_climate.h
+++ b/esphome/components/haier/smartair2_climate.h
@@ -15,16 +15,25 @@ class Smartair2Climate : public HaierClimateBase {
  void dump_config() override;

 protected:
-  void set_answers_handlers() override;
+  void set_handlers() override;
  void process_phase(std::chrono::steady_clock::time_point now) override;
  haier_protocol::HaierMessage get_control_message() override;
  bool is_message_invalid(uint8_t message_type) override;
-  // Answers handlers
+  void set_phase(HaierClimateBase::ProtocolPhases phase) override;
+  // Answer and timeout handlers
  haier_protocol::HandlerError status_handler_(uint8_t request_type, uint8_t message_type, const uint8_t *data,
                                               size_t data_size);
+  haier_protocol::HandlerError get_device_version_answer_handler_(uint8_t request_type, uint8_t message_type,
+                                                                  const uint8_t *data, size_t data_size);
+  haier_protocol::HandlerError get_device_id_answer_handler_(uint8_t request_type, uint8_t message_type,
+                                                             const uint8_t *data, size_t data_size);
+  haier_protocol::HandlerError report_network_status_answer_handler_(uint8_t request_type, uint8_t message_type,
+                                                                     const uint8_t *data, size_t data_size);
+  haier_protocol::HandlerError initial_messages_timeout_handler_(uint8_t message_type);
  // Helper functions
  haier_protocol::HandlerError process_status_message_(const uint8_t *packet, uint8_t size);
  std::unique_ptr<uint8_t[]> last_status_message_;
+  unsigned int timeouts_counter_;
 };

 }  // namespace haier
--- a/esphome/components/haier/smartair2_packet.h
+++ b/esphome/components/haier/smartair2_packet.h
@@ -53,8 +53,8 @@ struct HaierPacketControl {
  uint8_t : 2;
  uint8_t health_mode : 1;  // Health mode on or off
  uint8_t compressor : 1;   // Compressor on or off ???
-  uint8_t : 1;
-  uint8_t ten_degree : 1;  // 10 degree status (only work in heat mode)
+  uint8_t half_degree : 1;  // Use half degree
+  uint8_t ten_degree : 1;   // 10 degree status (only work in heat mode)
  uint8_t : 0;
  // 28
  uint8_t : 8;
@@ -88,6 +88,9 @@ enum class FrameType : uint8_t {
  INVALID = 0x03,
  CONFIRM = 0x05,
  GET_DEVICE_VERSION = 0x61,
+  GET_DEVICE_VERSION_RESPONSE = 0x62,
+  GET_DEVICE_ID = 0x70,
+  GET_DEVICE_ID_RESPONSE = 0x71,
  REPORT_NETWORK_STATUS = 0xF7,
  NO_COMMAND = 0xFF,
 };
--- a/esphome/components/i2c/i2c_bus_esp_idf.cpp
+++ b/esphome/components/i2c/i2c_bus_esp_idf.cpp
@@ -202,11 +202,13 @@ ErrorCode IDFI2CBus::writev(uint8_t address, WriteBuffer *buffers, size_t cnt, b
      return ERROR_UNKNOWN;
    }
  }
-  err = i2c_master_stop(cmd);
-  if (err != ESP_OK) {
-    ESP_LOGVV(TAG, "TX to %02X master stop failed: %s", address, esp_err_to_name(err));
-    i2c_cmd_link_delete(cmd);
-    return ERROR_UNKNOWN;
+  if (stop) {
+    err = i2c_master_stop(cmd);
+    if (err != ESP_OK) {
+      ESP_LOGVV(TAG, "TX to %02X master stop failed: %s", address, esp_err_to_name(err));
+      i2c_cmd_link_delete(cmd);
+      return ERROR_UNKNOWN;
+    }
  }
  err = i2c_master_cmd_begin(port_, cmd, 20 / portTICK_PERIOD_MS);
  i2c_cmd_link_delete(cmd);
--- a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
@@ -51,7 +51,7 @@ class I2SAudioSpeaker : public Component, public speaker::Speaker, public I2SAud
 #endif
  void set_external_dac_channels(uint8_t channels) { this->external_dac_channels_ = channels; }

-  void start();
+  void start() override;
  void stop() override;

  size_t play(const uint8_t *data, size_t length) override;
--- a/esphome/components/ld2410/init.py
+++ b/esphome/components/ld2410/init.py
@@ -1,113 +1,64 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import uart
-from esphome.const import CONF_ID, CONF_TIMEOUT
+from esphome.const import CONF_ID, CONF_THROTTLE, CONF_TIMEOUT, CONF_PASSWORD
 from esphome import automation
 from esphome.automation import maybe_simple_id

 DEPENDENCIES = ["uart"]
-CODEOWNERS = ["@sebcaps"]
+CODEOWNERS = ["@sebcaps", "@regevbr"]
 MULTI_CONF = True

 ld2410_ns = cg.esphome_ns.namespace("ld2410")
 LD2410Component = ld2410_ns.class_("LD2410Component", cg.Component, uart.UARTDevice)
-LD2410Restart = ld2410_ns.class_("LD2410Restart", automation.Action)
+
 CONF_LD2410_ID = "ld2410_id"
+
 CONF_MAX_MOVE_DISTANCE = "max_move_distance"
 CONF_MAX_STILL_DISTANCE = "max_still_distance"
-CONF_G0_MOVE_THRESHOLD = "g0_move_threshold"
-CONF_G0_STILL_THRESHOLD = "g0_still_threshold"
-CONF_G1_MOVE_THRESHOLD = "g1_move_threshold"
-CONF_G1_STILL_THRESHOLD = "g1_still_threshold"
-CONF_G2_MOVE_THRESHOLD = "g2_move_threshold"
-CONF_G2_STILL_THRESHOLD = "g2_still_threshold"
-CONF_G3_MOVE_THRESHOLD = "g3_move_threshold"
-CONF_G3_STILL_THRESHOLD = "g3_still_threshold"
-CONF_G4_MOVE_THRESHOLD = "g4_move_threshold"
-CONF_G4_STILL_THRESHOLD = "g4_still_threshold"
-CONF_G5_MOVE_THRESHOLD = "g5_move_threshold"
-CONF_G5_STILL_THRESHOLD = "g5_still_threshold"
-CONF_G6_MOVE_THRESHOLD = "g6_move_threshold"
-CONF_G6_STILL_THRESHOLD = "g6_still_threshold"
-CONF_G7_MOVE_THRESHOLD = "g7_move_threshold"
-CONF_G7_STILL_THRESHOLD = "g7_still_threshold"
-CONF_G8_MOVE_THRESHOLD = "g8_move_threshold"
-CONF_G8_STILL_THRESHOLD = "g8_still_threshold"
+CONF_STILL_THRESHOLDS = [f"g{x}_still_threshold" for x in range(9)]
+CONF_MOVE_THRESHOLDS = [f"g{x}_move_threshold" for x in range(9)]

-DISTANCES = [0.75, 1.5, 2.25, 3, 3.75, 4.5, 5.25, 6]
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(LD2410Component),
+        cv.Optional(CONF_THROTTLE, default="1000ms"): cv.All(
+            cv.positive_time_period_milliseconds,
+            cv.Range(min=cv.TimePeriod(milliseconds=1)),
+        ),
+        cv.Optional(CONF_MAX_MOVE_DISTANCE): cv.invalid(
+            f"The '{CONF_MAX_MOVE_DISTANCE}' option has been moved to the '{CONF_MAX_MOVE_DISTANCE}'"
+            f" number component"
+        ),
+        cv.Optional(CONF_MAX_STILL_DISTANCE): cv.invalid(
+            f"The '{CONF_MAX_STILL_DISTANCE}' option has been moved to the '{CONF_MAX_STILL_DISTANCE}'"
+            f" number component"
+        ),
+        cv.Optional(CONF_TIMEOUT): cv.invalid(
+            f"The '{CONF_TIMEOUT}' option has been moved to the '{CONF_TIMEOUT}'"
+            f" number component"
+        ),
+    }
+)
+
+for i in range(9):
+    CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+        cv.Schema(
+            {
+                cv.Optional(CONF_MOVE_THRESHOLDS[i]): cv.invalid(
+                    f"The '{CONF_MOVE_THRESHOLDS[i]}' option has been moved to the '{CONF_MOVE_THRESHOLDS[i]}'"
+                    f" number component"
+                ),
+                cv.Optional(CONF_STILL_THRESHOLDS[i]): cv.invalid(
+                    f"The '{CONF_STILL_THRESHOLDS[i]}' option has been moved to the '{CONF_STILL_THRESHOLDS[i]}'"
+                    f" number component"
+                ),
+            }
+        )
+    )

 CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(LD2410Component),
-            cv.Optional(CONF_MAX_MOVE_DISTANCE, default="4.5m"): cv.All(
-                cv.distance, cv.one_of(*DISTANCES, float=True)
-            ),
-            cv.Optional(CONF_MAX_STILL_DISTANCE, default="4.5m"): cv.All(
-                cv.distance, cv.one_of(*DISTANCES, float=True)
-            ),
-            cv.Optional(CONF_TIMEOUT, default="5s"): cv.All(
-                cv.positive_time_period_seconds,
-                cv.Range(max=cv.TimePeriod(seconds=32767)),
-            ),
-            cv.Optional(CONF_G0_MOVE_THRESHOLD, default=50): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G0_STILL_THRESHOLD, default=0): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G1_MOVE_THRESHOLD, default=50): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G1_STILL_THRESHOLD, default=0): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G2_MOVE_THRESHOLD, default=40): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G2_STILL_THRESHOLD, default=40): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G3_MOVE_THRESHOLD, default=40): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G3_STILL_THRESHOLD, default=40): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G4_MOVE_THRESHOLD, default=40): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G4_STILL_THRESHOLD, default=40): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G5_MOVE_THRESHOLD, default=40): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G5_STILL_THRESHOLD, default=40): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G6_MOVE_THRESHOLD, default=30): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G6_STILL_THRESHOLD, default=15): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G7_MOVE_THRESHOLD, default=30): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G7_STILL_THRESHOLD, default=15): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G8_MOVE_THRESHOLD, default=30): cv.int_range(
-                min=0, max=100
-            ),
-            cv.Optional(CONF_G8_STILL_THRESHOLD, default=15): cv.int_range(
-                min=0, max=100
-            ),
-        }
-    )
-    .extend(uart.UART_DEVICE_SCHEMA)
-    .extend(cv.COMPONENT_SCHEMA)
+    CONFIG_SCHEMA.extend(uart.UART_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
 )

 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
@@ -123,31 +74,7 @@ async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)
-    cg.add(var.set_timeout(config[CONF_TIMEOUT]))
-    cg.add(var.set_max_move_distance(int(config[CONF_MAX_MOVE_DISTANCE] / 0.75)))
-    cg.add(var.set_max_still_distance(int(config[CONF_MAX_STILL_DISTANCE] / 0.75)))
-    cg.add(
-        var.set_range_config(
-            config[CONF_G0_MOVE_THRESHOLD],
-            config[CONF_G0_STILL_THRESHOLD],
-            config[CONF_G1_MOVE_THRESHOLD],
-            config[CONF_G1_STILL_THRESHOLD],
-            config[CONF_G2_MOVE_THRESHOLD],
-            config[CONF_G2_STILL_THRESHOLD],
-            config[CONF_G3_MOVE_THRESHOLD],
-            config[CONF_G3_STILL_THRESHOLD],
-            config[CONF_G4_MOVE_THRESHOLD],
-            config[CONF_G4_STILL_THRESHOLD],
-            config[CONF_G5_MOVE_THRESHOLD],
-            config[CONF_G5_STILL_THRESHOLD],
-            config[CONF_G6_MOVE_THRESHOLD],
-            config[CONF_G6_STILL_THRESHOLD],
-            config[CONF_G7_MOVE_THRESHOLD],
-            config[CONF_G7_STILL_THRESHOLD],
-            config[CONF_G8_MOVE_THRESHOLD],
-            config[CONF_G8_STILL_THRESHOLD],
-        )
-    )
+    cg.add(var.set_throttle(config[CONF_THROTTLE]))


 CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
@@ -155,3 +82,28 @@ CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
        cv.Required(CONF_ID): cv.use_id(LD2410Component),
    }
 )
+
+
+# Actions
+BluetoothPasswordSetAction = ld2410_ns.class_(
+    "BluetoothPasswordSetAction", automation.Action
+)
+
+
+BLUETOOTH_PASSWORD_SET_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.use_id(LD2410Component),
+        cv.Required(CONF_PASSWORD): cv.templatable(cv.string_strict),
+    }
+)
+
+
+@automation.register_action(
+    "bluetooth_password.set", BluetoothPasswordSetAction, BLUETOOTH_PASSWORD_SET_SCHEMA
+)
+async def bluetooth_password_set_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    template_ = await cg.templatable(config[CONF_PASSWORD], args, cg.std_string)
+    cg.add(var.set_password(template_))
+    return var
--- a/esphome/components/ld2410/automation.h
+++ b/esphome/components/ld2410/automation.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+template<typename... Ts> class BluetoothPasswordSetAction : public Action<Ts...> {
+ public:
+  explicit BluetoothPasswordSetAction(LD2410Component *ld2410_comp) : ld2410_comp_(ld2410_comp) {}
+  TEMPLATABLE_VALUE(std::string, password)
+
+  void play(Ts... x) override { this->ld2410_comp_->set_bluetooth_password(this->password_.value(x...)); }
+
+ protected:
+  LD2410Component *ld2410_comp_;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/binary_sensor.py
+++ b/esphome/components/ld2410/binary_sensor.py
@@ -1,36 +1,55 @@
 import esphome.codegen as cg
 from esphome.components import binary_sensor
 import esphome.config_validation as cv
-from esphome.const import DEVICE_CLASS_MOTION, DEVICE_CLASS_OCCUPANCY
+from esphome.const import (
+    DEVICE_CLASS_MOTION,
+    DEVICE_CLASS_OCCUPANCY,
+    DEVICE_CLASS_PRESENCE,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ICON_MOTION_SENSOR,
+    ICON_ACCOUNT,
+)
 from . import CONF_LD2410_ID, LD2410Component

 DEPENDENCIES = ["ld2410"]
 CONF_HAS_TARGET = "has_target"
 CONF_HAS_MOVING_TARGET = "has_moving_target"
 CONF_HAS_STILL_TARGET = "has_still_target"
+CONF_OUT_PIN_PRESENCE_STATUS = "out_pin_presence_status"

 CONFIG_SCHEMA = {
    cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
    cv.Optional(CONF_HAS_TARGET): binary_sensor.binary_sensor_schema(
-        device_class=DEVICE_CLASS_OCCUPANCY
+        device_class=DEVICE_CLASS_OCCUPANCY,
+        icon=ICON_ACCOUNT,
    ),
    cv.Optional(CONF_HAS_MOVING_TARGET): binary_sensor.binary_sensor_schema(
-        device_class=DEVICE_CLASS_MOTION
+        device_class=DEVICE_CLASS_MOTION,
+        icon=ICON_MOTION_SENSOR,
    ),
    cv.Optional(CONF_HAS_STILL_TARGET): binary_sensor.binary_sensor_schema(
-        device_class=DEVICE_CLASS_OCCUPANCY
+        device_class=DEVICE_CLASS_OCCUPANCY,
+        icon=ICON_MOTION_SENSOR,
+    ),
+    cv.Optional(CONF_OUT_PIN_PRESENCE_STATUS): binary_sensor.binary_sensor_schema(
+        device_class=DEVICE_CLASS_PRESENCE,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        icon=ICON_ACCOUNT,
    ),
 }


 async def to_code(config):
    ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
-    if CONF_HAS_TARGET in config:
-        sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_TARGET])
-        cg.add(ld2410_component.set_target_sensor(sens))
-    if CONF_HAS_MOVING_TARGET in config:
-        sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_MOVING_TARGET])
-        cg.add(ld2410_component.set_moving_target_sensor(sens))
-    if CONF_HAS_STILL_TARGET in config:
-        sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_STILL_TARGET])
-        cg.add(ld2410_component.set_still_target_sensor(sens))
+    if has_target_config := config.get(CONF_HAS_TARGET):
+        sens = await binary_sensor.new_binary_sensor(has_target_config)
+        cg.add(ld2410_component.set_target_binary_sensor(sens))
+    if has_moving_target_config := config.get(CONF_HAS_MOVING_TARGET):
+        sens = await binary_sensor.new_binary_sensor(has_moving_target_config)
+        cg.add(ld2410_component.set_moving_target_binary_sensor(sens))
+    if has_still_target_config := config.get(CONF_HAS_STILL_TARGET):
+        sens = await binary_sensor.new_binary_sensor(has_still_target_config)
+        cg.add(ld2410_component.set_still_target_binary_sensor(sens))
+    if out_pin_presence_status_config := config.get(CONF_OUT_PIN_PRESENCE_STATUS):
+        sens = await binary_sensor.new_binary_sensor(out_pin_presence_status_config)
+        cg.add(ld2410_component.set_out_pin_presence_status_binary_sensor(sens))
--- a/esphome/components/ld2410/button/init.py
+++ b/esphome/components/ld2410/button/init.py
@@ -0,0 +1,57 @@
+import esphome.codegen as cg
+from esphome.components import button
+import esphome.config_validation as cv
+from esphome.const import (
+    DEVICE_CLASS_RESTART,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_RESTART,
+    ICON_RESTART_ALERT,
+    ICON_DATABASE,
+)
+from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
+
+QueryButton = ld2410_ns.class_("QueryButton", button.Button)
+ResetButton = ld2410_ns.class_("ResetButton", button.Button)
+RestartButton = ld2410_ns.class_("RestartButton", button.Button)
+
+CONF_FACTORY_RESET = "factory_reset"
+CONF_RESTART = "restart"
+CONF_QUERY_PARAMS = "query_params"
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
+    cv.Optional(CONF_FACTORY_RESET): button.button_schema(
+        ResetButton,
+        device_class=DEVICE_CLASS_RESTART,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_RESTART_ALERT,
+    ),
+    cv.Optional(CONF_RESTART): button.button_schema(
+        RestartButton,
+        device_class=DEVICE_CLASS_RESTART,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        icon=ICON_RESTART,
+    ),
+    cv.Optional(CONF_QUERY_PARAMS): button.button_schema(
+        QueryButton,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        icon=ICON_DATABASE,
+    ),
+}
+
+
+async def to_code(config):
+    ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
+    if factory_reset_config := config.get(CONF_FACTORY_RESET):
+        b = await button.new_button(factory_reset_config)
+        await cg.register_parented(b, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_reset_button(b))
+    if restart_config := config.get(CONF_RESTART):
+        b = await button.new_button(restart_config)
+        await cg.register_parented(b, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_restart_button(b))
+    if query_params_config := config.get(CONF_QUERY_PARAMS):
+        b = await button.new_button(query_params_config)
+        await cg.register_parented(b, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_query_button(b))
--- a/esphome/components/ld2410/button/query_button.cpp
+++ b/esphome/components/ld2410/button/query_button.cpp
@@ -0,0 +1,9 @@
+#include "query_button.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void QueryButton::press_action() { this->parent_->read_all_info(); }
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/button/query_button.h
+++ b/esphome/components/ld2410/button/query_button.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/button/button.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class QueryButton : public button::Button, public Parented<LD2410Component> {
+ public:
+  QueryButton() = default;
+
+ protected:
+  void press_action() override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/button/reset_button.cpp
+++ b/esphome/components/ld2410/button/reset_button.cpp
@@ -0,0 +1,9 @@
+#include "reset_button.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void ResetButton::press_action() { this->parent_->factory_reset(); }
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/button/reset_button.h
+++ b/esphome/components/ld2410/button/reset_button.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/button/button.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class ResetButton : public button::Button, public Parented<LD2410Component> {
+ public:
+  ResetButton() = default;
+
+ protected:
+  void press_action() override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/button/restart_button.cpp
+++ b/esphome/components/ld2410/button/restart_button.cpp
@@ -0,0 +1,9 @@
+#include "restart_button.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void RestartButton::press_action() { this->parent_->restart_and_read_all_info(); }
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/button/restart_button.h
+++ b/esphome/components/ld2410/button/restart_button.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/button/button.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class RestartButton : public button::Button, public Parented<LD2410Component> {
+ public:
+  RestartButton() = default;
+
+ protected:
+  void press_action() override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/ld2410.cpp
+++ b/esphome/components/ld2410/ld2410.cpp
@@ -1,5 +1,13 @@
 #include "ld2410.h"

+#include <utility>
+#ifdef USE_NUMBER
+#include "esphome/components/number/number.h"
+#endif
+#ifdef USE_SENSOR
+#include "esphome/components/sensor/sensor.h"
+#endif
+
 #define highbyte(val) (uint8_t)((val) >> 8)
 #define lowbyte(val) (uint8_t)((val) &0xff)

@@ -8,48 +16,97 @@ namespace ld2410 {

 static const char *const TAG = "ld2410";

+LD2410Component::LD2410Component() {}
+
 void LD2410Component::dump_config() {
  ESP_LOGCONFIG(TAG, "LD2410:");
 #ifdef USE_BINARY_SENSOR
-  LOG_BINARY_SENSOR("  ", "HasTargetSensor", this->target_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "MovingSensor", this->moving_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "StillSensor", this->still_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "TargetBinarySensor", this->target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "MovingTargetBinarySensor", this->moving_target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "StillTargetBinarySensor", this->still_target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "OutPinPresenceStatusBinarySensor", this->out_pin_presence_status_binary_sensor_);
+#endif
+#ifdef USE_SWITCH
+  LOG_SWITCH("  ", "EngineeringModeSwitch", this->engineering_mode_switch_);
+  LOG_SWITCH("  ", "BluetoothSwitch", this->bluetooth_switch_);
+#endif
+#ifdef USE_BUTTON
+  LOG_BUTTON("  ", "ResetButton", this->reset_button_);
+  LOG_BUTTON("  ", "RestartButton", this->restart_button_);
+  LOG_BUTTON("  ", "QueryButton", this->query_button_);
 #endif
 #ifdef USE_SENSOR
-  LOG_SENSOR("  ", "Moving Distance", this->moving_target_distance_sensor_);
-  LOG_SENSOR("  ", "Still Distance", this->still_target_distance_sensor_);
-  LOG_SENSOR("  ", "Moving Energy", this->moving_target_energy_sensor_);
-  LOG_SENSOR("  ", "Still Energy", this->still_target_energy_sensor_);
-  LOG_SENSOR("  ", "Detection Distance", this->detection_distance_sensor_);
+  LOG_SENSOR("  ", "LightSensor", this->light_sensor_);
+  LOG_SENSOR("  ", "MovingTargetDistanceSensor", this->moving_target_distance_sensor_);
+  LOG_SENSOR("  ", "StillTargetDistanceSensor", this->still_target_distance_sensor_);
+  LOG_SENSOR("  ", "MovingTargetEnergySensor", this->moving_target_energy_sensor_);
+  LOG_SENSOR("  ", "StillTargetEnergySensor", this->still_target_energy_sensor_);
+  LOG_SENSOR("  ", "DetectionDistanceSensor", this->detection_distance_sensor_);
+  for (sensor::Sensor *s : this->gate_still_sensors_) {
+    LOG_SENSOR("  ", "NthGateStillSesnsor", s);
+  }
+  for (sensor::Sensor *s : this->gate_move_sensors_) {
+    LOG_SENSOR("  ", "NthGateMoveSesnsor", s);
+  }
 #endif
-  this->set_config_mode_(true);
-  this->get_version_();
-  this->set_config_mode_(false);
-  ESP_LOGCONFIG(TAG, "  Firmware Version : %u.%u.%u%u%u%u", this->version_[0], this->version_[1], this->version_[2],
-                this->version_[3], this->version_[4], this->version_[5]);
+#ifdef USE_TEXT_SENSOR
+  LOG_TEXT_SENSOR("  ", "VersionTextSensor", this->version_text_sensor_);
+  LOG_TEXT_SENSOR("  ", "MacTextSensor", this->mac_text_sensor_);
+#endif
+#ifdef USE_SELECT
+  LOG_SELECT("  ", "LightFunctionSelect", this->light_function_select_);
+  LOG_SELECT("  ", "OutPinLevelSelect", this->out_pin_level_select_);
+  LOG_SELECT("  ", "DistanceResolutionSelect", this->distance_resolution_select_);
+  LOG_SELECT("  ", "BaudRateSelect", this->baud_rate_select_);
+#endif
+#ifdef USE_NUMBER
+  LOG_NUMBER("  ", "LightThresholdNumber", this->light_threshold_number_);
+  LOG_NUMBER("  ", "MaxStillDistanceGateNumber", this->max_still_distance_gate_number_);
+  LOG_NUMBER("  ", "MaxMoveDistanceGateNumber", this->max_move_distance_gate_number_);
+  LOG_NUMBER("  ", "TimeoutNumber", this->timeout_number_);
+  for (number::Number *n : this->gate_still_threshold_numbers_) {
+    LOG_NUMBER("  ", "Still Thresholds Number", n);
+  }
+  for (number::Number *n : this->gate_move_threshold_numbers_) {
+    LOG_NUMBER("  ", "Move Thresholds Number", n);
+  }
+#endif
+  this->read_all_info();
+  ESP_LOGCONFIG(TAG, "  Throttle_ : %ums", this->throttle_);
+  ESP_LOGCONFIG(TAG, "  MAC Address : %s", const_cast<char *>(this->mac_.c_str()));
+  ESP_LOGCONFIG(TAG, "  Firmware Version : %s", const_cast<char *>(this->version_.c_str()));
 }

 void LD2410Component::setup() {
  ESP_LOGCONFIG(TAG, "Setting up LD2410...");
-  this->set_config_mode_(true);
-  this->set_max_distances_timeout_(this->max_move_distance_, this->max_still_distance_, this->timeout_);
-  // Configure Gates sensitivity
-  this->set_gate_threshold_(0, this->rg0_move_threshold_, this->rg0_still_threshold_);
-  this->set_gate_threshold_(1, this->rg1_move_threshold_, this->rg1_still_threshold_);
-  this->set_gate_threshold_(2, this->rg2_move_threshold_, this->rg2_still_threshold_);
-  this->set_gate_threshold_(3, this->rg3_move_threshold_, this->rg3_still_threshold_);
-  this->set_gate_threshold_(4, this->rg4_move_threshold_, this->rg4_still_threshold_);
-  this->set_gate_threshold_(5, this->rg5_move_threshold_, this->rg5_still_threshold_);
-  this->set_gate_threshold_(6, this->rg6_move_threshold_, this->rg6_still_threshold_);
-  this->set_gate_threshold_(7, this->rg7_move_threshold_, this->rg7_still_threshold_);
-  this->set_gate_threshold_(8, this->rg8_move_threshold_, this->rg8_still_threshold_);
-  this->get_version_();
-  this->set_config_mode_(false);
-  ESP_LOGCONFIG(TAG, "Firmware Version : %u.%u.%u%u%u%u", this->version_[0], this->version_[1], this->version_[2],
-                this->version_[3], this->version_[4], this->version_[5]);
+  this->read_all_info();
+  ESP_LOGCONFIG(TAG, "Mac Address : %s", const_cast<char *>(this->mac_.c_str()));
+  ESP_LOGCONFIG(TAG, "Firmware Version : %s", const_cast<char *>(this->version_.c_str()));
  ESP_LOGCONFIG(TAG, "LD2410 setup complete.");
 }

+void LD2410Component::read_all_info() {
+  this->set_config_mode_(true);
+  this->get_version_();
+  this->get_mac_();
+  this->get_distance_resolution_();
+  this->get_light_control_();
+  this->query_parameters_();
+  this->set_config_mode_(false);
+#ifdef USE_SELECT
+  const auto baud_rate = std::to_string(this->parent_->get_baud_rate());
+  if (this->baud_rate_select_ != nullptr && this->baud_rate_select_->state != baud_rate) {
+    this->baud_rate_select_->publish_state(baud_rate);
+  }
+#endif
+}
+
+void LD2410Component::restart_and_read_all_info() {
+  this->set_config_mode_(true);
+  this->restart_();
+  this->set_timeout(1000, [this]() { this->read_all_info(); });
+}
+
 void LD2410Component::loop() {
  const int max_line_length = 80;
  static uint8_t buffer[max_line_length];
@@ -59,9 +116,8 @@ void LD2410Component::loop() {
  }
 }

-void LD2410Component::send_command_(uint8_t command, uint8_t *command_value, int command_value_len) {
-  // lastCommandSuccess->publish_state(false);
-
+void LD2410Component::send_command_(uint8_t command, const uint8_t *command_value, int command_value_len) {
+  ESP_LOGV(TAG, "Sending COMMAND %02X", command);
  // frame start bytes
  this->write_array(CMD_FRAME_HEADER, 4);
  // length bytes
@@ -95,40 +151,43 @@ void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
  if (buffer[7] != HEAD || buffer[len - 6] != END || buffer[len - 5] != CHECK)  // Check constant values
    return;  // data head=0xAA, data end=0x55, crc=0x00

-    /*
-      Data Type: 6th
-      0x01: Engineering mode
-      0x02: Normal mode
-    */
-    // char data_type = buffer[DATA_TYPES];
-    /*
-      Target states: 9th
-      0x00 = No target
-      0x01 = Moving targets
-      0x02 = Still targets
-      0x03 = Moving+Still targets
-    */
-#ifdef USE_BINARY_SENSOR
-  char target_state = buffer[TARGET_STATES];
-  if (this->target_binary_sensor_ != nullptr) {
-    this->target_binary_sensor_->publish_state(target_state != 0x00);
-  }
-#endif
-
  /*
    Reduce data update rate to prevent home assistant database size grow fast
  */
  int32_t current_millis = millis();
-  if (current_millis - last_periodic_millis < 1000)
+  if (current_millis - last_periodic_millis_ < this->throttle_)
    return;
-  last_periodic_millis = current_millis;
+  last_periodic_millis_ = current_millis;

-#ifdef USE_BINARY_SENSOR
-  if (this->moving_binary_sensor_ != nullptr) {
-    this->moving_binary_sensor_->publish_state(CHECK_BIT(target_state, 0));
+  /*
+    Data Type: 7th
+    0x01: Engineering mode
+    0x02: Normal mode
+  */
+  bool engineering_mode = buffer[DATA_TYPES] == 0x01;
+#ifdef USE_SWITCH
+  if (this->engineering_mode_switch_ != nullptr &&
+      current_millis - last_engineering_mode_change_millis_ > this->throttle_) {
+    this->engineering_mode_switch_->publish_state(engineering_mode);
  }
-  if (this->still_binary_sensor_ != nullptr) {
-    this->still_binary_sensor_->publish_state(CHECK_BIT(target_state, 1));
+#endif
+#ifdef USE_BINARY_SENSOR
+  /*
+    Target states: 9th
+    0x00 = No target
+    0x01 = Moving targets
+    0x02 = Still targets
+    0x03 = Moving+Still targets
+  */
+  char target_state = buffer[TARGET_STATES];
+  if (this->target_binary_sensor_ != nullptr) {
+    this->target_binary_sensor_->publish_state(target_state != 0x00);
+  }
+  if (this->moving_target_binary_sensor_ != nullptr) {
+    this->moving_target_binary_sensor_->publish_state(CHECK_BIT(target_state, 0));
+  }
+  if (this->still_target_binary_sensor_ != nullptr) {
+    this->still_target_binary_sensor_->publish_state(CHECK_BIT(target_state, 1));
  }
 #endif
  /*
@@ -164,26 +223,126 @@ void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
    if (this->detection_distance_sensor_->get_state() != new_detect_distance)
      this->detection_distance_sensor_->publish_state(new_detect_distance);
  }
+  if (engineering_mode) {
+    /*
+      Moving distance range: 18th byte
+      Still distance range: 19th byte
+      Moving enery: 20~28th bytes
+    */
+    for (std::vector<sensor::Sensor *>::size_type i = 0; i != this->gate_move_sensors_.size(); i++) {
+      sensor::Sensor *s = this->gate_move_sensors_[i];
+      if (s != nullptr) {
+        s->publish_state(buffer[MOVING_SENSOR_START + i]);
+      }
+    }
+    /*
+      Still energy: 29~37th bytes
+    */
+    for (std::vector<sensor::Sensor *>::size_type i = 0; i != this->gate_still_sensors_.size(); i++) {
+      sensor::Sensor *s = this->gate_still_sensors_[i];
+      if (s != nullptr) {
+        s->publish_state(buffer[STILL_SENSOR_START + i]);
+      }
+    }
+    /*
+      Light sensor: 38th bytes
+    */
+    if (this->light_sensor_ != nullptr) {
+      int new_light_sensor = buffer[LIGHT_SENSOR];
+      if (this->light_sensor_->get_state() != new_light_sensor)
+        this->light_sensor_->publish_state(new_light_sensor);
+    }
+  } else {
+    for (auto *s : this->gate_move_sensors_) {
+      if (s != nullptr && !std::isnan(s->get_state())) {
+        s->publish_state(NAN);
+      }
+    }
+    for (auto *s : this->gate_still_sensors_) {
+      if (s != nullptr && !std::isnan(s->get_state())) {
+        s->publish_state(NAN);
+      }
+    }
+    if (this->light_sensor_ != nullptr && !std::isnan(this->light_sensor_->get_state())) {
+      this->light_sensor_->publish_state(NAN);
+    }
+  }
+#endif
+#ifdef USE_BINARY_SENSOR
+  if (engineering_mode) {
+    if (this->out_pin_presence_status_binary_sensor_ != nullptr) {
+      this->out_pin_presence_status_binary_sensor_->publish_state(buffer[OUT_PIN_SENSOR] == 0x01);
+    }
+  } else {
+    if (this->out_pin_presence_status_binary_sensor_ != nullptr) {
+      this->out_pin_presence_status_binary_sensor_->publish_state(false);
+    }
+  }
 #endif
 }

-void LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
-  ESP_LOGV(TAG, "Handling ACK DATA for COMMAND");
+const char VERSION_FMT[] = "%u.%02X.%02X%02X%02X%02X";
+
+std::string format_version(uint8_t *buffer) {
+  std::string::size_type version_size = 256;
+  std::string version;
+  do {
+    version.resize(version_size + 1);
+    version_size = std::snprintf(&version[0], version.size(), VERSION_FMT, buffer[13], buffer[12], buffer[17],
+                                 buffer[16], buffer[15], buffer[14]);
+  } while (version_size + 1 > version.size());
+  version.resize(version_size);
+  return version;
+}
+
+const char MAC_FMT[] = "%02X:%02X:%02X:%02X:%02X:%02X";
+
+const std::string UNKNOWN_MAC("unknown");
+const std::string NO_MAC("08:05:04:03:02:01");
+
+std::string format_mac(uint8_t *buffer) {
+  std::string::size_type mac_size = 256;
+  std::string mac;
+  do {
+    mac.resize(mac_size + 1);
+    mac_size = std::snprintf(&mac[0], mac.size(), MAC_FMT, buffer[10], buffer[11], buffer[12], buffer[13], buffer[14],
+                             buffer[15]);
+  } while (mac_size + 1 > mac.size());
+  mac.resize(mac_size);
+  if (mac == NO_MAC) {
+    return UNKNOWN_MAC;
+  }
+  return mac;
+}
+
+#ifdef USE_NUMBER
+std::function<void(void)> set_number_value(number::Number *n, float value) {
+  float normalized_value = value * 1.0;
+  if (n != nullptr && (!n->has_state() || n->state != normalized_value)) {
+    n->state = normalized_value;
+    return [n, normalized_value]() { n->publish_state(normalized_value); };
+  }
+  return []() {};
+}
+#endif
+
+bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
+  ESP_LOGV(TAG, "Handling ACK DATA for COMMAND %02X", buffer[COMMAND]);
  if (len < 10) {
    ESP_LOGE(TAG, "Error with last command : incorrect length");
-    return;
+    return true;
  }
  if (buffer[0] != 0xFD || buffer[1] != 0xFC || buffer[2] != 0xFB || buffer[3] != 0xFA) {  // check 4 frame start bytes
    ESP_LOGE(TAG, "Error with last command : incorrect Header");
-    return;
+    return true;
  }
  if (buffer[COMMAND_STATUS] != 0x01) {
    ESP_LOGE(TAG, "Error with last command : status != 0x01");
-    return;
+    return true;
  }
  if (this->two_byte_to_int_(buffer[8], buffer[9]) != 0x00) {
    ESP_LOGE(TAG, "Error with last command , last buffer was: %u , %u", buffer[8], buffer[9]);
-    return;
+    return true;
  }

  switch (buffer[COMMAND]) {
@@ -193,49 +352,127 @@ void LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
    case lowbyte(CMD_DISABLE_CONF):
      ESP_LOGV(TAG, "Handled Disabled conf command");
      break;
+    case lowbyte(CMD_SET_BAUD_RATE):
+      ESP_LOGV(TAG, "Handled baud rate change command");
+#ifdef USE_SELECT
+      if (this->baud_rate_select_ != nullptr) {
+        ESP_LOGE(TAG, "Change baud rate component config to %s and reinstall", this->baud_rate_select_->state.c_str());
+      }
+#endif
+      break;
    case lowbyte(CMD_VERSION):
-      ESP_LOGV(TAG, "FW Version is: %u.%u.%u%u%u%u", buffer[13], buffer[12], buffer[17], buffer[16], buffer[15],
-               buffer[14]);
-      this->version_[0] = buffer[13];
-      this->version_[1] = buffer[12];
-      this->version_[2] = buffer[17];
-      this->version_[3] = buffer[16];
-      this->version_[4] = buffer[15];
-      this->version_[5] = buffer[14];
-
+      this->version_ = format_version(buffer);
+      ESP_LOGV(TAG, "FW Version is: %s", const_cast<char *>(this->version_.c_str()));
+#ifdef USE_TEXT_SENSOR
+      if (this->version_text_sensor_ != nullptr) {
+        this->version_text_sensor_->publish_state(this->version_);
+      }
+#endif
+      break;
+    case lowbyte(CMD_QUERY_DISTANCE_RESOLUTION): {
+      std::string distance_resolution =
+          DISTANCE_RESOLUTION_INT_TO_ENUM.at(this->two_byte_to_int_(buffer[10], buffer[11]));
+      ESP_LOGV(TAG, "Distance resolution is: %s", const_cast<char *>(distance_resolution.c_str()));
+#ifdef USE_SELECT
+      if (this->distance_resolution_select_ != nullptr &&
+          this->distance_resolution_select_->state != distance_resolution) {
+        this->distance_resolution_select_->publish_state(distance_resolution);
+      }
+#endif
+    } break;
+    case lowbyte(CMD_QUERY_LIGHT_CONTROL): {
+      this->light_function_ = LIGHT_FUNCTION_INT_TO_ENUM.at(buffer[10]);
+      this->light_threshold_ = buffer[11] * 1.0;
+      this->out_pin_level_ = OUT_PIN_LEVEL_INT_TO_ENUM.at(buffer[12]);
+      ESP_LOGV(TAG, "Light function is: %s", const_cast<char *>(this->light_function_.c_str()));
+      ESP_LOGV(TAG, "Light threshold is: %f", this->light_threshold_);
+      ESP_LOGV(TAG, "Out pin level is: %s", const_cast<char *>(this->out_pin_level_.c_str()));
+#ifdef USE_SELECT
+      if (this->light_function_select_ != nullptr && this->light_function_select_->state != this->light_function_) {
+        this->light_function_select_->publish_state(this->light_function_);
+      }
+      if (this->out_pin_level_select_ != nullptr && this->out_pin_level_select_->state != this->out_pin_level_) {
+        this->out_pin_level_select_->publish_state(this->out_pin_level_);
+      }
+#endif
+#ifdef USE_NUMBER
+      if (this->light_threshold_number_ != nullptr &&
+          (!this->light_threshold_number_->has_state() ||
+           this->light_threshold_number_->state != this->light_threshold_)) {
+        this->light_threshold_number_->publish_state(this->light_threshold_);
+      }
+#endif
+    } break;
+    case lowbyte(CMD_MAC):
+      if (len < 20) {
+        return false;
+      }
+      this->mac_ = format_mac(buffer);
+      ESP_LOGV(TAG, "MAC Address is: %s", const_cast<char *>(this->mac_.c_str()));
+#ifdef USE_TEXT_SENSOR
+      if (this->mac_text_sensor_ != nullptr) {
+        this->mac_text_sensor_->publish_state(this->mac_);
+      }
+#endif
+#ifdef USE_SWITCH
+      if (this->bluetooth_switch_ != nullptr) {
+        this->bluetooth_switch_->publish_state(this->mac_ != UNKNOWN_MAC);
+      }
+#endif
      break;
    case lowbyte(CMD_GATE_SENS):
      ESP_LOGV(TAG, "Handled sensitivity command");
      break;
+    case lowbyte(CMD_BLUETOOTH):
+      ESP_LOGV(TAG, "Handled bluetooth command");
+      break;
+    case lowbyte(CMD_SET_DISTANCE_RESOLUTION):
+      ESP_LOGV(TAG, "Handled set distance resolution command");
+      break;
+    case lowbyte(CMD_SET_LIGHT_CONTROL):
+      ESP_LOGV(TAG, "Handled set light control command");
+      break;
+    case lowbyte(CMD_BT_PASSWORD):
+      ESP_LOGV(TAG, "Handled set bluetooth password command");
+      break;
    case lowbyte(CMD_QUERY):  // Query parameters response
    {
      if (buffer[10] != 0xAA)
-        return;  // value head=0xAA
+        return true;  // value head=0xAA
+#ifdef USE_NUMBER
      /*
        Moving distance range: 13th byte
        Still distance range: 14th byte
      */
-      // TODO
-      // maxMovingDistanceRange->publish_state(buffer[12]);
-      // maxStillDistanceRange->publish_state(buffer[13]);
+      std::vector<std::function<void(void)>> updates;
+      updates.push_back(set_number_value(this->max_move_distance_gate_number_, buffer[12]));
+      updates.push_back(set_number_value(this->max_still_distance_gate_number_, buffer[13]));
      /*
        Moving Sensitivities: 15~23th bytes
+      */
+      for (std::vector<number::Number *>::size_type i = 0; i != this->gate_move_threshold_numbers_.size(); i++) {
+        updates.push_back(set_number_value(this->gate_move_threshold_numbers_[i], buffer[14 + i]));
+      }
+      /*
        Still Sensitivities: 24~32th bytes
      */
-      for (int i = 0; i < 9; i++) {
-        moving_sensitivities[i] = buffer[14 + i];
-      }
-      for (int i = 0; i < 9; i++) {
-        still_sensitivities[i] = buffer[23 + i];
+      for (std::vector<number::Number *>::size_type i = 0; i != this->gate_still_threshold_numbers_.size(); i++) {
+        updates.push_back(set_number_value(this->gate_still_threshold_numbers_[i], buffer[23 + i]));
      }
      /*
        None Duration: 33~34th bytes
      */
-      // noneDuration->publish_state(this->two_byte_to_int_(buffer[32], buffer[33]));
+      updates.push_back(set_number_value(this->timeout_number_, this->two_byte_to_int_(buffer[32], buffer[33])));
+      for (auto &update : updates) {
+        update();
+      }
+#endif
    } break;
    default:
      break;
  }
+
+  return true;
 }

 void LD2410Component::readline_(int readch, uint8_t *buffer, int len) {
@@ -256,8 +493,11 @@ void LD2410Component::readline_(int readch, uint8_t *buffer, int len) {
      } else if (buffer[pos - 4] == 0x04 && buffer[pos - 3] == 0x03 && buffer[pos - 2] == 0x02 &&
                 buffer[pos - 1] == 0x01) {
        ESP_LOGV(TAG, "Will handle ACK Data");
-        this->handle_ack_data_(buffer, pos);
-        pos = 0;  // Reset position index ready for next time
+        if (this->handle_ack_data_(buffer, pos)) {
+          pos = 0;  // Reset position index ready for next time
+        } else {
+          ESP_LOGV(TAG, "ACK Data incomplete");
+        }
      }
    }
  }
@@ -269,21 +509,85 @@ void LD2410Component::set_config_mode_(bool enable) {
  this->send_command_(cmd, enable ? cmd_value : nullptr, 2);
 }

+void LD2410Component::set_bluetooth(bool enable) {
+  this->set_config_mode_(true);
+  uint8_t enable_cmd_value[2] = {0x01, 0x00};
+  uint8_t disable_cmd_value[2] = {0x00, 0x00};
+  this->send_command_(CMD_BLUETOOTH, enable ? enable_cmd_value : disable_cmd_value, 2);
+  this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
+}
+
+void LD2410Component::set_distance_resolution(const std::string &state) {
+  this->set_config_mode_(true);
+  uint8_t cmd_value[2] = {DISTANCE_RESOLUTION_ENUM_TO_INT.at(state), 0x00};
+  this->send_command_(CMD_SET_DISTANCE_RESOLUTION, cmd_value, 2);
+  this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
+}
+
+void LD2410Component::set_baud_rate(const std::string &state) {
+  this->set_config_mode_(true);
+  uint8_t cmd_value[2] = {BAUD_RATE_ENUM_TO_INT.at(state), 0x00};
+  this->send_command_(CMD_SET_BAUD_RATE, cmd_value, 2);
+  this->set_timeout(200, [this]() { this->restart_(); });
+}
+
+void LD2410Component::set_bluetooth_password(const std::string &password) {
+  if (password.length() != 6) {
+    ESP_LOGE(TAG, "set_bluetooth_password(): invalid password length, must be exactly 6 chars '%s'", password.c_str());
+    return;
+  }
+  this->set_config_mode_(true);
+  uint8_t cmd_value[6];
+  std::copy(password.begin(), password.end(), std::begin(cmd_value));
+  this->send_command_(CMD_BT_PASSWORD, cmd_value, 6);
+  this->set_config_mode_(false);
+}
+
+void LD2410Component::set_engineering_mode(bool enable) {
+  this->set_config_mode_(true);
+  last_engineering_mode_change_millis_ = millis();
+  uint8_t cmd = enable ? CMD_ENABLE_ENG : CMD_DISABLE_ENG;
+  this->send_command_(cmd, nullptr, 0);
+  this->set_config_mode_(false);
+}
+
+void LD2410Component::factory_reset() {
+  this->set_config_mode_(true);
+  this->send_command_(CMD_RESET, nullptr, 0);
+  this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
+}
+
+void LD2410Component::restart_() { this->send_command_(CMD_RESTART, nullptr, 0); }
+
 void LD2410Component::query_parameters_() { this->send_command_(CMD_QUERY, nullptr, 0); }
 void LD2410Component::get_version_() { this->send_command_(CMD_VERSION, nullptr, 0); }
+void LD2410Component::get_mac_() {
+  uint8_t cmd_value[2] = {0x01, 0x00};
+  this->send_command_(CMD_MAC, cmd_value, 2);
+}
+void LD2410Component::get_distance_resolution_() { this->send_command_(CMD_QUERY_DISTANCE_RESOLUTION, nullptr, 0); }

-void LD2410Component::set_max_distances_timeout_(uint8_t max_moving_distance_range, uint8_t max_still_distance_range,
-                                                 uint16_t timeout) {
+void LD2410Component::get_light_control_() { this->send_command_(CMD_QUERY_LIGHT_CONTROL, nullptr, 0); }
+
+#ifdef USE_NUMBER
+void LD2410Component::set_max_distances_timeout() {
+  if (!this->max_move_distance_gate_number_->has_state() || !this->max_still_distance_gate_number_->has_state() ||
+      !this->timeout_number_->has_state()) {
+    return;
+  }
+  int max_moving_distance_gate_range = static_cast<int>(this->max_move_distance_gate_number_->state);
+  int max_still_distance_gate_range = static_cast<int>(this->max_still_distance_gate_number_->state);
+  int timeout = static_cast<int>(this->timeout_number_->state);
  uint8_t value[18] = {0x00,
                       0x00,
-                       lowbyte(max_moving_distance_range),
-                       highbyte(max_moving_distance_range),
+                       lowbyte(max_moving_distance_gate_range),
+                       highbyte(max_moving_distance_gate_range),
                       0x00,
                       0x00,
                       0x01,
                       0x00,
-                       lowbyte(max_still_distance_range),
-                       highbyte(max_still_distance_range),
+                       lowbyte(max_still_distance_gate_range),
+                       highbyte(max_still_distance_gate_range),
                       0x00,
                       0x00,
                       0x02,
@@ -292,10 +596,25 @@ void LD2410Component::set_max_distances_timeout_(uint8_t max_moving_distance_ran
                       highbyte(timeout),
                       0x00,
                       0x00};
+  this->set_config_mode_(true);
  this->send_command_(CMD_MAXDIST_DURATION, value, 18);
+  delay(50);  // NOLINT
  this->query_parameters_();
+  this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
+  this->set_config_mode_(false);
 }
-void LD2410Component::set_gate_threshold_(uint8_t gate, uint8_t motionsens, uint8_t stillsens) {
+
+void LD2410Component::set_gate_threshold(uint8_t gate) {
+  number::Number *motionsens = this->gate_move_threshold_numbers_[gate];
+  number::Number *stillsens = this->gate_still_threshold_numbers_[gate];
+
+  if (!motionsens->has_state() || !stillsens->has_state()) {
+    return;
+  }
+  int motion = static_cast<int>(motionsens->state);
+  int still = static_cast<int>(stillsens->state);
+
+  this->set_config_mode_(true);
  // reference
  // https://drive.google.com/drive/folders/1p4dhbEJA3YubyIjIIC7wwVsSo8x29Fq-?spm=a2g0o.detail.1000023.17.93465697yFwVxH
  //   Send data: configure the motion sensitivity of distance gate 3 to 40, and the static sensitivity of 40
@@ -305,11 +624,57 @@ void LD2410Component::set_gate_threshold_(uint8_t gate, uint8_t motionsens, uint
  // 28 00 00 00 (value)
  // 02 00 (still sensitivtiy)
  // 28 00 00 00 (value)
-  uint8_t value[18] = {0x00, 0x00, lowbyte(gate),       highbyte(gate),       0x00, 0x00,
-                       0x01, 0x00, lowbyte(motionsens), highbyte(motionsens), 0x00, 0x00,
-                       0x02, 0x00, lowbyte(stillsens),  highbyte(stillsens),  0x00, 0x00};
+  uint8_t value[18] = {0x00, 0x00, lowbyte(gate),   highbyte(gate),   0x00, 0x00,
+                       0x01, 0x00, lowbyte(motion), highbyte(motion), 0x00, 0x00,
+                       0x02, 0x00, lowbyte(still),  highbyte(still),  0x00, 0x00};
  this->send_command_(CMD_GATE_SENS, value, 18);
+  delay(50);  // NOLINT
+  this->query_parameters_();
+  this->set_config_mode_(false);
 }

+void LD2410Component::set_gate_still_threshold_number(int gate, number::Number *n) {
+  this->gate_still_threshold_numbers_[gate] = n;
+}
+
+void LD2410Component::set_gate_move_threshold_number(int gate, number::Number *n) {
+  this->gate_move_threshold_numbers_[gate] = n;
+}
+#endif
+
+void LD2410Component::set_light_out_control() {
+#ifdef USE_NUMBER
+  if (this->light_threshold_number_ != nullptr && this->light_threshold_number_->has_state()) {
+    this->light_threshold_ = this->light_threshold_number_->state;
+  }
+#endif
+#ifdef USE_SELECT
+  if (this->light_function_select_ != nullptr && this->light_function_select_->has_state()) {
+    this->light_function_ = this->light_function_select_->state;
+  }
+  if (this->out_pin_level_select_ != nullptr && this->out_pin_level_select_->has_state()) {
+    this->out_pin_level_ = this->out_pin_level_select_->state;
+  }
+#endif
+  if (this->light_function_.empty() || this->out_pin_level_.empty() || this->light_threshold_ < 0) {
+    return;
+  }
+  this->set_config_mode_(true);
+  uint8_t light_function = LIGHT_FUNCTION_ENUM_TO_INT.at(this->light_function_);
+  uint8_t light_threshold = static_cast<uint8_t>(this->light_threshold_);
+  uint8_t out_pin_level = OUT_PIN_LEVEL_ENUM_TO_INT.at(this->out_pin_level_);
+  uint8_t value[4] = {light_function, light_threshold, out_pin_level, 0x00};
+  this->send_command_(CMD_SET_LIGHT_CONTROL, value, 4);
+  delay(50);  // NOLINT
+  this->get_light_control_();
+  this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
+  this->set_config_mode_(false);
+}
+
+#ifdef USE_SENSOR
+void LD2410Component::set_gate_move_sensor(int gate, sensor::Sensor *s) { this->gate_move_sensors_[gate] = s; }
+void LD2410Component::set_gate_still_sensor(int gate, sensor::Sensor *s) { this->gate_still_sensors_[gate] = s; }
+#endif
+
 }  // namespace ld2410
 }  // namespace esphome
--- a/esphome/components/ld2410/ld2410.h
+++ b/esphome/components/ld2410/ld2410.h
@@ -7,10 +7,27 @@
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
+#ifdef USE_NUMBER
+#include "esphome/components/number/number.h"
+#endif
+#ifdef USE_SWITCH
+#include "esphome/components/switch/switch.h"
+#endif
+#ifdef USE_BUTTON
+#include "esphome/components/button/button.h"
+#endif
+#ifdef USE_SELECT
+#include "esphome/components/select/select.h"
+#endif
+#ifdef USE_TEXT_SENSOR
+#include "esphome/components/text_sensor/text_sensor.h"
+#endif
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"

+#include <map>
+
 namespace esphome {
 namespace ld2410 {

@@ -19,10 +36,63 @@ namespace ld2410 {
 // Commands
 static const uint8_t CMD_ENABLE_CONF = 0x00FF;
 static const uint8_t CMD_DISABLE_CONF = 0x00FE;
+static const uint8_t CMD_ENABLE_ENG = 0x0062;
+static const uint8_t CMD_DISABLE_ENG = 0x0063;
 static const uint8_t CMD_MAXDIST_DURATION = 0x0060;
 static const uint8_t CMD_QUERY = 0x0061;
 static const uint8_t CMD_GATE_SENS = 0x0064;
 static const uint8_t CMD_VERSION = 0x00A0;
+static const uint8_t CMD_QUERY_DISTANCE_RESOLUTION = 0x00AB;
+static const uint8_t CMD_SET_DISTANCE_RESOLUTION = 0x00AA;
+static const uint8_t CMD_QUERY_LIGHT_CONTROL = 0x00AE;
+static const uint8_t CMD_SET_LIGHT_CONTROL = 0x00AD;
+static const uint8_t CMD_SET_BAUD_RATE = 0x00A1;
+static const uint8_t CMD_BT_PASSWORD = 0x00A9;
+static const uint8_t CMD_MAC = 0x00A5;
+static const uint8_t CMD_RESET = 0x00A2;
+static const uint8_t CMD_RESTART = 0x00A3;
+static const uint8_t CMD_BLUETOOTH = 0x00A4;
+
+enum BaudRateStructure : uint8_t {
+  BAUD_RATE_9600 = 1,
+  BAUD_RATE_19200 = 2,
+  BAUD_RATE_38400 = 3,
+  BAUD_RATE_57600 = 4,
+  BAUD_RATE_115200 = 5,
+  BAUD_RATE_230400 = 6,
+  BAUD_RATE_256000 = 7,
+  BAUD_RATE_460800 = 8
+};
+
+static const std::map<std::string, uint8_t> BAUD_RATE_ENUM_TO_INT{
+    {"9600", BAUD_RATE_9600},     {"19200", BAUD_RATE_19200},   {"38400", BAUD_RATE_38400},
+    {"57600", BAUD_RATE_57600},   {"115200", BAUD_RATE_115200}, {"230400", BAUD_RATE_230400},
+    {"256000", BAUD_RATE_256000}, {"460800", BAUD_RATE_460800}};
+
+enum DistanceResolutionStructure : uint8_t { DISTANCE_RESOLUTION_0_2 = 0x01, DISTANCE_RESOLUTION_0_75 = 0x00 };
+
+static const std::map<std::string, uint8_t> DISTANCE_RESOLUTION_ENUM_TO_INT{{"0.2m", DISTANCE_RESOLUTION_0_2},
+                                                                            {"0.75m", DISTANCE_RESOLUTION_0_75}};
+static const std::map<uint8_t, std::string> DISTANCE_RESOLUTION_INT_TO_ENUM{{DISTANCE_RESOLUTION_0_2, "0.2m"},
+                                                                            {DISTANCE_RESOLUTION_0_75, "0.75m"}};
+
+enum LightFunctionStructure : uint8_t {
+  LIGHT_FUNCTION_OFF = 0x00,
+  LIGHT_FUNCTION_BELOW = 0x01,
+  LIGHT_FUNCTION_ABOVE = 0x02
+};
+
+static const std::map<std::string, uint8_t> LIGHT_FUNCTION_ENUM_TO_INT{
+    {"off", LIGHT_FUNCTION_OFF}, {"below", LIGHT_FUNCTION_BELOW}, {"above", LIGHT_FUNCTION_ABOVE}};
+static const std::map<uint8_t, std::string> LIGHT_FUNCTION_INT_TO_ENUM{
+    {LIGHT_FUNCTION_OFF, "off"}, {LIGHT_FUNCTION_BELOW, "below"}, {LIGHT_FUNCTION_ABOVE, "above"}};
+
+enum OutPinLevelStructure : uint8_t { OUT_PIN_LEVEL_LOW = 0x00, OUT_PIN_LEVEL_HIGH = 0x01 };
+
+static const std::map<std::string, uint8_t> OUT_PIN_LEVEL_ENUM_TO_INT{{"low", OUT_PIN_LEVEL_LOW},
+                                                                      {"high", OUT_PIN_LEVEL_HIGH}};
+static const std::map<uint8_t, std::string> OUT_PIN_LEVEL_INT_TO_ENUM{{OUT_PIN_LEVEL_LOW, "low"},
+                                                                      {OUT_PIN_LEVEL_HIGH, "high"}};

 // Commands values
 static const uint8_t CMD_MAX_MOVE_VALUE = 0x0000;
@@ -44,7 +114,7 @@ Target states: 9th byte
    Detect distance: 16~17th bytes
 */
 enum PeriodicDataStructure : uint8_t {
-  DATA_TYPES = 5,
+  DATA_TYPES = 6,
  TARGET_STATES = 8,
  MOVING_TARGET_LOW = 9,
  MOVING_TARGET_HIGH = 10,
@@ -54,6 +124,10 @@ enum PeriodicDataStructure : uint8_t {
  STILL_ENERGY = 14,
  DETECT_DISTANCE_LOW = 15,
  DETECT_DISTANCE_HIGH = 16,
+  MOVING_SENSOR_START = 19,
+  STILL_SENSOR_START = 28,
+  LIGHT_SENSOR = 37,
+  OUT_PIN_SENSOR = 38,
 };
 enum PeriodicDataValue : uint8_t { HEAD = 0XAA, END = 0x55, CHECK = 0x00 };

@@ -66,80 +140,97 @@ class LD2410Component : public Component, public uart::UARTDevice {
  SUB_SENSOR(still_target_distance)
  SUB_SENSOR(moving_target_energy)
  SUB_SENSOR(still_target_energy)
+  SUB_SENSOR(light)
  SUB_SENSOR(detection_distance)
 #endif
+#ifdef USE_BINARY_SENSOR
+  SUB_BINARY_SENSOR(target)
+  SUB_BINARY_SENSOR(moving_target)
+  SUB_BINARY_SENSOR(still_target)
+  SUB_BINARY_SENSOR(out_pin_presence_status)
+#endif
+#ifdef USE_TEXT_SENSOR
+  SUB_TEXT_SENSOR(version)
+  SUB_TEXT_SENSOR(mac)
+#endif
+#ifdef USE_SELECT
+  SUB_SELECT(distance_resolution)
+  SUB_SELECT(baud_rate)
+  SUB_SELECT(light_function)
+  SUB_SELECT(out_pin_level)
+#endif
+#ifdef USE_SWITCH
+  SUB_SWITCH(engineering_mode)
+  SUB_SWITCH(bluetooth)
+#endif
+#ifdef USE_BUTTON
+  SUB_BUTTON(reset)
+  SUB_BUTTON(restart)
+  SUB_BUTTON(query)
+#endif
+#ifdef USE_NUMBER
+  SUB_NUMBER(max_still_distance_gate)
+  SUB_NUMBER(max_move_distance_gate)
+  SUB_NUMBER(timeout)
+  SUB_NUMBER(light_threshold)
+#endif

 public:
+  LD2410Component();
  void setup() override;
  void dump_config() override;
  void loop() override;
-
-#ifdef USE_BINARY_SENSOR
-  void set_target_sensor(binary_sensor::BinarySensor *sens) { this->target_binary_sensor_ = sens; };
-  void set_moving_target_sensor(binary_sensor::BinarySensor *sens) { this->moving_binary_sensor_ = sens; };
-  void set_still_target_sensor(binary_sensor::BinarySensor *sens) { this->still_binary_sensor_ = sens; };
+  void set_light_out_control();
+#ifdef USE_NUMBER
+  void set_gate_still_threshold_number(int gate, number::Number *n);
+  void set_gate_move_threshold_number(int gate, number::Number *n);
+  void set_max_distances_timeout();
+  void set_gate_threshold(uint8_t gate);
 #endif
-
-  void set_timeout(uint16_t value) { this->timeout_ = value; };
-  void set_max_move_distance(uint8_t value) { this->max_move_distance_ = value; };
-  void set_max_still_distance(uint8_t value) { this->max_still_distance_ = value; };
-  void set_range_config(int rg0_move, int rg0_still, int rg1_move, int rg1_still, int rg2_move, int rg2_still,
-                        int rg3_move, int rg3_still, int rg4_move, int rg4_still, int rg5_move, int rg5_still,
-                        int rg6_move, int rg6_still, int rg7_move, int rg7_still, int rg8_move, int rg8_still) {
-    this->rg0_move_threshold_ = rg0_move;
-    this->rg0_still_threshold_ = rg0_still;
-    this->rg1_move_threshold_ = rg1_move;
-    this->rg1_still_threshold_ = rg1_still;
-    this->rg2_move_threshold_ = rg2_move;
-    this->rg2_still_threshold_ = rg2_still;
-    this->rg3_move_threshold_ = rg3_move;
-    this->rg3_still_threshold_ = rg3_still;
-    this->rg4_move_threshold_ = rg4_move;
-    this->rg4_still_threshold_ = rg4_still;
-    this->rg5_move_threshold_ = rg5_move;
-    this->rg5_still_threshold_ = rg5_still;
-    this->rg6_move_threshold_ = rg6_move;
-    this->rg6_still_threshold_ = rg6_still;
-    this->rg7_move_threshold_ = rg7_move;
-    this->rg7_still_threshold_ = rg7_still;
-    this->rg8_move_threshold_ = rg8_move;
-    this->rg8_still_threshold_ = rg8_still;
-  };
-  int moving_sensitivities[9] = {0};
-  int still_sensitivities[9] = {0};
-
-  int32_t last_periodic_millis = millis();
+#ifdef USE_SENSOR
+  void set_gate_move_sensor(int gate, sensor::Sensor *s);
+  void set_gate_still_sensor(int gate, sensor::Sensor *s);
+#endif
+  void set_throttle(uint16_t value) { this->throttle_ = value; };
+  void set_bluetooth_password(const std::string &password);
+  void set_engineering_mode(bool enable);
+  void read_all_info();
+  void restart_and_read_all_info();
+  void set_bluetooth(bool enable);
+  void set_distance_resolution(const std::string &state);
+  void set_baud_rate(const std::string &state);
+  void factory_reset();

 protected:
-#ifdef USE_BINARY_SENSOR
-  binary_sensor::BinarySensor *target_binary_sensor_{nullptr};
-  binary_sensor::BinarySensor *moving_binary_sensor_{nullptr};
-  binary_sensor::BinarySensor *still_binary_sensor_{nullptr};
-#endif
-
-  std::vector<uint8_t> rx_buffer_;
  int two_byte_to_int_(char firstbyte, char secondbyte) { return (int16_t) (secondbyte << 8) + firstbyte; }
-  void send_command_(uint8_t command_str, uint8_t *command_value, int command_value_len);
-
-  void set_max_distances_timeout_(uint8_t max_moving_distance_range, uint8_t max_still_distance_range,
-                                  uint16_t timeout);
-  void set_gate_threshold_(uint8_t gate, uint8_t motionsens, uint8_t stillsens);
+  void send_command_(uint8_t command_str, const uint8_t *command_value, int command_value_len);
  void set_config_mode_(bool enable);
  void handle_periodic_data_(uint8_t *buffer, int len);
-  void handle_ack_data_(uint8_t *buffer, int len);
+  bool handle_ack_data_(uint8_t *buffer, int len);
  void readline_(int readch, uint8_t *buffer, int len);
  void query_parameters_();
  void get_version_();
+  void get_mac_();
+  void get_distance_resolution_();
+  void get_light_control_();
+  void restart_();

-  uint16_t timeout_;
-  uint8_t max_move_distance_;
-  uint8_t max_still_distance_;
-
-  uint8_t version_[6];
-  uint8_t rg0_move_threshold_, rg0_still_threshold_, rg1_move_threshold_, rg1_still_threshold_, rg2_move_threshold_,
-      rg2_still_threshold_, rg3_move_threshold_, rg3_still_threshold_, rg4_move_threshold_, rg4_still_threshold_,
-      rg5_move_threshold_, rg5_still_threshold_, rg6_move_threshold_, rg6_still_threshold_, rg7_move_threshold_,
-      rg7_still_threshold_, rg8_move_threshold_, rg8_still_threshold_;
+  int32_t last_periodic_millis_ = millis();
+  int32_t last_engineering_mode_change_millis_ = millis();
+  uint16_t throttle_;
+  std::string version_;
+  std::string mac_;
+  std::string out_pin_level_;
+  std::string light_function_;
+  float light_threshold_ = -1;
+#ifdef USE_NUMBER
+  std::vector<number::Number *> gate_still_threshold_numbers_ = std::vector<number::Number *>(9);
+  std::vector<number::Number *> gate_move_threshold_numbers_ = std::vector<number::Number *>(9);
+#endif
+#ifdef USE_SENSOR
+  std::vector<sensor::Sensor *> gate_still_sensors_ = std::vector<sensor::Sensor *>(9);
+  std::vector<sensor::Sensor *> gate_move_sensors_ = std::vector<sensor::Sensor *>(9);
+#endif
 };

 }  // namespace ld2410
--- a/esphome/components/ld2410/number/init.py
+++ b/esphome/components/ld2410/number/init.py
@@ -0,0 +1,128 @@
+import esphome.codegen as cg
+from esphome.components import number
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    CONF_TIMEOUT,
+    DEVICE_CLASS_DISTANCE,
+    DEVICE_CLASS_SIGNAL_STRENGTH,
+    DEVICE_CLASS_ILLUMINANCE,
+    UNIT_SECOND,
+    UNIT_PERCENT,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_MOTION_SENSOR,
+    ICON_TIMELAPSE,
+    ICON_LIGHTBULB,
+)
+from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
+
+GateThresholdNumber = ld2410_ns.class_("GateThresholdNumber", number.Number)
+LightThresholdNumber = ld2410_ns.class_("LightThresholdNumber", number.Number)
+MaxDistanceTimeoutNumber = ld2410_ns.class_("MaxDistanceTimeoutNumber", number.Number)
+
+CONF_MAX_MOVE_DISTANCE_GATE = "max_move_distance_gate"
+CONF_MAX_STILL_DISTANCE_GATE = "max_still_distance_gate"
+CONF_LIGHT_THRESHOLD = "light_threshold"
+CONF_STILL_THRESHOLD = "still_threshold"
+CONF_MOVE_THRESHOLD = "move_threshold"
+
+TIMEOUT_GROUP = "timeout"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
+        cv.Inclusive(CONF_TIMEOUT, TIMEOUT_GROUP): number.number_schema(
+            MaxDistanceTimeoutNumber,
+            unit_of_measurement=UNIT_SECOND,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_TIMELAPSE,
+        ),
+        cv.Inclusive(CONF_MAX_MOVE_DISTANCE_GATE, TIMEOUT_GROUP): number.number_schema(
+            MaxDistanceTimeoutNumber,
+            device_class=DEVICE_CLASS_DISTANCE,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_MOTION_SENSOR,
+        ),
+        cv.Inclusive(CONF_MAX_STILL_DISTANCE_GATE, TIMEOUT_GROUP): number.number_schema(
+            MaxDistanceTimeoutNumber,
+            device_class=DEVICE_CLASS_DISTANCE,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_MOTION_SENSOR,
+        ),
+        cv.Optional(CONF_LIGHT_THRESHOLD): number.number_schema(
+            LightThresholdNumber,
+            device_class=DEVICE_CLASS_ILLUMINANCE,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_LIGHTBULB,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"g{x}"): cv.Schema(
+            {
+                cv.Required(CONF_MOVE_THRESHOLD): number.number_schema(
+                    GateThresholdNumber,
+                    device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
+                    unit_of_measurement=UNIT_PERCENT,
+                    entity_category=ENTITY_CATEGORY_CONFIG,
+                    icon=ICON_MOTION_SENSOR,
+                ),
+                cv.Required(CONF_STILL_THRESHOLD): number.number_schema(
+                    GateThresholdNumber,
+                    device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
+                    unit_of_measurement=UNIT_PERCENT,
+                    entity_category=ENTITY_CATEGORY_CONFIG,
+                    icon=ICON_MOTION_SENSOR,
+                ),
+            }
+        )
+        for x in range(9)
+    }
+)
+
+
+async def to_code(config):
+    ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
+    if timeout_config := config.get(CONF_TIMEOUT):
+        n = await number.new_number(
+            timeout_config, min_value=0, max_value=65535, step=1
+        )
+        await cg.register_parented(n, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_timeout_number(n))
+    if max_move_distance_gate_config := config.get(CONF_MAX_MOVE_DISTANCE_GATE):
+        n = await number.new_number(
+            max_move_distance_gate_config, min_value=2, max_value=8, step=1
+        )
+        await cg.register_parented(n, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_max_move_distance_gate_number(n))
+    if max_still_distance_gate_config := config.get(CONF_MAX_STILL_DISTANCE_GATE):
+        n = await number.new_number(
+            max_still_distance_gate_config, min_value=2, max_value=8, step=1
+        )
+        await cg.register_parented(n, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_max_still_distance_gate_number(n))
+    if light_threshold_config := config.get(CONF_LIGHT_THRESHOLD):
+        n = await number.new_number(
+            light_threshold_config, min_value=0, max_value=255, step=1
+        )
+        await cg.register_parented(n, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_light_threshold_number(n))
+    for x in range(9):
+        if gate_conf := config.get(f"g{x}"):
+            move_config = gate_conf[CONF_MOVE_THRESHOLD]
+            n = cg.new_Pvariable(move_config[CONF_ID], x)
+            await number.register_number(
+                n, move_config, min_value=0, max_value=100, step=1
+            )
+            await cg.register_parented(n, config[CONF_LD2410_ID])
+            cg.add(ld2410_component.set_gate_move_threshold_number(x, n))
+
+            still_config = gate_conf[CONF_STILL_THRESHOLD]
+            n = cg.new_Pvariable(still_config[CONF_ID], x)
+            await number.register_number(
+                n, still_config, min_value=0, max_value=100, step=1
+            )
+            await cg.register_parented(n, config[CONF_LD2410_ID])
+            cg.add(ld2410_component.set_gate_still_threshold_number(x, n))
--- a/esphome/components/ld2410/number/gate_threshold_number.cpp
+++ b/esphome/components/ld2410/number/gate_threshold_number.cpp
@@ -0,0 +1,14 @@
+#include "gate_threshold_number.h"
+
+namespace esphome {
+namespace ld2410 {
+
+GateThresholdNumber::GateThresholdNumber(uint8_t gate) : gate_(gate) {}
+
+void GateThresholdNumber::control(float value) {
+  this->publish_state(value);
+  this->parent_->set_gate_threshold(this->gate_);
+}
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/number/gate_threshold_number.h
+++ b/esphome/components/ld2410/number/gate_threshold_number.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class GateThresholdNumber : public number::Number, public Parented<LD2410Component> {
+ public:
+  GateThresholdNumber(uint8_t gate);
+
+ protected:
+  uint8_t gate_;
+  void control(float value) override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/number/light_threshold_number.cpp
+++ b/esphome/components/ld2410/number/light_threshold_number.cpp
@@ -0,0 +1,12 @@
+#include "light_threshold_number.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void LightThresholdNumber::control(float value) {
+  this->publish_state(value);
+  this->parent_->set_light_out_control();
+}
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/number/light_threshold_number.h
+++ b/esphome/components/ld2410/number/light_threshold_number.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class LightThresholdNumber : public number::Number, public Parented<LD2410Component> {
+ public:
+  LightThresholdNumber() = default;
+
+ protected:
+  void control(float value) override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/number/max_distance_timeout_number.cpp
+++ b/esphome/components/ld2410/number/max_distance_timeout_number.cpp
@@ -0,0 +1,12 @@
+#include "max_distance_timeout_number.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void MaxDistanceTimeoutNumber::control(float value) {
+  this->publish_state(value);
+  this->parent_->set_max_distances_timeout();
+}
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/number/max_distance_timeout_number.h
+++ b/esphome/components/ld2410/number/max_distance_timeout_number.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class MaxDistanceTimeoutNumber : public number::Number, public Parented<LD2410Component> {
+ public:
+  MaxDistanceTimeoutNumber() = default;
+
+ protected:
+  void control(float value) override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/select/init.py
+++ b/esphome/components/ld2410/select/init.py
@@ -0,0 +1,81 @@
+import esphome.codegen as cg
+from esphome.components import select
+import esphome.config_validation as cv
+from esphome.const import (
+    ENTITY_CATEGORY_CONFIG,
+    CONF_BAUD_RATE,
+    ICON_THERMOMETER,
+    ICON_SCALE,
+    ICON_LIGHTBULB,
+    ICON_RULER,
+)
+from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
+
+BaudRateSelect = ld2410_ns.class_("BaudRateSelect", select.Select)
+DistanceResolutionSelect = ld2410_ns.class_("DistanceResolutionSelect", select.Select)
+LightOutControlSelect = ld2410_ns.class_("LightOutControlSelect", select.Select)
+
+CONF_DISTANCE_RESOLUTION = "distance_resolution"
+CONF_LIGHT_FUNCTION = "light_function"
+CONF_OUT_PIN_LEVEL = "out_pin_level"
+
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
+    cv.Optional(CONF_DISTANCE_RESOLUTION): select.select_schema(
+        DistanceResolutionSelect,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_RULER,
+    ),
+    cv.Optional(CONF_LIGHT_FUNCTION): select.select_schema(
+        LightOutControlSelect,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_LIGHTBULB,
+    ),
+    cv.Optional(CONF_OUT_PIN_LEVEL): select.select_schema(
+        LightOutControlSelect,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_SCALE,
+    ),
+    cv.Optional(CONF_BAUD_RATE): select.select_schema(
+        BaudRateSelect,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_THERMOMETER,
+    ),
+}
+
+
+async def to_code(config):
+    ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
+    if distance_resolution_config := config.get(CONF_DISTANCE_RESOLUTION):
+        s = await select.new_select(
+            distance_resolution_config, options=["0.2m", "0.75m"]
+        )
+        await cg.register_parented(s, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_distance_resolution_select(s))
+    if out_pin_level_config := config.get(CONF_OUT_PIN_LEVEL):
+        s = await select.new_select(out_pin_level_config, options=["low", "high"])
+        await cg.register_parented(s, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_out_pin_level_select(s))
+    if light_function_config := config.get(CONF_LIGHT_FUNCTION):
+        s = await select.new_select(
+            light_function_config, options=["off", "below", "above"]
+        )
+        await cg.register_parented(s, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_light_function_select(s))
+    if baud_rate_config := config.get(CONF_BAUD_RATE):
+        s = await select.new_select(
+            baud_rate_config,
+            options=[
+                "9600",
+                "19200",
+                "38400",
+                "57600",
+                "115200",
+                "230400",
+                "256000",
+                "460800",
+            ],
+        )
+        await cg.register_parented(s, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_baud_rate_select(s))
--- a/esphome/components/ld2410/select/baud_rate_select.cpp
+++ b/esphome/components/ld2410/select/baud_rate_select.cpp
@@ -0,0 +1,12 @@
+#include "baud_rate_select.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void BaudRateSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_baud_rate(state);
+}
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/select/baud_rate_select.h
+++ b/esphome/components/ld2410/select/baud_rate_select.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class BaudRateSelect : public select::Select, public Parented<LD2410Component> {
+ public:
+  BaudRateSelect() = default;
+
+ protected:
+  void control(const std::string &value) override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/select/distance_resolution_select.cpp
+++ b/esphome/components/ld2410/select/distance_resolution_select.cpp
@@ -0,0 +1,12 @@
+#include "distance_resolution_select.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void DistanceResolutionSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_distance_resolution(state);
+}
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/select/distance_resolution_select.h
+++ b/esphome/components/ld2410/select/distance_resolution_select.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class DistanceResolutionSelect : public select::Select, public Parented<LD2410Component> {
+ public:
+  DistanceResolutionSelect() = default;
+
+ protected:
+  void control(const std::string &value) override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/select/light_out_control_select.cpp
+++ b/esphome/components/ld2410/select/light_out_control_select.cpp
@@ -0,0 +1,12 @@
+#include "light_out_control_select.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void LightOutControlSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_light_out_control();
+}
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/select/light_out_control_select.h
+++ b/esphome/components/ld2410/select/light_out_control_select.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class LightOutControlSelect : public select::Select, public Parented<LD2410Component> {
+ public:
+  LightOutControlSelect() = default;
+
+ protected:
+  void control(const std::string &value) override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/sensor.py
+++ b/esphome/components/ld2410/sensor.py
@@ -3,9 +3,15 @@ from esphome.components import sensor
 import esphome.config_validation as cv
 from esphome.const import (
    DEVICE_CLASS_DISTANCE,
-    DEVICE_CLASS_ENERGY,
    UNIT_CENTIMETER,
    UNIT_PERCENT,
+    CONF_LIGHT,
+    DEVICE_CLASS_ILLUMINANCE,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ICON_SIGNAL,
+    ICON_FLASH,
+    ICON_MOTION_SENSOR,
+    ICON_LIGHTBULB,
 )
 from . import CONF_LD2410_ID, LD2410Component

@@ -15,41 +21,88 @@ CONF_STILL_DISTANCE = "still_distance"
 CONF_MOVING_ENERGY = "moving_energy"
 CONF_STILL_ENERGY = "still_energy"
 CONF_DETECTION_DISTANCE = "detection_distance"
+CONF_MOVE_ENERGY = "move_energy"

-CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
-    cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
-        device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
-    ),
-    cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
-        device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
-    ),
-    cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-        device_class=DEVICE_CLASS_ENERGY, unit_of_measurement=UNIT_PERCENT
-    ),
-    cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-        device_class=DEVICE_CLASS_ENERGY, unit_of_measurement=UNIT_PERCENT
-    ),
-    cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
-        device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
-    ),
-}
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
+        cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
+            device_class=DEVICE_CLASS_DISTANCE,
+            unit_of_measurement=UNIT_CENTIMETER,
+            icon=ICON_SIGNAL,
+        ),
+        cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
+            device_class=DEVICE_CLASS_DISTANCE,
+            unit_of_measurement=UNIT_CENTIMETER,
+            icon=ICON_SIGNAL,
+        ),
+        cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PERCENT,
+            icon=ICON_MOTION_SENSOR,
+        ),
+        cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PERCENT,
+            icon=ICON_FLASH,
+        ),
+        cv.Optional(CONF_LIGHT): sensor.sensor_schema(
+            device_class=DEVICE_CLASS_ILLUMINANCE,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            icon=ICON_LIGHTBULB,
+        ),
+        cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
+            device_class=DEVICE_CLASS_DISTANCE,
+            unit_of_measurement=UNIT_CENTIMETER,
+            icon=ICON_SIGNAL,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"g{x}"): cv.Schema(
+            {
+                cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_PERCENT,
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                    icon=ICON_MOTION_SENSOR,
+                ),
+                cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_PERCENT,
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                    icon=ICON_FLASH,
+                ),
+            }
+        )
+        for x in range(9)
+    }
+)


 async def to_code(config):
    ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
-    if CONF_MOVING_DISTANCE in config:
-        sens = await sensor.new_sensor(config[CONF_MOVING_DISTANCE])
+    if moving_distance_config := config.get(CONF_MOVING_DISTANCE):
+        sens = await sensor.new_sensor(moving_distance_config)
        cg.add(ld2410_component.set_moving_target_distance_sensor(sens))
-    if CONF_STILL_DISTANCE in config:
-        sens = await sensor.new_sensor(config[CONF_STILL_DISTANCE])
+    if still_distance_config := config.get(CONF_STILL_DISTANCE):
+        sens = await sensor.new_sensor(still_distance_config)
        cg.add(ld2410_component.set_still_target_distance_sensor(sens))
-    if CONF_MOVING_ENERGY in config:
-        sens = await sensor.new_sensor(config[CONF_MOVING_ENERGY])
+    if moving_energy_config := config.get(CONF_MOVING_ENERGY):
+        sens = await sensor.new_sensor(moving_energy_config)
        cg.add(ld2410_component.set_moving_target_energy_sensor(sens))
-    if CONF_STILL_ENERGY in config:
-        sens = await sensor.new_sensor(config[CONF_STILL_ENERGY])
+    if still_energy_config := config.get(CONF_STILL_ENERGY):
+        sens = await sensor.new_sensor(still_energy_config)
        cg.add(ld2410_component.set_still_target_energy_sensor(sens))
-    if CONF_DETECTION_DISTANCE in config:
-        sens = await sensor.new_sensor(config[CONF_DETECTION_DISTANCE])
+    if light_config := config.get(CONF_LIGHT):
+        sens = await sensor.new_sensor(light_config)
+        cg.add(ld2410_component.set_light_sensor(sens))
+    if detection_distance_config := config.get(CONF_DETECTION_DISTANCE):
+        sens = await sensor.new_sensor(detection_distance_config)
        cg.add(ld2410_component.set_detection_distance_sensor(sens))
+    for x in range(9):
+        if gate_conf := config.get(f"g{x}"):
+            if move_config := gate_conf.get(CONF_MOVE_ENERGY):
+                sens = await sensor.new_sensor(move_config)
+                cg.add(ld2410_component.set_gate_move_sensor(x, sens))
+            if still_config := gate_conf.get(CONF_STILL_ENERGY):
+                sens = await sensor.new_sensor(still_config)
+                cg.add(ld2410_component.set_gate_still_sensor(x, sens))
--- a/esphome/components/ld2410/switch/init.py
+++ b/esphome/components/ld2410/switch/init.py
@@ -0,0 +1,44 @@
+import esphome.codegen as cg
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import (
+    DEVICE_CLASS_SWITCH,
+    ICON_BLUETOOTH,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_PULSE,
+)
+from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
+
+BluetoothSwitch = ld2410_ns.class_("BluetoothSwitch", switch.Switch)
+EngineeringModeSwitch = ld2410_ns.class_("EngineeringModeSwitch", switch.Switch)
+
+CONF_ENGINEERING_MODE = "engineering_mode"
+CONF_BLUETOOTH = "bluetooth"
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
+    cv.Optional(CONF_ENGINEERING_MODE): switch.switch_schema(
+        EngineeringModeSwitch,
+        device_class=DEVICE_CLASS_SWITCH,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_PULSE,
+    ),
+    cv.Optional(CONF_BLUETOOTH): switch.switch_schema(
+        BluetoothSwitch,
+        device_class=DEVICE_CLASS_SWITCH,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_BLUETOOTH,
+    ),
+}
+
+
+async def to_code(config):
+    ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
+    if engineering_mode_config := config.get(CONF_ENGINEERING_MODE):
+        s = await switch.new_switch(engineering_mode_config)
+        await cg.register_parented(s, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_engineering_mode_switch(s))
+    if bluetooth_config := config.get(CONF_BLUETOOTH):
+        s = await switch.new_switch(bluetooth_config)
+        await cg.register_parented(s, config[CONF_LD2410_ID])
+        cg.add(ld2410_component.set_bluetooth_switch(s))
--- a/esphome/components/ld2410/switch/bluetooth_switch.cpp
+++ b/esphome/components/ld2410/switch/bluetooth_switch.cpp
@@ -0,0 +1,12 @@
+#include "bluetooth_switch.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void BluetoothSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_bluetooth(state);
+}
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/switch/bluetooth_switch.h
+++ b/esphome/components/ld2410/switch/bluetooth_switch.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class BluetoothSwitch : public switch_::Switch, public Parented<LD2410Component> {
+ public:
+  BluetoothSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/switch/engineering_mode_switch.cpp
+++ b/esphome/components/ld2410/switch/engineering_mode_switch.cpp
@@ -0,0 +1,12 @@
+#include "engineering_mode_switch.h"
+
+namespace esphome {
+namespace ld2410 {
+
+void EngineeringModeSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_engineering_mode(state);
+}
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/switch/engineering_mode_switch.h
+++ b/esphome/components/ld2410/switch/engineering_mode_switch.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../ld2410.h"
+
+namespace esphome {
+namespace ld2410 {
+
+class EngineeringModeSwitch : public switch_::Switch, public Parented<LD2410Component> {
+ public:
+  EngineeringModeSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ld2410
+}  // namespace esphome
--- a/esphome/components/ld2410/text_sensor.py
+++ b/esphome/components/ld2410/text_sensor.py
@@ -0,0 +1,33 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    CONF_VERSION,
+    CONF_MAC_ADDRESS,
+    ICON_BLUETOOTH,
+    ICON_CHIP,
+)
+from . import CONF_LD2410_ID, LD2410Component
+
+DEPENDENCIES = ["ld2410"]
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
+    cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_CHIP
+    ),
+    cv.Optional(CONF_MAC_ADDRESS): text_sensor.text_sensor_schema(
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_BLUETOOTH
+    ),
+}
+
+
+async def to_code(config):
+    ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
+    if version_config := config.get(CONF_VERSION):
+        sens = await text_sensor.new_text_sensor(version_config)
+        cg.add(ld2410_component.set_version_text_sensor(sens))
+    if mac_address_config := config.get(CONF_MAC_ADDRESS):
+        sens = await text_sensor.new_text_sensor(mac_address_config)
+        cg.add(ld2410_component.set_mac_text_sensor(sens))
--- a/esphome/components/pca9554/pca9554.cpp
+++ b/esphome/components/pca9554/pca9554.cpp
@@ -26,7 +26,7 @@ void PCA9554Component::setup() {
  this->config_mask_ = 0;
  // Invert mask as the part sees a 1 as an input
  this->write_register_(CONFIG_REG, ~this->config_mask_);
-  // All ouputs low
+  // All outputs low
  this->output_mask_ = 0;
  this->write_register_(OUTPUT_REG, this->output_mask_);
  // Read the inputs
@@ -34,6 +34,14 @@ void PCA9554Component::setup() {
  ESP_LOGD(TAG, "Initialization complete. Warning: %d, Error: %d", this->status_has_warning(),
           this->status_has_error());
 }
+
+void PCA9554Component::loop() {
+  // The read_inputs_() method will cache the input values from the chip.
+  this->read_inputs_();
+  // Clear all the previously read flags.
+  this->was_previously_read_ = 0x00;
+}
+
 void PCA9554Component::dump_config() {
  ESP_LOGCONFIG(TAG, "PCA9554:");
  LOG_I2C_DEVICE(this)
@@ -43,7 +51,16 @@ void PCA9554Component::dump_config() {
 }

 bool PCA9554Component::digital_read(uint8_t pin) {
-  this->read_inputs_();
+  // Note: We want to try and avoid doing any I2C bus read transactions here
+  // to conserve I2C bus bandwidth. So what we do is check to see if we
+  // have seen a read during the time esphome is running this loop. If we have,
+  // we do an I2C bus transaction to get the latest value. If we haven't
+  // we return a cached value which was read at the time loop() was called.
+  if (this->was_previously_read_ & (1 << pin))
+    this->read_inputs_();  // Force a read of a new value
+  // Indicate we saw a read request for this pin in case a
+  // read happens later in the same loop.
+  this->was_previously_read_ |= (1 << pin);
  return this->input_mask_ & (1 << pin);
 }

@@ -98,6 +115,10 @@ bool PCA9554Component::write_register_(uint8_t reg, uint8_t value) {

 float PCA9554Component::get_setup_priority() const { return setup_priority::IO; }

+// Run our loop() method very early in the loop, so that we cache read values before
+// before other components call our digital_read() method.
+float PCA9554Component::get_loop_priority() const { return 9.0f; }  // Just after WIFI
+
 void PCA9554GPIOPin::setup() { pin_mode(flags_); }
 void PCA9554GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
 bool PCA9554GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
--- a/esphome/components/pca9554/pca9554.h
+++ b/esphome/components/pca9554/pca9554.h
@@ -13,6 +13,8 @@ class PCA9554Component : public Component, public i2c::I2CDevice {

  /// Check i2c availability and setup masks
  void setup() override;
+  /// Poll for input changes periodically
+  void loop() override;
  /// Helper function to read the value of a pin.
  bool digital_read(uint8_t pin);
  /// Helper function to write the value of a pin.
@@ -22,6 +24,8 @@ class PCA9554Component : public Component, public i2c::I2CDevice {

  float get_setup_priority() const override;

+  float get_loop_priority() const override;
+
  void dump_config() override;

 protected:
@@ -35,6 +39,8 @@ class PCA9554Component : public Component, public i2c::I2CDevice {
  uint8_t output_mask_{0x00};
  /// The state of the actual input pin states - 1 means HIGH, 0 means LOW
  uint8_t input_mask_{0x00};
+  /// Flags to check if read previously during this loop
+  uint8_t was_previously_read_ = {0x00};
  /// Storage for last I2C error seen
  esphome::i2c::ErrorCode last_error_;
 };
--- a/esphome/components/remote_base/init.py
+++ b/esphome/components/remote_base/init.py
@@ -1488,12 +1488,7 @@ MideaData, MideaBinarySensor, MideaTrigger, MideaAction, MideaDumper = declare_p
 MideaAction = ns.class_("MideaAction", RemoteTransmitterActionBase)
 MIDEA_SCHEMA = cv.Schema(
    {
-        cv.Required(CONF_CODE): cv.templatable(
-            cv.All(
-                [cv.Any(cv.hex_uint8_t, cv.uint8_t)],
-                cv.Length(min=5, max=5),
-            )
-        ),
+        cv.Required(CONF_CODE): cv.All([cv.hex_uint8_t], cv.Length(min=5, max=5)),
    }
 )

@@ -1513,18 +1508,11 @@ def midea_dumper(var, config):
    pass


-@register_action(
-    "midea",
-    MideaAction,
-    MIDEA_SCHEMA,
-)
+@register_action("midea", MideaAction, MIDEA_SCHEMA)
 async def midea_action(var, config, args):
-    code_ = config[CONF_CODE]
-    if cg.is_template(code_):
-        template_ = await cg.templatable(code_, args, cg.std_vector.template(cg.uint8))
-        cg.add(var.set_code_template(template_))
-    else:
-        cg.add(var.set_code_static(code_))
+    vec_ = cg.std_vector.template(cg.uint8)
+    template_ = await cg.templatable(config[CONF_CODE], args, vec_, vec_)
+    cg.add(var.set_code(template_))


 # AEHA
@@ -1534,10 +1522,7 @@ AEHAData, AEHABinarySensor, AEHATrigger, AEHAAction, AEHADumper = declare_protoc
 AEHA_SCHEMA = cv.Schema(
    {
        cv.Required(CONF_ADDRESS): cv.hex_uint16_t,
-        cv.Required(CONF_DATA): cv.All(
-            [cv.Any(cv.hex_uint8_t, cv.uint8_t)],
-            cv.Length(min=2, max=35),
-        ),
+        cv.Required(CONF_DATA): cv.All([cv.hex_uint8_t], cv.Length(min=2, max=35)),
    }
 )

@@ -1569,4 +1554,7 @@ def aeha_dumper(var, config):
 async def aeha_action(var, config, args):
    template_ = await cg.templatable(config[CONF_ADDRESS], args, cg.uint16)
    cg.add(var.set_address(template_))
-    cg.add(var.set_data(config[CONF_DATA]))
+    template_ = await cg.templatable(
+        config[CONF_DATA], args, cg.std_vector.template(cg.uint8)
+    )
+    cg.add(var.set_data(template_))
--- a/esphome/components/remote_base/midea_protocol.h
+++ b/esphome/components/remote_base/midea_protocol.h
@@ -1,11 +1,11 @@
 #pragma once

+#include <array>
+#include <vector>
+
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "remote_base.h"
-#include <array>
-#include <utility>
-#include <vector>

 namespace esphome {
 namespace remote_base {
@@ -84,23 +84,12 @@ using MideaDumper = RemoteReceiverDumper<MideaProtocol, MideaData>;

 template<typename... Ts> class MideaAction : public RemoteTransmitterActionBase<Ts...> {
  TEMPLATABLE_VALUE(std::vector<uint8_t>, code)
-  void set_code_static(std::vector<uint8_t> code) { code_static_ = std::move(code); }
-  void set_code_template(std::function<std::vector<uint8_t>(Ts...)> func) { this->code_func_ = func; }

  void encode(RemoteTransmitData *dst, Ts... x) override {
-    MideaData data;
-    if (!this->code_static_.empty()) {
-      data = MideaData(this->code_static_);
-    } else {
-      data = MideaData(this->code_func_(x...));
-    }
+    MideaData data(this->code_.value(x...));
    data.finalize();
    MideaProtocol().encode(dst, data);
  }
-
- protected:
-  std::function<std::vector<uint8_t>(Ts...)> code_func_{};
-  std::vector<uint8_t> code_static_{};
 };

 }  // namespace remote_base
--- a/esphome/components/sml/sml.cpp
+++ b/esphome/components/sml/sml.cpp
@@ -100,14 +100,14 @@ bool check_sml_data(const bytes &buffer) {
  }

  uint16_t crc_received = (buffer.at(buffer.size() - 2) << 8) | buffer.at(buffer.size() - 1);
-  uint16_t crc_calculated = crc16(buffer.data(), buffer.size(), 0x6e23, 0x8408, true, true);
+  uint16_t crc_calculated = crc16(buffer.data(), buffer.size() - 2, 0x6e23, 0x8408, true, true);
  crc_calculated = (crc_calculated >> 8) | (crc_calculated << 8);
  if (crc_received == crc_calculated) {
    ESP_LOGV(TAG, "Checksum verification successful with CRC16/X25.");
    return true;
  }

-  crc_calculated = crc16(buffer.data(), buffer.size(), 0xed50, 0x8408);
+  crc_calculated = crc16(buffer.data(), buffer.size() - 2, 0xed50, 0x8408);
  if (crc_received == crc_calculated) {
    ESP_LOGV(TAG, "Checksum verification successful with CRC16/KERMIT.");
    return true;
--- a/esphome/components/sml/sml_parser.cpp
+++ b/esphome/components/sml/sml_parser.cpp
@@ -88,6 +88,11 @@ uint64_t bytes_to_uint(const bytes &buffer) {
  for (auto const value : buffer) {
    val = (val << 8) + value;
  }
+  // Some smart meters send 24 bit signed integers. Sign extend to 64 bit if the
+  // 24 bit value is negative.
+  if (buffer.size() == 3 && buffer[0] & 0x80) {
+    val |= 0xFFFFFFFFFF000000;
+  }
  return val;
 }

--- a/esphome/components/speaker/speaker.h
+++ b/esphome/components/speaker/speaker.h
@@ -13,8 +13,9 @@ enum State : uint8_t {
 class Speaker {
 public:
  virtual size_t play(const uint8_t *data, size_t length) = 0;
-  virtual size_t play(const std::vector<uint8_t> &data) { return this->play(data.data(), data.size()); }
+  size_t play(const std::vector<uint8_t> &data) { return this->play(data.data(), data.size()); }

+  virtual void start() = 0;
  virtual void stop() = 0;

  bool is_running() const { return this->state_ == STATE_RUNNING; }
--- a/esphome/components/tuya/tuya.cpp
+++ b/esphome/components/tuya/tuya.cpp
@@ -1,9 +1,9 @@
 #include "tuya.h"
 #include "esphome/components/network/util.h"
+#include "esphome/core/gpio.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
-#include "esphome/core/gpio.h"

 #ifdef USE_WIFI
 #include "esphome/components/wifi/wifi_component.h"
@@ -246,14 +246,18 @@ void Tuya::handle_command_(uint8_t command, uint8_t version, const uint8_t *buff
 #ifdef USE_TIME
      if (this->time_id_.has_value()) {
        this->send_local_time_();
-        auto *time_id = *this->time_id_;
-        time_id->add_on_time_sync_callback([this] { this->send_local_time_(); });
-      } else {
+
+        if (!this->time_sync_callback_registered_) {
+          // tuya mcu supports time, so we let them know when our time changed
+          auto *time_id = *this->time_id_;
+          time_id->add_on_time_sync_callback([this] { this->send_local_time_(); });
+          this->time_sync_callback_registered_ = true;
+        }
+      } else
+#endif
+      {
        ESP_LOGW(TAG, "LOCAL_TIME_QUERY is not handled because time is not configured");
      }
-#else
-      ESP_LOGE(TAG, "LOCAL_TIME_QUERY is not handled");
-#endif
      break;
    case TuyaCommandType::VACUUM_MAP_UPLOAD:
      this->send_command_(
--- a/esphome/components/tuya/tuya.h
+++ b/esphome/components/tuya/tuya.h
@@ -130,6 +130,7 @@ class Tuya : public Component, public uart::UARTDevice {
 #ifdef USE_TIME
  void send_local_time_();
  optional<time::RealTimeClock *> time_id_{};
+  bool time_sync_callback_registered_{false};
 #endif
  TuyaInitState init_state_ = TuyaInitState::INIT_HEARTBEAT;
  bool init_failed_{false};
--- a/esphome/components/wifi/wifi_component_esp32_arduino.cpp
+++ b/esphome/components/wifi/wifi_component_esp32_arduino.cpp
@@ -486,7 +486,7 @@ void WiFiComponent::wifi_event_callback_(esphome_wifi_event_id_t event, esphome_
      ESP_LOGV(TAG, "Event: Connected ssid='%s' bssid=" LOG_SECRET("%s") " channel=%u, authmode=%s", buf,
               format_mac_addr(it.bssid).c_str(), it.channel, get_auth_mode_str(it.authmode));
 #if LWIP_IPV6
-      WiFi.enableIpV6();
+      this->set_timeout(100, [] { WiFi.enableIpV6(); });
 #endif /* LWIP_IPV6 */

      break;
--- a/esphome/components/xl9535/xl9535.h
+++ b/esphome/components/xl9535/xl9535.h
@@ -26,7 +26,7 @@ class XL9535Component : public Component, public i2c::I2CDevice {

  void setup() override;
  void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
+  float get_setup_priority() const override { return setup_priority::IO; }
 };

 class XL9535GPIOPin : public GPIOPin {
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -1,6 +1,6 @@
 """Constants used by esphome."""

-__version__ = "2023.8.0-dev"
+__version__ = "2023.8.1"

 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
--- a/esphome/helpers.py
+++ b/esphome/helpers.py
@@ -144,7 +144,14 @@ def resolve_ip_address(host):


 def get_bool_env(var, default=False):
-    return bool(os.getenv(var, default))
+    value = os.getenv(var, default)
+    if isinstance(value, str):
+        value = value.lower()
+        if value in ["1", "true"]:
+            return True
+        if value in ["0", "false"]:
+            return False
+    return bool(value)


 def get_str_env(var, default=None):
--- a/platformio.ini
+++ b/platformio.ini
@@ -39,7 +39,7 @@ lib_deps =
    bblanchon/ArduinoJson@6.18.5           ; json
    wjtje/qr-code-generator-library@1.7.0  ; qr_code
    functionpointer/arduino-MLX90393@1.0.0 ; mlx90393
-    pavlodn/HaierProtocol@0.9.18           ; haier
+    pavlodn/HaierProtocol@0.9.20           ; haier
    ; This is using the repository until a new release is published to PlatformIO
    https://github.com/Sensirion/arduino-gas-index-algorithm.git#3.2.1 ; Sensirion Gas Index Algorithm Arduino Library
 build_flags =
--- a/requirements.txt
+++ b/requirements.txt
@@ -11,7 +11,7 @@ esptool==4.6.2
 click==8.1.6
 esphome-dashboard==20230711.0
 aioesphomeapi==15.0.0
-zeroconf==0.74.0
+zeroconf==0.80.0

 # esp-idf requires this, but doesn't bundle it by default
 # https://github.com/espressif/esp-idf/blob/220590d599e134d7a5e7f1e683cc4550349ffbf8/requirements.txt#L24
--- a/tests/test1.yaml
+++ b/tests/test1.yaml
@@ -170,6 +170,9 @@ mqtt:
                id: uart_0
                data: !lambda |-
                  return {};
+            - bluetooth_password.set:
+                id: my_ld2410
+                password: abcdef
  on_connect:
    - light.turn_on: ${roomname}_lights
    - mqtt.publish:
@@ -1333,16 +1336,64 @@ sensor:
    speed:
      name: "Radiator Pump Speed"
  - platform: ld2410
+    light:
+      name: light
    moving_distance:
      name: "Moving distance (cm)"
    still_distance:
      name: "Still Distance (cm)"
    moving_energy:
-      name: "Move Energy"
+      name: "Move Energy (%)"
    still_energy:
-      name: "Still Energy"
+      name: "Still Energy (%)"
    detection_distance:
-      name: "Distance Detection"
+      name: "Distance Detection (cm)"
+    g0:
+      move_energy:
+        name: g0 move energy
+      still_energy:
+        name: g0 still energy
+    g1:
+      move_energy:
+        name: g1 move energy
+      still_energy:
+        name: g1 still energy
+    g2:
+      move_energy:
+        name: g2 move energy
+      still_energy:
+        name: g2 still energy
+    g3:
+      move_energy:
+        name: g3 move energy
+      still_energy:
+        name: g3 still energy
+    g4:
+      move_energy:
+        name: g4 move energy
+      still_energy:
+        name: g4 still energy
+    g5:
+      move_energy:
+        name: g5 move energy
+      still_energy:
+        name: g5 still energy
+    g6:
+      move_energy:
+        name: g6 move energy
+      still_energy:
+        name: g6 still energy
+    g7:
+      move_energy:
+        name: g7 move energy
+      still_energy:
+        name: g7 still energy
+    g8:
+      move_energy:
+        name: g8 move energy
+      still_energy:
+        name: g8 still energy
+
  - platform: sen21231
    name: "Person Sensor"
    i2c_id: i2c_bus
@@ -1684,6 +1735,8 @@ binary_sensor:
      name: movement
    has_still_target:
      name: still
+    out_pin_presence_status:
+      name: out pin presence status

 pca9685:
  frequency: 500
@@ -2333,6 +2386,8 @@ switch:
          second: !lambda "return 0xB21F98;"
      - remote_transmitter.transmit_midea:
          code: [0xA2, 0x08, 0xFF, 0xFF, 0xFF]
+      - remote_transmitter.transmit_midea:
+          code: !lambda "return {0xA2, 0x08, 0xFF, 0xFF, 0xFF};"
  - platform: gpio
    name: "MCP23S08 Pin #0"
    pin:
@@ -2624,6 +2679,11 @@ switch:
    id: outlet_switch
    optimistic: true
    device_class: outlet
+  - platform: ld2410
+    engineering_mode:
+      name: "control ld2410 engineering mode"
+    bluetooth:
+      name: "control ld2410 bluetooth"

 fan:
  - platform: binary
@@ -3205,6 +3265,11 @@ text_sensor:
    tag_name: OPTARIF
    name: optarif
    teleinfo_id: myteleinfo
+  - platform: ld2410
+    version:
+      name: "presenece sensor version"
+    mac_address:
+      name: "presenece sensor mac address"

 sn74hc595:
  - id: sn74hc595_hub
@@ -3309,6 +3374,61 @@ number:
    step: 1
    max_value: 10
    optimistic: true
+  - platform: ld2410
+    light_threshold:
+      name: light threshold
+    timeout:
+      name: timeout
+    max_move_distance_gate:
+      name: max move distance gate
+    max_still_distance_gate:
+      name: max still distance gate
+    g0:
+      move_threshold:
+        name: g0 move threshold
+      still_threshold:
+        name: g0 still threshold
+    g1:
+      move_threshold:
+        name: g1 move threshold
+      still_threshold:
+        name: g1 still threshold
+    g2:
+      move_threshold:
+        name: g2 move threshold
+      still_threshold:
+        name: g2 still threshold
+    g3:
+      move_threshold:
+        name: g3 move threshold
+      still_threshold:
+        name: g3 still threshold
+    g4:
+      move_threshold:
+        name: g4 move threshold
+      still_threshold:
+        name: g4 still threshold
+    g5:
+      move_threshold:
+        name: g5 move threshold
+      still_threshold:
+        name: g5 still threshold
+    g6:
+      move_threshold:
+        name: g6 move threshold
+      still_threshold:
+        name: g6 still threshold
+    g7:
+      move_threshold:
+        name: g7 move threshold
+      still_threshold:
+        name: g7 still threshold
+    g8:
+      move_threshold:
+        name: g8 move threshold
+      still_threshold:
+        name: g8 still threshold
+

 select:
  - platform: template
@@ -3322,6 +3442,15 @@ select:
  - platform: copy
    source_id: test_select
    name: Test Select Copy
+  - platform: ld2410
+    distance_resolution:
+      name: distance resolution
+    baud_rate:
+      name: baud rate
+    light_function:
+      name: light function
+    out_pin_level:
+      name: out ping level

 qr_code:
  - id: homepage_qr
@@ -3384,19 +3513,17 @@ button:
    name: Midea Power Inverse
    on_press:
      midea_ac.power_toggle:
+  - platform: ld2410
+    factory_reset:
+      name: "factory reset"
+    restart:
+      name: "restart"
+    query_params:
+      name: query params

 ld2410:
  id: my_ld2410
  uart_id: ld2410_uart
-  timeout: 150s
-  max_move_distance: 6m
-  max_still_distance: 0.75m
-  g0_move_threshold: 10
-  g0_still_threshold: 20
-  g2_move_threshold: 20
-  g2_still_threshold: 21
-  g8_move_threshold: 80
-  g8_still_threshold: 81

 lcd_menu:
  display_id: my_lcd_gpio
--- a/tests/test3.yaml
+++ b/tests/test3.yaml
@@ -957,7 +957,7 @@ climate:
      temperature_step: 1 °C
    supported_modes:
    - 'OFF'
-    - AUTO
+    - HEAT_COOL
    - COOL
    - HEAT
    - DRY
--- a/tests/unit_tests/test_helpers.py
+++ b/tests/unit_tests/test_helpers.py
@@ -108,6 +108,10 @@ def test_is_ip_address__valid(value):
        ("FOO", None, False, False),
        ("FOO", None, True, True),
        ("FOO", "", False, False),
+        ("FOO", "False", False, False),
+        ("FOO", "True", False, True),
+        ("FOO", "FALSE", True, False),
+        ("FOO", "fAlSe", True, False),
        ("FOO", "Yes", False, True),
        ("FOO", "123", False, True),
    ),
Author	SHA1	Message	Date
Jesse Hills	8bf112669f	Merge pull request #5273 from esphome/bump-2023.8.1 2023.8.1	2023-08-18 09:09:07 +12:00
Jesse Hills	4278664208	Bump version to 2023.8.1	2023-08-18 08:12:42 +12:00
Jesse Hills	0789657fd5	Change haier from AUTO to HEAT_COOL (#5267 )	2023-08-18 08:12:42 +12:00
Mat931	b566c78f00	Fix checksum calculation for sml (#5271 )	2023-08-18 08:12:42 +12:00
Jesse Hills	a35122231c	Merge pull request #5264 from esphome/bump-2023.8.0 2023.8.0	2023-08-17 16:00:56 +12:00
Jesse Hills	7e4ee32b54	Bump version to 2023.8.0	2023-08-17 14:33:35 +12:00
Jesse Hills	7df80eadcf	Merge pull request #5263 from esphome/bump-2023.8.0b4 2023.8.0b4	2023-08-17 14:30:18 +12:00
Jesse Hills	2aaba1d2b8	Bump version to 2023.8.0b4	2023-08-17 13:04:32 +12:00
dependabot[bot]	7c129a4018	Bump zeroconf from 0.74.0 to 0.80.0 (#5260 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-08-17 13:04:32 +12:00
Jimmy Hedman	cb66ce069e	Add delay before enabling ipv6 (#5256 )	2023-08-17 13:04:31 +12:00
Pierre Gordon	a27e72362a	Add `libfreetype-dev` Debian package for armv7 Docker builds (#5262 )	2023-08-17 13:04:31 +12:00
Jesse Hills	f44e5d3142	Merge pull request #5258 from esphome/bump-2023.8.0b3 2023.8.0b3	2023-08-16 13:25:54 +12:00
Jesse Hills	532163738e	Bump version to 2023.8.0b3	2023-08-16 11:49:08 +12:00
Regev Brody	63fa922547	Add configuration flow abilites to the ld2410 component (#4434 )	2023-08-16 11:49:07 +12:00
Carson Full	48e4cb5ae2	Fix IDFI2CBus::writev ignoring stop parameter (#4840 ) Co-authored-by: Alexander Dimitrov <admin@sharkydog.info>	2023-08-16 11:49:07 +12:00
mulder-fbi	ff8a73c2d1	Fix 24 bit signed integer parsing in sml parser (#5250 )	2023-08-16 11:49:07 +12:00
Sergey Dudanov	afd26c6f1a	rmt_base additional minor changes (#5245 )	2023-08-16 11:49:07 +12:00
MrEditor97	67b06a88b2	Change XL9535 `setup_priority` to IO (#5246 )	2023-08-16 11:49:07 +12:00
Jesse Hills	265e019381	Merge pull request #5244 from esphome/bump-2023.8.0b2 2023.8.0b2	2023-08-14 12:48:17 +12:00
Jesse Hills	560e36a65c	Bump version to 2023.8.0b2	2023-08-14 11:09:49 +12:00
Jesse Hills	b05a3fbb55	Fix duplicate tuya time warning (#5243 )	2023-08-14 11:09:48 +12:00
Kjell Braden	3a899e28dc	tuya: add time sync callback only once to prevent memleak (#5234 )	2023-08-14 11:09:48 +12:00
Pavlo Dudnytskyi	f26238e824	Fixing smartair2 protocol implementation if no Wi-Fi (#5238 )	2023-08-14 11:09:48 +12:00
Sergey Dudanov	3717e34bba	fix midea: undo approved PR#4053 (#5233 )	2023-08-14 11:09:48 +12:00
Steve Rodgers	be6f95d43e	pca9554 cache reads (#5137 )	2023-08-14 11:09:48 +12:00
Pavlo Dudnytskyi	99a765dc06	New features added for Haier integration (#5196 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2023-08-14 11:09:48 +12:00
Jesse Hills	351e7ea16b	Expose start to speaker interface (#5228 )	2023-08-14 11:09:48 +12:00
Samuel Sieb	2fa79a2e2f	fix aeha data template (#5231 ) Co-authored-by: Samuel Sieb <samuel@sieb.net>	2023-08-14 11:09:48 +12:00
Jesse Hills	44a917929d	Read string of bool env and match against well known values (#5232 )	2023-08-14 11:09:48 +12:00
Jesse Hills	21ebc7f95b	Merge pull request #5224 from esphome/bump-2023.8.0b1 2023.8.0b1	2023-08-10 19:17:58 +12:00
Jesse Hills	72e72d7d4b	Fix duplicate	2023-08-10 18:40:13 +12:00
Jesse Hills	02ed2c0ebe	Bump version to 2023.8.0b1	2023-08-10 17:30:26 +12:00
Jesse Hills	0f506ea8eb	Merge branch 'dev' into bump-2023.8.0b1	2023-08-10 17:30:26 +12:00
Jesse Hills	b914d6e305	Merge pull request #5173 from esphome/bump-2023.7.1 2023.7.1	2023-08-01 16:54:20 +12:00
Jesse Hills	956e19be7d	Bump version to 2023.7.1	2023-08-01 12:08:36 +12:00
Maxime Michel	b3d5a4dfdb	Fix graininess & streaks for 7.50inV2alt Waveshare e-paper (#5168 )	2023-08-01 12:08:36 +12:00
Joris S	c63cdae84f	invert min_rssi check (#5150 )	2023-08-01 12:08:36 +12:00
J. Nick Koston	dec044ad8b	Increase maximum number of BLE notifications (#5155 )	2023-08-01 12:08:36 +12:00
PlainTechEnthusiast	2a12ec09fb	update "Can't convert" warning to match others in homeassistant_sensor (#5162 )	2023-08-01 12:08:36 +12:00
cvwillegen	91e920c498	Slightly lower template switch setup priority (#5163 )	2023-08-01 12:08:35 +12:00
Stijn Tintel	9b19c45735	wifi: handle WIFI_REASON_ROAMING reason in event (#5153 )	2023-08-01 12:08:35 +12:00
Keith Burzinski	3843d21dbf	Swap ADC back to use 'int' because C3 (#5151 )	2023-08-01 12:08:35 +12:00
Kuba Szczodrzyński	73db164fb1	Dashboard: use Popen() on Windows (#5110 )	2023-08-01 12:08:35 +12:00
Jesse Hills	ab32dd7420	Merge pull request #5122 from esphome/bump-2023.7.0 2023.7.0	2023-07-19 15:44:34 +12:00
Jesse Hills	2a7aa2fc0d	bump pyyaml to 6.0.1	2023-07-19 14:07:42 +12:00
Jesse Hills	f5e98eb86f	Bump version to 2023.7.0	2023-07-19 12:59:51 +12:00
Jesse Hills	362a19c2e1	Merge pull request #5121 from esphome/bump-2023.7.0b3 2023.7.0b3	2023-07-19 12:40:27 +12:00
Jesse Hills	f4a4956dd4	Bump version to 2023.7.0b3	2023-07-19 11:41:24 +12:00
Jesse Hills	746488cabf	Fix silence detection flag on voice assistant (#5120 )	2023-07-19 11:41:24 +12:00
voed	4449248c6f	[LD2410] Remove baud_rate check (#5112 )	2023-07-19 11:41:24 +12:00
PlainTechEnthusiast	036e14ab7f	Sigma delta fix (#4911 )	2023-07-19 11:41:24 +12:00
Kevin P. Fleming	f840eee1b7	airthings_wave: Silence compiler warnings (#5098 )	2023-07-19 11:41:24 +12:00
bwynants	553132443f	P1 values for capacity tariff in Belgium (#5081 )	2023-07-19 11:41:24 +12:00
Jesse Hills	d20242f589	Merge pull request #5107 from esphome/bump-2023.7.0b2 2023.7.0b2	2023-07-17 10:19:32 +12:00
Jesse Hills	68affce274	Bump version to 2023.7.0b2	2023-07-17 09:29:32 +12:00
Clyde Stubbs	c4b9065749	Add timeout filter (#5104 )	2023-07-17 09:29:32 +12:00
Jesse Hills	d57a5d1793	Remove template switch restore_state (#5106 )	2023-07-17 09:29:32 +12:00
Ilia Sotnikov	74e062fdb3	[Sprinkler] Resume fixes (#5100 )	2023-07-17 09:29:32 +12:00
Pierre-Alexis Ciavaldini	6bdc0c92fe	ESP32 enable ADC2 when wifi is disabled (#4381 ) Co-authored-by: Keith Burzinski <kbx81x@gmail.com>	2023-07-17 09:29:32 +12:00
Jesse Hills	d7945de001	Dont do mqtt ip lookup if `use_address` has ip address (#5096 ) * Dont do mqtt ip lookup id `use_address` is in config * Fix after actually testing =)	2023-07-17 09:29:32 +12:00
Jesse Hills	3ba2a29e54	Merge pull request #5095 from esphome/bump-2023.7.0b1 2023.7.0b1	2023-07-13 10:53:51 +12:00
Jesse Hills	76b438f79c	Bump version to 2023.7.0b1	2023-07-13 09:50:48 +12:00
Jesse Hills	bc14f06a07	Merge branch 'dev' into bump-2023.7.0b1	2023-07-13 09:50:47 +12:00
Jesse Hills	feee075122	Merge pull request #5077 from esphome/bump-2023.6.5 2023.6.5	2023-07-10 13:53:25 +12:00
Jesse Hills	a77cf1beec	Bump version to 2023.6.5	2023-07-10 11:24:49 +12:00
Kevin P. Fleming	d7bfdd0efc	binary_sensor: Validate max_length for on_click/on_double_click (#5068 )	2023-07-10 11:24:49 +12:00
J. Nick Koston	62aee36f82	Fix bulk and single Bluetooth parser coexistence (#5073 )	2023-07-10 11:24:49 +12:00
Jesse Hills	0709367587	Merge pull request #5047 from esphome/bump-2023.6.4 2023.6.4	2023-07-04 14:42:36 +12:00
Jesse Hills	98277f6ceb	Bump version to 2023.6.4	2023-07-04 14:03:58 +12:00
Jesse Hills	8dd509ba53	Update webserver to ea86d81 (#5023 )	2023-07-04 14:03:57 +12:00
J. Nick Koston	8df455f55b	Advertise noise is enabled (#5034 )	2023-07-04 14:03:57 +12:00
Graham Brown	36782f13bf	Add alarm to reserved ids (#5042 )	2023-07-04 14:03:57 +12:00
Sergey Dudanov	e823067a6b	fix template binary_sensor publish_initial_state option (#5033 )	2023-07-04 14:03:57 +12:00
Ryan DeShone	c3ef12d580	[SCD30] Disable negative temperature offset (#4850 )	2023-07-04 14:03:57 +12:00
Jesse Hills	321155eb40	Merge pull request #5020 from esphome/bump-2023.6.3 2023.6.3	2023-06-29 07:26:05 +12:00
Jesse Hills	d34c074b92	Bump version to 2023.6.3	2023-06-28 12:35:16 +12:00
Jesse Hills	abc8e903c1	Add CONFIG_BT_BLE_42_FEATURES_SUPPORTED for ble (#5008 )	2023-06-28 12:35:15 +12:00
F.D.Castel	832ba38f1b	Fixes compressed downloads (#5014 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2023-06-28 12:35:15 +12:00
esphomebot	70de2f5278	Synchronise Device Classes from Home Assistant (#5018 )	2023-06-28 12:35:15 +12:00
Jesse Hills	604d4eec79	Update webserver to 56d73b5 (#5007 )	2023-06-28 12:35:14 +12:00
Jesse Hills	b806eb6a61	Merge pull request #4997 from esphome/bump-2023.6.2 2023.6.2	2023-06-23 22:47:41 +12:00
Jesse Hills	39948db59a	Bump version to 2023.6.2	2023-06-23 17:17:43 +12:00
Jesse Hills	fbfb4e2a73	Fix rp2040 pio tool download (#4994 )	2023-06-23 17:17:43 +12:00
Samuel Sieb	595ac84779	remove unused static declarations (#4993 )	2023-06-23 17:17:43 +12:00
Jesse Hills	746f72a279	Merge pull request #4992 from esphome/bump-2023.6.1 2023.6.1	2023-06-23 08:50:39 +12:00
Jesse Hills	dec6f04499	Bump version to 2023.6.1	2023-06-23 07:34:55 +12:00
Kamil Trzciński	a90d266017	display: fix white screen on binary displays (#4991 )	2023-06-23 07:34:54 +12:00
Jimmy Hedman	df9fcf9850	Make ethernet_info work with esp-idf framework (#4976 )	2023-06-23 07:34:54 +12:00