[ld24xx] Call the dedup publish methods directly instead of through macros

# Conflicts:
#	esphome/components/ld24xx/ld24xx.h

esphome/components/dfrobot_sen0609/dfrobot_sen0609.cpp

@@ -138,9 +138,9 @@ void DFRobotSEN0609Component::dump_config() {
   LOG_BINARY_SENSOR("  ", "HasTarget", this->has_target_binary_sensor_);
 #endif
 #ifdef USE_SENSOR
-  LOG_SENSOR("  ", "TargetDistance", this->target_distance_sensor_);
-  LOG_SENSOR("  ", "TargetSpeed", this->target_speed_sensor_);
-  LOG_SENSOR("  ", "TargetEnergy", this->target_energy_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "TargetDistance", this->target_distance_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "TargetSpeed", this->target_speed_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "TargetEnergy", this->target_energy_sensor_);
 #endif
 #ifdef USE_TEXT_SENSOR
   LOG_TEXT_SENSOR("  ", "Version", this->version_text_sensor_);
@@ -330,17 +330,18 @@ void DFRobotSEN0609Component::log_bad_frame_(const LogString *problem, const cha
 }
 
 #ifdef USE_SENSOR
-static void publish_deduplicated(sensor::Sensor *sens, Deduplicator<float> &dedup, float value) {
-  if (sens == nullptr)
-    return;
-  if (std::isnan(value) ? dedup.next_unknown() : dedup.next(value))
-    sens->publish_state(value);
+static void publish_deduplicated(sensor::SensorWithDedup<float> &sens, float value) {
+  if (std::isnan(value)) {
+    sens.publish_state_unknown();
+  } else {
+    sens.publish_state_if_not_dup(value);
+  }
 }
 
 void DFRobotSEN0609Component::publish_target_(float distance, float speed, float energy) {
-  publish_deduplicated(this->target_distance_sensor_, this->distance_dedup_, distance);
-  publish_deduplicated(this->target_speed_sensor_, this->speed_dedup_, speed);
-  publish_deduplicated(this->target_energy_sensor_, this->energy_dedup_, energy);
+  publish_deduplicated(this->target_distance_sensor_, distance);
+  publish_deduplicated(this->target_speed_sensor_, speed);
+  publish_deduplicated(this->target_energy_sensor_, energy);
 }
 #endif
 

esphome/components/dfrobot_sen0609/dfrobot_sen0609.h

@@ -7,7 +7,7 @@
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif
 #ifdef USE_SENSOR
-#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/sensor/sensor_with_dedup.h"
 #endif
 #ifdef USE_TEXT_SENSOR
 #include "esphome/components/text_sensor/text_sensor.h"
@@ -103,9 +103,9 @@ class DFRobotSEN0609Component final : public Component, public uart::UARTDevice
   SUB_BINARY_SENSOR(has_target)
 #endif
 #ifdef USE_SENSOR
-  SUB_SENSOR(target_distance)
-  SUB_SENSOR(target_speed)
-  SUB_SENSOR(target_energy)
+  SUB_SENSOR_WITH_DEDUP(target_distance, float)
+  SUB_SENSOR_WITH_DEDUP(target_speed, float)
+  SUB_SENSOR_WITH_DEDUP(target_energy, float)
 #endif
 #ifdef USE_TEXT_SENSOR
   SUB_TEXT_SENSOR(version)
@@ -175,9 +175,6 @@ class DFRobotSEN0609Component final : public Component, public uart::UARTDevice
 #endif
 #ifdef USE_SENSOR
   void publish_target_(float distance, float speed, float energy);
-  Deduplicator<float> distance_dedup_;
-  Deduplicator<float> speed_dedup_;
-  Deduplicator<float> energy_dedup_;
 #endif
 
 #ifdef USE_NUMBER

esphome/components/ld2410/ld2410.cpp

@@ -197,17 +197,17 @@ void LD2410Component::dump_config() {
 #endif
 #ifdef USE_SENSOR
   ESP_LOGCONFIG(TAG, "Sensors:");
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "Light", this->light_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "DetectionDistance", this->detection_distance_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "MovingTargetDistance", this->moving_target_distance_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "MovingTargetEnergy", this->moving_target_energy_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "StillTargetDistance", this->still_target_distance_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "StillTargetEnergy", this->still_target_energy_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "Light", this->light_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "DetectionDistance", this->detection_distance_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "MovingTargetDistance", this->moving_target_distance_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "MovingTargetEnergy", this->moving_target_energy_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "StillTargetDistance", this->still_target_distance_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "StillTargetEnergy", this->still_target_energy_sensor_);
   for (auto &s : this->gate_move_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "GateMove", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "GateMove", s);
   }
   for (auto &s : this->gate_still_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "GateStill", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "GateStill", s);
   }
 #endif
 #ifdef USE_TEXT_SENSOR
