esphome 2025.7.4__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

esphome/components/ld2412/ld2412.h

@@ -0,0 +1,141 @@
+#pragma once
+#include "esphome/core/defines.h"
+#include "esphome/core/component.h"
+#ifdef USE_BINARY_SENSOR
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
+#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/ld24xx/ld24xx.h"
+#include "esphome/components/uart/uart.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
+
+#include <array>
+
+namespace esphome {
+namespace ld2412 {
+
+using namespace ld24xx;
+
+static constexpr uint8_t MAX_LINE_LENGTH = 54;  // Max characters for serial buffer
+static constexpr uint8_t TOTAL_GATES = 14;      // Total number of gates supported by the LD2412
+
+class LD2412Component : public Component, public uart::UARTDevice {
+#ifdef USE_BINARY_SENSOR
+  SUB_BINARY_SENSOR(dynamic_background_correction_status)
+  SUB_BINARY_SENSOR(moving_target)
+  SUB_BINARY_SENSOR(still_target)
+  SUB_BINARY_SENSOR(target)
+#endif
+#ifdef USE_SENSOR
+  SUB_SENSOR_WITH_DEDUP(light, uint8_t)
+  SUB_SENSOR_WITH_DEDUP(detection_distance, int)
+  SUB_SENSOR_WITH_DEDUP(moving_target_distance, int)
+  SUB_SENSOR_WITH_DEDUP(moving_target_energy, uint8_t)
+  SUB_SENSOR_WITH_DEDUP(still_target_distance, int)
+  SUB_SENSOR_WITH_DEDUP(still_target_energy, uint8_t)
+#endif
+#ifdef USE_TEXT_SENSOR
+  SUB_TEXT_SENSOR(mac)
+  SUB_TEXT_SENSOR(version)
+#endif
+#ifdef USE_NUMBER
+  SUB_NUMBER(light_threshold)
+  SUB_NUMBER(max_distance_gate)
+  SUB_NUMBER(min_distance_gate)
+  SUB_NUMBER(timeout)
+#endif
+#ifdef USE_SELECT
+  SUB_SELECT(baud_rate)
+  SUB_SELECT(distance_resolution)
+  SUB_SELECT(light_function)
+  SUB_SELECT(out_pin_level)
+#endif
+#ifdef USE_SWITCH
+  SUB_SWITCH(bluetooth)
+  SUB_SWITCH(engineering_mode)
+#endif
+#ifdef USE_BUTTON
+  SUB_BUTTON(factory_reset)
+  SUB_BUTTON(query)
+  SUB_BUTTON(restart)
+  SUB_BUTTON(start_dynamic_background_correction)
+#endif
+
+ public:
+  void setup() override;
+  void dump_config() override;
+  void loop() override;
+  void set_light_out_control();
+  void set_basic_config();
+#ifdef USE_NUMBER
+  void set_gate_move_threshold_number(uint8_t gate, number::Number *n);
+  void set_gate_still_threshold_number(uint8_t gate, number::Number *n);
+  void set_gate_threshold();
+  void get_gate_threshold();
+#endif
+#ifdef USE_SENSOR
+  void set_gate_move_sensor(uint8_t gate, sensor::Sensor *s);
+  void set_gate_still_sensor(uint8_t gate, sensor::Sensor *s);
+#endif
+  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();
+  void start_dynamic_background_correction();
+
+ protected:
+  void send_command_(uint8_t command_str, const uint8_t *command_value, uint8_t command_value_len);
+  void set_config_mode_(bool enable);
+  void handle_periodic_data_();
+  bool handle_ack_data_();
+  void readline_(int readch);
+  void query_parameters_();
+  void get_version_();
+  void get_mac_();
+  void get_distance_resolution_();
+  void query_light_control_();
+  void restart_();
+  void query_dynamic_background_correction_();
+
+  uint8_t light_function_ = 0;
+  uint8_t light_threshold_ = 0;
+  uint8_t out_pin_level_ = 0;
+  uint8_t buffer_pos_ = 0;  // where to resume processing/populating buffer
+  uint8_t buffer_data_[MAX_LINE_LENGTH];
+  uint8_t mac_address_[6] = {0, 0, 0, 0, 0, 0};
+  uint8_t version_[6] = {0, 0, 0, 0, 0, 0};
+  bool bluetooth_on_{false};
+  bool dynamic_background_correction_active_{false};
+#ifdef USE_NUMBER
+  std::array<number::Number *, TOTAL_GATES> gate_move_threshold_numbers_{};
+  std::array<number::Number *, TOTAL_GATES> gate_still_threshold_numbers_{};
+#endif
+#ifdef USE_SENSOR
+  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_move_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_still_sensors_{};
+#endif
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/number/__init__.py

@@ -0,0 +1,126 @@
+import esphome.codegen as cg
+from esphome.components import number
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    CONF_MOVE_THRESHOLD,
+    CONF_STILL_THRESHOLD,
+    CONF_TIMEOUT,
+    DEVICE_CLASS_DISTANCE,
+    DEVICE_CLASS_ILLUMINANCE,
+    DEVICE_CLASS_SIGNAL_STRENGTH,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_LIGHTBULB,
+    ICON_MOTION_SENSOR,
+    ICON_TIMELAPSE,
+    UNIT_PERCENT,
+    UNIT_SECOND,
+)
+
+from .. import CONF_LD2412_ID, LD2412_ns, LD2412Component
+
+GateThresholdNumber = LD2412_ns.class_("GateThresholdNumber", number.Number)
+LightThresholdNumber = LD2412_ns.class_("LightThresholdNumber", number.Number)
+MaxDistanceTimeoutNumber = LD2412_ns.class_("MaxDistanceTimeoutNumber", number.Number)
+
+CONF_LIGHT_THRESHOLD = "light_threshold"
+CONF_MAX_DISTANCE_GATE = "max_distance_gate"
+CONF_MIN_DISTANCE_GATE = "min_distance_gate"
+
+TIMEOUT_GROUP = "timeout"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
+        cv.Optional(CONF_LIGHT_THRESHOLD): number.number_schema(
+            LightThresholdNumber,
+            device_class=DEVICE_CLASS_ILLUMINANCE,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_LIGHTBULB,
+        ),
+        cv.Optional(CONF_MAX_DISTANCE_GATE): number.number_schema(
+            MaxDistanceTimeoutNumber,
+            device_class=DEVICE_CLASS_DISTANCE,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_MOTION_SENSOR,
+        ),
+        cv.Optional(CONF_MIN_DISTANCE_GATE): number.number_schema(
+            MaxDistanceTimeoutNumber,
+            device_class=DEVICE_CLASS_DISTANCE,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_MOTION_SENSOR,
+        ),
+        cv.Optional(CONF_TIMEOUT): number.number_schema(
+            MaxDistanceTimeoutNumber,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_TIMELAPSE,
+            unit_of_measurement=UNIT_SECOND,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"gate_{x}"): (
+            {
+                cv.Required(CONF_MOVE_THRESHOLD): number.number_schema(
+                    GateThresholdNumber,
+                    device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
+                    entity_category=ENTITY_CATEGORY_CONFIG,
+                    icon=ICON_MOTION_SENSOR,
+                    unit_of_measurement=UNIT_PERCENT,
+                ),
+                cv.Required(CONF_STILL_THRESHOLD): number.number_schema(
+                    GateThresholdNumber,
+                    device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
+                    entity_category=ENTITY_CATEGORY_CONFIG,
+                    icon=ICON_MOTION_SENSOR,
+                    unit_of_measurement=UNIT_PERCENT,
+                ),
+            }
+        )
+        for x in range(14)
+    }
+)
+
+
+async def to_code(config):
+    LD2412_component = await cg.get_variable(config[CONF_LD2412_ID])
+    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_LD2412_ID])
+        cg.add(LD2412_component.set_light_threshold_number(n))
+    if max_distance_gate_config := config.get(CONF_MAX_DISTANCE_GATE):
+        n = await number.new_number(
+            max_distance_gate_config, min_value=2, max_value=13, step=1
+        )
+        await cg.register_parented(n, config[CONF_LD2412_ID])
+        cg.add(LD2412_component.set_max_distance_gate_number(n))
+    if min_distance_gate_config := config.get(CONF_MIN_DISTANCE_GATE):
+        n = await number.new_number(
+            min_distance_gate_config, min_value=1, max_value=12, step=1
+        )
+        await cg.register_parented(n, config[CONF_LD2412_ID])
+        cg.add(LD2412_component.set_min_distance_gate_number(n))
+    for x in range(14):
+        if gate_conf := config.get(f"gate_{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_LD2412_ID])
+            cg.add(LD2412_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_LD2412_ID])
+            cg.add(LD2412_component.set_gate_still_threshold_number(x, n))
+    if timeout_config := config.get(CONF_TIMEOUT):
+        n = await number.new_number(timeout_config, min_value=0, max_value=900, step=1)
+        await cg.register_parented(n, config[CONF_LD2412_ID])
+        cg.add(LD2412_component.set_timeout_number(n))

