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

esphome/components/ld2412/switch/__init__.py

@@ -0,0 +1,45 @@
+import esphome.codegen as cg
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BLUETOOTH,
+    DEVICE_CLASS_SWITCH,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_BLUETOOTH,
+    ICON_PULSE,
+)
+
+from .. import CONF_LD2412_ID, LD2412_ns, LD2412Component
+
+BluetoothSwitch = LD2412_ns.class_("BluetoothSwitch", switch.Switch)
+EngineeringModeSwitch = LD2412_ns.class_("EngineeringModeSwitch", switch.Switch)
+
+CONF_ENGINEERING_MODE = "engineering_mode"
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
+    cv.Optional(CONF_BLUETOOTH): switch.switch_schema(
+        BluetoothSwitch,
+        device_class=DEVICE_CLASS_SWITCH,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_BLUETOOTH,
+    ),
+    cv.Optional(CONF_ENGINEERING_MODE): switch.switch_schema(
+        EngineeringModeSwitch,
+        device_class=DEVICE_CLASS_SWITCH,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_PULSE,
+    ),
+}
+
+
+async def to_code(config):
+    LD2412_component = await cg.get_variable(config[CONF_LD2412_ID])
+    if bluetooth_config := config.get(CONF_BLUETOOTH):
+        s = await switch.new_switch(bluetooth_config)
+        await cg.register_parented(s, config[CONF_LD2412_ID])
+        cg.add(LD2412_component.set_bluetooth_switch(s))
+    if engineering_mode_config := config.get(CONF_ENGINEERING_MODE):
+        s = await switch.new_switch(engineering_mode_config)
+        await cg.register_parented(s, config[CONF_LD2412_ID])
+        cg.add(LD2412_component.set_engineering_mode_switch(s))

esphome/components/ld2412/switch/bluetooth_switch.cpp