@@ -360,14 +360,14 @@ void LD2410Component::handle_periodic_data_() {
     Detect distance: 16~17th bytes
   */
 #ifdef USE_SENSOR
-  SAFE_PUBLISH_SENSOR(this->moving_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]));
-  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY]);
-  SAFE_PUBLISH_SENSOR(this->still_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]));
-  SAFE_PUBLISH_SENSOR(this->still_target_energy_sensor_, this->buffer_data_[STILL_ENERGY]);
-  SAFE_PUBLISH_SENSOR(this->detection_distance_sensor_,
-                      encode_uint16(this->buffer_data_[DETECT_DISTANCE_HIGH], this->buffer_data_[DETECT_DISTANCE_LOW]));
+  this->moving_target_distance_sensor_.publish_state_if_not_dup(
+      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]));
+  this->moving_target_energy_sensor_.publish_state_if_not_dup(this->buffer_data_[MOVING_ENERGY]);
+  this->still_target_distance_sensor_.publish_state_if_not_dup(
+      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]));
+  this->still_target_energy_sensor_.publish_state_if_not_dup(this->buffer_data_[STILL_ENERGY]);
+  this->detection_distance_sensor_.publish_state_if_not_dup(
+      encode_uint16(this->buffer_data_[DETECT_DISTANCE_HIGH], this->buffer_data_[DETECT_DISTANCE_LOW]));
 
   if (engineering_mode) {
     /*
@@ -376,26 +376,26 @@ void LD2410Component::handle_periodic_data_() {
       Moving energy: 20~28th bytes
     */
     for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-      SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i]);
+      this->gate_move_sensors_[i].publish_state_if_not_dup(this->buffer_data_[MOVING_SENSOR_START + i]);
     }
     /*
       Still energy: 29~37th bytes
     */
     for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-      SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i]);
+      this->gate_still_sensors_[i].publish_state_if_not_dup(this->buffer_data_[STILL_SENSOR_START + i]);
     }
     /*
       Light sensor: 38th bytes
     */
-    SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR]);
+    this->light_sensor_.publish_state_if_not_dup(this->buffer_data_[LIGHT_SENSOR]);
   } else {
     for (auto &gate_move_sensor : this->gate_move_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor);
+      gate_move_sensor.publish_state_unknown();
     }
     for (auto &gate_still_sensor : this->gate_still_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor);
+      gate_still_sensor.publish_state_unknown();
     }
-    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_);
+    this->light_sensor_.publish_state_unknown();
   }
 #endif
 #ifdef USE_BINARY_SENSOR

esphome/components/ld2410/ld2410.h

@@ -128,8 +128,8 @@ class LD2410Component final : public Component, public uart::UARTDevice {
   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_{};
+  std::array<sensor::SensorWithDedup<uint8_t>, TOTAL_GATES> gate_move_sensors_{};
+  std::array<sensor::SensorWithDedup<uint8_t>, TOTAL_GATES> gate_still_sensors_{};
 #endif
 };
 

esphome/components/ld2410s/ld2410s.cpp

@@ -79,7 +79,7 @@ void LD2410SComponent::dump_config() {
   LOG_BINARY_SENSOR("  ", "Has Target", this->target_binary_sensor_);
 #endif
 #ifdef USE_SENSOR
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "Distance", this->distance_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "Distance", this->distance_sensor_);
 #endif
 #ifdef USE_LD2410S_VERSION
   LOG_TEXT_SENSOR("  ", "Version", this->version_text_sensor_);
