Merge pull request #5258 from esphome/bump-2023.8.0b3

2023.8.0b3

CODEOWNERS

@@ -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

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 (stop) {
-  if (err != ESP_OK) {
+    err = i2c_master_stop(cmd);
-    ESP_LOGVV(TAG, "TX to %02X master stop failed: %s", address, esp_err_to_name(err));
+    if (err != ESP_OK) {
-    i2c_cmd_link_delete(cmd);
+      ESP_LOGVV(TAG, "TX to %02X master stop failed: %s", address, esp_err_to_name(err));
-    return ERROR_UNKNOWN;
+      i2c_cmd_link_delete(cmd);
+      return ERROR_UNKNOWN;
+    }
   }
   err = i2c_master_cmd_begin(port_, cmd, 20 / portTICK_PERIOD_MS);
   i2c_cmd_link_delete(cmd);

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_STILL_THRESHOLDS = [f"g{x}_still_threshold" for x in range(9)]
-CONF_G0_STILL_THRESHOLD = "g0_still_threshold"
+CONF_MOVE_THRESHOLDS = [f"g{x}_move_threshold" for x in range(9)]
-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"
 
-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(
+    CONFIG_SCHEMA.extend(uart.UART_DEVICE_SCHEMA).extend(cv.COMPONENT_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)
 )
 
 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_throttle(config[CONF_THROTTLE]))
