esphome 2025.2.2__py3-none-any.whl → 2025.3.0b1__py3-none-any.whl

esphome/components/ld2450/ld2450.h

@@ -0,0 +1,234 @@
+#pragma once
+
+#include <iomanip>
+#include <map>
+#include "esphome/components/uart/uart.h"
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/preferences.h"
+#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
+#ifdef USE_BINARY_SENSOR
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
+
+#ifndef M_PI
+#define M_PI 3.14
+#endif
+
+namespace esphome {
+namespace ld2450 {
+
+// Constants
+static const uint8_t DEFAULT_PRESENCE_TIMEOUT = 5;  // Timeout to reset presense status 5 sec.
+static const uint8_t MAX_LINE_LENGTH = 60;          // Max characters for serial buffer
+static const uint8_t MAX_TARGETS = 3;               // Max 3 Targets in LD2450
+static const uint8_t MAX_ZONES = 3;                 // Max 3 Zones in LD2450
+
+// Target coordinate struct
+struct Target {
+  int16_t x;
+  int16_t y;
+  bool is_moving;
+};
+
+// Zone coordinate struct
+struct Zone {
+  int16_t x1 = 0;
+  int16_t y1 = 0;
+  int16_t x2 = 0;
+  int16_t y2 = 0;
+};
+
+#ifdef USE_NUMBER
+struct ZoneOfNumbers {
+  number::Number *x1 = nullptr;
+  number::Number *y1 = nullptr;
+  number::Number *x2 = nullptr;
+  number::Number *y2 = nullptr;
+};
+#endif
+
+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
+};
+
+// Convert baud rate enum to int
+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}};
+
+// Zone type struct
+enum ZoneTypeStructure : uint8_t { ZONE_DISABLED = 0, ZONE_DETECTION = 1, ZONE_FILTER = 2 };
+
+// Convert zone type int to enum
+static const std::map<ZoneTypeStructure, std::string> ZONE_TYPE_INT_TO_ENUM{
+    {ZONE_DISABLED, "Disabled"}, {ZONE_DETECTION, "Detection"}, {ZONE_FILTER, "Filter"}};
+
+// Convert zone type enum to int
+static const std::map<std::string, uint8_t> ZONE_TYPE_ENUM_TO_INT{
+    {"Disabled", ZONE_DISABLED}, {"Detection", ZONE_DETECTION}, {"Filter", ZONE_FILTER}};
+
+// LD2450 serial command header & footer
+static const uint8_t CMD_FRAME_HEADER[4] = {0xFD, 0xFC, 0xFB, 0xFA};
+static const uint8_t CMD_FRAME_END[4] = {0x04, 0x03, 0x02, 0x01};
+
+enum PeriodicDataStructure : uint8_t {
+  TARGET_X = 4,
+  TARGET_Y = 6,
+  TARGET_SPEED = 8,
+  TARGET_RESOLUTION = 10,
+};
+
+enum PeriodicDataValue : uint8_t { HEAD = 0XAA, END = 0x55, CHECK = 0x00 };
+
+enum AckDataStructure : uint8_t { COMMAND = 6, COMMAND_STATUS = 7 };
+
+class LD2450Component : public Component, public uart::UARTDevice {
+#ifdef USE_SENSOR
+  SUB_SENSOR(target_count)
+  SUB_SENSOR(still_target_count)
+  SUB_SENSOR(moving_target_count)
+#endif
+#ifdef USE_BINARY_SENSOR
+  SUB_BINARY_SENSOR(target)
+  SUB_BINARY_SENSOR(moving_target)
+  SUB_BINARY_SENSOR(still_target)
+#endif
+#ifdef USE_TEXT_SENSOR
+  SUB_TEXT_SENSOR(version)
+  SUB_TEXT_SENSOR(mac)
+#endif
+#ifdef USE_SELECT
+  SUB_SELECT(baud_rate)
+  SUB_SELECT(zone_type)
+#endif
+#ifdef USE_SWITCH
+  SUB_SWITCH(bluetooth)
+  SUB_SWITCH(multi_target)
+#endif
+#ifdef USE_BUTTON
+  SUB_BUTTON(reset)
+  SUB_BUTTON(restart)
+#endif
+#ifdef USE_NUMBER
+  SUB_NUMBER(presence_timeout)
+#endif
+
+ public:
+  LD2450Component();
+  void setup() override;
+  void dump_config() override;
+  void loop() override;
+  void set_presence_timeout();
+  void set_throttle(uint16_t value) { this->throttle_ = value; };
+  void read_all_info();
+  void query_zone_info();
+  void restart_and_read_all_info();
+  void set_bluetooth(bool enable);
+  void set_multi_target(bool enable);
+  void set_baud_rate(const std::string &state);
+  void set_zone_type(const std::string &state);
+  void publish_zone_type();
+  void factory_reset();
+#ifdef USE_TEXT_SENSOR
+  void set_direction_text_sensor(uint8_t target, text_sensor::TextSensor *s);
+#endif
+#ifdef USE_NUMBER
+  void set_zone_coordinate(uint8_t zone);
+  void set_zone_numbers(uint8_t zone, number::Number *x1, number::Number *y1, number::Number *x2, number::Number *y2);
+#endif
+#ifdef USE_SENSOR
+  void set_move_x_sensor(uint8_t target, sensor::Sensor *s);
+  void set_move_y_sensor(uint8_t target, sensor::Sensor *s);
+  void set_move_speed_sensor(uint8_t target, sensor::Sensor *s);
+  void set_move_angle_sensor(uint8_t target, sensor::Sensor *s);
+  void set_move_distance_sensor(uint8_t target, sensor::Sensor *s);
+  void set_move_resolution_sensor(uint8_t target, sensor::Sensor *s);
+  void set_zone_target_count_sensor(uint8_t zone, sensor::Sensor *s);
+  void set_zone_still_target_count_sensor(uint8_t zone, sensor::Sensor *s);
+  void set_zone_moving_target_count_sensor(uint8_t zone, sensor::Sensor *s);
+#endif
+  void reset_radar_zone();
+  void set_radar_zone(int32_t zone_type, int32_t zone1_x1, int32_t zone1_y1, int32_t zone1_x2, int32_t zone1_y2,
+                      int32_t zone2_x1, int32_t zone2_y1, int32_t zone2_x2, int32_t zone2_y2, int32_t zone3_x1,
+                      int32_t zone3_y1, int32_t zone3_x2, int32_t zone3_y2);
+
+ 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_(uint8_t *buffer, uint8_t len);
+  bool handle_ack_data_(uint8_t *buffer, uint8_t len);
+  void process_zone_(uint8_t *buffer);
+  void readline_(int readch, uint8_t *buffer, uint8_t len);
+  void get_version_();
+  void get_mac_();
+  void query_target_tracking_mode_();
+  void query_zone_();
+  void restart_();
+  void send_set_zone_command_();
+  void save_to_flash_(float value);
+  float restore_from_flash_();
+  bool get_timeout_status_(uint32_t check_millis);
+  uint8_t count_targets_in_zone_(const Zone &zone, bool is_moving);
+
+  Target target_info_[MAX_TARGETS];
+  Zone zone_config_[MAX_ZONES];
+  uint8_t buffer_pos_ = 0;  // where to resume processing/populating buffer
+  uint8_t buffer_data_[MAX_LINE_LENGTH];
+  uint32_t last_periodic_millis_ = 0;
+  uint32_t presence_millis_ = 0;
+  uint32_t still_presence_millis_ = 0;
+  uint32_t moving_presence_millis_ = 0;
+  uint16_t throttle_ = 0;
+  uint16_t timeout_ = 5;
+  uint8_t zone_type_ = 0;
+  std::string version_{};
+  std::string mac_{};
+#ifdef USE_NUMBER
+  ESPPreferenceObject pref_;  // only used when numbers are in use
+  ZoneOfNumbers zone_numbers_[MAX_ZONES];
+#endif
+#ifdef USE_SENSOR
+  std::vector<sensor::Sensor *> move_x_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
+  std::vector<sensor::Sensor *> move_y_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
+  std::vector<sensor::Sensor *> move_speed_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
+  std::vector<sensor::Sensor *> move_angle_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
+  std::vector<sensor::Sensor *> move_distance_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
+  std::vector<sensor::Sensor *> move_resolution_sensors_ = std::vector<sensor::Sensor *>(MAX_TARGETS);
+  std::vector<sensor::Sensor *> zone_target_count_sensors_ = std::vector<sensor::Sensor *>(MAX_ZONES);
+  std::vector<sensor::Sensor *> zone_still_target_count_sensors_ = std::vector<sensor::Sensor *>(MAX_ZONES);
+  std::vector<sensor::Sensor *> zone_moving_target_count_sensors_ = std::vector<sensor::Sensor *>(MAX_ZONES);
+#endif
+#ifdef USE_TEXT_SENSOR
+  std::vector<text_sensor::TextSensor *> direction_text_sensors_ = std::vector<text_sensor::TextSensor *>(3);
+#endif
+};
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/number/__init__.py

