esphome 2025.7.0b1__py3-none-any.whl → 2025.7.0b3__py3-none-any.whl

esphome/components/esp_ldo/__init__.py

@@ -20,14 +20,16 @@ adjusted_ids = set()
 
 CONFIG_SCHEMA = cv.All(
     cv.ensure_list(
-        {
-            cv.GenerateID(): cv.declare_id(EspLdo),
-            cv.Required(CONF_VOLTAGE): cv.All(
-                cv.voltage, cv.float_range(min=0.5, max=2.7)
-            ),
-            cv.Required(CONF_CHANNEL): cv.one_of(*CHANNELS, int=True),
-            cv.Optional(CONF_ADJUSTABLE, default=False): cv.boolean,
-        }
+        cv.COMPONENT_SCHEMA.extend(
+            {
+                cv.GenerateID(): cv.declare_id(EspLdo),
+                cv.Required(CONF_VOLTAGE): cv.All(
+                    cv.voltage, cv.float_range(min=0.5, max=2.7)
+                ),
+                cv.Required(CONF_CHANNEL): cv.one_of(*CHANNELS, int=True),
+                cv.Optional(CONF_ADJUSTABLE, default=False): cv.boolean,
+            }
+        )
     ),
     cv.only_with_esp_idf,
     only_on_variant(supported=[VARIANT_ESP32P4]),

esphome/components/esp_ldo/esp_ldo.h

@@ -17,6 +17,9 @@ class EspLdo : public Component {
   void set_adjustable(bool adjustable) { this->adjustable_ = adjustable; }
   void set_voltage(float voltage) { this->voltage_ = voltage; }
   void adjust_voltage(float voltage);
+  float get_setup_priority() const override {
+    return setup_priority::BUS;  // LDO setup should be done early
+  }
 
  protected:
   int channel_;

esphome/components/gpio/binary_sensor/__init__.py

@@ -1,11 +1,16 @@
+import logging
+
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import binary_sensor
 import esphome.config_validation as cv
-from esphome.const import CONF_PIN
+from esphome.const import CONF_ID, CONF_NAME, CONF_NUMBER, CONF_PIN
+from esphome.core import CORE
 
 from .. import gpio_ns
 
+_LOGGER = logging.getLogger(__name__)
+
 GPIOBinarySensor = gpio_ns.class_(
     "GPIOBinarySensor", binary_sensor.BinarySensor, cg.Component
 )
@@ -41,6 +46,22 @@ async def to_code(config):
     pin = await cg.gpio_pin_expression(config[CONF_PIN])
     cg.add(var.set_pin(pin))
 
-    cg.add(var.set_use_interrupt(config[CONF_USE_INTERRUPT]))
-    if config[CONF_USE_INTERRUPT]:
+    # Check for ESP8266 GPIO16 interrupt limitation
+    # GPIO16 on ESP8266 is a special pin that doesn't support interrupts through
+    # the Arduino attachInterrupt() function. This is the only known GPIO pin
+    # across all supported platforms that has this limitation, so we handle it
+    # here instead of in the platform-specific code.
+    use_interrupt = config[CONF_USE_INTERRUPT]
+    if use_interrupt and CORE.is_esp8266 and config[CONF_PIN][CONF_NUMBER] == 16:
+        _LOGGER.warning(
+            "GPIO binary_sensor '%s': GPIO16 on ESP8266 doesn't support interrupts. "
+            "Falling back to polling mode (same as in ESPHome <2025.7). "
+            "The sensor will work exactly as before, but other pins have better "
+            "performance with interrupts.",
+            config.get(CONF_NAME, config[CONF_ID]),
+        )
+        use_interrupt = False
+
+    cg.add(var.set_use_interrupt(use_interrupt))
+    if use_interrupt:
         cg.add(var.set_interrupt_type(config[CONF_INTERRUPT_TYPE]))

esphome/components/host/__init__.py

@@ -45,3 +45,4 @@ async def to_code(config):
     cg.add_define("ESPHOME_BOARD", "host")
     cg.add_platformio_option("platform", "platformio/native")
     cg.add_platformio_option("lib_ldf_mode", "off")
+    cg.add_platformio_option("lib_compat_mode", "strict")

esphome/components/i2s_audio/speaker/__init__.py

@@ -180,7 +180,7 @@ async def to_code(config):
     await speaker.register_speaker(var, config)
 
     if config[CONF_DAC_TYPE] == "internal":
-        cg.add(var.set_internal_dac_mode(config[CONF_CHANNEL]))
+        cg.add(var.set_internal_dac_mode(config[CONF_MODE]))
     else:
         cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
         if use_legacy():

esphome/components/ld2410/ld2410.cpp

@@ -178,13 +178,8 @@ static constexpr uint8_t NO_MAC[] = {0x08, 0x05, 0x04, 0x03, 0x02, 0x01};
 
 static inline int two_byte_to_int(char firstbyte, char secondbyte) { return (int16_t) (secondbyte << 8) + firstbyte; }
 
-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 LD2410Component::dump_config() {
@@ -300,14 +295,12 @@ void LD2410Component::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));
@@ -401,7 +394,7 @@ void LD2410Component::handle_periodic_data_() {
     /*
       Moving distance range: 18th byte
       Still distance range: 19th byte
-      Moving enery: 20~28th bytes
+      Moving energy: 20~28th bytes
     */
     for (std::vector<sensor::Sensor *>::size_type i = 0; i != this->gate_move_sensors_.size(); i++) {
       sensor::Sensor *s = this->gate_move_sensors_[i];
@@ -480,7 +473,7 @@ bool LD2410Component::handle_ack_data_() {
     ESP_LOGE(TAG, "Invalid status");
     return true;
   }
-  if (ld2410::two_byte_to_int(this->buffer_data_[8], this->buffer_data_[9]) != 0x00) {
+  if (this->buffer_data_[8] || this->buffer_data_[9]) {
     ESP_LOGW(TAG, "Invalid command: %02X, %02X", this->buffer_data_[8], this->buffer_data_[9]);
     return true;
   }
@@ -534,8 +527,8 @@ bool LD2410Component::handle_ack_data_() {
       const auto *light_function_str = find_str(LIGHT_FUNCTIONS_BY_UINT, this->light_function_);
       const auto *out_pin_level_str = find_str(OUT_PIN_LEVELS_BY_UINT, this->out_pin_level_);
       ESP_LOGV(TAG,
-               "Light function is: %s\n"
-               "Light threshold is: %u\n"
+               "Light function: %s\n"
+               "Light threshold: %u\n"
                "Out pin level: %s",
                light_function_str, this->light_threshold_, out_pin_level_str);
 #ifdef USE_SELECT
@@ -600,7 +593,7 @@ bool LD2410Component::handle_ack_data_() {
       break;
 
     case CMD_QUERY: {  // Query parameters response
-      if (this->buffer_data_[10] != 0xAA)
+      if (this->buffer_data_[10] != HEADER)
         return true;  // value head=0xAA
 #ifdef USE_NUMBER
       /*
@@ -656,17 +649,11 @@ void LD2410Component::readline_(int readch) {
   if (this->buffer_pos_ < 4) {
     return;  // Not enough data to process yet
   }
-  if (this->buffer_data_[this->buffer_pos_ - 4] == DATA_FRAME_FOOTER[0] &&
-      this->buffer_data_[this->buffer_pos_ - 3] == DATA_FRAME_FOOTER[1] &&
-      this->buffer_data_[this->buffer_pos_ - 2] == DATA_FRAME_FOOTER[2] &&
-      this->buffer_data_[this->buffer_pos_ - 1] == DATA_FRAME_FOOTER[3]) {
+  if (ld2410::validate_header_footer(DATA_FRAME_FOOTER, &this->buffer_data_[this->buffer_pos_ - 4])) {
     ESP_LOGV(TAG, "Handling Periodic Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
     this->handle_periodic_data_();
     this->buffer_pos_ = 0;  // Reset position index for next message
-  } else if (this->buffer_data_[this->buffer_pos_ - 4] == CMD_FRAME_FOOTER[0] &&
-             this->buffer_data_[this->buffer_pos_ - 3] == CMD_FRAME_FOOTER[1] &&
-             this->buffer_data_[this->buffer_pos_ - 2] == CMD_FRAME_FOOTER[2] &&
-             this->buffer_data_[this->buffer_pos_ - 1] == CMD_FRAME_FOOTER[3]) {
+  } else if (ld2410::validate_header_footer(CMD_FRAME_FOOTER, &this->buffer_data_[this->buffer_pos_ - 4])) {
     ESP_LOGV(TAG, "Handling Ack Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
     if (this->handle_ack_data_()) {
       this->buffer_pos_ = 0;  // Reset position index for next message
@@ -772,7 +759,6 @@ void LD2410Component::set_max_distances_timeout() {
                        0x00};
   this->set_config_mode_(true);
   this->send_command_(CMD_MAXDIST_DURATION, value, sizeof(value));
-  delay(50);  // NOLINT
   this->query_parameters_();
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
   this->set_config_mode_(false);
@@ -802,7 +788,6 @@ void LD2410Component::set_gate_threshold(uint8_t gate) {
                        0x01, 0x00, lowbyte(motion), highbyte(motion), 0x00, 0x00,
                        0x02, 0x00, lowbyte(still),  highbyte(still),  0x00, 0x00};
   this->send_command_(CMD_GATE_SENS, value, sizeof(value));
-  delay(50);  // NOLINT
   this->query_parameters_();
   this->set_config_mode_(false);
 }
@@ -833,7 +818,6 @@ void LD2410Component::set_light_out_control() {
   this->set_config_mode_(true);
   uint8_t value[4] = {this->light_function_, this->light_threshold_, this->out_pin_level_, 0x00};
   this->send_command_(CMD_SET_LIGHT_CONTROL, value, sizeof(value));
-  delay(50);  // NOLINT
   this->query_light_control_();
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
   this->set_config_mode_(false);

esphome/components/ld2420/binary_sensor/ld2420_binary_sensor.cpp

@@ -5,10 +5,10 @@
 namespace esphome {
 namespace ld2420 {
 
-static const char *const TAG = "LD2420.binary_sensor";
+static const char *const TAG = "ld2420.binary_sensor";
 
 void LD2420BinarySensor::dump_config() {
-  ESP_LOGCONFIG(TAG, "LD2420 BinarySensor:");
+  ESP_LOGCONFIG(TAG, "Binary Sensor:");
   LOG_BINARY_SENSOR("  ", "Presence", this->presence_bsensor_);
 }
 

esphome/components/ld2420/button/reconfig_buttons.cpp

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

esphome/components/ld2420/ld2420.cpp

@@ -137,7 +137,7 @@ static const std::string OP_SIMPLE_MODE_STRING = "Simple";
 // Memory-efficient lookup tables
 struct StringToUint8 {
   const char *str;
-  uint8_t value;
+  const uint8_t value;
 };
 
 static constexpr StringToUint8 OP_MODE_BY_STR[] = {
@@ -155,8 +155,9 @@ static constexpr const char *ERR_MESSAGE[] = {
 // Helper function for lookups
 template<size_t N> uint8_t find_uint8(const StringToUint8 (&arr)[N], const std::string &str) {
   for (const auto &entry : arr) {
-    if (str == entry.str)
+    if (str == entry.str) {
       return entry.value;
+    }
   }
   return 0xFF;  // Not found
 }
@@ -326,15 +327,8 @@ void LD2420Component::revert_config_action() {
 
 void LD2420Component::loop() {
   // If there is a active send command do not process it here, the send command call will handle it.
-  if (!this->get_cmd_active_()) {
-    if (!this->available())
-      return;
-    static uint8_t buffer[2048];
-    static uint8_t rx_data;
-    while (this->available()) {
-      rx_data = this->read();
-      this->readline_(rx_data, buffer, sizeof(buffer));
-    }
+  while (!this->cmd_active_ && this->available()) {
+    this->readline_(this->read(), this->buffer_data_, MAX_LINE_LENGTH);
   }
 }
 
@@ -365,8 +359,9 @@ void LD2420Component::auto_calibrate_sensitivity() {
 
     // Store average and peak values
     this->gate_avg[gate] = sum / CALIBRATE_SAMPLES;
-    if (this->gate_peak[gate] < peak)
+    if (this->gate_peak[gate] < peak) {
       this->gate_peak[gate] = peak;
+    }
 
     uint32_t calculated_value =
         (static_cast<uint32_t>(this->gate_peak[gate]) + (move_factor * static_cast<uint32_t>(this->gate_peak[gate])));
@@ -403,8 +398,9 @@ void LD2420Component::set_operating_mode(const std::string &state) {
       }
     } else {
       // Set the current data back so we don't have new data that can be applied in error.
-      if (this->get_calibration_())
+      if (this->get_calibration_()) {
         memcpy(&this->new_config, &this->current_config, sizeof(this->current_config));
+      }
       this->set_calibration_(false);
     }
   } else {
@@ -414,30 +410,32 @@ void LD2420Component::set_operating_mode(const std::string &state) {
 }
 
 void LD2420Component::readline_(int rx_data, uint8_t *buffer, int len) {
-  static int pos = 0;
-
-  if (rx_data >= 0) {
-    if (pos < len - 1) {
-      buffer[pos++] = rx_data;
-      buffer[pos] = 0;
-    } else {
-      pos = 0;
-    }
-    if (pos >= 4) {
-      if (memcmp(&buffer[pos - 4], &CMD_FRAME_FOOTER, sizeof(CMD_FRAME_FOOTER)) == 0) {
-        this->set_cmd_active_(false);  // Set command state to inactive after responce.
-        this->handle_ack_data_(buffer, pos);
-        pos = 0;
-      } else if ((buffer[pos - 2] == 0x0D && buffer[pos - 1] == 0x0A) &&
-                 (this->get_mode_() == CMD_SYSTEM_MODE_SIMPLE)) {
-        this->handle_simple_mode_(buffer, pos);
-        pos = 0;
-      } else if ((memcmp(&buffer[pos - 4], &ENERGY_FRAME_FOOTER, sizeof(ENERGY_FRAME_FOOTER)) == 0) &&
-                 (this->get_mode_() == CMD_SYSTEM_MODE_ENERGY)) {
-        this->handle_energy_mode_(buffer, pos);
-        pos = 0;
-      }
-    }
+  if (rx_data < 0) {
+    return;  // No data available
+  }
+  if (this->buffer_pos_ < len - 1) {
+    buffer[this->buffer_pos_++] = rx_data;
+    buffer[this->buffer_pos_] = 0;
+  } else {
+    // We should never get here, but just in case...
+    ESP_LOGW(TAG, "Max command length exceeded; ignoring");
+    this->buffer_pos_ = 0;
+  }
+  if (this->buffer_pos_ < 4) {
+    return;  // Not enough data to process yet
+  }
+  if (memcmp(&buffer[this->buffer_pos_ - 4], &CMD_FRAME_FOOTER, sizeof(CMD_FRAME_FOOTER)) == 0) {
+    this->cmd_active_ = false;  // Set command state to inactive after response
+    this->handle_ack_data_(buffer, this->buffer_pos_);
+    this->buffer_pos_ = 0;
+  } else if ((buffer[this->buffer_pos_ - 2] == 0x0D && buffer[this->buffer_pos_ - 1] == 0x0A) &&
+             (this->get_mode_() == CMD_SYSTEM_MODE_SIMPLE)) {
+    this->handle_simple_mode_(buffer, this->buffer_pos_);
+    this->buffer_pos_ = 0;
+  } else if ((memcmp(&buffer[this->buffer_pos_ - 4], &ENERGY_FRAME_FOOTER, sizeof(ENERGY_FRAME_FOOTER)) == 0) &&
+             (this->get_mode_() == CMD_SYSTEM_MODE_ENERGY)) {
+    this->handle_energy_mode_(buffer, this->buffer_pos_);
+    this->buffer_pos_ = 0;
   }
 }
 
@@ -462,8 +460,9 @@ void LD2420Component::handle_energy_mode_(uint8_t *buffer, int len) {
 
   // Resonable refresh rate for home assistant database size health
   const int32_t current_millis = App.get_loop_component_start_time();
-  if (current_millis - this->last_periodic_millis < REFRESH_RATE_MS)
+  if (current_millis - this->last_periodic_millis < REFRESH_RATE_MS) {
     return;
+  }
   this->last_periodic_millis = current_millis;
   for (auto &listener : this->listeners_) {
     listener->on_distance(this->get_distance_());
@@ -506,14 +505,16 @@ void LD2420Component::handle_simple_mode_(const uint8_t *inbuf, int len) {
     }
   }
   outbuf[index] = '\0';
-  if (index > 1)
+  if (index > 1) {
     this->set_distance_(strtol(outbuf, &endptr, 10));
+  }
 
   if (this->get_mode_() == CMD_SYSTEM_MODE_SIMPLE) {
     // Resonable refresh rate for home assistant database size health
     const int32_t current_millis = App.get_loop_component_start_time();
-    if (current_millis - this->last_normal_periodic_millis < REFRESH_RATE_MS)
+    if (current_millis - this->last_normal_periodic_millis < REFRESH_RATE_MS) {
       return;
+    }
     this->last_normal_periodic_millis = current_millis;
     for (auto &listener : this->listeners_)
       listener->on_distance(this->get_distance_());
@@ -593,11 +594,12 @@ void LD2420Component::handle_ack_data_(uint8_t *buffer, int len) {
 int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
   uint32_t start_millis = millis();
   uint8_t error = 0;
-  uint8_t ack_buffer[64];
-  uint8_t cmd_buffer[64];
+  uint8_t ack_buffer[MAX_LINE_LENGTH];
+  uint8_t cmd_buffer[MAX_LINE_LENGTH];
   this->cmd_reply_.ack = false;
-  if (frame.command != CMD_RESTART)
-    this->set_cmd_active_(true);  // Restart does not reply, thus no ack state required.
+  if (frame.command != CMD_RESTART) {
+    this->cmd_active_ = true;
+  }  // Restart does not reply, thus no ack state required
   uint8_t retry = 3;
   while (retry) {
     frame.length = 0;
@@ -619,9 +621,7 @@ int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
 
     memcpy(cmd_buffer + frame.length, &frame.footer, sizeof(frame.footer));
     frame.length += sizeof(frame.footer);
-    for (uint16_t index = 0; index < frame.length; index++) {
-      this->write_byte(cmd_buffer[index]);
-    }
+    this->write_array(cmd_buffer, frame.length);
 
     error = 0;
     if (frame.command == CMD_RESTART) {
@@ -630,7 +630,7 @@ int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
 
     while (!this->cmd_reply_.ack) {
       while (this->available()) {
-        this->readline_(read(), ack_buffer, sizeof(ack_buffer));
+        this->readline_(this->read(), ack_buffer, sizeof(ack_buffer));
       }
       delay_microseconds_safe(1450);
       // Wait on an Rx from the LD2420 for up to 3 1 second loops, otherwise it could trigger a WDT.
@@ -641,10 +641,12 @@ int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
         break;
       }
     }
-    if (this->cmd_reply_.ack)
+    if (this->cmd_reply_.ack) {
       retry = 0;
-    if (this->cmd_reply_.error > 0)
+    }
+    if (this->cmd_reply_.error > 0) {
       this->handle_cmd_error(error);
+    }
   }
   return error;
 }
@@ -764,8 +766,9 @@ void LD2420Component::set_system_mode(uint16_t mode) {
   cmd_frame.data_length += sizeof(unknown_parm);
   cmd_frame.footer = CMD_FRAME_FOOTER;
   ESP_LOGV(TAG, "Sending write system mode command: %2X", cmd_frame.command);
-  if (this->send_cmd_from_array(cmd_frame) == 0)
+  if (this->send_cmd_from_array(cmd_frame) == 0) {
     this->set_mode_(mode);
+  }
 }
 
 void LD2420Component::get_firmware_version_() {
@@ -840,18 +843,24 @@ void LD2420Component::set_gate_threshold(uint8_t gate) {
 
 #ifdef USE_NUMBER
 void LD2420Component::init_gate_config_numbers() {
-  if (this->gate_timeout_number_ != nullptr)
+  if (this->gate_timeout_number_ != nullptr) {
     this->gate_timeout_number_->publish_state(static_cast<uint16_t>(this->current_config.timeout));
-  if (this->gate_select_number_ != nullptr)
+  }
+  if (this->gate_select_number_ != nullptr) {
     this->gate_select_number_->publish_state(0);
-  if (this->min_gate_distance_number_ != nullptr)
+  }
+  if (this->min_gate_distance_number_ != nullptr) {
     this->min_gate_distance_number_->publish_state(static_cast<uint16_t>(this->current_config.min_gate));
-  if (this->max_gate_distance_number_ != nullptr)
+  }
+  if (this->max_gate_distance_number_ != nullptr) {
     this->max_gate_distance_number_->publish_state(static_cast<uint16_t>(this->current_config.max_gate));
-  if (this->gate_move_sensitivity_factor_number_ != nullptr)
+  }
+  if (this->gate_move_sensitivity_factor_number_ != nullptr) {
     this->gate_move_sensitivity_factor_number_->publish_state(this->gate_move_sensitivity_factor);
-  if (this->gate_still_sensitivity_factor_number_ != nullptr)
+  }
+  if (this->gate_still_sensitivity_factor_number_ != nullptr) {
     this->gate_still_sensitivity_factor_number_->publish_state(this->gate_still_sensitivity_factor);
+  }
   for (uint8_t gate = 0; gate < TOTAL_GATES; gate++) {
     if (this->gate_still_threshold_numbers_[gate] != nullptr) {
       this->gate_still_threshold_numbers_[gate]->publish_state(

esphome/components/ld2420/ld2420.h

@@ -20,8 +20,9 @@
 namespace esphome {
 namespace ld2420 {
 
-static const uint8_t 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;
 
 enum OpMode : uint8_t {
   OP_NORMAL_MODE = 1,
@@ -118,10 +119,10 @@ class LD2420Component : public Component, public uart::UARTDevice {
 
   float gate_move_sensitivity_factor{0.5};
   float gate_still_sensitivity_factor{0.5};
-  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();
+  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];
@@ -161,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);
@@ -181,12 +180,11 @@ class LD2420Component : public Component, public uart::UARTDevice {
   std::vector<number::Number *> gate_move_threshold_numbers_ = std::vector<number::Number *>(16);
 #endif
 
-  uint32_t max_distance_gate_;
-  uint32_t min_distance_gate_;
+  uint16_t distance_{0};
   uint16_t system_mode_;
   uint16_t gate_energy_[TOTAL_GATES];
-  uint16_t distance_{0};
-  uint8_t config_checksum_{0};
+  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};
   bool presence_{false};

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/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/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/libretiny/__init__.py

@@ -268,6 +268,7 @@ async def component_to_code(config):
 
     # disable library compatibility checks
     cg.add_platformio_option("lib_ldf_mode", "off")
+    cg.add_platformio_option("lib_compat_mode", "soft")
     # include <Arduino.h> in every file
     cg.add_platformio_option("build_src_flags", "-include Arduino.h")
     # dummy version code