-    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],
-        )
-    )
 
 
 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

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

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:
+    if has_target_config := config.get(CONF_HAS_TARGET):
-        sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_TARGET])
+        sens = await binary_sensor.new_binary_sensor(has_target_config)
-        cg.add(ld2410_component.set_target_sensor(sens))
+        cg.add(ld2410_component.set_target_binary_sensor(sens))
-    if CONF_HAS_MOVING_TARGET in config:
+    if has_moving_target_config := config.get(CONF_HAS_MOVING_TARGET):
-        sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_MOVING_TARGET])
+        sens = await binary_sensor.new_binary_sensor(has_moving_target_config)
-        cg.add(ld2410_component.set_moving_target_sensor(sens))
+        cg.add(ld2410_component.set_moving_target_binary_sensor(sens))
-    if CONF_HAS_STILL_TARGET in config:
+    if has_still_target_config := config.get(CONF_HAS_STILL_TARGET):
-        sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_STILL_TARGET])
+        sens = await binary_sensor.new_binary_sensor(has_still_target_config)
-        cg.add(ld2410_component.set_still_target_sensor(sens))
+        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))

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))

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

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

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

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

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

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

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("  ", "TargetBinarySensor", this->target_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "MovingSensor", this->moving_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "MovingTargetBinarySensor", this->moving_target_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "StillSensor", this->still_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("  ", "LightSensor", this->light_sensor_);
-  LOG_SENSOR("  ", "Still Distance", this->still_target_distance_sensor_);
+  LOG_SENSOR("  ", "MovingTargetDistanceSensor", this->moving_target_distance_sensor_);
-  LOG_SENSOR("  ", "Moving Energy", this->moving_target_energy_sensor_);
+  LOG_SENSOR("  ", "StillTargetDistanceSensor", this->still_target_distance_sensor_);
-  LOG_SENSOR("  ", "Still Energy", this->still_target_energy_sensor_);
+  LOG_SENSOR("  ", "MovingTargetEnergySensor", this->moving_target_energy_sensor_);
-  LOG_SENSOR("  ", "Detection Distance", this->detection_distance_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);
+#ifdef USE_TEXT_SENSOR
-  this->get_version_();
+  LOG_TEXT_SENSOR("  ", "VersionTextSensor", this->version_text_sensor_);
-  this->set_config_mode_(false);
+  LOG_TEXT_SENSOR("  ", "MacTextSensor", this->mac_text_sensor_);
-  ESP_LOGCONFIG(TAG, "  Firmware Version : %u.%u.%u%u%u%u", this->version_[0], this->version_[1], this->version_[2],
+#endif
-                this->version_[3], this->version_[4], this->version_[5]);
+#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->read_all_info();
-  this->set_max_distances_timeout_(this->max_move_distance_, this->max_still_distance_, this->timeout_);
+  ESP_LOGCONFIG(TAG, "Mac Address : %s", const_cast<char *>(this->mac_.c_str()));
-  // Configure Gates sensitivity
+  ESP_LOGCONFIG(TAG, "Firmware Version : %s", const_cast<char *>(this->version_.c_str()));
-  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]);
   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) {
+void LD2410Component::send_command_(uint8_t command, const uint8_t *command_value, int command_value_len) {
-  // lastCommandSuccess->publish_state(false);
+  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) {
+    Data Type: 7th
-    this->moving_binary_sensor_->publish_state(CHECK_BIT(target_state, 0));
+    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) {
+#endif
-    this->still_binary_sensor_->publish_state(CHECK_BIT(target_state, 1));
+#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) {
+const char VERSION_FMT[] = "%u.%02X.%02X%02X%02X%02X";
-  ESP_LOGV(TAG, "Handling ACK DATA for COMMAND");
+
+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],
+      this->version_ = format_version(buffer);
-               buffer[14]);
+      ESP_LOGV(TAG, "FW Version is: %s", const_cast<char *>(this->version_.c_str()));
-      this->version_[0] = buffer[13];
+#ifdef USE_TEXT_SENSOR
-      this->version_[1] = buffer[12];
+      if (this->version_text_sensor_ != nullptr) {
-      this->version_[2] = buffer[17];
+        this->version_text_sensor_->publish_state(this->version_);
-      this->version_[3] = buffer[16];
+      }
-      this->version_[4] = buffer[15];
+#endif
-      this->version_[5] = buffer[14];
+      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
+      std::vector<std::function<void(void)>> updates;
-      // maxMovingDistanceRange->publish_state(buffer[12]);
+      updates.push_back(set_number_value(this->max_move_distance_gate_number_, buffer[12]));
-      // maxStillDistanceRange->publish_state(buffer[13]);
+      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++) {
+      for (std::vector<number::Number *>::size_type i = 0; i != this->gate_still_threshold_numbers_.size(); i++) {
-        moving_sensitivities[i] = buffer[14 + i];
+        updates.push_back(set_number_value(this->gate_still_threshold_numbers_[i], buffer[23 + i]));
-      }
-      for (int i = 0; i < 9; i++) {
-        still_sensitivities[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);
+        if (this->handle_ack_data_(buffer, pos)) {
-        pos = 0;  // Reset position index ready for next time
+          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,
+void LD2410Component::get_light_control_() { this->send_command_(CMD_QUERY_LIGHT_CONTROL, nullptr, 0); }
-                                                 uint16_t timeout) {
+
+#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),
+                       lowbyte(max_moving_distance_gate_range),
-                       highbyte(max_moving_distance_range),
+                       highbyte(max_moving_distance_gate_range),
                        0x00,
                        0x00,
                        0x01,
                        0x00,
-                       lowbyte(max_still_distance_range),
+                       lowbyte(max_still_distance_gate_range),
-                       highbyte(max_still_distance_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,
+  uint8_t value[18] = {0x00, 0x00, lowbyte(gate),   highbyte(gate),   0x00, 0x00,
-                       0x01, 0x00, lowbyte(motionsens), highbyte(motionsens), 0x00, 0x00,
+                       0x01, 0x00, lowbyte(motion), highbyte(motion), 0x00, 0x00,
-                       0x02, 0x00, lowbyte(stillsens),  highbyte(stillsens),  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

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;
-
+  void set_light_out_control();
-#ifdef USE_BINARY_SENSOR
+#ifdef USE_NUMBER
-  void set_target_sensor(binary_sensor::BinarySensor *sens) { this->target_binary_sensor_ = sens; };
+  void set_gate_still_threshold_number(int gate, number::Number *n);
-  void set_moving_target_sensor(binary_sensor::BinarySensor *sens) { this->moving_binary_sensor_ = sens; };
+  void set_gate_move_threshold_number(int gate, number::Number *n);
-  void set_still_target_sensor(binary_sensor::BinarySensor *sens) { this->still_binary_sensor_ = sens; };
+  void set_max_distances_timeout();
+  void set_gate_threshold(uint8_t gate);
 #endif
-
+#ifdef USE_SENSOR
-  void set_timeout(uint16_t value) { this->timeout_ = value; };
+  void set_gate_move_sensor(int gate, sensor::Sensor *s);
-  void set_max_move_distance(uint8_t value) { this->max_move_distance_ = value; };
+  void set_gate_still_sensor(int gate, sensor::Sensor *s);
-  void set_max_still_distance(uint8_t value) { this->max_still_distance_ = value; };
+#endif
-  void set_range_config(int rg0_move, int rg0_still, int rg1_move, int rg1_still, int rg2_move, int rg2_still,
+  void set_throttle(uint16_t value) { this->throttle_ = value; };
-                        int rg3_move, int rg3_still, int rg4_move, int rg4_still, int rg5_move, int rg5_still,
+  void set_bluetooth_password(const std::string &password);
-                        int rg6_move, int rg6_still, int rg7_move, int rg7_still, int rg8_move, int rg8_still) {
+  void set_engineering_mode(bool enable);
-    this->rg0_move_threshold_ = rg0_move;
+  void read_all_info();
-    this->rg0_still_threshold_ = rg0_still;
+  void restart_and_read_all_info();
-    this->rg1_move_threshold_ = rg1_move;
+  void set_bluetooth(bool enable);
-    this->rg1_still_threshold_ = rg1_still;
+  void set_distance_resolution(const std::string &state);
-    this->rg2_move_threshold_ = rg2_move;
+  void set_baud_rate(const std::string &state);
-    this->rg2_still_threshold_ = rg2_still;
+  void factory_reset();
-    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();
 
  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 send_command_(uint8_t command_str, const 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 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_;
+  int32_t last_periodic_millis_ = millis();
-  uint8_t max_move_distance_;
+  int32_t last_engineering_mode_change_millis_ = millis();
-  uint8_t max_still_distance_;
+  uint16_t throttle_;
-
+  std::string version_;
-  uint8_t version_[6];
+  std::string mac_;
-  uint8_t rg0_move_threshold_, rg0_still_threshold_, rg1_move_threshold_, rg1_still_threshold_, rg2_move_threshold_,
+  std::string out_pin_level_;
-      rg2_still_threshold_, rg3_move_threshold_, rg3_still_threshold_, rg4_move_threshold_, rg4_still_threshold_,
+  std::string light_function_;
-      rg5_move_threshold_, rg5_still_threshold_, rg6_move_threshold_, rg6_still_threshold_, rg7_move_threshold_,
+  float light_threshold_ = -1;
-      rg7_still_threshold_, rg8_move_threshold_, rg8_still_threshold_;
+#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

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))

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

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

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

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

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

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

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))

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

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

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

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

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

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

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 = {
+CONFIG_SCHEMA = cv.Schema(
-    cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
+    {
-    cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
+        cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
-        device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
+        cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
-    ),
+            device_class=DEVICE_CLASS_DISTANCE,
-    cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_CENTIMETER,
-        device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
+            icon=ICON_SIGNAL,
-    ),
+        ),
-    cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
+        cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
-        device_class=DEVICE_CLASS_ENERGY, unit_of_measurement=UNIT_PERCENT
+            device_class=DEVICE_CLASS_DISTANCE,
-    ),
+            unit_of_measurement=UNIT_CENTIMETER,
-    cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
+            icon=ICON_SIGNAL,
-        device_class=DEVICE_CLASS_ENERGY, unit_of_measurement=UNIT_PERCENT
+        ),
-    ),
+        cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-    cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PERCENT,
-        device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
+            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:
+    if moving_distance_config := config.get(CONF_MOVING_DISTANCE):
-        sens = await sensor.new_sensor(config[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:
+    if still_distance_config := config.get(CONF_STILL_DISTANCE):
-        sens = await sensor.new_sensor(config[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:
+    if moving_energy_config := config.get(CONF_MOVING_ENERGY):
-        sens = await sensor.new_sensor(config[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:
+    if still_energy_config := config.get(CONF_STILL_ENERGY):
-        sens = await sensor.new_sensor(config[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:
+    if light_config := config.get(CONF_LIGHT):
-        sens = await sensor.new_sensor(config[CONF_DETECTION_DISTANCE])
+        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))

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))

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

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

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

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

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))

esphome/components/remote_base/__init__.py

@@ -1488,10 +1488,7 @@ MideaData, MideaBinarySensor, MideaTrigger, MideaAction, MideaDumper = declare_p
 MideaAction = ns.class_("MideaAction", RemoteTransmitterActionBase)
 MIDEA_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_CODE): cv.All(
+        cv.Required(CONF_CODE): cv.All([cv.hex_uint8_t], cv.Length(min=5, max=5)),
-            [cv.Any(cv.hex_uint8_t, cv.uint8_t)],
-            cv.Length(min=5, max=5),
-        ),
     }
 )
 