@@ -0,0 +1,121 @@
+import esphome.codegen as cg
+from esphome.components import number
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    DEVICE_CLASS_DISTANCE,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_TIMELAPSE,
+    UNIT_MILLIMETER,
+    UNIT_SECOND,
+)
+
+from .. import CONF_LD2450_ID, LD2450Component, ld2450_ns
+
+CONF_PRESENCE_TIMEOUT = "presence_timeout"
+CONF_X1 = "x1"
+CONF_X2 = "x2"
+CONF_Y1 = "y1"
+CONF_Y2 = "y2"
+ICON_ARROW_BOTTOM_RIGHT = "mdi:arrow-bottom-right"
+ICON_ARROW_BOTTOM_RIGHT_BOLD_BOX_OUTLINE = "mdi:arrow-bottom-right-bold-box-outline"
+ICON_ARROW_TOP_LEFT = "mdi:arrow-top-left"
+ICON_ARROW_TOP_LEFT_BOLD_BOX_OUTLINE = "mdi:arrow-top-left-bold-box-outline"
+MAX_ZONES = 3
+
+PresenceTimeoutNumber = ld2450_ns.class_("PresenceTimeoutNumber", number.Number)
+ZoneCoordinateNumber = ld2450_ns.class_("ZoneCoordinateNumber", number.Number)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
+        cv.Required(CONF_PRESENCE_TIMEOUT): number.number_schema(
+            PresenceTimeoutNumber,
+            unit_of_measurement=UNIT_SECOND,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+            icon=ICON_TIMELAPSE,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"zone_{n + 1}"): cv.Schema(
+            {
+                cv.Required(CONF_X1): number.number_schema(
+                    ZoneCoordinateNumber,
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    entity_category=ENTITY_CATEGORY_CONFIG,
+                    icon=ICON_ARROW_TOP_LEFT_BOLD_BOX_OUTLINE,
+                ),
+                cv.Required(CONF_Y1): number.number_schema(
+                    ZoneCoordinateNumber,
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    entity_category=ENTITY_CATEGORY_CONFIG,
+                    icon=ICON_ARROW_TOP_LEFT,
+                ),
+                cv.Required(CONF_X2): number.number_schema(
+                    ZoneCoordinateNumber,
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    entity_category=ENTITY_CATEGORY_CONFIG,
+                    icon=ICON_ARROW_BOTTOM_RIGHT_BOLD_BOX_OUTLINE,
+                ),
+                cv.Required(CONF_Y2): number.number_schema(
+                    ZoneCoordinateNumber,
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    entity_category=ENTITY_CATEGORY_CONFIG,
+                    icon=ICON_ARROW_BOTTOM_RIGHT,
+                ),
+            }
+        )
+        for n in range(MAX_ZONES)
+    }
+)
+
+
+async def to_code(config):
+    ld2450_component = await cg.get_variable(config[CONF_LD2450_ID])
+    if presence_timeout_config := config.get(CONF_PRESENCE_TIMEOUT):
+        n = await number.new_number(
+            presence_timeout_config,
+            min_value=0,
+            max_value=3600,
+            step=1,
+        )
+        await cg.register_parented(n, config[CONF_LD2450_ID])
+        cg.add(ld2450_component.set_presence_timeout_number(n))
+    for zone_num in range(MAX_ZONES):
+        if zone_conf := config.get(f"zone_{zone_num + 1}"):
+            zone_x1_config = zone_conf.get(CONF_X1)
+            x1 = cg.new_Pvariable(zone_x1_config[CONF_ID], zone_num)
+            await number.register_number(
+                x1, zone_x1_config, min_value=-4860, max_value=4860, step=1
+            )
+            await cg.register_parented(x1, config[CONF_LD2450_ID])
+
+            zone_y1_config = zone_conf.get(CONF_Y1)
+            y1 = cg.new_Pvariable(zone_y1_config[CONF_ID], zone_num)
+            await number.register_number(
+                y1, zone_y1_config, min_value=0, max_value=7560, step=1
+            )
+            await cg.register_parented(y1, config[CONF_LD2450_ID])
+
+            zone_x2_config = zone_conf.get(CONF_X2)
+            x2 = cg.new_Pvariable(zone_x2_config[CONF_ID], zone_num)
+            await number.register_number(
+                x2, zone_x2_config, min_value=-4860, max_value=4860, step=1
+            )
+            await cg.register_parented(x2, config[CONF_LD2450_ID])
+
+            zone_y2_config = zone_conf.get(CONF_Y2)
+            y2 = cg.new_Pvariable(zone_y2_config[CONF_ID], zone_num)
+            await number.register_number(
+                y2, zone_y2_config, min_value=0, max_value=7560, step=1
+            )
+            await cg.register_parented(y2, config[CONF_LD2450_ID])
+
+            cg.add(ld2450_component.set_zone_numbers(zone_num, x1, y1, x2, y2))