@@ -0,0 +1,12 @@
+#include "bluetooth_switch.h"
+
+namespace esphome {
+namespace ld2412 {
+
+void BluetoothSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_bluetooth(state);
+}
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/switch/bluetooth_switch.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../ld2412.h"
+
+namespace esphome {
+namespace ld2412 {
+
+class BluetoothSwitch : public switch_::Switch, public Parented<LD2412Component> {
+ public:
+  BluetoothSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/switch/engineering_mode_switch.cpp

@@ -0,0 +1,12 @@
+#include "engineering_mode_switch.h"
+
+namespace esphome {
+namespace ld2412 {
+
+void EngineeringModeSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_engineering_mode(state);
+}
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/switch/engineering_mode_switch.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../ld2412.h"
+
+namespace esphome {
+namespace ld2412 {
+
+class EngineeringModeSwitch : public switch_::Switch, public Parented<LD2412Component> {
+ public:
+  EngineeringModeSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ld2412
+}  // namespace esphome

esphome/components/ld2412/text_sensor.py

@@ -0,0 +1,34 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_MAC_ADDRESS,
+    CONF_VERSION,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ICON_BLUETOOTH,
+    ICON_CHIP,
+)
+
+from . import CONF_LD2412_ID, LD2412Component
+
+DEPENDENCIES = ["ld2412"]
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
+    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):
+    LD2412_component = await cg.get_variable(config[CONF_LD2412_ID])
+    if version_config := config.get(CONF_VERSION):
+        sens = await text_sensor.new_text_sensor(version_config)
+        cg.add(LD2412_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(LD2412_component.set_mac_text_sensor(sens))

esphome/components/ld2420/ld2420.cpp

@@ -213,7 +213,6 @@ void LD2420Component::dump_config() {
 }
 
 void LD2420Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->set_config_mode(true) == LD2420_ERROR_TIMEOUT) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->mark_failed();

esphome/components/ld2450/__init__.py

@@ -3,6 +3,7 @@ from esphome.components import uart
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_THROTTLE
 
+AUTO_LOAD = ["ld24xx"]
 DEPENDENCIES = ["uart"]
 CODEOWNERS = ["@hareeshmu"]
 MULTI_CONF = True
@@ -16,9 +17,8 @@ CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(LD2450Component),
-            cv.Optional(CONF_THROTTLE, default="1000ms"): cv.All(
-                cv.positive_time_period_milliseconds,
-                cv.Range(min=cv.TimePeriod(milliseconds=1)),
+            cv.Optional(CONF_THROTTLE): cv.invalid(
+                f"{CONF_THROTTLE} has been removed; use per-sensor filters, instead"
             ),
         }
     )
@@ -45,4 +45,3 @@ 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_throttle(config[CONF_THROTTLE]))

esphome/components/ld2450/binary_sensor.py

@@ -21,14 +21,17 @@ CONFIG_SCHEMA = {
     cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
     cv.Optional(CONF_HAS_TARGET): binary_sensor.binary_sensor_schema(
         device_class=DEVICE_CLASS_OCCUPANCY,
+        filters=[{"settle": cv.TimePeriod(milliseconds=1000)}],
         icon=ICON_SHIELD_ACCOUNT,
     ),
     cv.Optional(CONF_HAS_MOVING_TARGET): binary_sensor.binary_sensor_schema(
         device_class=DEVICE_CLASS_MOTION,
+        filters=[{"settle": cv.TimePeriod(milliseconds=1000)}],
         icon=ICON_TARGET_ACCOUNT,
     ),
     cv.Optional(CONF_HAS_STILL_TARGET): binary_sensor.binary_sensor_schema(
         device_class=DEVICE_CLASS_OCCUPANCY,
+        filters=[{"settle": cv.TimePeriod(milliseconds=1000)}],
         icon=ICON_MEDITATION,
     ),
 }

esphome/components/ld2450/ld2450.cpp

@@ -1,6 +1,5 @@
 #include "ld2450.h"
-#include <utility>
-#include <cmath>
+
 #ifdef USE_NUMBER
 #include "esphome/components/number/number.h"
 #endif
@@ -11,8 +10,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-#define highbyte(val) (uint8_t)((val) >> 8)
-#define lowbyte(val) (uint8_t)((val) &0xff)
+#include <cmath>
+#include <numbers>
 
 namespace esphome {
 namespace ld2450 {
@@ -170,25 +169,19 @@ static inline int16_t hex_to_signed_int(const uint8_t *buffer, uint8_t offset) {
 }
 
 static inline float calculate_angle(float base, float hypotenuse) {
-  if (base < 0.0 || hypotenuse <= 0.0) {
-    return 0.0;
+  if (base < 0.0f || hypotenuse <= 0.0f) {
+    return 0.0f;
   }
-  float angle_radians = std::acos(base / hypotenuse);
-  float angle_degrees = angle_radians * (180.0 / M_PI);
+  float angle_radians = acosf(base / hypotenuse);
+  float angle_degrees = angle_radians * (180.0f / std::numbers::pi_v<float>);
   return angle_degrees;
 }
 
-static bool validate_header_footer(const uint8_t *header_footer, const uint8_t *buffer) {
-  for (uint8_t i = 0; i < HEADER_FOOTER_SIZE; i++) {
-    if (header_footer[i] != buffer[i]) {
-      return false;  // Mismatch in header/footer
-    }
-  }
-  return true;  // Valid header/footer
+static inline bool validate_header_footer(const uint8_t *header_footer, const uint8_t *buffer) {
+  return std::memcmp(header_footer, buffer, HEADER_FOOTER_SIZE) == 0;
 }
 
 void LD2450Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
 #ifdef USE_NUMBER
   if (this->presence_timeout_number_ != nullptr) {
     this->pref_ = global_preferences->make_preference<float>(this->presence_timeout_number_->get_object_id_hash());
@@ -206,9 +199,8 @@ void LD2450Component::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "LD2450:\n"
                 "  Firmware version: %s\n"
-                "  MAC address: %s\n"
-                "  Throttle: %u ms",
-                version.c_str(), mac_str.c_str(), this->throttle_);
+                "  MAC address: %s",
+                version.c_str(), mac_str.c_str());
 #ifdef USE_BINARY_SENSOR
   ESP_LOGCONFIG(TAG, "Binary Sensors:");
   LOG_BINARY_SENSOR("  ", "MovingTarget", this->moving_target_binary_sensor_);
@@ -217,41 +209,41 @@ void LD2450Component::dump_config() {
 #endif
 #ifdef USE_SENSOR
   ESP_LOGCONFIG(TAG, "Sensors:");
-  LOG_SENSOR("  ", "MovingTargetCount", this->moving_target_count_sensor_);
-  LOG_SENSOR("  ", "StillTargetCount", this->still_target_count_sensor_);
-  LOG_SENSOR("  ", "TargetCount", this->target_count_sensor_);
-  for (sensor::Sensor *s : this->move_x_sensors_) {
-    LOG_SENSOR("  ", "TargetX", s);
+  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "MovingTargetCount", this->moving_target_count_sensor_);
+  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "StillTargetCount", this->still_target_count_sensor_);
+  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetCount", this->target_count_sensor_);
+  for (auto &s : this->move_x_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetX", s);
   }
-  for (sensor::Sensor *s : this->move_y_sensors_) {
-    LOG_SENSOR("  ", "TargetY", s);
+  for (auto &s : this->move_y_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetY", s);
   }
-  for (sensor::Sensor *s : this->move_angle_sensors_) {
-    LOG_SENSOR("  ", "TargetAngle", s);
+  for (auto &s : this->move_angle_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetAngle", s);
   }
-  for (sensor::Sensor *s : this->move_distance_sensors_) {
-    LOG_SENSOR("  ", "TargetDistance", s);
+  for (auto &s : this->move_distance_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetDistance", s);
   }
-  for (sensor::Sensor *s : this->move_resolution_sensors_) {
-    LOG_SENSOR("  ", "TargetResolution", s);
+  for (auto &s : this->move_resolution_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetResolution", s);
   }
-  for (sensor::Sensor *s : this->move_speed_sensors_) {
-    LOG_SENSOR("  ", "TargetSpeed", s);
+  for (auto &s : this->move_speed_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetSpeed", s);
   }
-  for (sensor::Sensor *s : this->zone_target_count_sensors_) {
-    LOG_SENSOR("  ", "ZoneTargetCount", s);
+  for (auto &s : this->zone_target_count_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "ZoneTargetCount", s);
   }
-  for (sensor::Sensor *s : this->zone_moving_target_count_sensors_) {
-    LOG_SENSOR("  ", "ZoneMovingTargetCount", s);
+  for (auto &s : this->zone_moving_target_count_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "ZoneMovingTargetCount", s);
   }
-  for (sensor::Sensor *s : this->zone_still_target_count_sensors_) {
-    LOG_SENSOR("  ", "ZoneStillTargetCount", s);
+  for (auto &s : this->zone_still_target_count_sensors_) {
+    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "ZoneStillTargetCount", s);
   }
 #endif
 #ifdef USE_TEXT_SENSOR
   ESP_LOGCONFIG(TAG, "Text Sensors:");
   LOG_TEXT_SENSOR("  ", "Version", this->version_text_sensor_);
-  LOG_TEXT_SENSOR("  ", "Mac", this->mac_text_sensor_);
+  LOG_TEXT_SENSOR("  ", "MAC address", this->mac_text_sensor_);
   for (text_sensor::TextSensor *s : this->direction_text_sensors_) {
     LOG_TEXT_SENSOR("  ", "Direction", s);
   }
@@ -419,30 +411,25 @@ void LD2450Component::send_command_(uint8_t command, const uint8_t *command_valu
   if (command_value != nullptr) {
     len += command_value_len;
   }
-  uint8_t len_cmd[] = {lowbyte(len), highbyte(len), command, 0x00};
+  // 2 length bytes (low, high) + 2 command bytes (low, high)
+  uint8_t len_cmd[] = {len, 0x00, command, 0x00};
   this->write_array(len_cmd, sizeof(len_cmd));
-
   // command value bytes
   if (command_value != nullptr) {
-    for (uint8_t i = 0; i < command_value_len; i++) {
-      this->write_byte(command_value[i]);
-    }
+    this->write_array(command_value, command_value_len);
   }
   // frame footer bytes
   this->write_array(CMD_FRAME_FOOTER, sizeof(CMD_FRAME_FOOTER));
-  // FIXME to remove
-  delay(50);  // NOLINT
+
+  if (command != CMD_ENABLE_CONF && command != CMD_DISABLE_CONF) {
+    delay(50);  // NOLINT
+  }
 }
 
 // LD2450 Radar data message:
 //  [AA FF 03 00] [0E 03 B1 86 10 00 40 01] [00 00 00 00 00 00 00 00] [00 00 00 00 00 00 00 00] [55 CC]
 //   Header       Target 1                  Target 2                  Target 3                  End
 void LD2450Component::handle_periodic_data_() {
-  // Early throttle check - moved before any processing to save CPU cycles
-  if (App.get_loop_component_start_time() - this->last_periodic_millis_ < this->throttle_) {
-    return;
-  }
-
   if (this->buffer_pos_ < 29) {  // header (4 bytes) + 8 x 3 target data + footer (2 bytes)
     ESP_LOGE(TAG, "Invalid length");
     return;
@@ -453,14 +440,12 @@ void LD2450Component::handle_periodic_data_() {
     ESP_LOGE(TAG, "Invalid header/footer");
     return;
   }
-  // Save the timestamp after validating the frame so, if invalid, we'll take the next frame immediately
-  this->last_periodic_millis_ = App.get_loop_component_start_time();
 
   int16_t target_count = 0;
   int16_t still_target_count = 0;
   int16_t moving_target_count = 0;
+  int16_t res = 0;
   int16_t start = 0;
-  int16_t val = 0;
   int16_t tx = 0;
   int16_t ty = 0;
   int16_t td = 0;
@@ -478,85 +463,43 @@ void LD2450Component::handle_periodic_data_() {
     start = TARGET_X + index * 8;
     is_moving = false;
     // tx is used for further calculations, so always needs to be populated
-    val = ld2450::decode_coordinate(this->buffer_data_[start], this->buffer_data_[start + 1]);
-    tx = val;
-    sensor::Sensor *sx = this->move_x_sensors_[index];
-    if (sx != nullptr) {
-      if (this->cached_target_data_[index].x != val) {
-        sx->publish_state(val);
-        this->cached_target_data_[index].x = val;
-      }
-    }
+    tx = ld2450::decode_coordinate(this->buffer_data_[start], this->buffer_data_[start + 1]);
+    SAFE_PUBLISH_SENSOR(this->move_x_sensors_[index], tx);
     // Y
     start = TARGET_Y + index * 8;
-    // ty is used for further calculations, so always needs to be populated
-    val = ld2450::decode_coordinate(this->buffer_data_[start], this->buffer_data_[start + 1]);
-    ty = val;
-    sensor::Sensor *sy = this->move_y_sensors_[index];
-    if (sy != nullptr) {
-      if (this->cached_target_data_[index].y != val) {
-        sy->publish_state(val);
-        this->cached_target_data_[index].y = val;
-      }
-    }
+    ty = ld2450::decode_coordinate(this->buffer_data_[start], this->buffer_data_[start + 1]);
+    SAFE_PUBLISH_SENSOR(this->move_y_sensors_[index], ty);
     // RESOLUTION
     start = TARGET_RESOLUTION + index * 8;
-    sensor::Sensor *sr = this->move_resolution_sensors_[index];
-    if (sr != nullptr) {
-      val = (this->buffer_data_[start + 1] << 8) | this->buffer_data_[start];
-      if (this->cached_target_data_[index].resolution != val) {
-        sr->publish_state(val);
-        this->cached_target_data_[index].resolution = val;
-      }
-    }
+    res = (this->buffer_data_[start + 1] << 8) | this->buffer_data_[start];
+    SAFE_PUBLISH_SENSOR(this->move_resolution_sensors_[index], res);
 #endif
     // SPEED
     start = TARGET_SPEED + index * 8;
-    val = ld2450::decode_speed(this->buffer_data_[start], this->buffer_data_[start + 1]);
-    ts = val;
-    if (val) {
+    ts = ld2450::decode_speed(this->buffer_data_[start], this->buffer_data_[start + 1]);
+    if (ts) {
       is_moving = true;
       moving_target_count++;
     }
 #ifdef USE_SENSOR
-    sensor::Sensor *ss = this->move_speed_sensors_[index];
-    if (ss != nullptr) {
-      if (this->cached_target_data_[index].speed != val) {
-        ss->publish_state(val);
-        this->cached_target_data_[index].speed = val;
-      }
-    }
+    SAFE_PUBLISH_SENSOR(this->move_speed_sensors_[index], ts);
 #endif
     // DISTANCE
     // Optimized: use already decoded tx and ty values, replace pow() with multiplication
     int32_t x_squared = (int32_t) tx * tx;
     int32_t y_squared = (int32_t) ty * ty;
-    val = (uint16_t) sqrt(x_squared + y_squared);
-    td = val;
-    if (val > 0) {
+    td = (uint16_t) sqrtf(x_squared + y_squared);
+    if (td > 0) {
       target_count++;
     }
 #ifdef USE_SENSOR
-    sensor::Sensor *sd = this->move_distance_sensors_[index];
-    if (sd != nullptr) {
-      if (this->cached_target_data_[index].distance != val) {
-        sd->publish_state(val);
-        this->cached_target_data_[index].distance = val;
-      }
-    }
+    SAFE_PUBLISH_SENSOR(this->move_distance_sensors_[index], td);
     // ANGLE
     angle = ld2450::calculate_angle(static_cast<float>(ty), static_cast<float>(td));
     if (tx > 0) {
       angle = angle * -1;
     }
-    sensor::Sensor *sa = this->move_angle_sensors_[index];
-    if (sa != nullptr) {
-      if (std::isnan(this->cached_target_data_[index].angle) ||
-          std::abs(this->cached_target_data_[index].angle - angle) > 0.1f) {
-        sa->publish_state(angle);
-        this->cached_target_data_[index].angle = angle;
-      }
-    }
+    SAFE_PUBLISH_SENSOR(this->move_angle_sensors_[index], angle);
 #endif
 #ifdef USE_TEXT_SENSOR
     // DIRECTION
@@ -570,11 +513,9 @@ void LD2450Component::handle_periodic_data_() {
       direction = DIRECTION_STATIONARY;
     }
     text_sensor::TextSensor *tsd = this->direction_text_sensors_[index];
-    if (tsd != nullptr) {
-      if (this->cached_target_data_[index].direction != direction) {
-        tsd->publish_state(find_str(ld2450::DIRECTION_BY_UINT, direction));
-        this->cached_target_data_[index].direction = direction;
-      }
+    const auto *dir_str = find_str(ld2450::DIRECTION_BY_UINT, direction);
+    if (tsd != nullptr && (!tsd->has_state() || tsd->get_state() != dir_str)) {
+      tsd->publish_state(dir_str);
     }
 #endif
 
@@ -599,53 +540,19 @@ void LD2450Component::handle_periodic_data_() {
     zone_all_targets = zone_still_targets + zone_moving_targets;
 
     // Publish Still Target Count in Zones
-    sensor::Sensor *szstc = this->zone_still_target_count_sensors_[index];
-    if (szstc != nullptr) {
-      if (this->cached_zone_data_[index].still_count != zone_still_targets) {
-        szstc->publish_state(zone_still_targets);
-        this->cached_zone_data_[index].still_count = zone_still_targets;
-      }
-    }
+    SAFE_PUBLISH_SENSOR(this->zone_still_target_count_sensors_[index], zone_still_targets);
     // Publish Moving Target Count in Zones
-    sensor::Sensor *szmtc = this->zone_moving_target_count_sensors_[index];
-    if (szmtc != nullptr) {
-      if (this->cached_zone_data_[index].moving_count != zone_moving_targets) {
-        szmtc->publish_state(zone_moving_targets);
-        this->cached_zone_data_[index].moving_count = zone_moving_targets;
-      }
-    }
+    SAFE_PUBLISH_SENSOR(this->zone_moving_target_count_sensors_[index], zone_moving_targets);
     // Publish All Target Count in Zones
-    sensor::Sensor *sztc = this->zone_target_count_sensors_[index];
-    if (sztc != nullptr) {
-      if (this->cached_zone_data_[index].total_count != zone_all_targets) {
-        sztc->publish_state(zone_all_targets);
-        this->cached_zone_data_[index].total_count = zone_all_targets;
-      }
-    }
-
+    SAFE_PUBLISH_SENSOR(this->zone_target_count_sensors_[index], zone_all_targets);
   }  // End loop thru zones
 
   // Target Count
-  if (this->target_count_sensor_ != nullptr) {
-    if (this->cached_global_data_.target_count != target_count) {
-      this->target_count_sensor_->publish_state(target_count);
-      this->cached_global_data_.target_count = target_count;
-    }
-  }
+  SAFE_PUBLISH_SENSOR(this->target_count_sensor_, target_count);
   // Still Target Count
-  if (this->still_target_count_sensor_ != nullptr) {
-    if (this->cached_global_data_.still_count != still_target_count) {
-      this->still_target_count_sensor_->publish_state(still_target_count);
-      this->cached_global_data_.still_count = still_target_count;
-    }
-  }
+  SAFE_PUBLISH_SENSOR(this->still_target_count_sensor_, still_target_count);
   // Moving Target Count
-  if (this->moving_target_count_sensor_ != nullptr) {
-    if (this->cached_global_data_.moving_count != moving_target_count) {
-      this->moving_target_count_sensor_->publish_state(moving_target_count);
-      this->cached_global_data_.moving_count = moving_target_count;
-    }
-  }
+  SAFE_PUBLISH_SENSOR(this->moving_target_count_sensor_, moving_target_count);
 #endif
 
 #ifdef USE_BINARY_SENSOR
@@ -942,28 +849,33 @@ void LD2450Component::query_target_tracking_mode_() { this->send_command_(CMD_QU
 void LD2450Component::query_zone_() { this->send_command_(CMD_QUERY_ZONE, nullptr, 0); }
 
 #ifdef USE_SENSOR
-void LD2450Component::set_move_x_sensor(uint8_t target, sensor::Sensor *s) { this->move_x_sensors_[target] = s; }
-void LD2450Component::set_move_y_sensor(uint8_t target, sensor::Sensor *s) { this->move_y_sensors_[target] = s; }
+// These could leak memory, but they are only set once prior to 'setup()' and should never be used again.
+void LD2450Component::set_move_x_sensor(uint8_t target, sensor::Sensor *s) {
+  this->move_x_sensors_[target] = new SensorWithDedup<int16_t>(s);
+}
+void LD2450Component::set_move_y_sensor(uint8_t target, sensor::Sensor *s) {
+  this->move_y_sensors_[target] = new SensorWithDedup<int16_t>(s);
+}
 void LD2450Component::set_move_speed_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_speed_sensors_[target] = s;
+  this->move_speed_sensors_[target] = new SensorWithDedup<int16_t>(s);
 }
 void LD2450Component::set_move_angle_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_angle_sensors_[target] = s;
+  this->move_angle_sensors_[target] = new SensorWithDedup<float>(s);
 }
 void LD2450Component::set_move_distance_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_distance_sensors_[target] = s;
+  this->move_distance_sensors_[target] = new SensorWithDedup<uint16_t>(s);
 }
 void LD2450Component::set_move_resolution_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_resolution_sensors_[target] = s;
+  this->move_resolution_sensors_[target] = new SensorWithDedup<uint16_t>(s);
 }
 void LD2450Component::set_zone_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_target_count_sensors_[zone] = s;
+  this->zone_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
 }
 void LD2450Component::set_zone_still_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_still_target_count_sensors_[zone] = s;
+  this->zone_still_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
 }
 void LD2450Component::set_zone_moving_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_moving_target_count_sensors_[zone] = s;
+  this->zone_moving_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
 }
 #endif
 #ifdef USE_TEXT_SENSOR