@@ -502,7 +502,7 @@ void LD2410SComponent::publish_target_(bool target, uint16_t distance) {
 #endif
 #ifdef USE_SENSOR
   // The module keeps reporting the last distance after the target left
-  SAFE_PUBLISH_SENSOR(this->distance_sensor_, target ? distance : 0);
+  this->distance_sensor_.publish_state_if_not_dup(target ? distance : 0);
 #endif
 }
 

esphome/components/ld2412/ld2412.cpp

@@ -224,17 +224,17 @@ void LD2412Component::dump_config() {
 #endif
 #ifdef USE_SENSOR
   ESP_LOGCONFIG(TAG, "Sensors:");
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "Light", this->light_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "DetectionDistance", this->detection_distance_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "MovingTargetDistance", this->moving_target_distance_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "MovingTargetEnergy", this->moving_target_energy_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "StillTargetDistance", this->still_target_distance_sensor_);
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "StillTargetEnergy", this->still_target_energy_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "Light", this->light_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "DetectionDistance", this->detection_distance_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "MovingTargetDistance", this->moving_target_distance_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "MovingTargetEnergy", this->moving_target_energy_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "StillTargetDistance", this->still_target_distance_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "StillTargetEnergy", this->still_target_energy_sensor_);
   for (auto &s : this->gate_still_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "GateStill", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "GateStill", s);
   }
   for (auto &s : this->gate_move_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "GateMove", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "GateMove", s);
   }
 #endif
 #ifdef USE_TEXT_SENSOR
@@ -404,12 +404,12 @@ void LD2412Component::handle_periodic_data_() {
     Detect distance: 16~17th bytes
   */
 #ifdef USE_SENSOR
-  SAFE_PUBLISH_SENSOR(this->moving_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]));
-  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY]);
-  SAFE_PUBLISH_SENSOR(this->still_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]));
-  SAFE_PUBLISH_SENSOR(this->still_target_energy_sensor_, this->buffer_data_[STILL_ENERGY]);
+  this->moving_target_distance_sensor_.publish_state_if_not_dup(
+      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]));
+  this->moving_target_energy_sensor_.publish_state_if_not_dup(this->buffer_data_[MOVING_ENERGY]);
+  this->still_target_distance_sensor_.publish_state_if_not_dup(
+      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]));
+  this->still_target_energy_sensor_.publish_state_if_not_dup(this->buffer_data_[STILL_ENERGY]);
   if (this->detection_distance_sensor_.has_sensor()) {
     int new_detect_distance = 0;
     if (target_state != 0x00 && (target_state & MOVE_BITMASK)) {
@@ -431,27 +431,27 @@ void LD2412Component::handle_periodic_data_() {
         Moving energy: 20~28th bytes
       */
       for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-        SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i]);
+        this->gate_move_sensors_[i].publish_state_if_not_dup(this->buffer_data_[MOVING_SENSOR_START + i]);
       }
       /*
         Still energy: 29~37th bytes
       */
       for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-        SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i]);
+        this->gate_still_sensors_[i].publish_state_if_not_dup(this->buffer_data_[STILL_SENSOR_START + i]);
       }
       /*
         Light sensor value
       */
-      SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR]);
+      this->light_sensor_.publish_state_if_not_dup(this->buffer_data_[LIGHT_SENSOR]);
     }
   } else {
     for (auto &gate_move_sensor : this->gate_move_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor);
+      gate_move_sensor.publish_state_unknown();
     }
     for (auto &gate_still_sensor : this->gate_still_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor);
+      gate_still_sensor.publish_state_unknown();
     }
-    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_);
+    this->light_sensor_.publish_state_unknown();
   }
 #endif
   // the radar module won't tell us when it's done, so we just have to keep polling...

esphome/components/ld2412/ld2412.h

@@ -148,8 +148,8 @@ class LD2412Component final : public Component, public uart::UARTDevice {
   GateThresholds gate_still_thresholds_;
 #endif
 #ifdef USE_SENSOR
-  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_move_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_still_sensors_{};
+  std::array<sensor::SensorWithDedup<uint8_t>, TOTAL_GATES> gate_move_sensors_{};
+  std::array<sensor::SensorWithDedup<uint8_t>, TOTAL_GATES> gate_still_sensors_{};
 #endif
 };
 