esphome/components/ld2450/number/presence_timeout_number.cpp

@@ -0,0 +1,12 @@
+#include "presence_timeout_number.h"
+
+namespace esphome {
+namespace ld2450 {
+
+void PresenceTimeoutNumber::control(float value) {
+  this->publish_state(value);
+  this->parent_->set_presence_timeout();
+}
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/number/presence_timeout_number.h

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

esphome/components/ld2450/number/zone_coordinate_number.cpp

@@ -0,0 +1,14 @@
+#include "zone_coordinate_number.h"
+
+namespace esphome {
+namespace ld2450 {
+
+ZoneCoordinateNumber::ZoneCoordinateNumber(uint8_t zone) : zone_(zone) {}
+
+void ZoneCoordinateNumber::control(float value) {
+  this->publish_state(value);
+  this->parent_->set_zone_coordinate(this->zone_);
+}
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/number/zone_coordinate_number.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "esphome/components/number/number.h"
+#include "../ld2450.h"
+
+namespace esphome {
+namespace ld2450 {
+
+class ZoneCoordinateNumber : public number::Number, public Parented<LD2450Component> {
+ public:
+  ZoneCoordinateNumber(uint8_t zone);
+
+ protected:
+  uint8_t zone_;
+  void control(float value) override;
+};
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/select/__init__.py

@@ -0,0 +1,56 @@
+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_THERMOMETER
+
+from .. import CONF_LD2450_ID, LD2450Component, ld2450_ns
+
+CONF_ZONE_TYPE = "zone_type"
+
+BaudRateSelect = ld2450_ns.class_("BaudRateSelect", select.Select)
+ZoneTypeSelect = ld2450_ns.class_("ZoneTypeSelect", select.Select)
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
+    cv.Optional(CONF_BAUD_RATE): select.select_schema(
+        BaudRateSelect,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_THERMOMETER,
+    ),
+    cv.Optional(CONF_ZONE_TYPE): select.select_schema(
+        ZoneTypeSelect,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_THERMOMETER,
+    ),
+}
+
+
+async def to_code(config):
+    ld2450_component = await cg.get_variable(config[CONF_LD2450_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_LD2450_ID])
+        cg.add(ld2450_component.set_baud_rate_select(s))
+    if zone_type_config := config.get(CONF_ZONE_TYPE):
+        s = await select.new_select(
+            zone_type_config,
+            options=[
+                "Disabled",
+                "Detection",
+                "Filter",
+            ],
+        )
+        await cg.register_parented(s, config[CONF_LD2450_ID])
+        cg.add(ld2450_component.set_zone_type_select(s))

esphome/components/ld2450/select/baud_rate_select.cpp

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

esphome/components/ld2450/select/baud_rate_select.h

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

esphome/components/ld2450/select/zone_type_select.cpp

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

esphome/components/ld2450/select/zone_type_select.h

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