esphome/components/ld2412/number/gate_threshold_number.cpp

@@ -0,0 +1,14 @@
+#include "gate_threshold_number.h"
+
+namespace esphome {
+namespace ld2412 {
+
+GateThresholdNumber::GateThresholdNumber(uint8_t gate) : gate_(gate) {}
+
+void GateThresholdNumber::control(float value) {
+  this->publish_state(value);
+  this->parent_->set_gate_threshold();
+}
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/number/gate_threshold_number.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "../ld2412.h"
+
+namespace esphome {
+namespace ld2412 {
+
+class GateThresholdNumber : public number::Number, public Parented<LD2412Component> {
+ public:
+  GateThresholdNumber(uint8_t gate);
+
+ protected:
+  uint8_t gate_;
+  void control(float value) override;
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/number/light_threshold_number.cpp

@@ -0,0 +1,12 @@
+#include "light_threshold_number.h"
+
+namespace esphome {
+namespace ld2412 {
+
+void LightThresholdNumber::control(float value) {
+  this->publish_state(value);
+  this->parent_->set_light_out_control();
+}
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/number/light_threshold_number.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "../ld2412.h"
+
+namespace esphome {
+namespace ld2412 {
+
+class LightThresholdNumber : public number::Number, public Parented<LD2412Component> {
+ public:
+  LightThresholdNumber() = default;
+
+ protected:
+  void control(float value) override;
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/number/max_distance_timeout_number.cpp

@@ -0,0 +1,12 @@
+#include "max_distance_timeout_number.h"
+
+namespace esphome {
+namespace ld2412 {
+
+void MaxDistanceTimeoutNumber::control(float value) {
+  this->publish_state(value);
+  this->parent_->set_basic_config();
+}
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/number/max_distance_timeout_number.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "../ld2412.h"
+
+namespace esphome {
+namespace ld2412 {
+
+class MaxDistanceTimeoutNumber : public number::Number, public Parented<LD2412Component> {
+ public:
+  MaxDistanceTimeoutNumber() = default;
+
+ protected:
+  void control(float value) override;
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/select/__init__.py

@@ -0,0 +1,82 @@
+import esphome.codegen as cg
+from esphome.components import select
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BAUD_RATE,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_LIGHTBULB,
+    ICON_RULER,
+    ICON_SCALE,
+    ICON_THERMOMETER,
+)
+
+from .. import CONF_LD2412_ID, LD2412_ns, LD2412Component
+
+BaudRateSelect = LD2412_ns.class_("BaudRateSelect", select.Select)
+DistanceResolutionSelect = LD2412_ns.class_("DistanceResolutionSelect", select.Select)
+LightOutControlSelect = LD2412_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_LD2412_ID): cv.use_id(LD2412Component),
+    cv.Optional(CONF_BAUD_RATE): select.select_schema(
+        BaudRateSelect,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_THERMOMETER,
+    ),
+    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,
+    ),
+}
+
+
+async def to_code(config):
+    LD2412_component = await cg.get_variable(config[CONF_LD2412_ID])
+    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_LD2412_ID])
+        cg.add(LD2412_component.set_baud_rate_select(s))
+    if distance_resolution_config := config.get(CONF_DISTANCE_RESOLUTION):
+        s = await select.new_select(
+            distance_resolution_config, options=["0.2m", "0.5m", "0.75m"]
+        )
+        await cg.register_parented(s, config[CONF_LD2412_ID])
+        cg.add(LD2412_component.set_distance_resolution_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_LD2412_ID])
+        cg.add(LD2412_component.set_light_function_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_LD2412_ID])
+        cg.add(LD2412_component.set_out_pin_level_select(s))

esphome/components/ld2412/select/baud_rate_select.cpp

@@ -0,0 +1,12 @@
+#include "baud_rate_select.h"
+
+namespace esphome {
+namespace ld2412 {
+
+void BaudRateSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_baud_rate(state);
+}
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/select/baud_rate_select.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../ld2412.h"
+
+namespace esphome {
+namespace ld2412 {
+
+class BaudRateSelect : public select::Select, public Parented<LD2412Component> {
+ public:
+  BaudRateSelect() = default;
+
+ protected:
+  void control(const std::string &value) override;
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/select/distance_resolution_select.cpp

@@ -0,0 +1,12 @@
+#include "distance_resolution_select.h"
+
+namespace esphome {
+namespace ld2412 {
+
+void DistanceResolutionSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_distance_resolution(state);
+}
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/select/distance_resolution_select.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../ld2412.h"
+
+namespace esphome {
+namespace ld2412 {
+
+class DistanceResolutionSelect : public select::Select, public Parented<LD2412Component> {
+ public:
+  DistanceResolutionSelect() = default;
+
+ protected:
+  void control(const std::string &value) override;
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/select/light_out_control_select.cpp

@@ -0,0 +1,12 @@
+#include "light_out_control_select.h"
+
+namespace esphome {
+namespace ld2412 {
+
+void LightOutControlSelect::control(const std::string &value) {
+  this->publish_state(value);
+  this->parent_->set_light_out_control();
+}
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/select/light_out_control_select.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../ld2412.h"
+
+namespace esphome {
+namespace ld2412 {
+
+class LightOutControlSelect : public select::Select, public Parented<LD2412Component> {
+ public:
+  LightOutControlSelect() = default;
+
+ protected:
+  void control(const std::string &value) override;
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/sensor.py

@@ -0,0 +1,124 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_LIGHT,
+    CONF_MOVING_DISTANCE,
+    DEVICE_CLASS_DISTANCE,
+    DEVICE_CLASS_ILLUMINANCE,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ICON_FLASH,
+    ICON_LIGHTBULB,
+    ICON_MOTION_SENSOR,
+    ICON_SIGNAL,
+    UNIT_CENTIMETER,
+    UNIT_EMPTY,
+    UNIT_PERCENT,
+)
+
+from . import CONF_LD2412_ID, LD2412Component
+
+DEPENDENCIES = ["ld2412"]
+
+CONF_DETECTION_DISTANCE = "detection_distance"
+CONF_MOVE_ENERGY = "move_energy"
+CONF_MOVING_ENERGY = "moving_energy"
+CONF_STILL_DISTANCE = "still_distance"
+CONF_STILL_ENERGY = "still_energy"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
+        cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
+            device_class=DEVICE_CLASS_DISTANCE,
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            icon=ICON_SIGNAL,
+            unit_of_measurement=UNIT_CENTIMETER,
+        ),
+        cv.Optional(CONF_LIGHT): sensor.sensor_schema(
+            device_class=DEVICE_CLASS_ILLUMINANCE,
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            icon=ICON_LIGHTBULB,
+            unit_of_measurement=UNIT_EMPTY,  # No standard unit for this light sensor
+        ),
+        cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
+            device_class=DEVICE_CLASS_DISTANCE,
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            icon=ICON_SIGNAL,
+            unit_of_measurement=UNIT_CENTIMETER,
+        ),
+        cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            icon=ICON_MOTION_SENSOR,
+            unit_of_measurement=UNIT_PERCENT,
+        ),
+        cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
+            device_class=DEVICE_CLASS_DISTANCE,
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            icon=ICON_SIGNAL,
+            unit_of_measurement=UNIT_CENTIMETER,
+        ),
+        cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            icon=ICON_FLASH,
+            unit_of_measurement=UNIT_PERCENT,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"gate_{x}"): (
+            {
+                cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                    filters=[
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                    ],
+                    icon=ICON_MOTION_SENSOR,
+                    unit_of_measurement=UNIT_PERCENT,
+                ),
+                cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                    filters=[
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                    ],
+                    icon=ICON_FLASH,
+                    unit_of_measurement=UNIT_PERCENT,
+                ),
+            }
+        )
+        for x in range(14)
+    }
+)
+
+
+async def to_code(config):
+    LD2412_component = await cg.get_variable(config[CONF_LD2412_ID])
+    if detection_distance_config := config.get(CONF_DETECTION_DISTANCE):
+        sens = await sensor.new_sensor(detection_distance_config)
+        cg.add(LD2412_component.set_detection_distance_sensor(sens))
+    if light_config := config.get(CONF_LIGHT):
+        sens = await sensor.new_sensor(light_config)
+        cg.add(LD2412_component.set_light_sensor(sens))
+    if moving_distance_config := config.get(CONF_MOVING_DISTANCE):
+        sens = await sensor.new_sensor(moving_distance_config)
+        cg.add(LD2412_component.set_moving_target_distance_sensor(sens))
+    if moving_energy_config := config.get(CONF_MOVING_ENERGY):
+        sens = await sensor.new_sensor(moving_energy_config)
+        cg.add(LD2412_component.set_moving_target_energy_sensor(sens))
+    if still_distance_config := config.get(CONF_STILL_DISTANCE):
+        sens = await sensor.new_sensor(still_distance_config)
+        cg.add(LD2412_component.set_still_target_distance_sensor(sens))
+    if still_energy_config := config.get(CONF_STILL_ENERGY):
+        sens = await sensor.new_sensor(still_energy_config)
+        cg.add(LD2412_component.set_still_target_energy_sensor(sens))
+    for x in range(14):
+        if gate_conf := config.get(f"gate_{x}"):
+            if move_config := gate_conf.get(CONF_MOVE_ENERGY):
+                sens = await sensor.new_sensor(move_config)
+                cg.add(LD2412_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(LD2412_component.set_gate_still_sensor(x, sens))