esphome/components/ld2450/ld2450.cpp

@@ -215,35 +215,35 @@ void LD2450Component::dump_config() {
 #endif
 #ifdef USE_SENSOR
   ESP_LOGCONFIG(TAG, "Sensors:");
-  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_);
+  LOG_SENSOR_WITH_DEDUP("  ", "MovingTargetCount", this->moving_target_count_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "StillTargetCount", this->still_target_count_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "TargetCount", this->target_count_sensor_);
   for (auto &s : this->move_x_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetX", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetX", s);
   }
   for (auto &s : this->move_y_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetY", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetY", s);
   }
   for (auto &s : this->move_angle_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetAngle", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetAngle", s);
   }
   for (auto &s : this->move_distance_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetDistance", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetDistance", s);
   }
   for (auto &s : this->move_resolution_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetResolution", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetResolution", s);
   }
   for (auto &s : this->move_speed_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetSpeed", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetSpeed", s);
   }
   for (auto &s : this->zone_target_count_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "ZoneTargetCount", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "ZoneTargetCount", s);
   }
   for (auto &s : this->zone_moving_target_count_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "ZoneMovingTargetCount", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "ZoneMovingTargetCount", s);
   }
   for (auto &s : this->zone_still_target_count_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "ZoneStillTargetCount", s);
+    LOG_SENSOR_WITH_DEDUP("  ", "ZoneStillTargetCount", s);
   }
 #endif
 #ifdef USE_TEXT_SENSOR
@@ -515,21 +515,21 @@ void LD2450Component::handle_periodic_data_() {
     }
 #ifdef USE_SENSOR
     if (td == 0) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(this->move_x_sensors_[index]);
-      SAFE_PUBLISH_SENSOR_UNKNOWN(this->move_y_sensors_[index]);
-      SAFE_PUBLISH_SENSOR_UNKNOWN(this->move_resolution_sensors_[index]);
-      SAFE_PUBLISH_SENSOR_UNKNOWN(this->move_speed_sensors_[index]);
-      SAFE_PUBLISH_SENSOR_UNKNOWN(this->move_distance_sensors_[index]);
-      SAFE_PUBLISH_SENSOR_UNKNOWN(this->move_angle_sensors_[index]);
+      this->move_x_sensors_[index].publish_state_unknown();
+      this->move_y_sensors_[index].publish_state_unknown();
+      this->move_resolution_sensors_[index].publish_state_unknown();
+      this->move_speed_sensors_[index].publish_state_unknown();
+      this->move_distance_sensors_[index].publish_state_unknown();
+      this->move_angle_sensors_[index].publish_state_unknown();
     } else {
-      SAFE_PUBLISH_SENSOR(this->move_x_sensors_[index], tx);
-      SAFE_PUBLISH_SENSOR(this->move_y_sensors_[index], ty);
-      SAFE_PUBLISH_SENSOR(this->move_resolution_sensors_[index], res);
-      SAFE_PUBLISH_SENSOR(this->move_speed_sensors_[index], ts);
-      SAFE_PUBLISH_SENSOR(this->move_distance_sensors_[index], td);
+      this->move_x_sensors_[index].publish_state_if_not_dup(tx);
+      this->move_y_sensors_[index].publish_state_if_not_dup(ty);
+      this->move_resolution_sensors_[index].publish_state_if_not_dup(res);
+      this->move_speed_sensors_[index].publish_state_if_not_dup(ts);
+      this->move_distance_sensors_[index].publish_state_if_not_dup(td);
       // ANGLE - atan2f computes angle from Y axis directly, no sqrt/division needed
       angle = atan2f(static_cast<float>(-tx), static_cast<float>(ty)) * (180.0f / std::numbers::pi_v<float>);
-      SAFE_PUBLISH_SENSOR(this->move_angle_sensors_[index], angle);
+      this->move_angle_sensors_[index].publish_state_if_not_dup(angle);
     }
 #endif
 #ifdef USE_TEXT_SENSOR
