esphome 2025.6.2__py3-none-any.whl → 2025.7.0__py3-none-any.whl

esphome/components/ld2420/ld2420.h

@@ -16,88 +16,19 @@
 #ifdef USE_BUTTON
 #include "esphome/components/button/button.h"
 #endif
-#include <map>
-#include <functional>
 
 namespace esphome {
 namespace ld2420 {
 
-// Local const's
-static const uint16_t REFRESH_RATE_MS = 1000;
-
-// Command sets
-static const uint8_t CMD_ABD_DATA_REPLY_SIZE = 0x04;
-static const uint8_t CMD_ABD_DATA_REPLY_START = 0x0A;
-static const uint16_t CMD_DISABLE_CONF = 0x00FE;
-static const uint16_t CMD_ENABLE_CONF = 0x00FF;
-static const uint8_t CMD_MAX_BYTES = 0x64;
-static const uint16_t CMD_PARM_HIGH_TRESH = 0x0012;
-static const uint16_t CMD_PARM_LOW_TRESH = 0x0021;
-static const uint16_t CMD_PROTOCOL_VER = 0x0002;
-static const uint16_t CMD_READ_ABD_PARAM = 0x0008;
-static const uint16_t CMD_READ_REG_ADDR = 0x0020;
-static const uint16_t CMD_READ_REGISTER = 0x0002;
-static const uint16_t CMD_READ_SERIAL_NUM = 0x0011;
-static const uint16_t CMD_READ_SYS_PARAM = 0x0013;
-static const uint16_t CMD_READ_VERSION = 0x0000;
-static const uint8_t CMD_REG_DATA_REPLY_SIZE = 0x02;
-static const uint16_t CMD_RESTART = 0x0068;
-static const uint16_t CMD_SYSTEM_MODE = 0x0000;
-static const uint16_t CMD_SYSTEM_MODE_GR = 0x0003;
-static const uint16_t CMD_SYSTEM_MODE_MTT = 0x0001;
-static const uint16_t CMD_SYSTEM_MODE_SIMPLE = 0x0064;
-static const uint16_t CMD_SYSTEM_MODE_DEBUG = 0x0000;
-static const uint16_t CMD_SYSTEM_MODE_ENERGY = 0x0004;
-static const uint16_t CMD_SYSTEM_MODE_VS = 0x0002;
-static const uint16_t CMD_WRITE_ABD_PARAM = 0x0007;
-static const uint16_t CMD_WRITE_REGISTER = 0x0001;
-static const uint16_t CMD_WRITE_SYS_PARAM = 0x0012;
-
-static const uint8_t LD2420_ERROR_NONE = 0x00;
-static const uint8_t LD2420_ERROR_TIMEOUT = 0x02;
-static const uint8_t LD2420_ERROR_UNKNOWN = 0x01;
-static const uint8_t LD2420_TOTAL_GATES = 16;
 static const uint8_t CALIBRATE_SAMPLES = 64;
+static const uint8_t MAX_LINE_LENGTH = 46;  // Max characters for serial buffer
+static const uint8_t TOTAL_GATES = 16;
 
-// Register address values
-static const uint16_t CMD_MIN_GATE_REG = 0x0000;
-static const uint16_t CMD_MAX_GATE_REG = 0x0001;
-static const uint16_t CMD_TIMEOUT_REG = 0x0004;
-static const uint16_t CMD_GATE_MOVE_THRESH[LD2420_TOTAL_GATES] = {0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015,
-                                                                  0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001B,
-                                                                  0x001C, 0x001D, 0x001E, 0x001F};
-static const uint16_t CMD_GATE_STILL_THRESH[LD2420_TOTAL_GATES] = {0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025,
-                                                                   0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B,
-                                                                   0x002C, 0x002D, 0x002E, 0x002F};
-static const uint32_t FACTORY_MOVE_THRESH[LD2420_TOTAL_GATES] = {60000, 30000, 400, 250, 250, 250, 250, 250,
-                                                                 250,   250,   250, 250, 250, 250, 250, 250};
-static const uint32_t FACTORY_STILL_THRESH[LD2420_TOTAL_GATES] = {40000, 20000, 200, 200, 200, 200, 200, 150,
-                                                                  150,   100,   100, 100, 100, 100, 100, 100};
-static const uint16_t FACTORY_TIMEOUT = 120;
-static const uint16_t FACTORY_MIN_GATE = 1;
-static const uint16_t FACTORY_MAX_GATE = 12;
-
-// COMMAND_BYTE Header & Footer
-static const uint8_t CMD_FRAME_COMMAND = 6;
-static const uint8_t CMD_FRAME_DATA_LENGTH = 4;
-static const uint32_t CMD_FRAME_FOOTER = 0x01020304;
-static const uint32_t CMD_FRAME_HEADER = 0xFAFBFCFD;
-static const uint32_t DEBUG_FRAME_FOOTER = 0xFAFBFCFD;
-static const uint32_t DEBUG_FRAME_HEADER = 0x1410BFAA;
-static const uint32_t ENERGY_FRAME_FOOTER = 0xF5F6F7F8;
-static const uint32_t ENERGY_FRAME_HEADER = 0xF1F2F3F4;
-static const uint8_t CMD_FRAME_STATUS = 7;
-static const uint8_t CMD_ERROR_WORD = 8;
-static const uint8_t ENERGY_SENSOR_START = 9;
-static const uint8_t CALIBRATE_REPORT_INTERVAL = 4;
-static const int CALIBRATE_VERSION_MIN = 154;
-static const std::string OP_NORMAL_MODE_STRING = "Normal";
-static const std::string OP_SIMPLE_MODE_STRING = "Simple";
-
-enum OpModeStruct : uint8_t { OP_NORMAL_MODE = 1, OP_CALIBRATE_MODE = 2, OP_SIMPLE_MODE = 3 };
-static const std::map<std::string, uint8_t> OP_MODE_TO_UINT{
-    {"Normal", OP_NORMAL_MODE}, {"Calibrate", OP_CALIBRATE_MODE}, {"Simple", OP_SIMPLE_MODE}};
-static constexpr const char *ERR_MESSAGE[] = {"None", "Unknown", "Timeout"};
+enum OpMode : uint8_t {
+  OP_NORMAL_MODE = 1,
+  OP_CALIBRATE_MODE = 2,
+  OP_SIMPLE_MODE = 3,
+};
 
 class LD2420Listener {
  public:
@@ -109,6 +40,23 @@ class LD2420Listener {
 
 class LD2420Component : public Component, public uart::UARTDevice {
  public:
+  struct CmdFrameT {
+    uint32_t header{0};
+    uint32_t footer{0};
+    uint16_t length{0};
+    uint16_t command{0};
+    uint16_t data_length{0};
+    uint8_t data[18];
+  };
+
+  struct RegConfigT {
+    uint32_t move_thresh[TOTAL_GATES];
+    uint32_t still_thresh[TOTAL_GATES];
+    uint16_t min_gate{0};
+    uint16_t max_gate{0};
+    uint16_t timeout{0};
+  };
+
   void setup() override;
   void dump_config() override;
   void loop() override;
@@ -150,23 +98,6 @@ class LD2420Component : public Component, public uart::UARTDevice {
 #endif
   void register_listener(LD2420Listener *listener) { this->listeners_.push_back(listener); }
 
-  struct CmdFrameT {
-    uint32_t header{0};
-    uint16_t length{0};
-    uint16_t command{0};
-    uint8_t data[18];
-    uint16_t data_length{0};
-    uint32_t footer{0};
-  };
-
-  struct RegConfigT {
-    uint16_t min_gate{0};
-    uint16_t max_gate{0};
-    uint16_t timeout{0};
-    uint32_t move_thresh[LD2420_TOTAL_GATES];
-    uint32_t still_thresh[LD2420_TOTAL_GATES];
-  };
-
   void send_module_restart();
   void restart_module_action();
   void apply_config_action();
@@ -179,23 +110,28 @@ class LD2420Component : public Component, public uart::UARTDevice {
   void set_operating_mode(const std::string &state);
   void auto_calibrate_sensitivity();
   void update_radar_data(uint16_t const *gate_energy, uint8_t sample_number);
-  uint8_t calc_checksum(void *data, size_t size);
+  uint8_t set_config_mode(bool enable);
+  void set_min_max_distances_timeout(uint32_t max_gate_distance, uint32_t min_gate_distance, uint32_t timeout);
+  void set_gate_threshold(uint8_t gate);
+  void set_reg_value(uint16_t reg, uint16_t value);
+  void set_system_mode(uint16_t mode);
+  void ld2420_restart();
 
-  RegConfigT current_config;
-  RegConfigT new_config;
-  int32_t last_periodic_millis = millis();
-  int32_t report_periodic_millis = millis();
-  int32_t monitor_periodic_millis = millis();
-  int32_t last_normal_periodic_millis = millis();
-  bool output_energy_state{false};
-  uint8_t current_operating_mode{OP_NORMAL_MODE};
-  uint16_t radar_data[LD2420_TOTAL_GATES][CALIBRATE_SAMPLES];
-  uint16_t gate_avg[LD2420_TOTAL_GATES];
-  uint16_t gate_peak[LD2420_TOTAL_GATES];
-  uint8_t sample_number_counter{0};
-  uint16_t total_sample_number_counter{0};
   float gate_move_sensitivity_factor{0.5};
   float gate_still_sensitivity_factor{0.5};
+  int32_t last_periodic_millis{0};
+  int32_t report_periodic_millis{0};
+  int32_t monitor_periodic_millis{0};
+  int32_t last_normal_periodic_millis{0};
+  uint16_t radar_data[TOTAL_GATES][CALIBRATE_SAMPLES];
+  uint16_t gate_avg[TOTAL_GATES];
+  uint16_t gate_peak[TOTAL_GATES];
+  uint16_t total_sample_number_counter{0};
+  uint8_t current_operating_mode{OP_NORMAL_MODE};
+  uint8_t sample_number_counter{0};
+  bool output_energy_state{false};
+  RegConfigT current_config;
+  RegConfigT new_config;
 #ifdef USE_SELECT
   select::Select *operating_selector_{nullptr};
 #endif
@@ -205,24 +141,17 @@ class LD2420Component : public Component, public uart::UARTDevice {
   button::Button *restart_module_button_{nullptr};
   button::Button *factory_reset_button_{nullptr};
 #endif
-  void set_min_max_distances_timeout(uint32_t max_gate_distance, uint32_t min_gate_distance, uint32_t timeout);
-  void set_gate_threshold(uint8_t gate);
-  void set_reg_value(uint16_t reg, uint16_t value);
-  uint8_t set_config_mode(bool enable);
-  void set_system_mode(uint16_t mode);
-  void ld2420_restart();
 
  protected:
   struct CmdReplyT {
+    uint32_t data[4];
+    uint16_t error;
     uint8_t command;
     uint8_t status;
-    uint32_t data[4];
     uint8_t length;
-    uint16_t error;
     volatile bool ack;
   };
 
-  int get_firmware_int_(const char *version_string);
   void get_firmware_version_();
   int get_gate_threshold_(uint8_t gate);
   void get_reg_value_(uint16_t reg);
@@ -233,8 +162,6 @@ class LD2420Component : public Component, public uart::UARTDevice {
   void set_presence_(bool presence) { this->presence_ = presence; };
   uint16_t get_distance_() { return this->distance_; };
   void set_distance_(uint16_t distance) { this->distance_ = distance; };
-  bool get_cmd_active_() { return this->cmd_active_; };
-  void set_cmd_active_(bool active) { this->cmd_active_ = active; };
   void handle_simple_mode_(const uint8_t *inbuf, int len);
   void handle_energy_mode_(uint8_t *buffer, int len);
   void handle_ack_data_(uint8_t *buffer, int len);
@@ -253,17 +180,16 @@ class LD2420Component : public Component, public uart::UARTDevice {
   std::vector<number::Number *> gate_move_threshold_numbers_ = std::vector<number::Number *>(16);
 #endif
 
-  uint16_t gate_energy_[LD2420_TOTAL_GATES];
-  CmdReplyT cmd_reply_;
-  uint32_t max_distance_gate_;
-  uint32_t min_distance_gate_;
-  uint16_t system_mode_{CMD_SYSTEM_MODE_ENERGY};
+  uint16_t distance_{0};
+  uint16_t system_mode_;
+  uint16_t gate_energy_[TOTAL_GATES];
+  uint8_t buffer_pos_{0};  // where to resume processing/populating buffer
+  uint8_t buffer_data_[MAX_LINE_LENGTH];
+  char firmware_ver_[8]{"v0.0.0"};
   bool cmd_active_{false};
-  char ld2420_firmware_ver_[8]{"v0.0.0"};
   bool presence_{false};
   bool calibration_{false};
-  uint16_t distance_{0};
-  uint8_t config_checksum_{0};
+  CmdReplyT cmd_reply_;
   std::vector<LD2420Listener *> listeners_{};
 };
 

esphome/components/ld2420/number/__init__.py

@@ -3,6 +3,8 @@ from esphome.components import number
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
+    CONF_MOVE_THRESHOLD,
+    CONF_STILL_THRESHOLD,
     DEVICE_CLASS_DISTANCE,
     ENTITY_CATEGORY_CONFIG,
     ICON_MOTION_SENSOR,
@@ -31,8 +33,6 @@ LD2420StillThresholdNumbers = ld2420_ns.class_(
 )
 CONF_MIN_GATE_DISTANCE = "min_gate_distance"
 CONF_MAX_GATE_DISTANCE = "max_gate_distance"
-CONF_STILL_THRESHOLD = "still_threshold"
-CONF_MOVE_THRESHOLD = "move_threshold"
 CONF_GATE_MOVE_SENSITIVITY = "gate_move_sensitivity"
 CONF_GATE_STILL_SENSITIVITY = "gate_still_sensitivity"
 CONF_GATE_SELECT = "gate_select"

esphome/components/ld2420/number/gate_config_number.cpp

@@ -2,7 +2,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-static const char *const TAG = "LD2420.number";
+static const char *const TAG = "ld2420.number";
 
 namespace esphome {
 namespace ld2420 {

esphome/components/ld2420/select/operating_mode_select.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace ld2420 {
 
-static const char *const TAG = "LD2420.select";
+static const char *const TAG = "ld2420.select";
 
 void LD2420Select::control(const std::string &value) {
   this->publish_state(value);

esphome/components/ld2420/sensor/__init__.py

@@ -1,13 +1,17 @@
 import esphome.codegen as cg
 from esphome.components import sensor
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, DEVICE_CLASS_DISTANCE, UNIT_CENTIMETER
+from esphome.const import (
+    CONF_ID,
+    CONF_MOVING_DISTANCE,
+    DEVICE_CLASS_DISTANCE,
+    UNIT_CENTIMETER,
+)
 
 from .. import CONF_LD2420_ID, LD2420Component, ld2420_ns
 
 LD2420Sensor = ld2420_ns.class_("LD2420Sensor", sensor.Sensor, cg.Component)
 
-CONF_MOVING_DISTANCE = "moving_distance"
 CONF_GATE_ENERGY = "gate_energy"
 
 CONFIG_SCHEMA = cv.All(

esphome/components/ld2420/sensor/ld2420_sensor.cpp

@@ -5,10 +5,10 @@
 namespace esphome {
 namespace ld2420 {
 
-static const char *const TAG = "LD2420.sensor";
+static const char *const TAG = "ld2420.sensor";
 
 void LD2420Sensor::dump_config() {
-  ESP_LOGCONFIG(TAG, "LD2420 Sensor:");
+  ESP_LOGCONFIG(TAG, "Sensor:");
   LOG_SENSOR("  ", "Distance", this->distance_sensor_);
 }
 

esphome/components/ld2420/sensor/ld2420_sensor.h

@@ -27,7 +27,7 @@ class LD2420Sensor : public LD2420Listener, public Component, sensor::Sensor {
 
  protected:
   sensor::Sensor *distance_sensor_{nullptr};
-  std::vector<sensor::Sensor *> energy_sensors_ = std::vector<sensor::Sensor *>(LD2420_TOTAL_GATES);
+  std::vector<sensor::Sensor *> energy_sensors_ = std::vector<sensor::Sensor *>(TOTAL_GATES);
 };
 
 }  // namespace ld2420

esphome/components/ld2420/text_sensor/text_sensor.cpp

@@ -5,10 +5,10 @@
 namespace esphome {
 namespace ld2420 {
 
-static const char *const TAG = "LD2420.text_sensor";
+static const char *const TAG = "ld2420.text_sensor";
 
 void LD2420TextSensor::dump_config() {
-  ESP_LOGCONFIG(TAG, "LD2420 TextSensor:");
+  ESP_LOGCONFIG(TAG, "Text Sensor:");
   LOG_TEXT_SENSOR("  ", "Firmware", this->fw_version_text_sensor_);
 }
 

esphome/components/ld2450/button/__init__.py

@@ -13,13 +13,13 @@ from esphome.const import (
 
 from .. import CONF_LD2450_ID, LD2450Component, ld2450_ns
 
-ResetButton = ld2450_ns.class_("ResetButton", button.Button)
+FactoryResetButton = ld2450_ns.class_("FactoryResetButton", button.Button)
 RestartButton = ld2450_ns.class_("RestartButton", button.Button)
 
 CONFIG_SCHEMA = {
     cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
     cv.Optional(CONF_FACTORY_RESET): button.button_schema(
-        ResetButton,
+        FactoryResetButton,
         device_class=DEVICE_CLASS_RESTART,
         entity_category=ENTITY_CATEGORY_CONFIG,
         icon=ICON_RESTART_ALERT,
@@ -38,7 +38,7 @@ async def to_code(config):
     if factory_reset_config := config.get(CONF_FACTORY_RESET):
         b = await button.new_button(factory_reset_config)
         await cg.register_parented(b, config[CONF_LD2450_ID])
-        cg.add(ld2450_component.set_reset_button(b))
+        cg.add(ld2450_component.set_factory_reset_button(b))
     if restart_config := config.get(CONF_RESTART):
         b = await button.new_button(restart_config)
         await cg.register_parented(b, config[CONF_LD2450_ID])

esphome/components/ld2450/button/factory_reset_button.cpp

@@ -0,0 +1,9 @@
+#include "factory_reset_button.h"
+
+namespace esphome {
+namespace ld2450 {
+
+void FactoryResetButton::press_action() { this->parent_->factory_reset(); }
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/button/{reset_button.h → factory_reset_button.h}

@@ -6,9 +6,9 @@
 namespace esphome {
 namespace ld2450 {
 
-class ResetButton : public button::Button, public Parented<LD2450Component> {
+class FactoryResetButton : public button::Button, public Parented<LD2450Component> {
  public:
-  ResetButton() = default;
+  FactoryResetButton() = default;
 
  protected:
   void press_action() override;