@@ -1511,15 +1508,10 @@ def midea_dumper(var, config):
     pass
 
 
-@register_action(
+@register_action("midea", MideaAction, MIDEA_SCHEMA)
-    "midea",
-    MideaAction,
-    MIDEA_SCHEMA,
-)
 async def midea_action(var, config, args):
-    template_ = await cg.templatable(
+    vec_ = cg.std_vector.template(cg.uint8)
-        config[CONF_CODE], args, cg.std_vector.template(cg.uint8)
+    template_ = await cg.templatable(config[CONF_CODE], args, vec_, vec_)
-    )
     cg.add(var.set_code(template_))
 
 
@@ -1530,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.Required(CONF_DATA): cv.All([cv.hex_uint8_t], cv.Length(min=2, max=35)),
-            [cv.Any(cv.hex_uint8_t, cv.uint8_t)],
-            cv.Length(min=2, max=35),
-        ),
     }
 )
 

esphome/components/remote_base/midea_protocol.h

@@ -84,7 +84,6 @@ using MideaDumper = RemoteReceiverDumper<MideaProtocol, MideaData>;
 
 template<typename... Ts> class MideaAction : public RemoteTransmitterActionBase<Ts...> {
   TEMPLATABLE_VALUE(std::vector<uint8_t>, code)
-  void set_code(std::initializer_list<uint8_t> code) { this->code_ = code; }
 
   void encode(RemoteTransmitData *dst, Ts... x) override {
     MideaData data(this->code_.value(x...));

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;
 }
 

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 {

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2023.8.0b2"
+__version__ = "2023.8.0b3"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

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
@@ -2626,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
@@ -3207,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
@@ -3311,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
@@ -3324,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
@@ -3386,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