@@ -589,19 +589,19 @@ void LD2450Component::handle_periodic_data_() {
     zone_all_targets = zone_still_targets + zone_moving_targets;
 
     // Publish Still Target Count in Zones
-    SAFE_PUBLISH_SENSOR(this->zone_still_target_count_sensors_[index], zone_still_targets);
+    this->zone_still_target_count_sensors_[index].publish_state_if_not_dup(zone_still_targets);
     // Publish Moving Target Count in Zones
-    SAFE_PUBLISH_SENSOR(this->zone_moving_target_count_sensors_[index], zone_moving_targets);
+    this->zone_moving_target_count_sensors_[index].publish_state_if_not_dup(zone_moving_targets);
     // Publish All Target Count in Zones
-    SAFE_PUBLISH_SENSOR(this->zone_target_count_sensors_[index], zone_all_targets);
+    this->zone_target_count_sensors_[index].publish_state_if_not_dup(zone_all_targets);
   }  // End loop thru zones
 
   // Target Count
-  SAFE_PUBLISH_SENSOR(this->target_count_sensor_, target_count);
+  this->target_count_sensor_.publish_state_if_not_dup(target_count);
   // Still Target Count
-  SAFE_PUBLISH_SENSOR(this->still_target_count_sensor_, still_target_count);
+  this->still_target_count_sensor_.publish_state_if_not_dup(still_target_count);
   // Moving Target Count
-  SAFE_PUBLISH_SENSOR(this->moving_target_count_sensor_, moving_target_count);
+  this->moving_target_count_sensor_.publish_state_if_not_dup(moving_target_count);
 
 #endif
 

esphome/components/ld2450/ld2450.h

@@ -193,15 +193,15 @@ class LD2450Component : public Component, public uart::UARTDevice {
   ZoneOfNumbers zone_numbers_[MAX_ZONES];
 #endif
 #ifdef USE_SENSOR
-  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_x_sensors_{};
-  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_y_sensors_{};
-  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_speed_sensors_{};
-  std::array<SensorWithDedup<float>, MAX_TARGETS> move_angle_sensors_{};
-  std::array<SensorWithDedup<uint16_t>, MAX_TARGETS> move_distance_sensors_{};
-  std::array<SensorWithDedup<uint16_t>, MAX_TARGETS> move_resolution_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_target_count_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_still_target_count_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_moving_target_count_sensors_{};
+  std::array<sensor::SensorWithDedup<int16_t>, MAX_TARGETS> move_x_sensors_{};
+  std::array<sensor::SensorWithDedup<int16_t>, MAX_TARGETS> move_y_sensors_{};
+  std::array<sensor::SensorWithDedup<int16_t>, MAX_TARGETS> move_speed_sensors_{};
+  std::array<sensor::SensorWithDedup<float>, MAX_TARGETS> move_angle_sensors_{};
+  std::array<sensor::SensorWithDedup<uint16_t>, MAX_TARGETS> move_distance_sensors_{};
+  std::array<sensor::SensorWithDedup<uint16_t>, MAX_TARGETS> move_resolution_sensors_{};
+  std::array<sensor::SensorWithDedup<uint8_t>, MAX_ZONES> zone_target_count_sensors_{};
+  std::array<sensor::SensorWithDedup<uint8_t>, MAX_ZONES> zone_still_target_count_sensors_{};
+  std::array<sensor::SensorWithDedup<uint8_t>, MAX_ZONES> zone_moving_target_count_sensors_{};
 #endif
 #ifdef USE_TEXT_SENSOR
   std::array<text_sensor::TextSensor *, MAX_TARGETS> direction_text_sensors_{};

esphome/components/ld2460/ld2460.cpp

@@ -55,12 +55,12 @@ void LD2460Component::dump_config() {
                 : this->installation_mode_ == InstallationMode::INSTALLATION_MODE_TOP ? LOG_STR_LITERAL("top")
                                                                                       : LOG_STR_LITERAL("side"));
 #ifdef USE_SENSOR
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetCount", this->target_count_sensor_);
+  LOG_SENSOR_WITH_DEDUP("  ", "TargetCount", this->target_count_sensor_);
   for (const auto &t : this->target_sensors_) {
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetX", t.x);
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetY", t.y);
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetDistance", t.distance);
-    LOG_SENSOR_WITH_DEDUP_SAFE("  ", "TargetAngle", t.angle);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetX", t.x);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetY", t.y);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetDistance", t.distance);
+    LOG_SENSOR_WITH_DEDUP("  ", "TargetAngle", t.angle);
   }
 #endif
 }
@@ -111,10 +111,10 @@ void LD2460Component::handle_periodic_data_() {
     if (i >= num_targets) {
       t.last_x = INT16_MIN;
       t.last_y = INT16_MIN;
-      SAFE_PUBLISH_SENSOR_UNKNOWN(t.x);
-      SAFE_PUBLISH_SENSOR_UNKNOWN(t.y);
-      SAFE_PUBLISH_SENSOR_UNKNOWN(t.distance);
-      SAFE_PUBLISH_SENSOR_UNKNOWN(t.angle);
+      t.x.publish_state_unknown();
+      t.y.publish_state_unknown();
+      t.distance.publish_state_unknown();
+      t.angle.publish_state_unknown();
       continue;
     }
     const uint8_t *p = &data[7 + i * 4];
@@ -129,10 +129,10 @@ void LD2460Component::handle_periodic_data_() {
     // Coordinates are reported in 0.1 m steps
     float x = raw_x * 0.1f;
     float y = raw_y * 0.1f;
-    SAFE_PUBLISH_SENSOR(t.x, x);
-    SAFE_PUBLISH_SENSOR(t.y, y);
+    t.x.publish_state_if_not_dup(x);
+    t.y.publish_state_if_not_dup(y);
     if (t.distance.has_sensor()) {
-      SAFE_PUBLISH_SENSOR(t.distance, std::sqrt(x * x + y * y));
+      t.distance.publish_state_if_not_dup(std::sqrt(x * x + y * y));
     }
     if (t.angle.has_sensor()) {
       float angle;
@@ -144,10 +144,10 @@ void LD2460Component::handle_periodic_data_() {
       } else {
         angle = std::atan2(x, y) * RADIANS_TO_DEGREES;
       }
-      SAFE_PUBLISH_SENSOR(t.angle, angle);
+      t.angle.publish_state_if_not_dup(angle);
     }
   }
-  SAFE_PUBLISH_SENSOR(this->target_count_sensor_, num_targets);
+  this->target_count_sensor_.publish_state_if_not_dup(num_targets);
 #endif
 
   this->data_callback_.call();

esphome/components/ld2460/ld2460.h

@@ -48,7 +48,7 @@ class LD2460Component : public Component, public uart::UARTDevice {
 #ifdef USE_SENSOR
   // INT16_MIN marks a slot with no published coordinates, so the next report always publishes
   struct TargetSensors {
-    ld24xx::SensorWithDedup<float> x, y, distance, angle;
+    sensor::SensorWithDedup<float> x, y, distance, angle;
     int16_t last_x{INT16_MIN};
     int16_t last_y{INT16_MIN};
   };

esphome/components/ld24xx/ld24xx.h

@@ -10,15 +10,6 @@
 #include "esphome/components/sensor/sensor_with_dedup.h"
 #endif
 
-#define LOG_SENSOR_WITH_DEDUP_SAFE(tag, name, sensor) \
-  if ((sensor).has_sensor()) { \
-    LOG_SENSOR(tag, name, (sensor).get_sensor()); \
-  }
-
-#define SAFE_PUBLISH_SENSOR(sensor, value) (sensor).publish_state_if_not_dup(value)
-
-#define SAFE_PUBLISH_SENSOR_UNKNOWN(sensor) (sensor).publish_state_unknown()
-
 #define highbyte(val) (uint8_t)((val) >> 8)
 #define lowbyte(val) (uint8_t)((val) &0xff)
 
@@ -53,7 +44,4 @@ inline void format_version_str(const uint8_t *version, std::span<char, 20> buffe
            version[2]);
 }
 
-#ifdef USE_SENSOR
-template<typename T> using SensorWithDedup = sensor::SensorWithDedup<T>;
-#endif
 }  // namespace esphome::ld24xx