Reduce modbus heap alloc

CODEOWNERS

@@ -87,7 +87,6 @@ esphome/components/bp1658cj/* @Cossid
 esphome/components/bp5758d/* @Cossid
 esphome/components/button/* @esphome/core
 esphome/components/bytebuffer/* @clydebarrow
-esphome/components/camera/* @DT-art1 @bdraco
 esphome/components/canbus/* @danielschramm @mvturnho
 esphome/components/cap1188/* @mreditor97
 esphome/components/captive_portal/* @OttoWinter
@@ -329,7 +328,6 @@ esphome/components/opentherm/* @olegtarasov
 esphome/components/openthread/* @mrene
 esphome/components/opt3001/* @ccutrer
 esphome/components/ota/* @esphome/core
-esphome/components/ota_base/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/packet_transport/* @clydebarrow
 esphome/components/pca6416a/* @Mat931
@@ -443,7 +441,6 @@ esphome/components/sun/* @OttoWinter
 esphome/components/sun_gtil2/* @Mat931
 esphome/components/switch/* @esphome/core
 esphome/components/switch/binary_sensor/* @ssieb
-esphome/components/sx126x/* @swoboda1337
 esphome/components/sx127x/* @swoboda1337
 esphome/components/syslog/* @clydebarrow
 esphome/components/t6615/* @tylermenezes

esphome/components/adc/__init__.py

@@ -10,15 +10,8 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
 )
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ANALOG,
-    CONF_INPUT,
-    CONF_NUMBER,
-    PLATFORM_ESP8266,
-    PlatformFramework,
-)
+from esphome.const import CONF_ANALOG, CONF_INPUT, CONF_NUMBER, PLATFORM_ESP8266
 from esphome.core import CORE
 
 CODEOWNERS = ["@esphome/core"]
@@ -236,20 +229,3 @@ def validate_adc_pin(value):
         )(value)
 
     raise NotImplementedError
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "adc_sensor_esp32.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        "adc_sensor_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "adc_sensor_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
-        "adc_sensor_libretiny.cpp": {
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-    }
-)

esphome/components/api/__init__.py

@@ -23,7 +23,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_VARIABLES,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import coroutine_with_priority
 
 DEPENDENCIES = ["network"]
 AUTO_LOAD = ["socket"]
@@ -313,14 +313,3 @@ async def homeassistant_tag_scanned_to_code(config, action_id, template_arg, arg
 @automation.register_condition("api.connected", APIConnectedCondition, {})
 async def api_connected_to_code(config, condition_id, template_arg, args):
     return cg.new_Pvariable(condition_id, template_arg)
-
-
-def FILTER_SOURCE_FILES() -> list[str]:
-    """Filter out api_pb2_dump.cpp when proto message dumping is not enabled."""
-    # api_pb2_dump.cpp is only needed when HAS_PROTO_MESSAGE_DUMP is defined
-    # This is a particularly large file that still needs to be opened and read
-    # all the way to the end even when ifdef'd out
-    if "HAS_PROTO_MESSAGE_DUMP" not in CORE.defines:
-        return ["api_pb2_dump.cpp"]
-
-    return []

esphome/components/api/api.proto

@@ -836,7 +836,7 @@ message ListEntitiesCameraResponse {
   option (id) = 43;
   option (base_class) = "InfoResponseProtoMessage";
   option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_CAMERA";
+  option (ifdef) = "USE_ESP32_CAMERA";
 
   string object_id = 1;
   fixed32 key = 2;
@@ -851,7 +851,7 @@ message ListEntitiesCameraResponse {
 message CameraImageResponse {
   option (id) = 44;
   option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_CAMERA";
+  option (ifdef) = "USE_ESP32_CAMERA";
 
   fixed32 key = 1;
   bytes data = 2;
@@ -860,7 +860,7 @@ message CameraImageResponse {
 message CameraImageRequest {
   option (id) = 45;
   option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_CAMERA";
+  option (ifdef) = "USE_ESP32_CAMERA";
   option (no_delay) = true;
 
   bool single = 1;

esphome/components/api/api_connection.cpp

@@ -38,23 +38,10 @@ static constexpr uint16_t PING_RETRY_INTERVAL = 1000;
 static constexpr uint32_t KEEPALIVE_DISCONNECT_TIMEOUT = (KEEPALIVE_TIMEOUT_MS * 5) / 2;
 
 static const char *const TAG = "api.connection";
-#ifdef USE_CAMERA
-static const int CAMERA_STOP_STREAM = 5000;
+#ifdef USE_ESP32_CAMERA
+static const int ESP32_CAMERA_STOP_STREAM = 5000;
 #endif
 
-// Helper macro for entity command handlers - gets entity by key, returns if not found, and creates call object
-#define ENTITY_COMMAND_MAKE_CALL(entity_type, entity_var, getter_name) \
-  entity_type *entity_var = App.get_##getter_name##_by_key(msg.key); \
-  if (entity_var == nullptr) \
-    return; \
-  auto call = entity_var->make_call();
-
-// Helper macro for entity command handlers that don't use make_call() - gets entity by key and returns if not found
-#define ENTITY_COMMAND_GET(entity_type, entity_var, getter_name) \
-  entity_type *entity_var = App.get_##getter_name##_by_key(msg.key); \
-  if (entity_var == nullptr) \
-    return;
-
 APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *parent)
     : parent_(parent), initial_state_iterator_(this), list_entities_iterator_(this) {
 #if defined(USE_API_PLAINTEXT) && defined(USE_API_NOISE)
@@ -71,11 +58,6 @@ APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *pa
 #else
 #error "No frame helper defined"
 #endif
-#ifdef USE_CAMERA
-  if (camera::Camera::instance() != nullptr) {
-    this->image_reader_ = std::unique_ptr<camera::CameraImageReader>{camera::Camera::instance()->create_image_reader()};
-  }
-#endif
 }
 
 uint32_t APIConnection::get_batch_delay_ms_() const { return this->parent_->get_batch_delay(); }
@@ -198,10 +180,10 @@ void APIConnection::loop() {
     }
   }
 
-#ifdef USE_CAMERA
-  if (this->image_reader_ && this->image_reader_->available() && this->helper_->can_write_without_blocking()) {
-    uint32_t to_send = std::min((size_t) MAX_PACKET_SIZE, this->image_reader_->available());
-    bool done = this->image_reader_->available() == to_send;
+#ifdef USE_ESP32_CAMERA
+  if (this->image_reader_.available() && this->helper_->can_write_without_blocking()) {
+    uint32_t to_send = std::min((size_t) MAX_PACKET_SIZE, this->image_reader_.available());
+    bool done = this->image_reader_.available() == to_send;
     uint32_t msg_size = 0;
     ProtoSize::add_fixed_field<4>(msg_size, 1, true);
     // partial message size calculated manually since its a special case
@@ -211,18 +193,18 @@ void APIConnection::loop() {
 
     auto buffer = this->create_buffer(msg_size);
     // fixed32 key = 1;
-    buffer.encode_fixed32(1, camera::Camera::instance()->get_object_id_hash());
+    buffer.encode_fixed32(1, esp32_camera::global_esp32_camera->get_object_id_hash());
     // bytes data = 2;
-    buffer.encode_bytes(2, this->image_reader_->peek_data_buffer(), to_send);
+    buffer.encode_bytes(2, this->image_reader_.peek_data_buffer(), to_send);
     // bool done = 3;
     buffer.encode_bool(3, done);
 
     bool success = this->send_buffer(buffer, CameraImageResponse::MESSAGE_TYPE);
 
     if (success) {
-      this->image_reader_->consume_data(to_send);
+      this->image_reader_.consume_data(to_send);
       if (done) {
-        this->image_reader_->return_image();
+        this->image_reader_.return_image();
       }
     }
   }
@@ -374,7 +356,11 @@ uint16_t APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *c
   return encode_message_to_buffer(msg, ListEntitiesCoverResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::cover_command(const CoverCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(cover::Cover, cover, cover)
+  cover::Cover *cover = App.get_cover_by_key(msg.key);
+  if (cover == nullptr)
+    return;
+
+  auto call = cover->make_call();
   if (msg.has_legacy_command) {
     switch (msg.legacy_command) {
       case enums::LEGACY_COVER_COMMAND_OPEN:
@@ -436,7 +422,11 @@ uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *con
   return encode_message_to_buffer(msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::fan_command(const FanCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(fan::Fan, fan, fan)
+  fan::Fan *fan = App.get_fan_by_key(msg.key);
+  if (fan == nullptr)
+    return;
+
+  auto call = fan->make_call();
   if (msg.has_state)
     call.set_state(msg.state);
   if (msg.has_oscillating)
@@ -509,7 +499,11 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
   return encode_message_to_buffer(msg, ListEntitiesLightResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::light_command(const LightCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(light::LightState, light, light)
+  light::LightState *light = App.get_light_by_key(msg.key);
+  if (light == nullptr)
+    return;
+
+  auto call = light->make_call();
   if (msg.has_state)
     call.set_state(msg.state);
   if (msg.has_brightness)
@@ -598,7 +592,9 @@ uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *
   return encode_message_to_buffer(msg, ListEntitiesSwitchResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::switch_command(const SwitchCommandRequest &msg) {
-  ENTITY_COMMAND_GET(switch_::Switch, a_switch, switch)
+  switch_::Switch *a_switch = App.get_switch_by_key(msg.key);
+  if (a_switch == nullptr)
+    return;
 
   if (msg.state) {
     a_switch->turn_on();
@@ -707,7 +703,11 @@ uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection
   return encode_message_to_buffer(msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::climate_command(const ClimateCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(climate::Climate, climate, climate)
+  climate::Climate *climate = App.get_climate_by_key(msg.key);
+  if (climate == nullptr)
+    return;
+
+  auto call = climate->make_call();
   if (msg.has_mode)
     call.set_mode(static_cast<climate::ClimateMode>(msg.mode));
   if (msg.has_target_temperature)
@@ -762,7 +762,11 @@ uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *
   return encode_message_to_buffer(msg, ListEntitiesNumberResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::number_command(const NumberCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(number::Number, number, number)
+  number::Number *number = App.get_number_by_key(msg.key);
+  if (number == nullptr)
+    return;
+
+  auto call = number->make_call();
   call.set_value(msg.state);
   call.perform();
 }
@@ -792,7 +796,11 @@ uint16_t APIConnection::try_send_date_info(EntityBase *entity, APIConnection *co
   return encode_message_to_buffer(msg, ListEntitiesDateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::date_command(const DateCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(datetime::DateEntity, date, date)
+  datetime::DateEntity *date = App.get_date_by_key(msg.key);
+  if (date == nullptr)
+    return;
+
+  auto call = date->make_call();
   call.set_date(msg.year, msg.month, msg.day);
   call.perform();
 }
@@ -822,7 +830,11 @@ uint16_t APIConnection::try_send_time_info(EntityBase *entity, APIConnection *co
   return encode_message_to_buffer(msg, ListEntitiesTimeResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::time_command(const TimeCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(datetime::TimeEntity, time, time)
+  datetime::TimeEntity *time = App.get_time_by_key(msg.key);
+  if (time == nullptr)
+    return;
+
+  auto call = time->make_call();
   call.set_time(msg.hour, msg.minute, msg.second);
   call.perform();
 }
@@ -854,7 +866,11 @@ uint16_t APIConnection::try_send_datetime_info(EntityBase *entity, APIConnection
   return encode_message_to_buffer(msg, ListEntitiesDateTimeResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::datetime_command(const DateTimeCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(datetime::DateTimeEntity, datetime, datetime)
+  datetime::DateTimeEntity *datetime = App.get_datetime_by_key(msg.key);
+  if (datetime == nullptr)
+    return;
+
+  auto call = datetime->make_call();
   call.set_datetime(msg.epoch_seconds);
   call.perform();
 }
@@ -888,7 +904,11 @@ uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *co
   return encode_message_to_buffer(msg, ListEntitiesTextResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::text_command(const TextCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(text::Text, text, text)
+  text::Text *text = App.get_text_by_key(msg.key);
+  if (text == nullptr)
+    return;
+
+  auto call = text->make_call();
   call.set_value(msg.state);
   call.perform();
 }
@@ -920,7 +940,11 @@ uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *
   return encode_message_to_buffer(msg, ListEntitiesSelectResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::select_command(const SelectCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(select::Select, select, select)
+  select::Select *select = App.get_select_by_key(msg.key);
+  if (select == nullptr)
+    return;
+
+  auto call = select->make_call();
   call.set_option(msg.state);
   call.perform();
 }
@@ -937,7 +961,10 @@ uint16_t APIConnection::try_send_button_info(EntityBase *entity, APIConnection *
   return encode_message_to_buffer(msg, ListEntitiesButtonResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void esphome::api::APIConnection::button_command(const ButtonCommandRequest &msg) {
-  ENTITY_COMMAND_GET(button::Button, button, button)
+  button::Button *button = App.get_button_by_key(msg.key);
+  if (button == nullptr)
+    return;
+
   button->press();
 }
 #endif
@@ -968,7 +995,9 @@ uint16_t APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *co
   return encode_message_to_buffer(msg, ListEntitiesLockResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::lock_command(const LockCommandRequest &msg) {
-  ENTITY_COMMAND_GET(lock::Lock, a_lock, lock)
+  lock::Lock *a_lock = App.get_lock_by_key(msg.key);
+  if (a_lock == nullptr)
+    return;
 
   switch (msg.command) {
     case enums::LOCK_UNLOCK:
@@ -1011,7 +1040,11 @@ uint16_t APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *c
   return encode_message_to_buffer(msg, ListEntitiesValveResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::valve_command(const ValveCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(valve::Valve, valve, valve)
+  valve::Valve *valve = App.get_valve_by_key(msg.key);
+  if (valve == nullptr)
+    return;
+
+  auto call = valve->make_call();
   if (msg.has_position)
     call.set_position(msg.position);
   if (msg.stop)
@@ -1058,7 +1091,11 @@ uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnec
   return encode_message_to_buffer(msg, ListEntitiesMediaPlayerResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(media_player::MediaPlayer, media_player, media_player)
+  media_player::MediaPlayer *media_player = App.get_media_player_by_key(msg.key);
+  if (media_player == nullptr)
+    return;
+
+  auto call = media_player->make_call();
   if (msg.has_command) {
     call.set_command(static_cast<media_player::MediaPlayerCommand>(msg.command));
   }
@@ -1075,36 +1112,36 @@ void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
 }
 #endif
 
-#ifdef USE_CAMERA
-void APIConnection::set_camera_state(std::shared_ptr<camera::CameraImage> image) {
+#ifdef USE_ESP32_CAMERA
+void APIConnection::set_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
   if (!this->flags_.state_subscription)
     return;
-  if (!this->image_reader_)
+  if (this->image_reader_.available())
     return;
-  if (this->image_reader_->available())
-    return;
-  if (image->was_requested_by(esphome::camera::API_REQUESTER) || image->was_requested_by(esphome::camera::IDLE))
-    this->image_reader_->set_image(std::move(image));
+  if (image->was_requested_by(esphome::esp32_camera::API_REQUESTER) ||
+      image->was_requested_by(esphome::esp32_camera::IDLE))
+    this->image_reader_.set_image(std::move(image));
 }
 uint16_t APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
-  auto *camera = static_cast<camera::Camera *>(entity);
+  auto *camera = static_cast<esp32_camera::ESP32Camera *>(entity);
   ListEntitiesCameraResponse msg;
   msg.unique_id = get_default_unique_id("camera", camera);
   fill_entity_info_base(camera, msg);
   return encode_message_to_buffer(msg, ListEntitiesCameraResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::camera_image(const CameraImageRequest &msg) {
-  if (camera::Camera::instance() == nullptr)
+  if (esp32_camera::global_esp32_camera == nullptr)
     return;
 
   if (msg.single)
-    camera::Camera::instance()->request_image(esphome::camera::API_REQUESTER);
+    esp32_camera::global_esp32_camera->request_image(esphome::esp32_camera::API_REQUESTER);
   if (msg.stream) {
-    camera::Camera::instance()->start_stream(esphome::camera::API_REQUESTER);
+    esp32_camera::global_esp32_camera->start_stream(esphome::esp32_camera::API_REQUESTER);
 
-    App.scheduler.set_timeout(this->parent_, "api_camera_stop_stream", CAMERA_STOP_STREAM,
-                              []() { camera::Camera::instance()->stop_stream(esphome::camera::API_REQUESTER); });
+    App.scheduler.set_timeout(this->parent_, "api_esp32_camera_stop_stream", ESP32_CAMERA_STOP_STREAM, []() {
+      esp32_camera::global_esp32_camera->stop_stream(esphome::esp32_camera::API_REQUESTER);
+    });
   }
 }
 #endif
@@ -1304,7 +1341,11 @@ uint16_t APIConnection::try_send_alarm_control_panel_info(EntityBase *entity, AP
                                   is_single);
 }
 void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRequest &msg) {
-  ENTITY_COMMAND_MAKE_CALL(alarm_control_panel::AlarmControlPanel, a_alarm_control_panel, alarm_control_panel)
+  alarm_control_panel::AlarmControlPanel *a_alarm_control_panel = App.get_alarm_control_panel_by_key(msg.key);
+  if (a_alarm_control_panel == nullptr)
+    return;
+
+  auto call = a_alarm_control_panel->make_call();
   switch (msg.command) {
     case enums::ALARM_CONTROL_PANEL_DISARM:
       call.disarm();
@@ -1392,7 +1433,9 @@ uint16_t APIConnection::try_send_update_info(EntityBase *entity, APIConnection *
   return encode_message_to_buffer(msg, ListEntitiesUpdateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::update_command(const UpdateCommandRequest &msg) {
-  ENTITY_COMMAND_GET(update::UpdateEntity, update, update)
+  update::UpdateEntity *update = App.get_update_by_key(msg.key);
+  if (update == nullptr)
+    return;
 
   switch (msg.command) {
     case enums::UPDATE_COMMAND_UPDATE:
@@ -1411,11 +1454,12 @@ void APIConnection::update_command(const UpdateCommandRequest &msg) {
 }
 #endif
 
-bool APIConnection::try_send_log_message(int level, const char *tag, const char *line, size_t message_len) {
+bool APIConnection::try_send_log_message(int level, const char *tag, const char *line) {
   if (this->flags_.log_subscription < level)
     return false;
 
   // Pre-calculate message size to avoid reallocations
+  const size_t line_length = strlen(line);
   uint32_t msg_size = 0;
 
   // Add size for level field (field ID 1, varint type)
@@ -1424,14 +1468,14 @@ bool APIConnection::try_send_log_message(int level, const char *tag, const char
 
   // Add size for string field (field ID 3, string type)
   // 1 byte for field tag + size of length varint + string length
-  msg_size += 1 + api::ProtoSize::varint(static_cast<uint32_t>(message_len)) + message_len;
+  msg_size += 1 + api::ProtoSize::varint(static_cast<uint32_t>(line_length)) + line_length;
 
   // Create a pre-sized buffer
   auto buffer = this->create_buffer(msg_size);
 
   // Encode the message (SubscribeLogsResponse)
   buffer.encode_uint32(1, static_cast<uint32_t>(level));  // LogLevel level = 1
-  buffer.encode_string(3, line, message_len);             // string message = 3
+  buffer.encode_string(3, line, line_length);             // string message = 3
 
   // SubscribeLogsResponse - 29
   return this->send_buffer(buffer, SubscribeLogsResponse::MESSAGE_TYPE);

esphome/components/api/api_connection.h

@@ -60,8 +60,8 @@ class APIConnection : public APIServerConnection {
 #ifdef USE_TEXT_SENSOR
   bool send_text_sensor_state(text_sensor::TextSensor *text_sensor);
 #endif
-#ifdef USE_CAMERA
-  void set_camera_state(std::shared_ptr<camera::CameraImage> image);
+#ifdef USE_ESP32_CAMERA
+  void set_camera_state(std::shared_ptr<esp32_camera::CameraImage> image);
   void camera_image(const CameraImageRequest &msg) override;
 #endif
 #ifdef USE_CLIMATE
@@ -107,7 +107,7 @@ class APIConnection : public APIServerConnection {
   bool send_media_player_state(media_player::MediaPlayer *media_player);
   void media_player_command(const MediaPlayerCommandRequest &msg) override;
 #endif
-  bool try_send_log_message(int level, const char *tag, const char *line, size_t message_len);
+  bool try_send_log_message(int level, const char *tag, const char *line);
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
     if (!this->flags_.service_call_subscription)
       return;
@@ -425,7 +425,7 @@ class APIConnection : public APIServerConnection {
   static uint16_t try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                        bool is_single);
 #endif
-#ifdef USE_CAMERA
+#ifdef USE_ESP32_CAMERA
   static uint16_t try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                        bool is_single);
 #endif
@@ -455,8 +455,8 @@ class APIConnection : public APIServerConnection {
   // These contain vectors/pointers internally, so putting them early ensures good alignment
   InitialStateIterator initial_state_iterator_;
   ListEntitiesIterator list_entities_iterator_;
-#ifdef USE_CAMERA
-  std::unique_ptr<camera::CameraImageReader> image_reader_;
+#ifdef USE_ESP32_CAMERA
+  esp32_camera::CameraImageReader image_reader_;
 #endif
 
   // Group 3: Strings (12 bytes each on 32-bit, 4-byte aligned)

esphome/components/api/api_frame_helper.cpp

@@ -225,22 +225,6 @@ APIError APIFrameHelper::init_common_() {
 }
 
 #define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s: " msg, this->info_.c_str(), ##__VA_ARGS__)
-
-APIError APIFrameHelper::handle_socket_read_result_(ssize_t received) {
-  if (received == -1) {
-    if (errno == EWOULDBLOCK || errno == EAGAIN) {
-      return APIError::WOULD_BLOCK;
-    }
-    state_ = State::FAILED;
-    HELPER_LOG("Socket read failed with errno %d", errno);
-    return APIError::SOCKET_READ_FAILED;
-  } else if (received == 0) {
-    state_ = State::FAILED;
-    HELPER_LOG("Connection closed");
-    return APIError::CONNECTION_CLOSED;
-  }
-  return APIError::OK;
-}
 // uncomment to log raw packets
 //#define HELPER_LOG_PACKETS
 
@@ -343,9 +327,17 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
     // no header information yet
     uint8_t to_read = 3 - rx_header_buf_len_;
     ssize_t received = this->socket_->read(&rx_header_buf_[rx_header_buf_len_], to_read);
-    APIError err = handle_socket_read_result_(received);
-    if (err != APIError::OK) {
-      return err;
+    if (received == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+        return APIError::WOULD_BLOCK;
+      }
+      state_ = State::FAILED;
+      HELPER_LOG("Socket read failed with errno %d", errno);
+      return APIError::SOCKET_READ_FAILED;
+    } else if (received == 0) {
+      state_ = State::FAILED;
+      HELPER_LOG("Connection closed");
+      return APIError::CONNECTION_CLOSED;
     }
     rx_header_buf_len_ += static_cast<uint8_t>(received);
     if (static_cast<uint8_t>(received) != to_read) {
@@ -380,9 +372,17 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
     // more data to read
     uint16_t to_read = msg_size - rx_buf_len_;
     ssize_t received = this->socket_->read(&rx_buf_[rx_buf_len_], to_read);
-    APIError err = handle_socket_read_result_(received);
-    if (err != APIError::OK) {
-      return err;
+    if (received == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+        return APIError::WOULD_BLOCK;
+      }
+      state_ = State::FAILED;
+      HELPER_LOG("Socket read failed with errno %d", errno);
+      return APIError::SOCKET_READ_FAILED;
+    } else if (received == 0) {
+      state_ = State::FAILED;
+      HELPER_LOG("Connection closed");
+      return APIError::CONNECTION_CLOSED;
     }
     rx_buf_len_ += static_cast<uint16_t>(received);
     if (static_cast<uint16_t>(received) != to_read) {
@@ -614,14 +614,20 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   return APIError::OK;
 }
 APIError APINoiseFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) {
+  std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
+  uint16_t payload_len = static_cast<uint16_t>(raw_buffer->size() - frame_header_padding_);
+
   // Resize to include MAC space (required for Noise encryption)
-  buffer.get_buffer()->resize(buffer.get_buffer()->size() + frame_footer_size_);
-  PacketInfo packet{type, 0,
-                    static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_ - frame_footer_size_)};
-  return write_protobuf_packets(buffer, std::span<const PacketInfo>(&packet, 1));
+  raw_buffer->resize(raw_buffer->size() + frame_footer_size_);
+
+  // Use write_protobuf_packets with a single packet
+  std::vector<PacketInfo> packets;
+  packets.emplace_back(type, 0, payload_len);
+
+  return write_protobuf_packets(buffer, packets);
 }
 
-APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) {
+APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, const std::vector<PacketInfo> &packets) {
   APIError aerr = state_action_();
   if (aerr != APIError::OK) {
     return aerr;
@@ -636,15 +642,18 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, st
   }
 
   std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
-  uint8_t *buffer_data = raw_buffer->data();  // Cache buffer pointer
-
   this->reusable_iovs_.clear();
   this->reusable_iovs_.reserve(packets.size());
 
   // We need to encrypt each packet in place
   for (const auto &packet : packets) {
+    uint16_t type = packet.message_type;
+    uint16_t offset = packet.offset;
+    uint16_t payload_len = packet.payload_size;
+    uint16_t msg_len = 4 + payload_len;  // type(2) + data_len(2) + payload
+
     // The buffer already has padding at offset
-    uint8_t *buf_start = buffer_data + packet.offset;
+    uint8_t *buf_start = raw_buffer->data() + offset;
 
     // Write noise header
     buf_start[0] = 0x01;  // indicator
@@ -652,10 +661,10 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, st
 
     // Write message header (to be encrypted)
     const uint8_t msg_offset = 3;
-    buf_start[msg_offset] = static_cast<uint8_t>(packet.message_type >> 8);      // type high byte
-    buf_start[msg_offset + 1] = static_cast<uint8_t>(packet.message_type);       // type low byte
-    buf_start[msg_offset + 2] = static_cast<uint8_t>(packet.payload_size >> 8);  // data_len high byte
-    buf_start[msg_offset + 3] = static_cast<uint8_t>(packet.payload_size);       // data_len low byte
+    buf_start[msg_offset + 0] = (uint8_t) (type >> 8);         // type high byte
+    buf_start[msg_offset + 1] = (uint8_t) type;                // type low byte
+    buf_start[msg_offset + 2] = (uint8_t) (payload_len >> 8);  // data_len high byte
+    buf_start[msg_offset + 3] = (uint8_t) payload_len;         // data_len low byte
     // payload data is already in the buffer starting at offset + 7
 
     // Make sure we have space for MAC
@@ -664,8 +673,7 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, st
     // Encrypt the message in place
     NoiseBuffer mbuf;
     noise_buffer_init(mbuf);
-    noise_buffer_set_inout(mbuf, buf_start + msg_offset, 4 + packet.payload_size,
-                           4 + packet.payload_size + frame_footer_size_);
+    noise_buffer_set_inout(mbuf, buf_start + msg_offset, msg_len, msg_len + frame_footer_size_);
 
     int err = noise_cipherstate_encrypt(send_cipher_, &mbuf);
     if (err != 0) {
@@ -675,12 +683,14 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, st
     }
 
     // Fill in the encrypted size
-    buf_start[1] = static_cast<uint8_t>(mbuf.size >> 8);
-    buf_start[2] = static_cast<uint8_t>(mbuf.size);
+    buf_start[1] = (uint8_t) (mbuf.size >> 8);
+    buf_start[2] = (uint8_t) mbuf.size;
 
     // Add iovec for this encrypted packet
-    this->reusable_iovs_.push_back(
-        {buf_start, static_cast<size_t>(3 + mbuf.size)});  // indicator + size + encrypted data
+    struct iovec iov;
+    iov.iov_base = buf_start;
+    iov.iov_len = 3 + mbuf.size;  // indicator + size + encrypted data
+    this->reusable_iovs_.push_back(iov);
   }
 
   // Send all encrypted packets in one writev call
@@ -855,9 +865,17 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
     // Try to get to at least 3 bytes total (indicator + 2 varint bytes), then read one byte at a time
     ssize_t received =
         this->socket_->read(&rx_header_buf_[rx_header_buf_pos_], rx_header_buf_pos_ < 3 ? 3 - rx_header_buf_pos_ : 1);
-    APIError err = handle_socket_read_result_(received);
-    if (err != APIError::OK) {
-      return err;
+    if (received == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+        return APIError::WOULD_BLOCK;
+      }
+      state_ = State::FAILED;
+      HELPER_LOG("Socket read failed with errno %d", errno);
+      return APIError::SOCKET_READ_FAILED;
+    } else if (received == 0) {
+      state_ = State::FAILED;
+      HELPER_LOG("Connection closed");
+      return APIError::CONNECTION_CLOSED;
     }
 
     // If this was the first read, validate the indicator byte
@@ -941,9 +959,17 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
     // more data to read
     uint16_t to_read = rx_header_parsed_len_ - rx_buf_len_;
     ssize_t received = this->socket_->read(&rx_buf_[rx_buf_len_], to_read);
-    APIError err = handle_socket_read_result_(received);
-    if (err != APIError::OK) {
-      return err;
+    if (received == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+        return APIError::WOULD_BLOCK;
+      }
+      state_ = State::FAILED;
+      HELPER_LOG("Socket read failed with errno %d", errno);
+      return APIError::SOCKET_READ_FAILED;
+    } else if (received == 0) {
+      state_ = State::FAILED;
+      HELPER_LOG("Connection closed");
+      return APIError::CONNECTION_CLOSED;
     }
     rx_buf_len_ += static_cast<uint16_t>(received);
     if (static_cast<uint16_t>(received) != to_read) {
@@ -1003,11 +1029,18 @@ APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   return APIError::OK;
 }
 APIError APIPlaintextFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) {
-  PacketInfo packet{type, 0, static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_)};
-  return write_protobuf_packets(buffer, std::span<const PacketInfo>(&packet, 1));
+  std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
+  uint16_t payload_len = static_cast<uint16_t>(raw_buffer->size() - frame_header_padding_);
+
+  // Use write_protobuf_packets with a single packet
+  std::vector<PacketInfo> packets;
+  packets.emplace_back(type, 0, payload_len);
+
+  return write_protobuf_packets(buffer, packets);
 }
 
-APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) {
+APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer,
+                                                         const std::vector<PacketInfo> &packets) {
   if (state_ != State::DATA) {
     return APIError::BAD_STATE;
   }
@@ -1017,15 +1050,17 @@ APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer
   }
 
   std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
-  uint8_t *buffer_data = raw_buffer->data();  // Cache buffer pointer
-
   this->reusable_iovs_.clear();
   this->reusable_iovs_.reserve(packets.size());
 
   for (const auto &packet : packets) {
+    uint16_t type = packet.message_type;
+    uint16_t offset = packet.offset;
+    uint16_t payload_len = packet.payload_size;
+
     // Calculate varint sizes for header layout
-    uint8_t size_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(packet.payload_size));
-    uint8_t type_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(packet.message_type));
+    uint8_t size_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(payload_len));
+    uint8_t type_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(type));
     uint8_t total_header_len = 1 + size_varint_len + type_varint_len;
 
     // Calculate where to start writing the header
@@ -1053,20 +1088,23 @@ APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer
     //
     // The message starts at offset + frame_header_padding_
     // So we write the header starting at offset + frame_header_padding_ - total_header_len
-    uint8_t *buf_start = buffer_data + packet.offset;
+    uint8_t *buf_start = raw_buffer->data() + offset;
     uint32_t header_offset = frame_header_padding_ - total_header_len;
 
     // Write the plaintext header
     buf_start[header_offset] = 0x00;  // indicator
 
-    // Encode varints directly into buffer
-    ProtoVarInt(packet.payload_size).encode_to_buffer_unchecked(buf_start + header_offset + 1, size_varint_len);
-    ProtoVarInt(packet.message_type)
-        .encode_to_buffer_unchecked(buf_start + header_offset + 1 + size_varint_len, type_varint_len);
+    // Encode size varint directly into buffer
+    ProtoVarInt(payload_len).encode_to_buffer_unchecked(buf_start + header_offset + 1, size_varint_len);
+
+    // Encode type varint directly into buffer
+    ProtoVarInt(type).encode_to_buffer_unchecked(buf_start + header_offset + 1 + size_varint_len, type_varint_len);
 
     // Add iovec for this packet (header + payload)
-    this->reusable_iovs_.push_back(
-        {buf_start + header_offset, static_cast<size_t>(total_header_len + packet.payload_size)});
+    struct iovec iov;
+    iov.iov_base = buf_start + header_offset;
+    iov.iov_len = total_header_len + payload_len;
+    this->reusable_iovs_.push_back(iov);
   }
 
   // Send all packets in one writev call

esphome/components/api/api_frame_helper.h

@@ -2,7 +2,6 @@
 #include <cstdint>
 #include <deque>
 #include <limits>
-#include <span>
 #include <utility>
 #include <vector>
 
@@ -102,7 +101,7 @@ class APIFrameHelper {
   // Write multiple protobuf packets in a single operation
   // packets contains (message_type, offset, length) for each message in the buffer
   // The buffer contains all messages with appropriate padding before each
-  virtual APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) = 0;
+  virtual APIError write_protobuf_packets(ProtoWriteBuffer buffer, const std::vector<PacketInfo> &packets) = 0;
   // Get the frame header padding required by this protocol
   virtual uint8_t frame_header_padding() = 0;
   // Get the frame footer size required by this protocol
@@ -176,9 +175,6 @@ class APIFrameHelper {
 
   // Common initialization for both plaintext and noise protocols
   APIError init_common_();
-
-  // Helper method to handle socket read results
-  APIError handle_socket_read_result_(ssize_t received);
 };
 
 #ifdef USE_API_NOISE
@@ -198,7 +194,7 @@ class APINoiseFrameHelper : public APIFrameHelper {
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
   APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
-  APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) override;
+  APIError write_protobuf_packets(ProtoWriteBuffer buffer, const std::vector<PacketInfo> &packets) override;
   // Get the frame header padding required by this protocol
   uint8_t frame_header_padding() override { return frame_header_padding_; }
   // Get the frame footer size required by this protocol
@@ -252,7 +248,7 @@ class APIPlaintextFrameHelper : public APIFrameHelper {
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
   APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
-  APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) override;
+  APIError write_protobuf_packets(ProtoWriteBuffer buffer, const std::vector<PacketInfo> &packets) override;
   uint8_t frame_header_padding() override { return frame_header_padding_; }
   // Get the frame footer size required by this protocol
   uint8_t frame_footer_size() override { return frame_footer_size_; }

esphome/components/api/api_pb2.cpp

@@ -2216,7 +2216,7 @@ void ExecuteServiceRequest::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_repeated_message(total_size, 1, this->args);
 }
-#ifdef USE_CAMERA
+#ifdef USE_ESP32_CAMERA
 bool ListEntitiesCameraResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 5: {

esphome/components/api/api_pb2.h

@@ -1273,7 +1273,7 @@ class ExecuteServiceRequest : public ProtoMessage {
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
 };
-#ifdef USE_CAMERA
+#ifdef USE_ESP32_CAMERA
 class ListEntitiesCameraResponse : public InfoResponseProtoMessage {
  public:
   static constexpr uint16_t MESSAGE_TYPE = 43;

esphome/components/api/api_pb2_service.cpp

@@ -204,7 +204,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_execute_service_request(msg);
       break;
     }
-#ifdef USE_CAMERA
+#ifdef USE_ESP32_CAMERA
     case 45: {
       CameraImageRequest msg;
       msg.decode(msg_data, msg_size);
@@ -682,7 +682,7 @@ void APIServerConnection::on_button_command_request(const ButtonCommandRequest &
   }
 }
 #endif
-#ifdef USE_CAMERA
+#ifdef USE_ESP32_CAMERA
 void APIServerConnection::on_camera_image_request(const CameraImageRequest &msg) {
   if (this->check_authenticated_()) {
     this->camera_image(msg);

esphome/components/api/api_pb2_service.h

@@ -71,7 +71,7 @@ class APIServerConnectionBase : public ProtoService {
 
   virtual void on_execute_service_request(const ExecuteServiceRequest &value){};
 
-#ifdef USE_CAMERA
+#ifdef USE_ESP32_CAMERA
   virtual void on_camera_image_request(const CameraImageRequest &value){};
 #endif
 
@@ -223,7 +223,7 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_BUTTON
   virtual void button_command(const ButtonCommandRequest &msg) = 0;
 #endif
-#ifdef USE_CAMERA
+#ifdef USE_ESP32_CAMERA
   virtual void camera_image(const CameraImageRequest &msg) = 0;
 #endif
 #ifdef USE_CLIMATE
@@ -340,7 +340,7 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_BUTTON
   void on_button_command_request(const ButtonCommandRequest &msg) override;
 #endif
-#ifdef USE_CAMERA
+#ifdef USE_ESP32_CAMERA
   void on_camera_image_request(const CameraImageRequest &msg) override;
 #endif
 #ifdef USE_CLIMATE

esphome/components/api/api_server.cpp

@@ -24,14 +24,6 @@ static const char *const TAG = "api";
 // APIServer
 APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-#ifndef USE_API_YAML_SERVICES
-// Global empty vector to avoid guard variables (saves 8 bytes)
-// This is initialized at program startup before any threads
-static const std::vector<UserServiceDescriptor *> empty_user_services{};
-
-const std::vector<UserServiceDescriptor *> &get_empty_user_services_instance() { return empty_user_services; }
-#endif
-
 APIServer::APIServer() {
   global_api_server = this;
   // Pre-allocate shared write buffer
@@ -104,30 +96,30 @@ void APIServer::setup() {
 
 #ifdef USE_LOGGER
   if (logger::global_logger != nullptr) {
-    logger::global_logger->add_on_log_callback(
-        [this](int level, const char *tag, const char *message, size_t message_len) {
-          if (this->shutting_down_) {
-            // Don't try to send logs during shutdown
-            // as it could result in a recursion and
-            // we would be filling a buffer we are trying to clear
-            return;
-          }
-          for (auto &c : this->clients_) {
-            if (!c->flags_.remove)
-              c->try_send_log_message(level, tag, message, message_len);
-          }
-        });
+    logger::global_logger->add_on_log_callback([this](int level, const char *tag, const char *message) {
+      if (this->shutting_down_) {
+        // Don't try to send logs during shutdown
+        // as it could result in a recursion and
+        // we would be filling a buffer we are trying to clear
+        return;
+      }
+      for (auto &c : this->clients_) {
+        if (!c->flags_.remove)
+          c->try_send_log_message(level, tag, message);
+      }
+    });
   }
 #endif
 
-#ifdef USE_CAMERA
-  if (camera::Camera::instance() != nullptr && !camera::Camera::instance()->is_internal()) {
-    camera::Camera::instance()->add_image_callback([this](const std::shared_ptr<camera::CameraImage> &image) {
-      for (auto &c : this->clients_) {
-        if (!c->flags_.remove)
-          c->set_camera_state(image);
-      }
-    });
+#ifdef USE_ESP32_CAMERA
+  if (esp32_camera::global_esp32_camera != nullptr && !esp32_camera::global_esp32_camera->is_internal()) {
+    esp32_camera::global_esp32_camera->add_image_callback(
+        [this](const std::shared_ptr<esp32_camera::CameraImage> &image) {
+          for (auto &c : this->clients_) {
+            if (!c->flags_.remove)
+              c->set_camera_state(image);
+          }
+        });
   }
 #endif
 }
@@ -261,108 +253,180 @@ bool APIServer::check_password(const std::string &password) const {
 
 void APIServer::handle_disconnect(APIConnection *conn) {}
 
-// Macro for entities without extra parameters
-#define API_DISPATCH_UPDATE(entity_type, entity_name) \
-  void APIServer::on_##entity_name##_update(entity_type *obj) { \
-    if (obj->is_internal()) \
-      return; \
-    for (auto &c : this->clients_) \
-      c->send_##entity_name##_state(obj); \
-  }
-
-// Macro for entities with extra parameters (but parameters not used in send)
-#define API_DISPATCH_UPDATE_IGNORE_PARAMS(entity_type, entity_name, ...) \
-  void APIServer::on_##entity_name##_update(entity_type *obj, __VA_ARGS__) { \
-    if (obj->is_internal()) \
-      return; \
-    for (auto &c : this->clients_) \
-      c->send_##entity_name##_state(obj); \
-  }
-
 #ifdef USE_BINARY_SENSOR
-API_DISPATCH_UPDATE(binary_sensor::BinarySensor, binary_sensor)
+void APIServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_binary_sensor_state(obj);
+}
 #endif
 
 #ifdef USE_COVER
-API_DISPATCH_UPDATE(cover::Cover, cover)
+void APIServer::on_cover_update(cover::Cover *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_cover_state(obj);
+}
 #endif
 
 #ifdef USE_FAN
-API_DISPATCH_UPDATE(fan::Fan, fan)
+void APIServer::on_fan_update(fan::Fan *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_fan_state(obj);
+}
 #endif
 
 #ifdef USE_LIGHT
-API_DISPATCH_UPDATE(light::LightState, light)
+void APIServer::on_light_update(light::LightState *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_light_state(obj);
+}
 #endif
 
 #ifdef USE_SENSOR
-API_DISPATCH_UPDATE_IGNORE_PARAMS(sensor::Sensor, sensor, float state)
+void APIServer::on_sensor_update(sensor::Sensor *obj, float state) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_sensor_state(obj);
+}
 #endif
 
 #ifdef USE_SWITCH
-API_DISPATCH_UPDATE_IGNORE_PARAMS(switch_::Switch, switch, bool state)
+void APIServer::on_switch_update(switch_::Switch *obj, bool state) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_switch_state(obj);
+}
 #endif
 
 #ifdef USE_TEXT_SENSOR
-API_DISPATCH_UPDATE_IGNORE_PARAMS(text_sensor::TextSensor, text_sensor, const std::string &state)
+void APIServer::on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_text_sensor_state(obj);
+}
 #endif
 
 #ifdef USE_CLIMATE
-API_DISPATCH_UPDATE(climate::Climate, climate)
+void APIServer::on_climate_update(climate::Climate *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_climate_state(obj);
+}
 #endif
 
 #ifdef USE_NUMBER
-API_DISPATCH_UPDATE_IGNORE_PARAMS(number::Number, number, float state)
+void APIServer::on_number_update(number::Number *obj, float state) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_number_state(obj);
+}
 #endif
 
 #ifdef USE_DATETIME_DATE
-API_DISPATCH_UPDATE(datetime::DateEntity, date)
+void APIServer::on_date_update(datetime::DateEntity *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_date_state(obj);
+}
 #endif
 
 #ifdef USE_DATETIME_TIME
-API_DISPATCH_UPDATE(datetime::TimeEntity, time)
+void APIServer::on_time_update(datetime::TimeEntity *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_time_state(obj);
+}
 #endif
 
 #ifdef USE_DATETIME_DATETIME
-API_DISPATCH_UPDATE(datetime::DateTimeEntity, datetime)
+void APIServer::on_datetime_update(datetime::DateTimeEntity *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_datetime_state(obj);
+}
 #endif
 
 #ifdef USE_TEXT
-API_DISPATCH_UPDATE_IGNORE_PARAMS(text::Text, text, const std::string &state)
+void APIServer::on_text_update(text::Text *obj, const std::string &state) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_text_state(obj);
+}
 #endif
 
 #ifdef USE_SELECT
-API_DISPATCH_UPDATE_IGNORE_PARAMS(select::Select, select, const std::string &state, size_t index)
+void APIServer::on_select_update(select::Select *obj, const std::string &state, size_t index) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_select_state(obj);
+}
 #endif
 
 #ifdef USE_LOCK
-API_DISPATCH_UPDATE(lock::Lock, lock)
+void APIServer::on_lock_update(lock::Lock *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_lock_state(obj);
+}
 #endif
 
 #ifdef USE_VALVE
-API_DISPATCH_UPDATE(valve::Valve, valve)
+void APIServer::on_valve_update(valve::Valve *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_valve_state(obj);
+}
 #endif
 
 #ifdef USE_MEDIA_PLAYER
-API_DISPATCH_UPDATE(media_player::MediaPlayer, media_player)
+void APIServer::on_media_player_update(media_player::MediaPlayer *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_media_player_state(obj);
+}
 #endif
 
 #ifdef USE_EVENT
-// Event is a special case - it's the only entity that passes extra parameters to the send method
 void APIServer::on_event(event::Event *obj, const std::string &event_type) {
-  if (obj->is_internal())
-    return;
   for (auto &c : this->clients_)
     c->send_event(obj, event_type);
 }
 #endif
 
 #ifdef USE_UPDATE
-API_DISPATCH_UPDATE(update::UpdateEntity, update)
+void APIServer::on_update(update::UpdateEntity *obj) {
+  for (auto &c : this->clients_)
+    c->send_update_state(obj);
+}
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
-API_DISPATCH_UPDATE(alarm_control_panel::AlarmControlPanel, alarm_control_panel)
+void APIServer::on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_alarm_control_panel_state(obj);
+}
 #endif
 
 float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }

esphome/components/api/api_server.h

@@ -25,11 +25,6 @@ struct SavedNoisePsk {
 } PACKED;  // NOLINT
 #endif
 
-#ifndef USE_API_YAML_SERVICES
-// Forward declaration of helper function
-const std::vector<UserServiceDescriptor *> &get_empty_user_services_instance();
-#endif
-
 class APIServer : public Component, public Controller {
  public:
   APIServer();
@@ -156,11 +151,8 @@ class APIServer : public Component, public Controller {
 #ifdef USE_API_YAML_SERVICES
     return this->user_services_;
 #else
-    if (this->user_services_) {
-      return *this->user_services_;
-    }
-    // Return reference to global empty instance (no guard needed)
-    return get_empty_user_services_instance();
+    static const std::vector<UserServiceDescriptor *> EMPTY;
+    return this->user_services_ ? *this->user_services_ : EMPTY;
 #endif
   }
 

esphome/components/api/list_entities.cpp

@@ -40,8 +40,8 @@ LIST_ENTITIES_HANDLER(lock, lock::Lock, ListEntitiesLockResponse)
 #ifdef USE_VALVE
 LIST_ENTITIES_HANDLER(valve, valve::Valve, ListEntitiesValveResponse)
 #endif
-#ifdef USE_CAMERA
-LIST_ENTITIES_HANDLER(camera, camera::Camera, ListEntitiesCameraResponse)
+#ifdef USE_ESP32_CAMERA
+LIST_ENTITIES_HANDLER(camera, esp32_camera::ESP32Camera, ListEntitiesCameraResponse)
 #endif
 #ifdef USE_CLIMATE
 LIST_ENTITIES_HANDLER(climate, climate::Climate, ListEntitiesClimateResponse)

esphome/components/api/list_entities.h

@@ -45,8 +45,8 @@ class ListEntitiesIterator : public ComponentIterator {
   bool on_text_sensor(text_sensor::TextSensor *entity) override;
 #endif
   bool on_service(UserServiceDescriptor *service) override;
-#ifdef USE_CAMERA
-  bool on_camera(camera::Camera *entity) override;
+#ifdef USE_ESP32_CAMERA
+  bool on_camera(esp32_camera::ESP32Camera *entity) override;
 #endif
 #ifdef USE_CLIMATE
   bool on_climate(climate::Climate *entity) override;

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -52,19 +52,11 @@ bool BluetoothProxy::parse_device(const esp32_ble_tracker::ESPBTDevice &device)
   return true;
 }
 
-// Batch size for BLE advertisements to maximize WiFi efficiency
-// Each advertisement is up to 80 bytes when packaged (including protocol overhead)
-// Most advertisements are 20-30 bytes, allowing even more to fit per packet
-// 16 advertisements × 80 bytes (worst case) = 1280 bytes out of ~1320 bytes usable payload
-// This achieves ~97% WiFi MTU utilization while staying under the limit
-static constexpr size_t FLUSH_BATCH_SIZE = 16;
-
-// Global batch buffer to avoid guard variable (saves 8 bytes)
-// This is initialized at program startup before any threads
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static std::vector<api::BluetoothLERawAdvertisement> batch_buffer;
-
-static std::vector<api::BluetoothLERawAdvertisement> &get_batch_buffer() { return batch_buffer; }
+static constexpr size_t FLUSH_BATCH_SIZE = 8;
+static std::vector<api::BluetoothLERawAdvertisement> &get_batch_buffer() {
+  static std::vector<api::BluetoothLERawAdvertisement> batch_buffer;
+  return batch_buffer;
+}
 
 bool BluetoothProxy::parse_devices(const esp32_ble::BLEScanResult *scan_results, size_t count) {
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || !this->raw_advertisements_)
@@ -178,7 +170,7 @@ int BluetoothProxy::get_bluetooth_connections_free() {
 void BluetoothProxy::loop() {
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr) {
     for (auto *connection : this->connections_) {
-      if (connection->get_address() != 0 && !connection->disconnect_pending()) {
+      if (connection->get_address() != 0) {
         connection->disconnect();
       }
     }

esphome/components/camera/__init__.py

@@ -1 +0,0 @@
-CODEOWNERS = ["@DT-art1", "@bdraco"]

esphome/components/camera/camera.cpp

@@ -1,22 +0,0 @@
-#include "camera.h"
-
-namespace esphome {
-namespace camera {
-
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-Camera *Camera::global_camera = nullptr;
-
-Camera::Camera() {
-  if (global_camera != nullptr) {
-    this->status_set_error("Multiple cameras are configured, but only one is supported.");
-    this->mark_failed();
-    return;
-  }
-
-  global_camera = this;
-}
-
-Camera *Camera::instance() { return global_camera; }
-
-}  // namespace camera
-}  // namespace esphome

esphome/components/camera/camera.h

@@ -1,80 +0,0 @@
-#pragma once
-
-#include "esphome/core/automation.h"
-#include "esphome/core/component.h"
-#include "esphome/core/entity_base.h"
-#include "esphome/core/helpers.h"
-
-namespace esphome {
-namespace camera {
-
-/** Different sources for filtering.
- *  IDLE: Camera requests to send an image to the API.
- *  API_REQUESTER: API requests a new image.
- *  WEB_REQUESTER: ESP32 web server request an image. Ignored by API.
- */
-enum CameraRequester : uint8_t { IDLE, API_REQUESTER, WEB_REQUESTER };
-
-/** Abstract camera image base class.
- *  Encapsulates the JPEG encoded data and it is shared among
- *  all connected clients.
- */
-class CameraImage {
- public:
-  virtual uint8_t *get_data_buffer() = 0;
-  virtual size_t get_data_length() = 0;
-  virtual bool was_requested_by(CameraRequester requester) const = 0;
-  virtual ~CameraImage() {}
-};
-
-/** Abstract image reader base class.
- *  Keeps track of the data offset of the camera image and
- *  how many bytes are remaining to read. When the image
- *  is returned, the shared_ptr is reset and the camera can
- *  reuse the memory of the camera image.
- */
-class CameraImageReader {
- public:
-  virtual void set_image(std::shared_ptr<CameraImage> image) = 0;
-  virtual size_t available() const = 0;
-  virtual uint8_t *peek_data_buffer() = 0;
-  virtual void consume_data(size_t consumed) = 0;
-  virtual void return_image() = 0;
-  virtual ~CameraImageReader() {}
-};
-
-/** Abstract camera base class. Collaborates with API.
- *  1) API server starts and installs callback (add_image_callback)
- *     which is called by the camera when a new image is available.
- *  2) New API client connects and creates a new image reader (create_image_reader).
- *  3) API connection receives protobuf CameraImageRequest and calls request_image.
- *  3.a) API connection receives protobuf CameraImageRequest and calls start_stream.
- *  4) Camera implementation provides JPEG data in the CameraImage and calls callback.
- *  5) API connection sets the image in the image reader.
- *  6) API connection consumes data from the image reader and returns the image when finished.
- *  7.a) Camera captures a new image and continues with 4) until start_stream is called.
- */
-class Camera : public EntityBase, public Component {
- public:
-  Camera();
-  // Camera implementation invokes callback to publish a new image.
-  virtual void add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&callback) = 0;
-  /// Returns a new camera image reader that keeps track of the JPEG data in the camera image.
-  virtual CameraImageReader *create_image_reader() = 0;
-  // Connection, camera or web server requests one new JPEG image.
-  virtual void request_image(CameraRequester requester) = 0;
-  // Connection, camera or web server requests a stream of images.
-  virtual void start_stream(CameraRequester requester) = 0;
-  // Connection or web server stops the previously started stream.
-  virtual void stop_stream(CameraRequester requester) = 0;
-  virtual ~Camera() {}
-  /// The singleton instance of the camera implementation.
-  static Camera *instance();
-
- protected:
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  static Camera *global_camera;
-};
-
-}  // namespace camera
-}  // namespace esphome

esphome/components/debug/__init__.py

@@ -1,5 +1,4 @@
 import esphome.codegen as cg
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BLOCK,
@@ -8,7 +7,6 @@ from esphome.const import (
     CONF_FREE,
     CONF_ID,
     CONF_LOOP_TIME,
-    PlatformFramework,
 )
 
 CODEOWNERS = ["@OttoWinter"]
@@ -46,21 +44,3 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "debug_esp32.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        "debug_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "debug_host.cpp": {PlatformFramework.HOST_NATIVE},
-        "debug_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
-        "debug_libretiny.cpp": {
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-    }
-)

esphome/components/deep_sleep/__init__.py

@@ -11,7 +11,6 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
 )
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DEFAULT,
@@ -28,7 +27,6 @@ from esphome.const import (
     CONF_WAKEUP_PIN,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
-    PlatformFramework,
 )
 
 WAKEUP_PINS = {
@@ -315,14 +313,3 @@ async def deep_sleep_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
     return var
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "deep_sleep_esp32.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        "deep_sleep_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-    }
-)

esphome/components/esp32/helpers.cpp

@@ -1,69 +0,0 @@
-#include "esphome/core/helpers.h"
-
-#ifdef USE_ESP32
-
-#include "esp_efuse.h"
-#include "esp_efuse_table.h"
-#include "esp_mac.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/portmacro.h>
-#include "esp_random.h"
-#include "esp_system.h"
-
-namespace esphome {
-
-uint32_t random_uint32() { return esp_random(); }
-bool random_bytes(uint8_t *data, size_t len) {
-  esp_fill_random(data, len);
-  return true;
-}
-
-Mutex::Mutex() { handle_ = xSemaphoreCreateMutex(); }
-Mutex::~Mutex() {}
-void Mutex::lock() { xSemaphoreTake(this->handle_, portMAX_DELAY); }
-bool Mutex::try_lock() { return xSemaphoreTake(this->handle_, 0) == pdTRUE; }
-void Mutex::unlock() { xSemaphoreGive(this->handle_); }
-
-// only affects the executing core
-// so should not be used as a mutex lock, only to get accurate timing
-IRAM_ATTR InterruptLock::InterruptLock() { portDISABLE_INTERRUPTS(); }
-IRAM_ATTR InterruptLock::~InterruptLock() { portENABLE_INTERRUPTS(); }
-
-void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
-#if defined(CONFIG_SOC_IEEE802154_SUPPORTED)
-  // When CONFIG_SOC_IEEE802154_SUPPORTED is defined, esp_efuse_mac_get_default
-  // returns the 802.15.4 EUI-64 address, so we read directly from eFuse instead.
-  if (has_custom_mac_address()) {
-    esp_efuse_read_field_blob(ESP_EFUSE_MAC_CUSTOM, mac, 48);
-  } else {
-    esp_efuse_read_field_blob(ESP_EFUSE_MAC_FACTORY, mac, 48);
-  }
-#else
-  if (has_custom_mac_address()) {
-    esp_efuse_mac_get_custom(mac);
-  } else {
-    esp_efuse_mac_get_default(mac);
-  }
-#endif
-}
-
-void set_mac_address(uint8_t *mac) { esp_base_mac_addr_set(mac); }
-
-bool has_custom_mac_address() {
-#if !defined(USE_ESP32_IGNORE_EFUSE_CUSTOM_MAC)
-  uint8_t mac[6];
-  // do not use 'esp_efuse_mac_get_custom(mac)' because it drops an error in the logs whenever it fails
-#ifndef USE_ESP32_VARIANT_ESP32
-  return (esp_efuse_read_field_blob(ESP_EFUSE_USER_DATA_MAC_CUSTOM, mac, 48) == ESP_OK) && mac_address_is_valid(mac);
-#else
-  return (esp_efuse_read_field_blob(ESP_EFUSE_MAC_CUSTOM, mac, 48) == ESP_OK) && mac_address_is_valid(mac);
-#endif
-#else
-  return false;
-#endif
-}
-
-}  // namespace esphome
-
-#endif  // USE_ESP32

esphome/components/esp32_ble/ble.h

@@ -25,15 +25,10 @@ namespace esphome {
 namespace esp32_ble {
 
 // Maximum number of BLE scan results to buffer
-// Sized to handle bursts of advertisements while allowing for processing delays
-// With 16 advertisements per batch and some safety margin:
-// - Without PSRAM: 24 entries (1.5× batch size)
-// - With PSRAM: 36 entries (2.25× batch size)
-// The reduced structure size (~80 bytes vs ~400 bytes) allows for larger buffers
 #ifdef USE_PSRAM
-static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 36;
+static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 32;
 #else
-static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 24;
+static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 20;
 #endif
 
 // Maximum size of the BLE event queue - must be power of 2 for lock-free queue
@@ -56,7 +51,7 @@ enum IoCapability {
   IO_CAP_KBDISP = ESP_IO_CAP_KBDISP,
 };
 
-enum BLEComponentState : uint8_t {
+enum BLEComponentState {
   /** Nothing has been initialized yet. */
   BLE_COMPONENT_STATE_OFF = 0,
   /** BLE should be disabled on next loop. */
@@ -146,31 +141,21 @@ class ESP32BLE : public Component {
  private:
   template<typename... Args> friend void enqueue_ble_event(Args... args);
 
-  // Vectors (12 bytes each on 32-bit, naturally aligned to 4 bytes)
   std::vector<GAPEventHandler *> gap_event_handlers_;
   std::vector<GAPScanEventHandler *> gap_scan_event_handlers_;
   std::vector<GATTcEventHandler *> gattc_event_handlers_;
   std::vector<GATTsEventHandler *> gatts_event_handlers_;
   std::vector<BLEStatusEventHandler *> ble_status_event_handlers_;
+  BLEComponentState state_{BLE_COMPONENT_STATE_OFF};
 
-  // Large objects (size depends on template parameters, but typically aligned to 4 bytes)
   esphome::LockFreeQueue<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_events_;
   esphome::EventPool<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_event_pool_;
-
-  // optional<string> (typically 16+ bytes on 32-bit, aligned to 4 bytes)
+  BLEAdvertising *advertising_{};
+  esp_ble_io_cap_t io_cap_{ESP_IO_CAP_NONE};
+  uint32_t advertising_cycle_time_{};
+  bool enable_on_boot_{};
   optional<std::string> name_;
-
-  // 4-byte aligned members
-  BLEAdvertising *advertising_{};             // 4 bytes (pointer)
-  esp_ble_io_cap_t io_cap_{ESP_IO_CAP_NONE};  // 4 bytes (enum)
-  uint32_t advertising_cycle_time_{};         // 4 bytes
-
-  // 2-byte aligned members
-  uint16_t appearance_{0};  // 2 bytes
-
-  // 1-byte aligned members (grouped together to minimize padding)
-  BLEComponentState state_{BLE_COMPONENT_STATE_OFF};  // 1 byte (uint8_t enum)
-  bool enable_on_boot_{};                             // 1 byte
+  uint16_t appearance_{0};
 };
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/esp32_camera/__init__.py

@@ -23,7 +23,7 @@ from esphome.core.entity_helpers import setup_entity
 
 DEPENDENCIES = ["esp32"]
 
-AUTO_LOAD = ["camera", "psram"]
+AUTO_LOAD = ["psram"]
 
 esp32_camera_ns = cg.esphome_ns.namespace("esp32_camera")
 ESP32Camera = esp32_camera_ns.class_("ESP32Camera", cg.PollingComponent, cg.EntityBase)
@@ -283,7 +283,6 @@ SETTERS = {
 
 
 async def to_code(config):
-    cg.add_define("USE_CAMERA")
     var = cg.new_Pvariable(config[CONF_ID])
     await setup_entity(var, config, "camera")
     await cg.register_component(var, config)

esphome/components/esp32_camera/esp32_camera.cpp

@@ -14,6 +14,8 @@ static const char *const TAG = "esp32_camera";
 
 /* ---------------- public API (derivated) ---------------- */
 void ESP32Camera::setup() {
+  global_esp32_camera = this;
+
 #ifdef USE_I2C
   if (this->i2c_bus_ != nullptr) {
     this->config_.sccb_i2c_port = this->i2c_bus_->get_port();
@@ -41,7 +43,7 @@ void ESP32Camera::setup() {
   xTaskCreatePinnedToCore(&ESP32Camera::framebuffer_task,
                           "framebuffer_task",  // name
                           1024,                // stack size
-                          this,                // task pv params
+                          nullptr,             // task pv params
                           1,                   // priority
                           nullptr,             // handle
                           1                    // core
@@ -174,7 +176,7 @@ void ESP32Camera::loop() {
   const uint32_t now = App.get_loop_component_start_time();
   if (this->idle_update_interval_ != 0 && now - this->last_idle_request_ > this->idle_update_interval_) {
     this->last_idle_request_ = now;
-    this->request_image(camera::IDLE);
+    this->request_image(IDLE);
   }
 
   // Check if we should fetch a new image
@@ -200,7 +202,7 @@ void ESP32Camera::loop() {
     xQueueSend(this->framebuffer_return_queue_, &fb, portMAX_DELAY);
     return;
   }
-  this->current_image_ = std::make_shared<ESP32CameraImage>(fb, this->single_requesters_ | this->stream_requesters_);
+  this->current_image_ = std::make_shared<CameraImage>(fb, this->single_requesters_ | this->stream_requesters_);
 
   ESP_LOGD(TAG, "Got Image: len=%u", fb->len);
   this->new_image_callback_.call(this->current_image_);
@@ -223,6 +225,8 @@ ESP32Camera::ESP32Camera() {
   this->config_.fb_count = 1;
   this->config_.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
   this->config_.fb_location = CAMERA_FB_IN_PSRAM;
+
+  global_esp32_camera = this;
 }
 
 /* ---------------- setters ---------------- */
@@ -352,7 +356,7 @@ void ESP32Camera::set_frame_buffer_count(uint8_t fb_count) {
 }
 
 /* ---------------- public API (specific) ---------------- */
-void ESP32Camera::add_image_callback(std::function<void(std::shared_ptr<camera::CameraImage>)> &&callback) {
+void ESP32Camera::add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&callback) {
   this->new_image_callback_.add(std::move(callback));
 }
 void ESP32Camera::add_stream_start_callback(std::function<void()> &&callback) {
@@ -361,16 +365,15 @@ void ESP32Camera::add_stream_start_callback(std::function<void()> &&callback) {
 void ESP32Camera::add_stream_stop_callback(std::function<void()> &&callback) {
   this->stream_stop_callback_.add(std::move(callback));
 }
-void ESP32Camera::start_stream(camera::CameraRequester requester) {
+void ESP32Camera::start_stream(CameraRequester requester) {
   this->stream_start_callback_.call();
   this->stream_requesters_ |= (1U << requester);
 }
-void ESP32Camera::stop_stream(camera::CameraRequester requester) {
+void ESP32Camera::stop_stream(CameraRequester requester) {
   this->stream_stop_callback_.call();
   this->stream_requesters_ &= ~(1U << requester);
 }
-void ESP32Camera::request_image(camera::CameraRequester requester) { this->single_requesters_ |= (1U << requester); }
-camera::CameraImageReader *ESP32Camera::create_image_reader() { return new ESP32CameraImageReader; }
+void ESP32Camera::request_image(CameraRequester requester) { this->single_requesters_ |= (1U << requester); }
 void ESP32Camera::update_camera_parameters() {
   sensor_t *s = esp_camera_sensor_get();
   /* update image */
@@ -399,39 +402,39 @@ void ESP32Camera::update_camera_parameters() {
 bool ESP32Camera::has_requested_image_() const { return this->single_requesters_ || this->stream_requesters_; }
 bool ESP32Camera::can_return_image_() const { return this->current_image_.use_count() == 1; }
 void ESP32Camera::framebuffer_task(void *pv) {
-  ESP32Camera *that = (ESP32Camera *) pv;
   while (true) {
     camera_fb_t *framebuffer = esp_camera_fb_get();
-    xQueueSend(that->framebuffer_get_queue_, &framebuffer, portMAX_DELAY);
+    xQueueSend(global_esp32_camera->framebuffer_get_queue_, &framebuffer, portMAX_DELAY);
     // return is no-op for config with 1 fb
-    xQueueReceive(that->framebuffer_return_queue_, &framebuffer, portMAX_DELAY);
+    xQueueReceive(global_esp32_camera->framebuffer_return_queue_, &framebuffer, portMAX_DELAY);
     esp_camera_fb_return(framebuffer);
   }
 }
 
-/* ---------------- ESP32CameraImageReader class ----------- */
-void ESP32CameraImageReader::set_image(std::shared_ptr<camera::CameraImage> image) {
-  this->image_ = std::static_pointer_cast<ESP32CameraImage>(image);
+ESP32Camera *global_esp32_camera;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+/* ---------------- CameraImageReader class ---------------- */
+void CameraImageReader::set_image(std::shared_ptr<CameraImage> image) {
+  this->image_ = std::move(image);
   this->offset_ = 0;
 }
-size_t ESP32CameraImageReader::available() const {
+size_t CameraImageReader::available() const {
   if (!this->image_)
     return 0;
 
   return this->image_->get_data_length() - this->offset_;
 }
-void ESP32CameraImageReader::return_image() { this->image_.reset(); }
-void ESP32CameraImageReader::consume_data(size_t consumed) { this->offset_ += consumed; }
-uint8_t *ESP32CameraImageReader::peek_data_buffer() { return this->image_->get_data_buffer() + this->offset_; }
+void CameraImageReader::return_image() { this->image_.reset(); }
+void CameraImageReader::consume_data(size_t consumed) { this->offset_ += consumed; }
+uint8_t *CameraImageReader::peek_data_buffer() { return this->image_->get_data_buffer() + this->offset_; }
 
-/* ---------------- ESP32CameraImage class ----------- */
-ESP32CameraImage::ESP32CameraImage(camera_fb_t *buffer, uint8_t requesters)
-    : buffer_(buffer), requesters_(requesters) {}
+/* ---------------- CameraImage class ---------------- */
+CameraImage::CameraImage(camera_fb_t *buffer, uint8_t requesters) : buffer_(buffer), requesters_(requesters) {}
 
-camera_fb_t *ESP32CameraImage::get_raw_buffer() { return this->buffer_; }
-uint8_t *ESP32CameraImage::get_data_buffer() { return this->buffer_->buf; }
-size_t ESP32CameraImage::get_data_length() { return this->buffer_->len; }
-bool ESP32CameraImage::was_requested_by(camera::CameraRequester requester) const {
+camera_fb_t *CameraImage::get_raw_buffer() { return this->buffer_; }
+uint8_t *CameraImage::get_data_buffer() { return this->buffer_->buf; }
+size_t CameraImage::get_data_length() { return this->buffer_->len; }
+bool CameraImage::was_requested_by(CameraRequester requester) const {
   return (this->requesters_ & (1 << requester)) != 0;
 }
 

esphome/components/esp32_camera/esp32_camera.h

@@ -7,7 +7,7 @@
 #include <freertos/queue.h>
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
-#include "esphome/components/camera/camera.h"
+#include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
 
 #ifdef USE_I2C
@@ -19,6 +19,9 @@ namespace esp32_camera {
 
 class ESP32Camera;
 
+/* ---------------- enum classes ---------------- */
+enum CameraRequester { IDLE, API_REQUESTER, WEB_REQUESTER };
+
 enum ESP32CameraFrameSize {
   ESP32_CAMERA_SIZE_160X120,    // QQVGA
   ESP32_CAMERA_SIZE_176X144,    // QCIF
@@ -74,13 +77,13 @@ enum ESP32SpecialEffect {
 };
 
 /* ---------------- CameraImage class ---------------- */
-class ESP32CameraImage : public camera::CameraImage {
+class CameraImage {
  public:
-  ESP32CameraImage(camera_fb_t *buffer, uint8_t requester);
+  CameraImage(camera_fb_t *buffer, uint8_t requester);
   camera_fb_t *get_raw_buffer();
-  uint8_t *get_data_buffer() override;
-  size_t get_data_length() override;
-  bool was_requested_by(camera::CameraRequester requester) const override;
+  uint8_t *get_data_buffer();
+  size_t get_data_length();
+  bool was_requested_by(CameraRequester requester) const;
 
  protected:
   camera_fb_t *buffer_;
@@ -93,21 +96,21 @@ struct CameraImageData {
 };
 
 /* ---------------- CameraImageReader class ---------------- */
-class ESP32CameraImageReader : public camera::CameraImageReader {
+class CameraImageReader {
  public:
-  void set_image(std::shared_ptr<camera::CameraImage> image) override;
-  size_t available() const override;
-  uint8_t *peek_data_buffer() override;
-  void consume_data(size_t consumed) override;
-  void return_image() override;
+  void set_image(std::shared_ptr<CameraImage> image);
+  size_t available() const;
+  uint8_t *peek_data_buffer();
+  void consume_data(size_t consumed);
+  void return_image();
 
  protected:
-  std::shared_ptr<ESP32CameraImage> image_;
+  std::shared_ptr<CameraImage> image_;
   size_t offset_{0};
 };
 
 /* ---------------- ESP32Camera class ---------------- */
-class ESP32Camera : public camera::Camera {
+class ESP32Camera : public EntityBase, public Component {
  public:
   ESP32Camera();
 
@@ -159,15 +162,14 @@ class ESP32Camera : public camera::Camera {
   void dump_config() override;
   float get_setup_priority() const override;
   /* public API (specific) */
-  void start_stream(camera::CameraRequester requester) override;
-  void stop_stream(camera::CameraRequester requester) override;
-  void request_image(camera::CameraRequester requester) override;
+  void start_stream(CameraRequester requester);
+  void stop_stream(CameraRequester requester);
+  void request_image(CameraRequester requester);
   void update_camera_parameters();
 
-  void add_image_callback(std::function<void(std::shared_ptr<camera::CameraImage>)> &&callback) override;
+  void add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&callback);
   void add_stream_start_callback(std::function<void()> &&callback);
   void add_stream_stop_callback(std::function<void()> &&callback);
-  camera::CameraImageReader *create_image_reader() override;
 
  protected:
   /* internal methods */
@@ -204,12 +206,12 @@ class ESP32Camera : public camera::Camera {
   uint32_t idle_update_interval_{15000};
 
   esp_err_t init_error_{ESP_OK};
-  std::shared_ptr<ESP32CameraImage> current_image_;
+  std::shared_ptr<CameraImage> current_image_;
   uint8_t single_requesters_{0};
   uint8_t stream_requesters_{0};
   QueueHandle_t framebuffer_get_queue_;
   QueueHandle_t framebuffer_return_queue_;
-  CallbackManager<void(std::shared_ptr<camera::CameraImage>)> new_image_callback_{};
+  CallbackManager<void(std::shared_ptr<CameraImage>)> new_image_callback_{};
   CallbackManager<void()> stream_start_callback_{};
   CallbackManager<void()> stream_stop_callback_{};
 
@@ -220,10 +222,13 @@ class ESP32Camera : public camera::Camera {
 #endif  // USE_I2C
 };
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+extern ESP32Camera *global_esp32_camera;
+
 class ESP32CameraImageTrigger : public Trigger<CameraImageData> {
  public:
   explicit ESP32CameraImageTrigger(ESP32Camera *parent) {
-    parent->add_image_callback([this](const std::shared_ptr<camera::CameraImage> &image) {
+    parent->add_image_callback([this](const std::shared_ptr<esp32_camera::CameraImage> &image) {
       CameraImageData camera_image_data{};
       camera_image_data.length = image->get_data_length();
       camera_image_data.data = image->get_data_buffer();

esphome/components/esp32_camera_web_server/__init__.py

@@ -3,8 +3,7 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_MODE, CONF_PORT
 
 CODEOWNERS = ["@ayufan"]
-AUTO_LOAD = ["camera"]
-DEPENDENCIES = ["network"]
+DEPENDENCIES = ["esp32_camera", "network"]
 MULTI_CONF = True
 
 esp32_camera_web_server_ns = cg.esphome_ns.namespace("esp32_camera_web_server")

esphome/components/esp32_camera_web_server/camera_web_server.cpp

@@ -40,7 +40,7 @@ CameraWebServer::CameraWebServer() {}
 CameraWebServer::~CameraWebServer() {}
 
 void CameraWebServer::setup() {
-  if (!camera::Camera::instance() || camera::Camera::instance()->is_failed()) {
+  if (!esp32_camera::global_esp32_camera || esp32_camera::global_esp32_camera->is_failed()) {
     this->mark_failed();
     return;
   }
@@ -67,8 +67,8 @@ void CameraWebServer::setup() {
 
   httpd_register_uri_handler(this->httpd_, &uri);
 
-  camera::Camera::instance()->add_image_callback([this](std::shared_ptr<camera::CameraImage> image) {
-    if (this->running_ && image->was_requested_by(camera::WEB_REQUESTER)) {
+  esp32_camera::global_esp32_camera->add_image_callback([this](std::shared_ptr<esp32_camera::CameraImage> image) {
+    if (this->running_ && image->was_requested_by(esp32_camera::WEB_REQUESTER)) {
       this->image_ = std::move(image);
       xSemaphoreGive(this->semaphore_);
     }
@@ -108,8 +108,8 @@ void CameraWebServer::loop() {
   }
 }
 
-std::shared_ptr<esphome::camera::CameraImage> CameraWebServer::wait_for_image_() {
-  std::shared_ptr<esphome::camera::CameraImage> image;
+std::shared_ptr<esphome::esp32_camera::CameraImage> CameraWebServer::wait_for_image_() {
+  std::shared_ptr<esphome::esp32_camera::CameraImage> image;
   image.swap(this->image_);
 
   if (!image) {
@@ -172,7 +172,7 @@ esp_err_t CameraWebServer::streaming_handler_(struct httpd_req *req) {
   uint32_t last_frame = millis();
   uint32_t frames = 0;
 
-  camera::Camera::instance()->start_stream(esphome::camera::WEB_REQUESTER);
+  esp32_camera::global_esp32_camera->start_stream(esphome::esp32_camera::WEB_REQUESTER);
 
   while (res == ESP_OK && this->running_) {
     auto image = this->wait_for_image_();
@@ -205,7 +205,7 @@ esp_err_t CameraWebServer::streaming_handler_(struct httpd_req *req) {
     res = httpd_send_all(req, STREAM_ERROR, strlen(STREAM_ERROR));
   }
 
-  camera::Camera::instance()->stop_stream(esphome::camera::WEB_REQUESTER);
+  esp32_camera::global_esp32_camera->stop_stream(esphome::esp32_camera::WEB_REQUESTER);
 
   ESP_LOGI(TAG, "STREAM: closed. Frames: %" PRIu32, frames);
 
@@ -215,7 +215,7 @@ esp_err_t CameraWebServer::streaming_handler_(struct httpd_req *req) {
 esp_err_t CameraWebServer::snapshot_handler_(struct httpd_req *req) {
   esp_err_t res = ESP_OK;
 
-  camera::Camera::instance()->request_image(esphome::camera::WEB_REQUESTER);
+  esp32_camera::global_esp32_camera->request_image(esphome::esp32_camera::WEB_REQUESTER);
 
   auto image = this->wait_for_image_();
 

esphome/components/esp32_camera_web_server/camera_web_server.h

@@ -6,7 +6,7 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 
-#include "esphome/components/camera/camera.h"
+#include "esphome/components/esp32_camera/esp32_camera.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
@@ -32,7 +32,7 @@ class CameraWebServer : public Component {
   void loop() override;
 
  protected:
-  std::shared_ptr<camera::CameraImage> wait_for_image_();
+  std::shared_ptr<esphome::esp32_camera::CameraImage> wait_for_image_();
   esp_err_t handler_(struct httpd_req *req);
   esp_err_t streaming_handler_(struct httpd_req *req);
   esp_err_t snapshot_handler_(struct httpd_req *req);
@@ -40,7 +40,7 @@ class CameraWebServer : public Component {
   uint16_t port_{0};
   void *httpd_{nullptr};
   SemaphoreHandle_t semaphore_;
-  std::shared_ptr<camera::CameraImage> image_;
+  std::shared_ptr<esphome::esp32_camera::CameraImage> image_;
   bool running_{false};
   Mode mode_{STREAM};
 };

esphome/components/esp8266/helpers.cpp

@@ -1,31 +0,0 @@
-#include "esphome/core/helpers.h"
-
-#ifdef USE_ESP8266
-
-#include <osapi.h>
-#include <user_interface.h>
-// for xt_rsil()/xt_wsr_ps()
-#include <Arduino.h>
-
-namespace esphome {
-
-uint32_t random_uint32() { return os_random(); }
-bool random_bytes(uint8_t *data, size_t len) { return os_get_random(data, len) == 0; }
-
-// ESP8266 doesn't have mutexes, but that shouldn't be an issue as it's single-core and non-preemptive OS.
-Mutex::Mutex() {}
-Mutex::~Mutex() {}
-void Mutex::lock() {}
-bool Mutex::try_lock() { return true; }
-void Mutex::unlock() {}
-
-IRAM_ATTR InterruptLock::InterruptLock() { state_ = xt_rsil(15); }
-IRAM_ATTR InterruptLock::~InterruptLock() { xt_wsr_ps(state_); }
-
-void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
-  wifi_get_macaddr(STATION_IF, mac);
-}
-
-}  // namespace esphome
-
-#endif  // USE_ESP8266

esphome/components/host/helpers.cpp

@@ -1,57 +0,0 @@
-#include "esphome/core/helpers.h"
-
-#ifdef USE_HOST
-
-#ifndef _WIN32
-#include <net/if.h>
-#include <netinet/in.h>
-#include <sys/ioctl.h>
-#endif
-#include <unistd.h>
-#include <limits>
-#include <random>
-
-#include "esphome/core/defines.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-
-static const char *const TAG = "helpers.host";
-
-uint32_t random_uint32() {
-  std::random_device dev;
-  std::mt19937 rng(dev());
-  std::uniform_int_distribution<uint32_t> dist(0, std::numeric_limits<uint32_t>::max());
-  return dist(rng);
-}
-
-bool random_bytes(uint8_t *data, size_t len) {
-  FILE *fp = fopen("/dev/urandom", "r");
-  if (fp == nullptr) {
-    ESP_LOGW(TAG, "Could not open /dev/urandom, errno=%d", errno);
-    exit(1);
-  }
-  size_t read = fread(data, 1, len, fp);
-  if (read != len) {
-    ESP_LOGW(TAG, "Not enough data from /dev/urandom");
-    exit(1);
-  }
-  fclose(fp);
-  return true;
-}
-
-// Host platform uses std::mutex for proper thread synchronization
-Mutex::Mutex() { handle_ = new std::mutex(); }
-Mutex::~Mutex() { delete static_cast<std::mutex *>(handle_); }
-void Mutex::lock() { static_cast<std::mutex *>(handle_)->lock(); }
-bool Mutex::try_lock() { return static_cast<std::mutex *>(handle_)->try_lock(); }
-void Mutex::unlock() { static_cast<std::mutex *>(handle_)->unlock(); }
-
-void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
-  static const uint8_t esphome_host_mac_address[6] = USE_ESPHOME_HOST_MAC_ADDRESS;
-  memcpy(mac, esphome_host_mac_address, sizeof(esphome_host_mac_address));
-}
-
-}  // namespace esphome
-
-#endif  // USE_HOST

esphome/components/http_request/__init__.py

@@ -2,7 +2,6 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import esp32
 from esphome.components.const import CONF_REQUEST_HEADERS
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ESP8266_DISABLE_SSL_SUPPORT,
@@ -14,7 +13,6 @@ from esphome.const import (
     CONF_URL,
     CONF_WATCHDOG_TIMEOUT,
     PLATFORM_HOST,
-    PlatformFramework,
     __version__,
 )
 from esphome.core import CORE, Lambda
@@ -321,19 +319,3 @@ async def http_request_action_to_code(config, action_id, template_arg, args):
         await automation.build_automation(trigger, [], conf)
 
     return var
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "http_request_host.cpp": {PlatformFramework.HOST_NATIVE},
-        "http_request_arduino.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP8266_ARDUINO,
-            PlatformFramework.RP2040_ARDUINO,
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-        "http_request_idf.cpp": {PlatformFramework.ESP32_IDF},
-    }
-)

esphome/components/http_request/update/http_request_update.cpp

@@ -50,8 +50,7 @@ void HttpRequestUpdate::update_task(void *params) {
 
   if (container == nullptr || container->status_code != HTTP_STATUS_OK) {
     std::string msg = str_sprintf("Failed to fetch manifest from %s", this_update->source_url_.c_str());
-    // Defer to main loop to avoid race condition on component_state_ read-modify-write
-    this_update->defer([this_update, msg]() { this_update->status_set_error(msg.c_str()); });
+    this_update->status_set_error(msg.c_str());
     UPDATE_RETURN;
   }
 
@@ -59,8 +58,7 @@ void HttpRequestUpdate::update_task(void *params) {
   uint8_t *data = allocator.allocate(container->content_length);
   if (data == nullptr) {
     std::string msg = str_sprintf("Failed to allocate %zu bytes for manifest", container->content_length);
-    // Defer to main loop to avoid race condition on component_state_ read-modify-write
-    this_update->defer([this_update, msg]() { this_update->status_set_error(msg.c_str()); });
+    this_update->status_set_error(msg.c_str());
     container->end();
     UPDATE_RETURN;
   }
@@ -122,8 +120,7 @@ void HttpRequestUpdate::update_task(void *params) {
 
   if (!valid) {
     std::string msg = str_sprintf("Failed to parse JSON from %s", this_update->source_url_.c_str());
-    // Defer to main loop to avoid race condition on component_state_ read-modify-write
-    this_update->defer([this_update, msg]() { this_update->status_set_error(msg.c_str()); });
+    this_update->status_set_error(msg.c_str());
     UPDATE_RETURN;
   }
 
@@ -150,34 +147,18 @@ void HttpRequestUpdate::update_task(void *params) {
     this_update->update_info_.current_version = current_version;
   }
 
-  bool trigger_update_available = false;
-
   if (this_update->update_info_.latest_version.empty() ||
       this_update->update_info_.latest_version == this_update->update_info_.current_version) {
     this_update->state_ = update::UPDATE_STATE_NO_UPDATE;
   } else {
-    if (this_update->state_ != update::UPDATE_STATE_AVAILABLE) {
-      trigger_update_available = true;
-    }
     this_update->state_ = update::UPDATE_STATE_AVAILABLE;
   }
 
-  // Defer to main loop to ensure thread-safe execution of:
-  // - status_clear_error() performs non-atomic read-modify-write on component_state_
-  // - publish_state() triggers API callbacks that write to the shared protobuf buffer
-  //   which can be corrupted if accessed concurrently from task and main loop threads
-  // - update_available trigger to ensure consistent state when the trigger fires
-  this_update->defer([this_update, trigger_update_available]() {
-    this_update->update_info_.has_progress = false;
-    this_update->update_info_.progress = 0.0f;
+  this_update->update_info_.has_progress = false;
+  this_update->update_info_.progress = 0.0f;
 
-    this_update->status_clear_error();
-    this_update->publish_state();
-
-    if (trigger_update_available) {
-      this_update->get_update_available_trigger()->trigger(this_update->update_info_);
-    }
-  });
+  this_update->status_clear_error();
+  this_update->publish_state();
 
   UPDATE_RETURN;
 }

esphome/components/i2c/__init__.py

@@ -3,7 +3,6 @@ import logging
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import esp32
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ADDRESS,
@@ -19,7 +18,6 @@ from esphome.const import (
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
     PLATFORM_RP2040,
-    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 import esphome.final_validate as fv
@@ -207,18 +205,3 @@ def final_validate_device_schema(
         {cv.Required(CONF_I2C_ID): fv.id_declaration_match_schema(hub_schema)},
         extra=cv.ALLOW_EXTRA,
     )
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "i2c_bus_arduino.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP8266_ARDUINO,
-            PlatformFramework.RP2040_ARDUINO,
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-        "i2c_bus_esp_idf.cpp": {PlatformFramework.ESP32_IDF},
-    }
-)

esphome/components/inkplate6/display.py

@@ -1,7 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import display, i2c
-from esphome.components.esp32 import CONF_CPU_FREQUENCY
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_FULL_UPDATE_EVERY,
@@ -14,9 +13,7 @@ from esphome.const import (
     CONF_PAGES,
     CONF_TRANSFORM,
     CONF_WAKEUP_PIN,
-    PLATFORM_ESP32,
 )
-import esphome.final_validate as fv
 
 DEPENDENCIES = ["i2c", "esp32"]
 AUTO_LOAD = ["psram"]
@@ -123,18 +120,6 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def _validate_cpu_frequency(config):
-    esp32_config = fv.full_config.get()[PLATFORM_ESP32]
-    if esp32_config[CONF_CPU_FREQUENCY] != "240MHZ":
-        raise cv.Invalid(
-            "Inkplate requires 240MHz CPU frequency (set in esp32 component)"
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _validate_cpu_frequency
-
-
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
 

esphome/components/ld2410/button/__init__.py

@@ -14,8 +14,8 @@ from esphome.const import (
 
 from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
 
-FactoryResetButton = ld2410_ns.class_("FactoryResetButton", button.Button)
 QueryButton = ld2410_ns.class_("QueryButton", button.Button)
+ResetButton = ld2410_ns.class_("ResetButton", button.Button)
 RestartButton = ld2410_ns.class_("RestartButton", button.Button)
 
 CONF_QUERY_PARAMS = "query_params"
@@ -23,7 +23,7 @@ CONF_QUERY_PARAMS = "query_params"
 CONFIG_SCHEMA = {
     cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
     cv.Optional(CONF_FACTORY_RESET): button.button_schema(
-        FactoryResetButton,
+        ResetButton,
         device_class=DEVICE_CLASS_RESTART,
         entity_category=ENTITY_CATEGORY_CONFIG,
         icon=ICON_RESTART_ALERT,
@@ -47,7 +47,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_LD2410_ID])
-        cg.add(ld2410_component.set_factory_reset_button(b))
+        cg.add(ld2410_component.set_reset_button(b))
     if restart_config := config.get(CONF_RESTART):
         b = await button.new_button(restart_config)
         await cg.register_parented(b, config[CONF_LD2410_ID])

esphome/components/ld2410/button/factory_reset_button.cpp

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

esphome/components/ld2410/button/reset_button.cpp

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

esphome/components/ld2410/button/reset_button.h

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

esphome/components/ld2410/ld2410.cpp

@@ -18,10 +18,11 @@ namespace esphome {
 namespace ld2410 {
 
 static const char *const TAG = "ld2410";
+static const char *const NO_MAC = "08:05:04:03:02:01";
 static const char *const UNKNOWN_MAC = "unknown";
 static const char *const VERSION_FMT = "%u.%02X.%02X%02X%02X%02X";
 
-enum BaudRate : uint8_t {
+enum BaudRateStructure : uint8_t {
   BAUD_RATE_9600 = 1,
   BAUD_RATE_19200 = 2,
   BAUD_RATE_38400 = 3,
@@ -32,23 +33,23 @@ enum BaudRate : uint8_t {
   BAUD_RATE_460800 = 8,
 };
 
-enum DistanceResolution : uint8_t {
+enum DistanceResolutionStructure : uint8_t {
   DISTANCE_RESOLUTION_0_2 = 0x01,
   DISTANCE_RESOLUTION_0_75 = 0x00,
 };
 
-enum LightFunction : uint8_t {
+enum LightFunctionStructure : uint8_t {
   LIGHT_FUNCTION_OFF = 0x00,
   LIGHT_FUNCTION_BELOW = 0x01,
   LIGHT_FUNCTION_ABOVE = 0x02,
 };
 
-enum OutPinLevel : uint8_t {
+enum OutPinLevelStructure : uint8_t {
   OUT_PIN_LEVEL_LOW = 0x00,
   OUT_PIN_LEVEL_HIGH = 0x01,
 };
 
-enum PeriodicData : uint8_t {
+enum PeriodicDataStructure : uint8_t {
   DATA_TYPES = 6,
   TARGET_STATES = 8,
   MOVING_TARGET_LOW = 9,
@@ -66,12 +67,12 @@ enum PeriodicData : uint8_t {
 };
 
 enum PeriodicDataValue : uint8_t {
-  HEADER = 0xAA,
-  FOOTER = 0x55,
+  HEAD = 0xAA,
+  END = 0x55,
   CHECK = 0x00,
 };
 
-enum AckData : uint8_t {
+enum AckDataStructure : uint8_t {
   COMMAND = 6,
   COMMAND_STATUS = 7,
 };
@@ -79,11 +80,11 @@ enum AckData : uint8_t {
 // Memory-efficient lookup tables
 struct StringToUint8 {
   const char *str;
-  const uint8_t value;
+  uint8_t value;
 };
 
 struct Uint8ToString {
-  const uint8_t value;
+  uint8_t value;
   const char *str;
 };
 
@@ -143,119 +144,96 @@ template<size_t N> const char *find_str(const Uint8ToString (&arr)[N], uint8_t v
 }
 
 // Commands
-static constexpr uint8_t CMD_ENABLE_CONF = 0xFF;
-static constexpr uint8_t CMD_DISABLE_CONF = 0xFE;
-static constexpr uint8_t CMD_ENABLE_ENG = 0x62;
-static constexpr uint8_t CMD_DISABLE_ENG = 0x63;
-static constexpr uint8_t CMD_MAXDIST_DURATION = 0x60;
-static constexpr uint8_t CMD_QUERY = 0x61;
-static constexpr uint8_t CMD_GATE_SENS = 0x64;
-static constexpr uint8_t CMD_QUERY_VERSION = 0xA0;
-static constexpr uint8_t CMD_QUERY_DISTANCE_RESOLUTION = 0xAB;
-static constexpr uint8_t CMD_SET_DISTANCE_RESOLUTION = 0xAA;
-static constexpr uint8_t CMD_QUERY_LIGHT_CONTROL = 0xAE;
-static constexpr uint8_t CMD_SET_LIGHT_CONTROL = 0xAD;
-static constexpr uint8_t CMD_SET_BAUD_RATE = 0xA1;
-static constexpr uint8_t CMD_BT_PASSWORD = 0xA9;
-static constexpr uint8_t CMD_QUERY_MAC_ADDRESS = 0xA5;
-static constexpr uint8_t CMD_RESET = 0xA2;
-static constexpr uint8_t CMD_RESTART = 0xA3;
-static constexpr uint8_t CMD_BLUETOOTH = 0xA4;
+static const uint8_t CMD_ENABLE_CONF = 0xFF;
+static const uint8_t CMD_DISABLE_CONF = 0xFE;
+static const uint8_t CMD_ENABLE_ENG = 0x62;
+static const uint8_t CMD_DISABLE_ENG = 0x63;
+static const uint8_t CMD_MAXDIST_DURATION = 0x60;
+static const uint8_t CMD_QUERY = 0x61;
+static const uint8_t CMD_GATE_SENS = 0x64;
+static const uint8_t CMD_VERSION = 0xA0;
+static const uint8_t CMD_QUERY_DISTANCE_RESOLUTION = 0xAB;
+static const uint8_t CMD_SET_DISTANCE_RESOLUTION = 0xAA;
+static const uint8_t CMD_QUERY_LIGHT_CONTROL = 0xAE;
+static const uint8_t CMD_SET_LIGHT_CONTROL = 0xAD;
+static const uint8_t CMD_SET_BAUD_RATE = 0xA1;
+static const uint8_t CMD_BT_PASSWORD = 0xA9;
+static const uint8_t CMD_MAC = 0xA5;
+static const uint8_t CMD_RESET = 0xA2;
+static const uint8_t CMD_RESTART = 0xA3;
+static const uint8_t CMD_BLUETOOTH = 0xA4;
 // Commands values
-static constexpr uint8_t CMD_MAX_MOVE_VALUE = 0x00;
-static constexpr uint8_t CMD_MAX_STILL_VALUE = 0x01;
-static constexpr uint8_t CMD_DURATION_VALUE = 0x02;
-// Header & Footer size
-static constexpr uint8_t HEADER_FOOTER_SIZE = 4;
+static const uint8_t CMD_MAX_MOVE_VALUE = 0x00;
+static const uint8_t CMD_MAX_STILL_VALUE = 0x01;
+static const uint8_t CMD_DURATION_VALUE = 0x02;
 // Command Header & Footer
-static constexpr uint8_t CMD_FRAME_HEADER[HEADER_FOOTER_SIZE] = {0xFD, 0xFC, 0xFB, 0xFA};
-static constexpr uint8_t CMD_FRAME_FOOTER[HEADER_FOOTER_SIZE] = {0x04, 0x03, 0x02, 0x01};
+static const uint8_t CMD_FRAME_HEADER[4] = {0xFD, 0xFC, 0xFB, 0xFA};
+static const uint8_t CMD_FRAME_END[4] = {0x04, 0x03, 0x02, 0x01};
 // Data Header & Footer
-static constexpr uint8_t DATA_FRAME_HEADER[HEADER_FOOTER_SIZE] = {0xF4, 0xF3, 0xF2, 0xF1};
-static constexpr uint8_t DATA_FRAME_FOOTER[HEADER_FOOTER_SIZE] = {0xF8, 0xF7, 0xF6, 0xF5};
-// MAC address the module uses when Bluetooth is disabled
-static constexpr uint8_t NO_MAC[] = {0x08, 0x05, 0x04, 0x03, 0x02, 0x01};
+static const uint8_t DATA_FRAME_HEADER[4] = {0xF4, 0xF3, 0xF2, 0xF1};
+static const uint8_t DATA_FRAME_END[4] = {0xF8, 0xF7, 0xF6, 0xF5};
 
 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
-}
-
 void LD2410Component::dump_config() {
-  std::string mac_str =
-      mac_address_is_valid(this->mac_address_) ? format_mac_address_pretty(this->mac_address_) : UNKNOWN_MAC;
-  std::string version = str_sprintf(VERSION_FMT, this->version_[1], this->version_[0], this->version_[5],
-                                    this->version_[4], this->version_[3], this->version_[2]);
-  ESP_LOGCONFIG(TAG,
-                "LD2410:\n"
-                "  Firmware version: %s\n"
-                "  MAC address: %s\n"
-                "  Throttle: %u ms",
-                version.c_str(), mac_str.c_str(), this->throttle_);
+  ESP_LOGCONFIG(TAG, "LD2410:");
 #ifdef USE_BINARY_SENSOR
-  ESP_LOGCONFIG(TAG, "Binary Sensors:");
-  LOG_BINARY_SENSOR("  ", "Target", this->target_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "MovingTarget", this->moving_target_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "StillTarget", this->still_target_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "OutPinPresenceStatus", this->out_pin_presence_status_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "TargetBinarySensor", this->target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "MovingTargetBinarySensor", this->moving_target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "StillTargetBinarySensor", this->still_target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "OutPinPresenceStatusBinarySensor", this->out_pin_presence_status_binary_sensor_);
+#endif
+#ifdef USE_SWITCH
+  LOG_SWITCH("  ", "EngineeringModeSwitch", this->engineering_mode_switch_);
+  LOG_SWITCH("  ", "BluetoothSwitch", this->bluetooth_switch_);
+#endif
+#ifdef USE_BUTTON
+  LOG_BUTTON("  ", "ResetButton", this->reset_button_);
+  LOG_BUTTON("  ", "RestartButton", this->restart_button_);
+  LOG_BUTTON("  ", "QueryButton", this->query_button_);
 #endif
 #ifdef USE_SENSOR
-  ESP_LOGCONFIG(TAG, "Sensors:");
-  LOG_SENSOR("  ", "Light", this->light_sensor_);
-  LOG_SENSOR("  ", "DetectionDistance", this->detection_distance_sensor_);
-  LOG_SENSOR("  ", "MovingTargetDistance", this->moving_target_distance_sensor_);
-  LOG_SENSOR("  ", "MovingTargetEnergy", this->moving_target_energy_sensor_);
-  LOG_SENSOR("  ", "StillTargetDistance", this->still_target_distance_sensor_);
-  LOG_SENSOR("  ", "StillTargetEnergy", this->still_target_energy_sensor_);
-  for (sensor::Sensor *s : this->gate_move_sensors_) {
-    LOG_SENSOR("  ", "GateMove", s);
-  }
+  LOG_SENSOR("  ", "LightSensor", this->light_sensor_);
+  LOG_SENSOR("  ", "MovingTargetDistanceSensor", this->moving_target_distance_sensor_);
+  LOG_SENSOR("  ", "StillTargetDistanceSensor", this->still_target_distance_sensor_);
+  LOG_SENSOR("  ", "MovingTargetEnergySensor", this->moving_target_energy_sensor_);
+  LOG_SENSOR("  ", "StillTargetEnergySensor", this->still_target_energy_sensor_);
+  LOG_SENSOR("  ", "DetectionDistanceSensor", this->detection_distance_sensor_);
   for (sensor::Sensor *s : this->gate_still_sensors_) {
-    LOG_SENSOR("  ", "GateStill", s);
+    LOG_SENSOR("  ", "NthGateStillSesnsor", s);
+  }
+  for (sensor::Sensor *s : this->gate_move_sensors_) {
+    LOG_SENSOR("  ", "NthGateMoveSesnsor", s);
   }
 #endif
 #ifdef USE_TEXT_SENSOR
-  ESP_LOGCONFIG(TAG, "Text Sensors:");
-  LOG_TEXT_SENSOR("  ", "Mac", this->mac_text_sensor_);
-  LOG_TEXT_SENSOR("  ", "Version", this->version_text_sensor_);
-#endif
-#ifdef USE_NUMBER
-  ESP_LOGCONFIG(TAG, "Numbers:");
-  LOG_NUMBER("  ", "LightThreshold", this->light_threshold_number_);
-  LOG_NUMBER("  ", "MaxMoveDistanceGate", this->max_move_distance_gate_number_);
-  LOG_NUMBER("  ", "MaxStillDistanceGate", this->max_still_distance_gate_number_);
-  LOG_NUMBER("  ", "Timeout", this->timeout_number_);
-  for (number::Number *n : this->gate_move_threshold_numbers_) {
-    LOG_NUMBER("  ", "MoveThreshold", n);
-  }
-  for (number::Number *n : this->gate_still_threshold_numbers_) {
-    LOG_NUMBER("  ", "StillThreshold", n);
-  }
+  LOG_TEXT_SENSOR("  ", "VersionTextSensor", this->version_text_sensor_);
+  LOG_TEXT_SENSOR("  ", "MacTextSensor", this->mac_text_sensor_);
 #endif
 #ifdef USE_SELECT
-  ESP_LOGCONFIG(TAG, "Selects:");
-  LOG_SELECT("  ", "BaudRate", this->baud_rate_select_);
-  LOG_SELECT("  ", "DistanceResolution", this->distance_resolution_select_);
-  LOG_SELECT("  ", "LightFunction", this->light_function_select_);
-  LOG_SELECT("  ", "OutPinLevel", this->out_pin_level_select_);
+  LOG_SELECT("  ", "LightFunctionSelect", this->light_function_select_);
+  LOG_SELECT("  ", "OutPinLevelSelect", this->out_pin_level_select_);
+  LOG_SELECT("  ", "DistanceResolutionSelect", this->distance_resolution_select_);
+  LOG_SELECT("  ", "BaudRateSelect", this->baud_rate_select_);
 #endif
-#ifdef USE_SWITCH
-  ESP_LOGCONFIG(TAG, "Switches:");
-  LOG_SWITCH("  ", "Bluetooth", this->bluetooth_switch_);
-  LOG_SWITCH("  ", "EngineeringMode", this->engineering_mode_switch_);
-#endif
-#ifdef USE_BUTTON
-  ESP_LOGCONFIG(TAG, "Buttons:");
-  LOG_BUTTON("  ", "FactoryReset", this->factory_reset_button_);
-  LOG_BUTTON("  ", "Query", this->query_button_);
-  LOG_BUTTON("  ", "Restart", this->restart_button_);
+#ifdef USE_NUMBER
+  LOG_NUMBER("  ", "LightThresholdNumber", this->light_threshold_number_);
+  LOG_NUMBER("  ", "MaxStillDistanceGateNumber", this->max_still_distance_gate_number_);
+  LOG_NUMBER("  ", "MaxMoveDistanceGateNumber", this->max_move_distance_gate_number_);
+  LOG_NUMBER("  ", "TimeoutNumber", this->timeout_number_);
+  for (number::Number *n : this->gate_still_threshold_numbers_) {
+    LOG_NUMBER("  ", "Still Thresholds Number", n);
+  }
+  for (number::Number *n : this->gate_move_threshold_numbers_) {
+    LOG_NUMBER("  ", "Move Thresholds Number", n);
+  }
 #endif
+  this->read_all_info();
+  ESP_LOGCONFIG(TAG,
+                "  Throttle: %ums\n"
+                "  MAC address: %s\n"
+                "  Firmware version: %s",
+                this->throttle_, this->mac_ == NO_MAC ? UNKNOWN_MAC : this->mac_.c_str(), this->version_.c_str());
 }
 
 void LD2410Component::setup() {
@@ -268,12 +246,12 @@ void LD2410Component::read_all_info() {
   this->get_version_();
   this->get_mac_();
   this->get_distance_resolution_();
-  this->query_light_control_();
+  this->get_light_control_();
   this->query_parameters_();
   this->set_config_mode_(false);
 #ifdef USE_SELECT
   const auto baud_rate = std::to_string(this->parent_->get_baud_rate());
-  if (this->baud_rate_select_ != nullptr) {
+  if (this->baud_rate_select_ != nullptr && this->baud_rate_select_->state != baud_rate) {
     this->baud_rate_select_->publish_state(baud_rate);
   }
 #endif
@@ -286,59 +264,66 @@ void LD2410Component::restart_and_read_all_info() {
 }
 
 void LD2410Component::loop() {
-  while (this->available()) {
-    this->readline_(this->read());
+  const int max_line_length = 80;
+  static uint8_t buffer[max_line_length];
+
+  while (available()) {
+    this->readline_(read(), buffer, max_line_length);
   }
 }
 
-void LD2410Component::send_command_(uint8_t command, const uint8_t *command_value, uint8_t command_value_len) {
+void LD2410Component::send_command_(uint8_t command, const uint8_t *command_value, int command_value_len) {
   ESP_LOGV(TAG, "Sending COMMAND %02X", command);
-  // frame header bytes
-  this->write_array(CMD_FRAME_HEADER, sizeof(CMD_FRAME_HEADER));
+  // frame start bytes
+  this->write_array(CMD_FRAME_HEADER, 4);
   // length bytes
-  uint8_t len = 2;
-  if (command_value != nullptr) {
+  int len = 2;
+  if (command_value != nullptr)
     len += command_value_len;
-  }
-  uint8_t len_cmd[] = {lowbyte(len), highbyte(len), command, 0x00};
-  this->write_array(len_cmd, sizeof(len_cmd));
+  this->write_byte(lowbyte(len));
+  this->write_byte(highbyte(len));
+
+  // command
+  this->write_byte(lowbyte(command));
+  this->write_byte(highbyte(command));
 
   // command value bytes
   if (command_value != nullptr) {
-    for (uint8_t i = 0; i < command_value_len; i++) {
+    for (int i = 0; i < command_value_len; i++) {
       this->write_byte(command_value[i]);
     }
   }
-  // frame footer bytes
-  this->write_array(CMD_FRAME_FOOTER, sizeof(CMD_FRAME_FOOTER));
+  // frame end bytes
+  this->write_array(CMD_FRAME_END, 4);
   // FIXME to remove
   delay(50);  // NOLINT
 }
 
-void LD2410Component::handle_periodic_data_() {
-  // Reduce data update rate to reduce home assistant database growth
-  // Check this first to prevent unnecessary processing done in later checks/parsing
-  if (App.get_loop_component_start_time() - this->last_periodic_millis_ < this->throttle_) {
+void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
+  if (len < 12)
+    return;  // 4 frame start bytes + 2 length bytes + 1 data end byte + 1 crc byte + 4 frame end bytes
+  if (buffer[0] != 0xF4 || buffer[1] != 0xF3 || buffer[2] != 0xF2 || buffer[3] != 0xF1)  // check 4 frame start bytes
     return;
-  }
-  // 4 frame header bytes + 2 length bytes + 1 data end byte + 1 crc byte + 4 frame footer bytes
-  // data header=0xAA, data footer=0x55, crc=0x00
-  if (this->buffer_pos_ < 12 || !ld2410::validate_header_footer(DATA_FRAME_HEADER, this->buffer_data_) ||
-      this->buffer_data_[7] != HEADER || this->buffer_data_[this->buffer_pos_ - 6] != FOOTER ||
-      this->buffer_data_[this->buffer_pos_ - 5] != CHECK) {
+  if (buffer[7] != HEAD || buffer[len - 6] != END || buffer[len - 5] != CHECK)  // Check constant values
+    return;  // data head=0xAA, data end=0x55, crc=0x00
+
+  /*
+    Reduce data update rate to prevent home assistant database size grow fast
+  */
+  int32_t current_millis = App.get_loop_component_start_time();
+  if (current_millis - last_periodic_millis_ < this->throttle_)
     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();
+  last_periodic_millis_ = current_millis;
 
   /*
     Data Type: 7th
     0x01: Engineering mode
     0x02: Normal mode
   */
-  bool engineering_mode = this->buffer_data_[DATA_TYPES] == 0x01;
+  bool engineering_mode = buffer[DATA_TYPES] == 0x01;
 #ifdef USE_SWITCH
-  if (this->engineering_mode_switch_ != nullptr) {
+  if (this->engineering_mode_switch_ != nullptr &&
+      current_millis - last_engineering_mode_change_millis_ > this->throttle_) {
     this->engineering_mode_switch_->publish_state(engineering_mode);
   }
 #endif
@@ -350,7 +335,7 @@ void LD2410Component::handle_periodic_data_() {
     0x02 = Still targets
     0x03 = Moving+Still targets
   */
-  char target_state = this->buffer_data_[TARGET_STATES];
+  char target_state = buffer[TARGET_STATES];
   if (this->target_binary_sensor_ != nullptr) {
     this->target_binary_sensor_->publish_state(target_state != 0x00);
   }
@@ -370,30 +355,27 @@ void LD2410Component::handle_periodic_data_() {
   */
 #ifdef USE_SENSOR
   if (this->moving_target_distance_sensor_ != nullptr) {
-    int new_moving_target_distance =
-        ld2410::two_byte_to_int(this->buffer_data_[MOVING_TARGET_LOW], this->buffer_data_[MOVING_TARGET_HIGH]);
+    int new_moving_target_distance = ld2410::two_byte_to_int(buffer[MOVING_TARGET_LOW], buffer[MOVING_TARGET_HIGH]);
     if (this->moving_target_distance_sensor_->get_state() != new_moving_target_distance)
       this->moving_target_distance_sensor_->publish_state(new_moving_target_distance);
   }
   if (this->moving_target_energy_sensor_ != nullptr) {
-    int new_moving_target_energy = this->buffer_data_[MOVING_ENERGY];
+    int new_moving_target_energy = buffer[MOVING_ENERGY];
     if (this->moving_target_energy_sensor_->get_state() != new_moving_target_energy)
       this->moving_target_energy_sensor_->publish_state(new_moving_target_energy);
   }
   if (this->still_target_distance_sensor_ != nullptr) {
-    int new_still_target_distance =
-        ld2410::two_byte_to_int(this->buffer_data_[STILL_TARGET_LOW], this->buffer_data_[STILL_TARGET_HIGH]);
+    int new_still_target_distance = ld2410::two_byte_to_int(buffer[STILL_TARGET_LOW], buffer[STILL_TARGET_HIGH]);
     if (this->still_target_distance_sensor_->get_state() != new_still_target_distance)
       this->still_target_distance_sensor_->publish_state(new_still_target_distance);
   }
   if (this->still_target_energy_sensor_ != nullptr) {
-    int new_still_target_energy = this->buffer_data_[STILL_ENERGY];
+    int new_still_target_energy = buffer[STILL_ENERGY];
     if (this->still_target_energy_sensor_->get_state() != new_still_target_energy)
       this->still_target_energy_sensor_->publish_state(new_still_target_energy);
   }
   if (this->detection_distance_sensor_ != nullptr) {
-    int new_detect_distance =
-        ld2410::two_byte_to_int(this->buffer_data_[DETECT_DISTANCE_LOW], this->buffer_data_[DETECT_DISTANCE_HIGH]);
+    int new_detect_distance = ld2410::two_byte_to_int(buffer[DETECT_DISTANCE_LOW], buffer[DETECT_DISTANCE_HIGH]);
     if (this->detection_distance_sensor_->get_state() != new_detect_distance)
       this->detection_distance_sensor_->publish_state(new_detect_distance);
   }
@@ -406,7 +388,7 @@ void LD2410Component::handle_periodic_data_() {
     for (std::vector<sensor::Sensor *>::size_type i = 0; i != this->gate_move_sensors_.size(); i++) {
       sensor::Sensor *s = this->gate_move_sensors_[i];
       if (s != nullptr) {
-        s->publish_state(this->buffer_data_[MOVING_SENSOR_START + i]);
+        s->publish_state(buffer[MOVING_SENSOR_START + i]);
       }
     }
     /*
@@ -415,17 +397,16 @@ void LD2410Component::handle_periodic_data_() {
     for (std::vector<sensor::Sensor *>::size_type i = 0; i != this->gate_still_sensors_.size(); i++) {
       sensor::Sensor *s = this->gate_still_sensors_[i];
       if (s != nullptr) {
-        s->publish_state(this->buffer_data_[STILL_SENSOR_START + i]);
+        s->publish_state(buffer[STILL_SENSOR_START + i]);
       }
     }
     /*
       Light sensor: 38th bytes
     */
     if (this->light_sensor_ != nullptr) {
-      int new_light_sensor = this->buffer_data_[LIGHT_SENSOR];
-      if (this->light_sensor_->get_state() != new_light_sensor) {
+      int new_light_sensor = buffer[LIGHT_SENSOR];
+      if (this->light_sensor_->get_state() != new_light_sensor)
         this->light_sensor_->publish_state(new_light_sensor);
-      }
     }
   } else {
     for (auto *s : this->gate_move_sensors_) {
@@ -446,7 +427,7 @@ void LD2410Component::handle_periodic_data_() {
 #ifdef USE_BINARY_SENSOR
   if (engineering_mode) {
     if (this->out_pin_presence_status_binary_sensor_ != nullptr) {
-      this->out_pin_presence_status_binary_sensor_->publish_state(this->buffer_data_[OUT_PIN_SENSOR] == 0x01);
+      this->out_pin_presence_status_binary_sensor_->publish_state(buffer[OUT_PIN_SENSOR] == 0x01);
     }
   } else {
     if (this->out_pin_presence_status_binary_sensor_ != nullptr) {
@@ -458,149 +439,127 @@ void LD2410Component::handle_periodic_data_() {
 
 #ifdef USE_NUMBER
 std::function<void(void)> set_number_value(number::Number *n, float value) {
-  if (n != nullptr && (!n->has_state() || n->state != value)) {
-    n->state = value;
-    return [n, value]() { n->publish_state(value); };
+  float normalized_value = value * 1.0;
+  if (n != nullptr && (!n->has_state() || n->state != normalized_value)) {
+    n->state = normalized_value;
+    return [n, normalized_value]() { n->publish_state(normalized_value); };
   }
   return []() {};
 }
 #endif
 
-bool LD2410Component::handle_ack_data_() {
-  ESP_LOGV(TAG, "Handling ACK DATA for COMMAND %02X", this->buffer_data_[COMMAND]);
-  if (this->buffer_pos_ < 10) {
+bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
+  ESP_LOGV(TAG, "Handling ACK DATA for COMMAND %02X", buffer[COMMAND]);
+  if (len < 10) {
     ESP_LOGE(TAG, "Invalid length");
     return true;
   }
-  if (!ld2410::validate_header_footer(CMD_FRAME_HEADER, this->buffer_data_)) {
-    ESP_LOGW(TAG, "Invalid header: %s", format_hex_pretty(this->buffer_data_, HEADER_FOOTER_SIZE).c_str());
+  if (buffer[0] != 0xFD || buffer[1] != 0xFC || buffer[2] != 0xFB || buffer[3] != 0xFA) {  // check 4 frame start bytes
+    ESP_LOGE(TAG, "Invalid header");
     return true;
   }
-  if (this->buffer_data_[COMMAND_STATUS] != 0x01) {
+  if (buffer[COMMAND_STATUS] != 0x01) {
     ESP_LOGE(TAG, "Invalid status");
     return true;
   }
-  if (ld2410::two_byte_to_int(this->buffer_data_[8], this->buffer_data_[9]) != 0x00) {
-    ESP_LOGW(TAG, "Invalid command: %02X, %02X", this->buffer_data_[8], this->buffer_data_[9]);
+  if (ld2410::two_byte_to_int(buffer[8], buffer[9]) != 0x00) {
+    ESP_LOGE(TAG, "Invalid command: %u, %u", buffer[8], buffer[9]);
     return true;
   }
 
-  switch (this->buffer_data_[COMMAND]) {
-    case CMD_ENABLE_CONF:
+  switch (buffer[COMMAND]) {
+    case lowbyte(CMD_ENABLE_CONF):
       ESP_LOGV(TAG, "Enable conf");
       break;
-
-    case CMD_DISABLE_CONF:
+    case lowbyte(CMD_DISABLE_CONF):
       ESP_LOGV(TAG, "Disabled conf");
       break;
-
-    case CMD_SET_BAUD_RATE:
+    case lowbyte(CMD_SET_BAUD_RATE):
       ESP_LOGV(TAG, "Baud rate change");
 #ifdef USE_SELECT
       if (this->baud_rate_select_ != nullptr) {
-        ESP_LOGE(TAG, "Change baud rate to %s and reinstall", this->baud_rate_select_->state.c_str());
+        ESP_LOGE(TAG, "Configure baud rate to %s and reinstall", this->baud_rate_select_->state.c_str());
       }
 #endif
       break;
-
-    case CMD_QUERY_VERSION: {
-      std::memcpy(this->version_, &this->buffer_data_[12], sizeof(this->version_));
-      std::string version = str_sprintf(VERSION_FMT, this->version_[1], this->version_[0], this->version_[5],
-                                        this->version_[4], this->version_[3], this->version_[2]);
-      ESP_LOGV(TAG, "Firmware version: %s", version.c_str());
+    case lowbyte(CMD_VERSION):
+      this->version_ = str_sprintf(VERSION_FMT, buffer[13], buffer[12], buffer[17], buffer[16], buffer[15], buffer[14]);
+      ESP_LOGV(TAG, "Firmware version: %s", this->version_.c_str());
 #ifdef USE_TEXT_SENSOR
       if (this->version_text_sensor_ != nullptr) {
-        this->version_text_sensor_->publish_state(version);
+        this->version_text_sensor_->publish_state(this->version_);
       }
 #endif
       break;
-    }
-
-    case CMD_QUERY_DISTANCE_RESOLUTION: {
-      const auto *distance_resolution = find_str(DISTANCE_RESOLUTIONS_BY_UINT, this->buffer_data_[10]);
-      ESP_LOGV(TAG, "Distance resolution: %s", distance_resolution);
+    case lowbyte(CMD_QUERY_DISTANCE_RESOLUTION): {
+      std::string distance_resolution =
+          find_str(DISTANCE_RESOLUTIONS_BY_UINT, ld2410::two_byte_to_int(buffer[10], buffer[11]));
+      ESP_LOGV(TAG, "Distance resolution: %s", distance_resolution.c_str());
 #ifdef USE_SELECT
-      if (this->distance_resolution_select_ != nullptr) {
+      if (this->distance_resolution_select_ != nullptr &&
+          this->distance_resolution_select_->state != distance_resolution) {
         this->distance_resolution_select_->publish_state(distance_resolution);
       }
 #endif
-      break;
-    }
-
-    case CMD_QUERY_LIGHT_CONTROL: {
-      this->light_function_ = this->buffer_data_[10];
-      this->light_threshold_ = this->buffer_data_[11];
-      this->out_pin_level_ = this->buffer_data_[12];
-      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"
-               "Out pin level: %s",
-               light_function_str, this->light_threshold_, out_pin_level_str);
+    } break;
+    case lowbyte(CMD_QUERY_LIGHT_CONTROL): {
+      this->light_function_ = find_str(LIGHT_FUNCTIONS_BY_UINT, buffer[10]);
+      this->light_threshold_ = buffer[11] * 1.0;
+      this->out_pin_level_ = find_str(OUT_PIN_LEVELS_BY_UINT, buffer[12]);
+      ESP_LOGV(TAG, "Light function: %s", const_cast<char *>(this->light_function_.c_str()));
+      ESP_LOGV(TAG, "Light threshold: %f", this->light_threshold_);
+      ESP_LOGV(TAG, "Out pin level: %s", const_cast<char *>(this->out_pin_level_.c_str()));
 #ifdef USE_SELECT
-      if (this->light_function_select_ != nullptr) {
-        this->light_function_select_->publish_state(light_function_str);
+      if (this->light_function_select_ != nullptr && this->light_function_select_->state != this->light_function_) {
+        this->light_function_select_->publish_state(this->light_function_);
       }
-      if (this->out_pin_level_select_ != nullptr) {
-        this->out_pin_level_select_->publish_state(out_pin_level_str);
+      if (this->out_pin_level_select_ != nullptr && this->out_pin_level_select_->state != this->out_pin_level_) {
+        this->out_pin_level_select_->publish_state(this->out_pin_level_);
       }
 #endif
 #ifdef USE_NUMBER
-      if (this->light_threshold_number_ != nullptr) {
-        this->light_threshold_number_->publish_state(static_cast<float>(this->light_threshold_));
+      if (this->light_threshold_number_ != nullptr &&
+          (!this->light_threshold_number_->has_state() ||
+           this->light_threshold_number_->state != this->light_threshold_)) {
+        this->light_threshold_number_->publish_state(this->light_threshold_);
       }
 #endif
-      break;
-    }
-    case CMD_QUERY_MAC_ADDRESS: {
-      if (this->buffer_pos_ < 20) {
+    } break;
+    case lowbyte(CMD_MAC):
+      if (len < 20) {
         return false;
       }
-
-      this->bluetooth_on_ = std::memcmp(&this->buffer_data_[10], NO_MAC, sizeof(NO_MAC)) != 0;
-      if (this->bluetooth_on_) {
-        std::memcpy(this->mac_address_, &this->buffer_data_[10], sizeof(this->mac_address_));
-      }
-
-      std::string mac_str =
-          mac_address_is_valid(this->mac_address_) ? format_mac_address_pretty(this->mac_address_) : UNKNOWN_MAC;
-      ESP_LOGV(TAG, "MAC address: %s", mac_str.c_str());
+      this->mac_ = format_mac_address_pretty(&buffer[10]);
+      ESP_LOGV(TAG, "MAC address: %s", this->mac_.c_str());
 #ifdef USE_TEXT_SENSOR
       if (this->mac_text_sensor_ != nullptr) {
-        this->mac_text_sensor_->publish_state(mac_str);
+        this->mac_text_sensor_->publish_state(this->mac_ == NO_MAC ? UNKNOWN_MAC : this->mac_);
       }
 #endif
 #ifdef USE_SWITCH
       if (this->bluetooth_switch_ != nullptr) {
-        this->bluetooth_switch_->publish_state(this->bluetooth_on_);
+        this->bluetooth_switch_->publish_state(this->mac_ != NO_MAC);
       }
 #endif
       break;
-    }
-
-    case CMD_GATE_SENS:
+    case lowbyte(CMD_GATE_SENS):
       ESP_LOGV(TAG, "Sensitivity");
       break;
-
-    case CMD_BLUETOOTH:
+    case lowbyte(CMD_BLUETOOTH):
       ESP_LOGV(TAG, "Bluetooth");
       break;
-
-    case CMD_SET_DISTANCE_RESOLUTION:
+    case lowbyte(CMD_SET_DISTANCE_RESOLUTION):
       ESP_LOGV(TAG, "Set distance resolution");
       break;
-
-    case CMD_SET_LIGHT_CONTROL:
+    case lowbyte(CMD_SET_LIGHT_CONTROL):
       ESP_LOGV(TAG, "Set light control");
       break;
-
-    case CMD_BT_PASSWORD:
+    case lowbyte(CMD_BT_PASSWORD):
       ESP_LOGV(TAG, "Set bluetooth password");
       break;
-
-    case CMD_QUERY: {  // Query parameters response
-      if (this->buffer_data_[10] != 0xAA)
+    case lowbyte(CMD_QUERY):  // Query parameters response
+    {
+      if (buffer[10] != 0xAA)
         return true;  // value head=0xAA
 #ifdef USE_NUMBER
       /*
@@ -608,31 +567,29 @@ bool LD2410Component::handle_ack_data_() {
         Still distance range: 14th byte
       */
       std::vector<std::function<void(void)>> updates;
-      updates.push_back(set_number_value(this->max_move_distance_gate_number_, this->buffer_data_[12]));
-      updates.push_back(set_number_value(this->max_still_distance_gate_number_, this->buffer_data_[13]));
+      updates.push_back(set_number_value(this->max_move_distance_gate_number_, buffer[12]));
+      updates.push_back(set_number_value(this->max_still_distance_gate_number_, buffer[13]));
       /*
         Moving Sensitivities: 15~23th bytes
       */
       for (std::vector<number::Number *>::size_type i = 0; i != this->gate_move_threshold_numbers_.size(); i++) {
-        updates.push_back(set_number_value(this->gate_move_threshold_numbers_[i], this->buffer_data_[14 + i]));
+        updates.push_back(set_number_value(this->gate_move_threshold_numbers_[i], buffer[14 + i]));
       }
       /*
         Still Sensitivities: 24~32th bytes
       */
       for (std::vector<number::Number *>::size_type i = 0; i != this->gate_still_threshold_numbers_.size(); i++) {
-        updates.push_back(set_number_value(this->gate_still_threshold_numbers_[i], this->buffer_data_[23 + i]));
+        updates.push_back(set_number_value(this->gate_still_threshold_numbers_[i], buffer[23 + i]));
       }
       /*
         None Duration: 33~34th bytes
       */
-      updates.push_back(set_number_value(this->timeout_number_,
-                                         ld2410::two_byte_to_int(this->buffer_data_[32], this->buffer_data_[33])));
+      updates.push_back(set_number_value(this->timeout_number_, ld2410::two_byte_to_int(buffer[32], buffer[33])));
       for (auto &update : updates) {
         update();
       }
 #endif
-      break;
-    }
+    } break;
     default:
       break;
   }
@@ -640,66 +597,59 @@ bool LD2410Component::handle_ack_data_() {
   return true;
 }
 
-void LD2410Component::readline_(int readch) {
-  if (readch < 0) {
-    return;  // No data available
-  }
+void LD2410Component::readline_(int readch, uint8_t *buffer, int len) {
+  static int pos = 0;
 
-  if (this->buffer_pos_ < MAX_LINE_LENGTH - 1) {
-    this->buffer_data_[this->buffer_pos_++] = readch;
-    this->buffer_data_[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 (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]) {
-    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]) {
-    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
+  if (readch >= 0) {
+    if (pos < len - 1) {
+      buffer[pos++] = readch;
+      buffer[pos] = 0;
     } else {
-      ESP_LOGV(TAG, "Ack Data incomplete");
+      pos = 0;
+    }
+    if (pos >= 4) {
+      if (buffer[pos - 4] == 0xF8 && buffer[pos - 3] == 0xF7 && buffer[pos - 2] == 0xF6 && buffer[pos - 1] == 0xF5) {
+        ESP_LOGV(TAG, "Will handle Periodic Data");
+        this->handle_periodic_data_(buffer, pos);
+        pos = 0;  // Reset position index ready for next time
+      } else if (buffer[pos - 4] == 0x04 && buffer[pos - 3] == 0x03 && buffer[pos - 2] == 0x02 &&
+                 buffer[pos - 1] == 0x01) {
+        ESP_LOGV(TAG, "Will handle ACK Data");
+        if (this->handle_ack_data_(buffer, pos)) {
+          pos = 0;  // Reset position index ready for next time
+        } else {
+          ESP_LOGV(TAG, "ACK Data incomplete");
+        }
+      }
     }
   }
 }
 
 void LD2410Component::set_config_mode_(bool enable) {
-  const uint8_t cmd = enable ? CMD_ENABLE_CONF : CMD_DISABLE_CONF;
-  const uint8_t cmd_value[2] = {0x01, 0x00};
-  this->send_command_(cmd, enable ? cmd_value : nullptr, sizeof(cmd_value));
+  uint8_t cmd = enable ? CMD_ENABLE_CONF : CMD_DISABLE_CONF;
+  uint8_t cmd_value[2] = {0x01, 0x00};
+  this->send_command_(cmd, enable ? cmd_value : nullptr, 2);
 }
 
 void LD2410Component::set_bluetooth(bool enable) {
   this->set_config_mode_(true);
-  const uint8_t cmd_value[2] = {enable ? (uint8_t) 0x01 : (uint8_t) 0x00, 0x00};
-  this->send_command_(CMD_BLUETOOTH, cmd_value, sizeof(cmd_value));
+  uint8_t enable_cmd_value[2] = {0x01, 0x00};
+  uint8_t disable_cmd_value[2] = {0x00, 0x00};
+  this->send_command_(CMD_BLUETOOTH, enable ? enable_cmd_value : disable_cmd_value, 2);
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
 }
 
 void LD2410Component::set_distance_resolution(const std::string &state) {
   this->set_config_mode_(true);
-  const uint8_t cmd_value[2] = {find_uint8(DISTANCE_RESOLUTIONS_BY_STR, state), 0x00};
-  this->send_command_(CMD_SET_DISTANCE_RESOLUTION, cmd_value, sizeof(cmd_value));
+  uint8_t cmd_value[2] = {find_uint8(DISTANCE_RESOLUTIONS_BY_STR, state), 0x00};
+  this->send_command_(CMD_SET_DISTANCE_RESOLUTION, cmd_value, 2);
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
 }
 
 void LD2410Component::set_baud_rate(const std::string &state) {
   this->set_config_mode_(true);
-  const uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
-  this->send_command_(CMD_SET_BAUD_RATE, cmd_value, sizeof(cmd_value));
+  uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
+  this->send_command_(CMD_SET_BAUD_RATE, cmd_value, 2);
   this->set_timeout(200, [this]() { this->restart_(); });
 }
 
@@ -711,13 +661,14 @@ void LD2410Component::set_bluetooth_password(const std::string &password) {
   this->set_config_mode_(true);
   uint8_t cmd_value[6];
   std::copy(password.begin(), password.end(), std::begin(cmd_value));
-  this->send_command_(CMD_BT_PASSWORD, cmd_value, sizeof(cmd_value));
+  this->send_command_(CMD_BT_PASSWORD, cmd_value, 6);
   this->set_config_mode_(false);
 }
 
 void LD2410Component::set_engineering_mode(bool enable) {
-  const uint8_t cmd = enable ? CMD_ENABLE_ENG : CMD_DISABLE_ENG;
   this->set_config_mode_(true);
+  last_engineering_mode_change_millis_ = App.get_loop_component_start_time();
+  uint8_t cmd = enable ? CMD_ENABLE_ENG : CMD_DISABLE_ENG;
   this->send_command_(cmd, nullptr, 0);
   this->set_config_mode_(false);
 }
@@ -731,17 +682,14 @@ void LD2410Component::factory_reset() {
 void LD2410Component::restart_() { this->send_command_(CMD_RESTART, nullptr, 0); }
 
 void LD2410Component::query_parameters_() { this->send_command_(CMD_QUERY, nullptr, 0); }
-
-void LD2410Component::get_version_() { this->send_command_(CMD_QUERY_VERSION, nullptr, 0); }
-
+void LD2410Component::get_version_() { this->send_command_(CMD_VERSION, nullptr, 0); }
 void LD2410Component::get_mac_() {
-  const uint8_t cmd_value[2] = {0x01, 0x00};
-  this->send_command_(CMD_QUERY_MAC_ADDRESS, cmd_value, sizeof(cmd_value));
+  uint8_t cmd_value[2] = {0x01, 0x00};
+  this->send_command_(CMD_MAC, cmd_value, 2);
 }
-
 void LD2410Component::get_distance_resolution_() { this->send_command_(CMD_QUERY_DISTANCE_RESOLUTION, nullptr, 0); }
 
-void LD2410Component::query_light_control_() { this->send_command_(CMD_QUERY_LIGHT_CONTROL, nullptr, 0); }
+void LD2410Component::get_light_control_() { this->send_command_(CMD_QUERY_LIGHT_CONTROL, nullptr, 0); }
 
 #ifdef USE_NUMBER
 void LD2410Component::set_max_distances_timeout() {
@@ -771,7 +719,7 @@ void LD2410Component::set_max_distances_timeout() {
                        0x00,
                        0x00};
   this->set_config_mode_(true);
-  this->send_command_(CMD_MAXDIST_DURATION, value, sizeof(value));
+  this->send_command_(CMD_MAXDIST_DURATION, value, 18);
   delay(50);  // NOLINT
   this->query_parameters_();
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
@@ -801,17 +749,17 @@ void LD2410Component::set_gate_threshold(uint8_t gate) {
   uint8_t value[18] = {0x00, 0x00, lowbyte(gate),   highbyte(gate),   0x00, 0x00,
                        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));
+  this->send_command_(CMD_GATE_SENS, value, 18);
   delay(50);  // NOLINT
   this->query_parameters_();
   this->set_config_mode_(false);
 }
 
-void LD2410Component::set_gate_still_threshold_number(uint8_t gate, number::Number *n) {
+void LD2410Component::set_gate_still_threshold_number(int gate, number::Number *n) {
   this->gate_still_threshold_numbers_[gate] = n;
 }
 
-void LD2410Component::set_gate_move_threshold_number(uint8_t gate, number::Number *n) {
+void LD2410Component::set_gate_move_threshold_number(int gate, number::Number *n) {
   this->gate_move_threshold_numbers_[gate] = n;
 }
 #endif
@@ -819,29 +767,35 @@ void LD2410Component::set_gate_move_threshold_number(uint8_t gate, number::Numbe
 void LD2410Component::set_light_out_control() {
 #ifdef USE_NUMBER
   if (this->light_threshold_number_ != nullptr && this->light_threshold_number_->has_state()) {
-    this->light_threshold_ = static_cast<uint8_t>(this->light_threshold_number_->state);
+    this->light_threshold_ = this->light_threshold_number_->state;
   }
 #endif
 #ifdef USE_SELECT
   if (this->light_function_select_ != nullptr && this->light_function_select_->has_state()) {
-    this->light_function_ = find_uint8(LIGHT_FUNCTIONS_BY_STR, this->light_function_select_->state);
+    this->light_function_ = this->light_function_select_->state;
   }
   if (this->out_pin_level_select_ != nullptr && this->out_pin_level_select_->has_state()) {
-    this->out_pin_level_ = find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->state);
+    this->out_pin_level_ = this->out_pin_level_select_->state;
   }
 #endif
+  if (this->light_function_.empty() || this->out_pin_level_.empty() || this->light_threshold_ < 0) {
+    return;
+  }
   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));
+  uint8_t light_function = find_uint8(LIGHT_FUNCTIONS_BY_STR, this->light_function_);
+  uint8_t light_threshold = static_cast<uint8_t>(this->light_threshold_);
+  uint8_t out_pin_level = find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_);
+  uint8_t value[4] = {light_function, light_threshold, out_pin_level, 0x00};
+  this->send_command_(CMD_SET_LIGHT_CONTROL, value, 4);
   delay(50);  // NOLINT
-  this->query_light_control_();
+  this->get_light_control_();
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
   this->set_config_mode_(false);
 }
 
 #ifdef USE_SENSOR
-void LD2410Component::set_gate_move_sensor(uint8_t gate, sensor::Sensor *s) { this->gate_move_sensors_[gate] = s; }
-void LD2410Component::set_gate_still_sensor(uint8_t gate, sensor::Sensor *s) { this->gate_still_sensors_[gate] = s; }
+void LD2410Component::set_gate_move_sensor(int gate, sensor::Sensor *s) { this->gate_move_sensors_[gate] = s; }
+void LD2410Component::set_gate_still_sensor(int gate, sensor::Sensor *s) { this->gate_still_sensors_[gate] = s; }
 #endif
 
 }  // namespace ld2410

esphome/components/ld2410/ld2410.h

@@ -29,48 +29,45 @@
 namespace esphome {
 namespace ld2410 {
 
-static const uint8_t MAX_LINE_LENGTH = 46;  // Max characters for serial buffer
-static const uint8_t TOTAL_GATES = 9;       // Total number of gates supported by the LD2410
-
 class LD2410Component : public Component, public uart::UARTDevice {
-#ifdef USE_BINARY_SENSOR
-  SUB_BINARY_SENSOR(out_pin_presence_status)
-  SUB_BINARY_SENSOR(moving_target)
-  SUB_BINARY_SENSOR(still_target)
-  SUB_BINARY_SENSOR(target)
-#endif
 #ifdef USE_SENSOR
+  SUB_SENSOR(moving_target_distance)
+  SUB_SENSOR(still_target_distance)
+  SUB_SENSOR(moving_target_energy)
+  SUB_SENSOR(still_target_energy)
   SUB_SENSOR(light)
   SUB_SENSOR(detection_distance)
-  SUB_SENSOR(moving_target_distance)
-  SUB_SENSOR(moving_target_energy)
-  SUB_SENSOR(still_target_distance)
-  SUB_SENSOR(still_target_energy)
+#endif
+#ifdef USE_BINARY_SENSOR
+  SUB_BINARY_SENSOR(target)
+  SUB_BINARY_SENSOR(moving_target)
+  SUB_BINARY_SENSOR(still_target)
+  SUB_BINARY_SENSOR(out_pin_presence_status)
 #endif
 #ifdef USE_TEXT_SENSOR
   SUB_TEXT_SENSOR(version)
   SUB_TEXT_SENSOR(mac)
 #endif
-#ifdef USE_NUMBER
-  SUB_NUMBER(light_threshold)
-  SUB_NUMBER(max_move_distance_gate)
-  SUB_NUMBER(max_still_distance_gate)
-  SUB_NUMBER(timeout)
-#endif
 #ifdef USE_SELECT
-  SUB_SELECT(baud_rate)
   SUB_SELECT(distance_resolution)
+  SUB_SELECT(baud_rate)
   SUB_SELECT(light_function)
   SUB_SELECT(out_pin_level)
 #endif
 #ifdef USE_SWITCH
-  SUB_SWITCH(bluetooth)
   SUB_SWITCH(engineering_mode)
+  SUB_SWITCH(bluetooth)
 #endif
 #ifdef USE_BUTTON
-  SUB_BUTTON(factory_reset)
-  SUB_BUTTON(query)
+  SUB_BUTTON(reset)
   SUB_BUTTON(restart)
+  SUB_BUTTON(query)
+#endif
+#ifdef USE_NUMBER
+  SUB_NUMBER(max_still_distance_gate)
+  SUB_NUMBER(max_move_distance_gate)
+  SUB_NUMBER(timeout)
+  SUB_NUMBER(light_threshold)
 #endif
 
  public:
@@ -79,14 +76,14 @@ class LD2410Component : public Component, public uart::UARTDevice {
   void loop() override;
   void set_light_out_control();
 #ifdef USE_NUMBER
-  void set_gate_still_threshold_number(uint8_t gate, number::Number *n);
-  void set_gate_move_threshold_number(uint8_t gate, number::Number *n);
+  void set_gate_still_threshold_number(int gate, number::Number *n);
+  void set_gate_move_threshold_number(int gate, number::Number *n);
   void set_max_distances_timeout();
   void set_gate_threshold(uint8_t gate);
 #endif
 #ifdef USE_SENSOR
-  void set_gate_move_sensor(uint8_t gate, sensor::Sensor *s);
-  void set_gate_still_sensor(uint8_t gate, sensor::Sensor *s);
+  void set_gate_move_sensor(int gate, sensor::Sensor *s);
+  void set_gate_still_sensor(int gate, sensor::Sensor *s);
 #endif
   void set_throttle(uint16_t value) { this->throttle_ = value; };
   void set_bluetooth_password(const std::string &password);
@@ -99,35 +96,33 @@ class LD2410Component : public Component, public uart::UARTDevice {
   void factory_reset();
 
  protected:
-  void send_command_(uint8_t command_str, const uint8_t *command_value, uint8_t command_value_len);
+  void send_command_(uint8_t command_str, const uint8_t *command_value, int command_value_len);
   void set_config_mode_(bool enable);
-  void handle_periodic_data_();
-  bool handle_ack_data_();
-  void readline_(int readch);
+  void handle_periodic_data_(uint8_t *buffer, int len);
+  bool handle_ack_data_(uint8_t *buffer, int len);
+  void readline_(int readch, uint8_t *buffer, int len);
   void query_parameters_();
   void get_version_();
   void get_mac_();
   void get_distance_resolution_();
-  void query_light_control_();
+  void get_light_control_();
   void restart_();
 
-  uint32_t last_periodic_millis_ = 0;
-  uint16_t throttle_ = 0;
-  uint8_t light_function_ = 0;
-  uint8_t light_threshold_ = 0;
-  uint8_t out_pin_level_ = 0;
-  uint8_t buffer_pos_ = 0;  // where to resume processing/populating buffer
-  uint8_t buffer_data_[MAX_LINE_LENGTH];
-  uint8_t mac_address_[6] = {0, 0, 0, 0, 0, 0};
-  uint8_t version_[6] = {0, 0, 0, 0, 0, 0};
-  bool bluetooth_on_{false};
+  int32_t last_periodic_millis_ = 0;
+  int32_t last_engineering_mode_change_millis_ = 0;
+  uint16_t throttle_;
+  float light_threshold_ = -1;
+  std::string version_;
+  std::string mac_;
+  std::string out_pin_level_;
+  std::string light_function_;
 #ifdef USE_NUMBER
-  std::vector<number::Number *> gate_move_threshold_numbers_ = std::vector<number::Number *>(TOTAL_GATES);
-  std::vector<number::Number *> gate_still_threshold_numbers_ = std::vector<number::Number *>(TOTAL_GATES);
+  std::vector<number::Number *> gate_still_threshold_numbers_ = std::vector<number::Number *>(9);
+  std::vector<number::Number *> gate_move_threshold_numbers_ = std::vector<number::Number *>(9);
 #endif
 #ifdef USE_SENSOR
-  std::vector<sensor::Sensor *> gate_move_sensors_ = std::vector<sensor::Sensor *>(TOTAL_GATES);
-  std::vector<sensor::Sensor *> gate_still_sensors_ = std::vector<sensor::Sensor *>(TOTAL_GATES);
+  std::vector<sensor::Sensor *> gate_still_sensors_ = std::vector<sensor::Sensor *>(9);
+  std::vector<sensor::Sensor *> gate_move_sensors_ = std::vector<sensor::Sensor *>(9);
 #endif
 };
 

esphome/components/ld2450/button/__init__.py

@@ -13,13 +13,13 @@ from esphome.const import (
 
 from .. import CONF_LD2450_ID, LD2450Component, ld2450_ns
 
-FactoryResetButton = ld2450_ns.class_("FactoryResetButton", button.Button)
+ResetButton = ld2450_ns.class_("ResetButton", 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(
-        FactoryResetButton,
+        ResetButton,
         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_factory_reset_button(b))
+        cg.add(ld2450_component.set_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

@@ -1,9 +0,0 @@
-#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.cpp

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

esphome/components/ld2450/button/reset_button.h

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

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
@@ -18,10 +17,11 @@ namespace esphome {
 namespace ld2450 {
 
 static const char *const TAG = "ld2450";
+static const char *const NO_MAC = "08:05:04:03:02:01";
 static const char *const UNKNOWN_MAC = "unknown";
 static const char *const VERSION_FMT = "%u.%02X.%02X%02X%02X%02X";
 
-enum BaudRate : uint8_t {
+enum BaudRateStructure : uint8_t {
   BAUD_RATE_9600 = 1,
   BAUD_RATE_19200 = 2,
   BAUD_RATE_38400 = 3,
@@ -32,13 +32,14 @@ enum BaudRate : uint8_t {
   BAUD_RATE_460800 = 8
 };
 
-enum ZoneType : uint8_t {
+// Zone type struct
+enum ZoneTypeStructure : uint8_t {
   ZONE_DISABLED = 0,
   ZONE_DETECTION = 1,
   ZONE_FILTER = 2,
 };
 
-enum PeriodicData : uint8_t {
+enum PeriodicDataStructure : uint8_t {
   TARGET_X = 4,
   TARGET_Y = 6,
   TARGET_SPEED = 8,
@@ -46,12 +47,12 @@ enum PeriodicData : uint8_t {
 };
 
 enum PeriodicDataValue : uint8_t {
-  HEADER = 0xAA,
-  FOOTER = 0x55,
+  HEAD = 0xAA,
+  END = 0x55,
   CHECK = 0x00,
 };
 
-enum AckData : uint8_t {
+enum AckDataStructure : uint8_t {
   COMMAND = 6,
   COMMAND_STATUS = 7,
 };
@@ -59,11 +60,11 @@ enum AckData : uint8_t {
 // Memory-efficient lookup tables
 struct StringToUint8 {
   const char *str;
-  const uint8_t value;
+  uint8_t value;
 };
 
 struct Uint8ToString {
-  const uint8_t value;
+  uint8_t value;
   const char *str;
 };
 
@@ -73,13 +74,6 @@ constexpr StringToUint8 BAUD_RATES_BY_STR[] = {
     {"256000", BAUD_RATE_256000}, {"460800", BAUD_RATE_460800},
 };
 
-constexpr Uint8ToString DIRECTION_BY_UINT[] = {
-    {DIRECTION_APPROACHING, "Approaching"},
-    {DIRECTION_MOVING_AWAY, "Moving away"},
-    {DIRECTION_STATIONARY, "Stationary"},
-    {DIRECTION_NA, "NA"},
-};
-
 constexpr Uint8ToString ZONE_TYPE_BY_UINT[] = {
     {ZONE_DISABLED, "Disabled"},
     {ZONE_DETECTION, "Detection"},
@@ -109,38 +103,36 @@ template<size_t N> const char *find_str(const Uint8ToString (&arr)[N], uint8_t v
   return "";  // Not found
 }
 
+// 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};
 // LD2450 UART Serial Commands
-static constexpr uint8_t CMD_ENABLE_CONF = 0xFF;
-static constexpr uint8_t CMD_DISABLE_CONF = 0xFE;
-static constexpr uint8_t CMD_QUERY_VERSION = 0xA0;
-static constexpr uint8_t CMD_QUERY_MAC_ADDRESS = 0xA5;
-static constexpr uint8_t CMD_RESET = 0xA2;
-static constexpr uint8_t CMD_RESTART = 0xA3;
-static constexpr uint8_t CMD_BLUETOOTH = 0xA4;
-static constexpr uint8_t CMD_SINGLE_TARGET_MODE = 0x80;
-static constexpr uint8_t CMD_MULTI_TARGET_MODE = 0x90;
-static constexpr uint8_t CMD_QUERY_TARGET_MODE = 0x91;
-static constexpr uint8_t CMD_SET_BAUD_RATE = 0xA1;
-static constexpr uint8_t CMD_QUERY_ZONE = 0xC1;
-static constexpr uint8_t CMD_SET_ZONE = 0xC2;
-// Header & Footer size
-static constexpr uint8_t HEADER_FOOTER_SIZE = 4;
-// Command Header & Footer
-static constexpr uint8_t CMD_FRAME_HEADER[HEADER_FOOTER_SIZE] = {0xFD, 0xFC, 0xFB, 0xFA};
-static constexpr uint8_t CMD_FRAME_FOOTER[HEADER_FOOTER_SIZE] = {0x04, 0x03, 0x02, 0x01};
-// Data Header & Footer
-static constexpr uint8_t DATA_FRAME_HEADER[HEADER_FOOTER_SIZE] = {0xAA, 0xFF, 0x03, 0x00};
-static constexpr uint8_t DATA_FRAME_FOOTER[2] = {0x55, 0xCC};
-// MAC address the module uses when Bluetooth is disabled
-static constexpr uint8_t NO_MAC[] = {0x08, 0x05, 0x04, 0x03, 0x02, 0x01};
+static const uint8_t CMD_ENABLE_CONF = 0xFF;
+static const uint8_t CMD_DISABLE_CONF = 0xFE;
+static const uint8_t CMD_VERSION = 0xA0;
+static const uint8_t CMD_MAC = 0xA5;
+static const uint8_t CMD_RESET = 0xA2;
+static const uint8_t CMD_RESTART = 0xA3;
+static const uint8_t CMD_BLUETOOTH = 0xA4;
+static const uint8_t CMD_SINGLE_TARGET_MODE = 0x80;
+static const uint8_t CMD_MULTI_TARGET_MODE = 0x90;
+static const uint8_t CMD_QUERY_TARGET_MODE = 0x91;
+static const uint8_t CMD_SET_BAUD_RATE = 0xA1;
+static const uint8_t CMD_QUERY_ZONE = 0xC1;
+static const uint8_t CMD_SET_ZONE = 0xC2;
 
 static inline uint16_t convert_seconds_to_ms(uint16_t value) { return value * 1000; };
 
+static inline std::string convert_signed_int_to_hex(int value) {
+  auto value_as_str = str_snprintf("%04x", 4, value & 0xFFFF);
+  return value_as_str;
+}
+
 static inline void convert_int_values_to_hex(const int *values, uint8_t *bytes) {
-  for (uint8_t i = 0; i < 4; i++) {
-    uint16_t val = values[i] & 0xFFFF;
-    bytes[i * 2] = val & 0xFF;             // Store low byte first (little-endian)
-    bytes[i * 2 + 1] = (val >> 8) & 0xFF;  // Store high byte second
+  for (int i = 0; i < 4; i++) {
+    std::string temp_hex = convert_signed_int_to_hex(values[i]);
+    bytes[i * 2] = std::stoi(temp_hex.substr(2, 2), nullptr, 16);      // Store high byte
+    bytes[i * 2 + 1] = std::stoi(temp_hex.substr(0, 2), nullptr, 16);  // Store low byte
   }
 }
 
@@ -178,13 +170,18 @@ static inline float calculate_angle(float base, float hypotenuse) {
   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
-    }
+static inline std::string get_direction(int16_t speed) {
+  static const char *const APPROACHING = "Approaching";
+  static const char *const MOVING_AWAY = "Moving away";
+  static const char *const STATIONARY = "Stationary";
+
+  if (speed > 0) {
+    return MOVING_AWAY;
   }
-  return true;  // Valid header/footer
+  if (speed < 0) {
+    return APPROACHING;
+  }
+  return STATIONARY;
 }
 
 void LD2450Component::setup() {
@@ -199,93 +196,84 @@ void LD2450Component::setup() {
 }
 
 void LD2450Component::dump_config() {
-  std::string mac_str =
-      mac_address_is_valid(this->mac_address_) ? format_mac_address_pretty(this->mac_address_) : UNKNOWN_MAC;
-  std::string version = str_sprintf(VERSION_FMT, this->version_[1], this->version_[0], this->version_[5],
-                                    this->version_[4], this->version_[3], this->version_[2]);
-  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_);
+  ESP_LOGCONFIG(TAG, "LD2450:");
 #ifdef USE_BINARY_SENSOR
-  ESP_LOGCONFIG(TAG, "Binary Sensors:");
-  LOG_BINARY_SENSOR("  ", "MovingTarget", this->moving_target_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "StillTarget", this->still_target_binary_sensor_);
-  LOG_BINARY_SENSOR("  ", "Target", this->target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "TargetBinarySensor", this->target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "MovingTargetBinarySensor", this->moving_target_binary_sensor_);
+  LOG_BINARY_SENSOR("  ", "StillTargetBinarySensor", this->still_target_binary_sensor_);
+#endif
+#ifdef USE_SWITCH
+  LOG_SWITCH("  ", "BluetoothSwitch", this->bluetooth_switch_);
+  LOG_SWITCH("  ", "MultiTargetSwitch", this->multi_target_switch_);
+#endif
+#ifdef USE_BUTTON
+  LOG_BUTTON("  ", "ResetButton", this->reset_button_);
+  LOG_BUTTON("  ", "RestartButton", this->restart_button_);
 #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_);
+  LOG_SENSOR("  ", "TargetCountSensor", this->target_count_sensor_);
+  LOG_SENSOR("  ", "StillTargetCountSensor", this->still_target_count_sensor_);
+  LOG_SENSOR("  ", "MovingTargetCountSensor", this->moving_target_count_sensor_);
   for (sensor::Sensor *s : this->move_x_sensors_) {
-    LOG_SENSOR("  ", "TargetX", s);
+    LOG_SENSOR("  ", "NthTargetXSensor", s);
   }
   for (sensor::Sensor *s : this->move_y_sensors_) {
-    LOG_SENSOR("  ", "TargetY", s);
-  }
-  for (sensor::Sensor *s : this->move_angle_sensors_) {
-    LOG_SENSOR("  ", "TargetAngle", s);
-  }
-  for (sensor::Sensor *s : this->move_distance_sensors_) {
-    LOG_SENSOR("  ", "TargetDistance", s);
-  }
-  for (sensor::Sensor *s : this->move_resolution_sensors_) {
-    LOG_SENSOR("  ", "TargetResolution", s);
+    LOG_SENSOR("  ", "NthTargetYSensor", s);
   }
   for (sensor::Sensor *s : this->move_speed_sensors_) {
-    LOG_SENSOR("  ", "TargetSpeed", s);
+    LOG_SENSOR("  ", "NthTargetSpeedSensor", s);
+  }
+  for (sensor::Sensor *s : this->move_angle_sensors_) {
+    LOG_SENSOR("  ", "NthTargetAngleSensor", s);
+  }
+  for (sensor::Sensor *s : this->move_distance_sensors_) {
+    LOG_SENSOR("  ", "NthTargetDistanceSensor", s);
+  }
+  for (sensor::Sensor *s : this->move_resolution_sensors_) {
+    LOG_SENSOR("  ", "NthTargetResolutionSensor", s);
   }
   for (sensor::Sensor *s : this->zone_target_count_sensors_) {
-    LOG_SENSOR("  ", "ZoneTargetCount", s);
-  }
-  for (sensor::Sensor *s : this->zone_moving_target_count_sensors_) {
-    LOG_SENSOR("  ", "ZoneMovingTargetCount", s);
+    LOG_SENSOR("  ", "NthZoneTargetCountSensor", s);
   }
   for (sensor::Sensor *s : this->zone_still_target_count_sensors_) {
-    LOG_SENSOR("  ", "ZoneStillTargetCount", s);
+    LOG_SENSOR("  ", "NthZoneStillTargetCountSensor", s);
+  }
+  for (sensor::Sensor *s : this->zone_moving_target_count_sensors_) {
+    LOG_SENSOR("  ", "NthZoneMovingTargetCountSensor", 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("  ", "VersionTextSensor", this->version_text_sensor_);
+  LOG_TEXT_SENSOR("  ", "MacTextSensor", this->mac_text_sensor_);
   for (text_sensor::TextSensor *s : this->direction_text_sensors_) {
-    LOG_TEXT_SENSOR("  ", "Direction", s);
+    LOG_TEXT_SENSOR("  ", "NthDirectionTextSensor", s);
   }
 #endif
 #ifdef USE_NUMBER
-  ESP_LOGCONFIG(TAG, "Numbers:");
-  LOG_NUMBER("  ", "PresenceTimeout", this->presence_timeout_number_);
   for (auto n : this->zone_numbers_) {
-    LOG_NUMBER("  ", "ZoneX1", n.x1);
-    LOG_NUMBER("  ", "ZoneY1", n.y1);
-    LOG_NUMBER("  ", "ZoneX2", n.x2);
-    LOG_NUMBER("  ", "ZoneY2", n.y2);
+    LOG_NUMBER("  ", "ZoneX1Number", n.x1);
+    LOG_NUMBER("  ", "ZoneY1Number", n.y1);
+    LOG_NUMBER("  ", "ZoneX2Number", n.x2);
+    LOG_NUMBER("  ", "ZoneY2Number", n.y2);
   }
 #endif
 #ifdef USE_SELECT
-  ESP_LOGCONFIG(TAG, "Selects:");
-  LOG_SELECT("  ", "BaudRate", this->baud_rate_select_);
-  LOG_SELECT("  ", "ZoneType", this->zone_type_select_);
+  LOG_SELECT("  ", "BaudRateSelect", this->baud_rate_select_);
+  LOG_SELECT("  ", "ZoneTypeSelect", this->zone_type_select_);
 #endif
-#ifdef USE_SWITCH
-  ESP_LOGCONFIG(TAG, "Switches:");
-  LOG_SWITCH("  ", "Bluetooth", this->bluetooth_switch_);
-  LOG_SWITCH("  ", "MultiTarget", this->multi_target_switch_);
-#endif
-#ifdef USE_BUTTON
-  ESP_LOGCONFIG(TAG, "Buttons:");
-  LOG_BUTTON("  ", "FactoryReset", this->factory_reset_button_);
-  LOG_BUTTON("  ", "Restart", this->restart_button_);
+#ifdef USE_NUMBER
+  LOG_NUMBER("  ", "PresenceTimeoutNumber", this->presence_timeout_number_);
 #endif
+  ESP_LOGCONFIG(TAG,
+                "  Throttle: %ums\n"
+                "  MAC Address: %s\n"
+                "  Firmware version: %s",
+                this->throttle_, this->mac_ == NO_MAC ? UNKNOWN_MAC : this->mac_.c_str(), this->version_.c_str());
 }
 
 void LD2450Component::loop() {
   while (this->available()) {
-    this->readline_(this->read());
+    this->readline_(read(), this->buffer_data_, MAX_LINE_LENGTH);
   }
 }
 
@@ -320,7 +308,7 @@ void LD2450Component::set_radar_zone(int32_t zone_type, int32_t zone1_x1, int32_
   this->zone_type_ = zone_type;
   int zone_parameters[12] = {zone1_x1, zone1_y1, zone1_x2, zone1_y2, zone2_x1, zone2_y1,
                              zone2_x2, zone2_y2, zone3_x1, zone3_y1, zone3_x2, zone3_y2};
-  for (uint8_t i = 0; i < MAX_ZONES; i++) {
+  for (int i = 0; i < MAX_ZONES; i++) {
     this->zone_config_[i].x1 = zone_parameters[i * 4];
     this->zone_config_[i].y1 = zone_parameters[i * 4 + 1];
     this->zone_config_[i].x2 = zone_parameters[i * 4 + 2];
@@ -334,15 +322,15 @@ void LD2450Component::send_set_zone_command_() {
   uint8_t cmd_value[26] = {};
   uint8_t zone_type_bytes[2] = {static_cast<uint8_t>(this->zone_type_), 0x00};
   uint8_t area_config[24] = {};
-  for (uint8_t i = 0; i < MAX_ZONES; i++) {
+  for (int i = 0; i < MAX_ZONES; i++) {
     int values[4] = {this->zone_config_[i].x1, this->zone_config_[i].y1, this->zone_config_[i].x2,
                      this->zone_config_[i].y2};
     ld2450::convert_int_values_to_hex(values, area_config + (i * 8));
   }
-  std::memcpy(cmd_value, zone_type_bytes, sizeof(zone_type_bytes));
-  std::memcpy(cmd_value + 2, area_config, sizeof(area_config));
+  std::memcpy(cmd_value, zone_type_bytes, 2);
+  std::memcpy(cmd_value + 2, area_config, 24);
   this->set_config_mode_(true);
-  this->send_command_(CMD_SET_ZONE, cmd_value, sizeof(cmd_value));
+  this->send_command_(CMD_SET_ZONE, cmd_value, 26);
   this->set_config_mode_(false);
 }
 
@@ -358,14 +346,14 @@ bool LD2450Component::get_timeout_status_(uint32_t check_millis) {
 }
 
 // Extract, store and publish zone details LD2450 buffer
-void LD2450Component::process_zone_() {
+void LD2450Component::process_zone_(uint8_t *buffer) {
   uint8_t index, start;
   for (index = 0; index < MAX_ZONES; index++) {
     start = 12 + index * 8;
-    this->zone_config_[index].x1 = ld2450::hex_to_signed_int(this->buffer_data_, start);
-    this->zone_config_[index].y1 = ld2450::hex_to_signed_int(this->buffer_data_, start + 2);
-    this->zone_config_[index].x2 = ld2450::hex_to_signed_int(this->buffer_data_, start + 4);
-    this->zone_config_[index].y2 = ld2450::hex_to_signed_int(this->buffer_data_, start + 6);
+    this->zone_config_[index].x1 = ld2450::hex_to_signed_int(buffer, start);
+    this->zone_config_[index].y1 = ld2450::hex_to_signed_int(buffer, start + 2);
+    this->zone_config_[index].x2 = ld2450::hex_to_signed_int(buffer, start + 4);
+    this->zone_config_[index].y2 = ld2450::hex_to_signed_int(buffer, start + 6);
 #ifdef USE_NUMBER
     // only one null check as all coordinates are required for a single zone
     if (this->zone_numbers_[index].x1 != nullptr) {
@@ -411,25 +399,27 @@ void LD2450Component::restart_and_read_all_info() {
 
 // Send command with values to LD2450
 void LD2450Component::send_command_(uint8_t command, const uint8_t *command_value, uint8_t command_value_len) {
-  ESP_LOGV(TAG, "Sending COMMAND %02X", command);
-  // frame header bytes
-  this->write_array(CMD_FRAME_HEADER, sizeof(CMD_FRAME_HEADER));
+  ESP_LOGV(TAG, "Sending command %02X", command);
+  // frame header
+  this->write_array(CMD_FRAME_HEADER, 4);
   // length bytes
-  uint8_t len = 2;
+  int len = 2;
   if (command_value != nullptr) {
     len += command_value_len;
   }
-  uint8_t len_cmd[] = {lowbyte(len), highbyte(len), command, 0x00};
-  this->write_array(len_cmd, sizeof(len_cmd));
-
+  this->write_byte(lowbyte(len));
+  this->write_byte(highbyte(len));
+  // command
+  this->write_byte(lowbyte(command));
+  this->write_byte(highbyte(command));
   // command value bytes
   if (command_value != nullptr) {
-    for (uint8_t i = 0; i < command_value_len; i++) {
+    for (int i = 0; i < command_value_len; i++) {
       this->write_byte(command_value[i]);
     }
   }
-  // frame footer bytes
-  this->write_array(CMD_FRAME_FOOTER, sizeof(CMD_FRAME_FOOTER));
+  // footer
+  this->write_array(CMD_FRAME_END, 4);
   // FIXME to remove
   delay(50);  // NOLINT
 }
@@ -437,23 +427,25 @@ void LD2450Component::send_command_(uint8_t command, const uint8_t *command_valu
 // 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_) {
+void LD2450Component::handle_periodic_data_(uint8_t *buffer, uint8_t len) {
+  if (len < 29) {  // header (4 bytes) + 8 x 3 target data + footer (2 bytes)
+    ESP_LOGE(TAG, "Invalid message length");
+    return;
+  }
+  if (buffer[0] != 0xAA || buffer[1] != 0xFF || buffer[2] != 0x03 || buffer[3] != 0x00) {  // header
+    ESP_LOGE(TAG, "Invalid message header");
+    return;
+  }
+  if (buffer[len - 2] != 0x55 || buffer[len - 1] != 0xCC) {  // footer
+    ESP_LOGE(TAG, "Invalid message footer");
     return;
   }
 
-  if (this->buffer_pos_ < 29) {  // header (4 bytes) + 8 x 3 target data + footer (2 bytes)
-    ESP_LOGE(TAG, "Invalid length");
+  if (App.get_loop_component_start_time() - this->last_periodic_millis_ < this->throttle_) {
+    ESP_LOGV(TAG, "Throttling: %d", this->throttle_);
     return;
   }
-  if (!ld2450::validate_header_footer(DATA_FRAME_HEADER, this->buffer_data_) ||
-      this->buffer_data_[this->buffer_pos_ - 2] != DATA_FRAME_FOOTER[0] ||
-      this->buffer_data_[this->buffer_pos_ - 1] != DATA_FRAME_FOOTER[1]) {
-    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;
@@ -461,13 +453,13 @@ void LD2450Component::handle_periodic_data_() {
   int16_t moving_target_count = 0;
   int16_t start = 0;
   int16_t val = 0;
+  uint8_t index = 0;
   int16_t tx = 0;
   int16_t ty = 0;
   int16_t td = 0;
   int16_t ts = 0;
   int16_t angle = 0;
-  uint8_t index = 0;
-  Direction direction{DIRECTION_UNDEFINED};
+  std::string direction{};
   bool is_moving = false;
 
 #if defined(USE_BINARY_SENSOR) || defined(USE_SENSOR) || defined(USE_TEXT_SENSOR)
@@ -479,38 +471,29 @@ void LD2450Component::handle_periodic_data_() {
     is_moving = false;
     sensor::Sensor *sx = this->move_x_sensors_[index];
     if (sx != nullptr) {
-      val = ld2450::decode_coordinate(this->buffer_data_[start], this->buffer_data_[start + 1]);
+      val = ld2450::decode_coordinate(buffer[start], buffer[start + 1]);
       tx = val;
-      if (this->cached_target_data_[index].x != val) {
-        sx->publish_state(val);
-        this->cached_target_data_[index].x = val;
-      }
+      sx->publish_state(val);
     }
     // Y
     start = TARGET_Y + index * 8;
     sensor::Sensor *sy = this->move_y_sensors_[index];
     if (sy != nullptr) {
-      val = ld2450::decode_coordinate(this->buffer_data_[start], this->buffer_data_[start + 1]);
+      val = ld2450::decode_coordinate(buffer[start], buffer[start + 1]);
       ty = val;
-      if (this->cached_target_data_[index].y != val) {
-        sy->publish_state(val);
-        this->cached_target_data_[index].y = val;
-      }
+      sy->publish_state(val);
     }
     // 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;
-      }
+      val = (buffer[start + 1] << 8) | buffer[start];
+      sr->publish_state(val);
     }
 #endif
     // SPEED
     start = TARGET_SPEED + index * 8;
-    val = ld2450::decode_speed(this->buffer_data_[start], this->buffer_data_[start + 1]);
+    val = ld2450::decode_speed(buffer[start], buffer[start + 1]);
     ts = val;
     if (val) {
       is_moving = true;
@@ -519,17 +502,13 @@ void LD2450Component::handle_periodic_data_() {
 #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;
-      }
+      ss->publish_state(val);
     }
 #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);
+    val = (uint16_t) sqrt(
+        pow(ld2450::decode_coordinate(buffer[TARGET_X + index * 8], buffer[(TARGET_X + index * 8) + 1]), 2) +
+        pow(ld2450::decode_coordinate(buffer[TARGET_Y + index * 8], buffer[(TARGET_Y + index * 8) + 1]), 2));
     td = val;
     if (val > 0) {
       target_count++;
@@ -537,42 +516,27 @@ void LD2450Component::handle_periodic_data_() {
 #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;
-      }
+      sd->publish_state(val);
     }
     // ANGLE
-    angle = ld2450::calculate_angle(static_cast<float>(ty), static_cast<float>(td));
+    angle = 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;
-      }
+      sa->publish_state(angle);
     }
 #endif
 #ifdef USE_TEXT_SENSOR
     // DIRECTION
+    direction = get_direction(ts);
     if (td == 0) {
-      direction = DIRECTION_NA;
-    } else if (ts > 0) {
-      direction = DIRECTION_MOVING_AWAY;
-    } else if (ts < 0) {
-      direction = DIRECTION_APPROACHING;
-    } else {
-      direction = DIRECTION_STATIONARY;
+      direction = "NA";
     }
     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;
-      }
+      tsd->publish_state(direction);
     }
 #endif
 
@@ -599,50 +563,32 @@ void LD2450Component::handle_periodic_data_() {
     // 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;
-      }
+      szstc->publish_state(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;
-      }
+      szmtc->publish_state(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;
-      }
+      sztc->publish_state(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;
-    }
+    this->target_count_sensor_->publish_state(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;
-    }
+    this->still_target_count_sensor_->publish_state(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;
-    }
+    this->moving_target_count_sensor_->publish_state(moving_target_count);
   }
 #endif
 
@@ -694,139 +640,117 @@ void LD2450Component::handle_periodic_data_() {
 #endif
 }
 
-bool LD2450Component::handle_ack_data_() {
-  ESP_LOGV(TAG, "Handling ACK DATA for COMMAND %02X", this->buffer_data_[COMMAND]);
-  if (this->buffer_pos_ < 10) {
-    ESP_LOGE(TAG, "Invalid length");
+bool LD2450Component::handle_ack_data_(uint8_t *buffer, uint8_t len) {
+  ESP_LOGV(TAG, "Handling ack data for command %02X", buffer[COMMAND]);
+  if (len < 10) {
+    ESP_LOGE(TAG, "Invalid ack length");
     return true;
   }
-  if (!ld2450::validate_header_footer(CMD_FRAME_HEADER, this->buffer_data_)) {
-    ESP_LOGW(TAG, "Invalid header: %s", format_hex_pretty(this->buffer_data_, HEADER_FOOTER_SIZE).c_str());
+  if (buffer[0] != 0xFD || buffer[1] != 0xFC || buffer[2] != 0xFB || buffer[3] != 0xFA) {  // frame header
+    ESP_LOGE(TAG, "Invalid ack header (command %02X)", buffer[COMMAND]);
     return true;
   }
-  if (this->buffer_data_[COMMAND_STATUS] != 0x01) {
-    ESP_LOGE(TAG, "Invalid status");
+  if (buffer[COMMAND_STATUS] != 0x01) {
+    ESP_LOGE(TAG, "Invalid ack status");
     return true;
   }
-  if (this->buffer_data_[8] || this->buffer_data_[9]) {
-    ESP_LOGW(TAG, "Invalid command: %02X, %02X", this->buffer_data_[8], this->buffer_data_[9]);
+  if (buffer[8] || buffer[9]) {
+    ESP_LOGE(TAG, "Last buffer was %u, %u", buffer[8], buffer[9]);
     return true;
   }
 
-  switch (this->buffer_data_[COMMAND]) {
-    case CMD_ENABLE_CONF:
-      ESP_LOGV(TAG, "Enable conf");
+  switch (buffer[COMMAND]) {
+    case lowbyte(CMD_ENABLE_CONF):
+      ESP_LOGV(TAG, "Enable conf command");
       break;
-
-    case CMD_DISABLE_CONF:
-      ESP_LOGV(TAG, "Disabled conf");
+    case lowbyte(CMD_DISABLE_CONF):
+      ESP_LOGV(TAG, "Disable conf command");
       break;
-
-    case CMD_SET_BAUD_RATE:
-      ESP_LOGV(TAG, "Baud rate change");
+    case lowbyte(CMD_SET_BAUD_RATE):
+      ESP_LOGV(TAG, "Baud rate change command");
 #ifdef USE_SELECT
       if (this->baud_rate_select_ != nullptr) {
-        ESP_LOGE(TAG, "Change baud rate to %s and reinstall", this->baud_rate_select_->state.c_str());
+        ESP_LOGV(TAG, "Change baud rate to %s", this->baud_rate_select_->state.c_str());
       }
 #endif
       break;
-
-    case CMD_QUERY_VERSION: {
-      std::memcpy(this->version_, &this->buffer_data_[12], sizeof(this->version_));
-      std::string version = str_sprintf(VERSION_FMT, this->version_[1], this->version_[0], this->version_[5],
-                                        this->version_[4], this->version_[3], this->version_[2]);
-      ESP_LOGV(TAG, "Firmware version: %s", version.c_str());
+    case lowbyte(CMD_VERSION):
+      this->version_ = str_sprintf(VERSION_FMT, buffer[13], buffer[12], buffer[17], buffer[16], buffer[15], buffer[14]);
+      ESP_LOGV(TAG, "Firmware version: %s", this->version_.c_str());
 #ifdef USE_TEXT_SENSOR
       if (this->version_text_sensor_ != nullptr) {
-        this->version_text_sensor_->publish_state(version);
+        this->version_text_sensor_->publish_state(this->version_);
       }
 #endif
       break;
-    }
-
-    case CMD_QUERY_MAC_ADDRESS: {
-      if (this->buffer_pos_ < 20) {
+    case lowbyte(CMD_MAC):
+      if (len < 20) {
         return false;
       }
-
-      this->bluetooth_on_ = std::memcmp(&this->buffer_data_[10], NO_MAC, sizeof(NO_MAC)) != 0;
-      if (this->bluetooth_on_) {
-        std::memcpy(this->mac_address_, &this->buffer_data_[10], sizeof(this->mac_address_));
-      }
-
-      std::string mac_str =
-          mac_address_is_valid(this->mac_address_) ? format_mac_address_pretty(this->mac_address_) : UNKNOWN_MAC;
-      ESP_LOGV(TAG, "MAC address: %s", mac_str.c_str());
+      this->mac_ = format_mac_address_pretty(&buffer[10]);
+      ESP_LOGV(TAG, "MAC address: %s", this->mac_.c_str());
 #ifdef USE_TEXT_SENSOR
       if (this->mac_text_sensor_ != nullptr) {
-        this->mac_text_sensor_->publish_state(mac_str);
+        this->mac_text_sensor_->publish_state(this->mac_ == NO_MAC ? UNKNOWN_MAC : this->mac_);
       }
 #endif
 #ifdef USE_SWITCH
       if (this->bluetooth_switch_ != nullptr) {
-        this->bluetooth_switch_->publish_state(this->bluetooth_on_);
+        this->bluetooth_switch_->publish_state(this->mac_ != NO_MAC);
       }
 #endif
       break;
-    }
-
-    case CMD_BLUETOOTH:
-      ESP_LOGV(TAG, "Bluetooth");
+    case lowbyte(CMD_BLUETOOTH):
+      ESP_LOGV(TAG, "Bluetooth command");
       break;
-
-    case CMD_SINGLE_TARGET_MODE:
-      ESP_LOGV(TAG, "Single target conf");
+    case lowbyte(CMD_SINGLE_TARGET_MODE):
+      ESP_LOGV(TAG, "Single target conf command");
 #ifdef USE_SWITCH
       if (this->multi_target_switch_ != nullptr) {
         this->multi_target_switch_->publish_state(false);
       }
 #endif
       break;
-
-    case CMD_MULTI_TARGET_MODE:
-      ESP_LOGV(TAG, "Multi target conf");
+    case lowbyte(CMD_MULTI_TARGET_MODE):
+      ESP_LOGV(TAG, "Multi target conf command");
 #ifdef USE_SWITCH
       if (this->multi_target_switch_ != nullptr) {
         this->multi_target_switch_->publish_state(true);
       }
 #endif
       break;
-
-    case CMD_QUERY_TARGET_MODE:
-      ESP_LOGV(TAG, "Query target tracking mode");
+    case lowbyte(CMD_QUERY_TARGET_MODE):
+      ESP_LOGV(TAG, "Query target tracking mode command");
 #ifdef USE_SWITCH
       if (this->multi_target_switch_ != nullptr) {
-        this->multi_target_switch_->publish_state(this->buffer_data_[10] == 0x02);
+        this->multi_target_switch_->publish_state(buffer[10] == 0x02);
       }
 #endif
       break;
-
-    case CMD_QUERY_ZONE:
-      ESP_LOGV(TAG, "Query zone conf");
-      this->zone_type_ = std::stoi(std::to_string(this->buffer_data_[10]), nullptr, 16);
+    case lowbyte(CMD_QUERY_ZONE):
+      ESP_LOGV(TAG, "Query zone conf command");
+      this->zone_type_ = std::stoi(std::to_string(buffer[10]), nullptr, 16);
       this->publish_zone_type();
 #ifdef USE_SELECT
       if (this->zone_type_select_ != nullptr) {
         ESP_LOGV(TAG, "Change zone type to: %s", this->zone_type_select_->state.c_str());
       }
 #endif
-      if (this->buffer_data_[10] == 0x00) {
+      if (buffer[10] == 0x00) {
         ESP_LOGV(TAG, "Zone: Disabled");
       }
-      if (this->buffer_data_[10] == 0x01) {
+      if (buffer[10] == 0x01) {
         ESP_LOGV(TAG, "Zone: Area detection");
       }
-      if (this->buffer_data_[10] == 0x02) {
+      if (buffer[10] == 0x02) {
         ESP_LOGV(TAG, "Zone: Area filter");
       }
-      this->process_zone_();
+      this->process_zone_(buffer);
       break;
-
-    case CMD_SET_ZONE:
-      ESP_LOGV(TAG, "Set zone conf");
+    case lowbyte(CMD_SET_ZONE):
+      ESP_LOGV(TAG, "Set zone conf command");
       this->query_zone_info();
       break;
-
     default:
       break;
   }
@@ -834,57 +758,55 @@ bool LD2450Component::handle_ack_data_() {
 }
 
 // Read LD2450 buffer data
-void LD2450Component::readline_(int readch) {
+void LD2450Component::readline_(int readch, uint8_t *buffer, uint8_t len) {
   if (readch < 0) {
-    return;  // No data available
+    return;
   }
-
-  if (this->buffer_pos_ < MAX_LINE_LENGTH - 1) {
-    this->buffer_data_[this->buffer_pos_++] = readch;
-    this->buffer_data_[this->buffer_pos_] = 0;
+  if (this->buffer_pos_ < len - 1) {
+    buffer[this->buffer_pos_++] = readch;
+    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
+    return;
   }
-  if (this->buffer_data_[this->buffer_pos_ - 2] == DATA_FRAME_FOOTER[0] &&
-      this->buffer_data_[this->buffer_pos_ - 1] == DATA_FRAME_FOOTER[1]) {
-    ESP_LOGV(TAG, "Handling Periodic Data: %s", format_hex_pretty(this->buffer_data_, this->buffer_pos_).c_str());
-    this->handle_periodic_data_();
+  if (buffer[this->buffer_pos_ - 2] == 0x55 && buffer[this->buffer_pos_ - 1] == 0xCC) {
+    ESP_LOGV(TAG, "Handle periodic radar data");
+    this->handle_periodic_data_(buffer, this->buffer_pos_);
     this->buffer_pos_ = 0;  // Reset position index for next frame
-  } else if (ld2450::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
+  } else if (buffer[this->buffer_pos_ - 4] == 0x04 && buffer[this->buffer_pos_ - 3] == 0x03 &&
+             buffer[this->buffer_pos_ - 2] == 0x02 && buffer[this->buffer_pos_ - 1] == 0x01) {
+    ESP_LOGV(TAG, "Handle command ack data");
+    if (this->handle_ack_data_(buffer, this->buffer_pos_)) {
+      this->buffer_pos_ = 0;  // Reset position index for next frame
     } else {
-      ESP_LOGV(TAG, "Ack Data incomplete");
+      ESP_LOGV(TAG, "Command ack data invalid");
     }
   }
 }
 
 // Set Config Mode - Pre-requisite sending commands
 void LD2450Component::set_config_mode_(bool enable) {
-  const uint8_t cmd = enable ? CMD_ENABLE_CONF : CMD_DISABLE_CONF;
-  const uint8_t cmd_value[2] = {0x01, 0x00};
-  this->send_command_(cmd, enable ? cmd_value : nullptr, sizeof(cmd_value));
+  uint8_t cmd = enable ? CMD_ENABLE_CONF : CMD_DISABLE_CONF;
+  uint8_t cmd_value[2] = {0x01, 0x00};
+  this->send_command_(cmd, enable ? cmd_value : nullptr, 2);
 }
 
 // Set Bluetooth Enable/Disable
 void LD2450Component::set_bluetooth(bool enable) {
   this->set_config_mode_(true);
-  const uint8_t cmd_value[2] = {enable ? (uint8_t) 0x01 : (uint8_t) 0x00, 0x00};
-  this->send_command_(CMD_BLUETOOTH, cmd_value, sizeof(cmd_value));
+  uint8_t enable_cmd_value[2] = {0x01, 0x00};
+  uint8_t disable_cmd_value[2] = {0x00, 0x00};
+  this->send_command_(CMD_BLUETOOTH, enable ? enable_cmd_value : disable_cmd_value, 2);
   this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
 }
 
 // Set Baud rate
 void LD2450Component::set_baud_rate(const std::string &state) {
   this->set_config_mode_(true);
-  const uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
-  this->send_command_(CMD_SET_BAUD_RATE, cmd_value, sizeof(cmd_value));
+  uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
+  this->send_command_(CMD_SET_BAUD_RATE, cmd_value, 2);
   this->set_timeout(200, [this]() { this->restart_(); });
 }
 
@@ -925,12 +847,12 @@ void LD2450Component::factory_reset() {
 void LD2450Component::restart_() { this->send_command_(CMD_RESTART, nullptr, 0); }
 
 // Get LD2450 firmware version
-void LD2450Component::get_version_() { this->send_command_(CMD_QUERY_VERSION, nullptr, 0); }
+void LD2450Component::get_version_() { this->send_command_(CMD_VERSION, nullptr, 0); }
 
 // Get LD2450 mac address
 void LD2450Component::get_mac_() {
   uint8_t cmd_value[2] = {0x01, 0x00};
-  this->send_command_(CMD_QUERY_MAC_ADDRESS, cmd_value, 2);
+  this->send_command_(CMD_MAC, cmd_value, 2);
 }
 
 // Query for target tracking mode

esphome/components/ld2450/ld2450.h

@@ -5,8 +5,6 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include <limits>
-#include <cmath>
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
@@ -38,18 +36,10 @@ 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 = 41;          // Max characters for serial buffer
+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
 
-enum Direction : uint8_t {
-  DIRECTION_APPROACHING = 0,
-  DIRECTION_MOVING_AWAY = 1,
-  DIRECTION_STATIONARY = 2,
-  DIRECTION_NA = 3,
-  DIRECTION_UNDEFINED = 4,
-};
-
 // Target coordinate struct
 struct Target {
   int16_t x;
@@ -75,22 +65,19 @@ struct ZoneOfNumbers {
 #endif
 
 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)
-  SUB_BINARY_SENSOR(target)
-#endif
-#ifdef USE_SENSOR
-  SUB_SENSOR(moving_target_count)
-  SUB_SENSOR(still_target_count)
-  SUB_SENSOR(target_count)
 #endif
 #ifdef USE_TEXT_SENSOR
-  SUB_TEXT_SENSOR(mac)
   SUB_TEXT_SENSOR(version)
-#endif
-#ifdef USE_NUMBER
-  SUB_NUMBER(presence_timeout)
+  SUB_TEXT_SENSOR(mac)
 #endif
 #ifdef USE_SELECT
   SUB_SELECT(baud_rate)
@@ -101,16 +88,19 @@ class LD2450Component : public Component, public uart::UARTDevice {
   SUB_SWITCH(multi_target)
 #endif
 #ifdef USE_BUTTON
-  SUB_BUTTON(factory_reset)
+  SUB_BUTTON(reset)
   SUB_BUTTON(restart)
 #endif
+#ifdef USE_NUMBER
+  SUB_NUMBER(presence_timeout)
+#endif
 
  public:
   void setup() override;
   void dump_config() override;
   void loop() override;
   void set_presence_timeout();
-  void set_throttle(uint16_t value) { this->throttle_ = value; }
+  void set_throttle(uint16_t value) { this->throttle_ = value; };
   void read_all_info();
   void query_zone_info();
   void restart_and_read_all_info();
@@ -146,10 +136,10 @@ class LD2450Component : public Component, public uart::UARTDevice {
  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_();
-  bool handle_ack_data_();
-  void process_zone_();
-  void readline_(int readch);
+  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_();
@@ -167,40 +157,13 @@ class LD2450Component : public Component, public uart::UARTDevice {
   uint32_t moving_presence_millis_ = 0;
   uint16_t throttle_ = 0;
   uint16_t timeout_ = 5;
-  uint8_t buffer_data_[MAX_LINE_LENGTH];
-  uint8_t mac_address_[6] = {0, 0, 0, 0, 0, 0};
-  uint8_t version_[6] = {0, 0, 0, 0, 0, 0};
   uint8_t buffer_pos_ = 0;  // where to resume processing/populating buffer
+  uint8_t buffer_data_[MAX_LINE_LENGTH];
   uint8_t zone_type_ = 0;
-  bool bluetooth_on_{false};
   Target target_info_[MAX_TARGETS];
   Zone zone_config_[MAX_ZONES];
-
-  // Change detection - cache previous values to avoid redundant publishes
-  // All values are initialized to sentinel values that are outside the valid sensor ranges
-  // to ensure the first real measurement is always published
-  struct CachedTargetData {
-    int16_t x = std::numeric_limits<int16_t>::min();             // -32768, outside range of -4860 to 4860
-    int16_t y = std::numeric_limits<int16_t>::min();             // -32768, outside range of 0 to 7560
-    int16_t speed = std::numeric_limits<int16_t>::min();         // -32768, outside practical sensor range
-    uint16_t resolution = std::numeric_limits<uint16_t>::max();  // 65535, unlikely resolution value
-    uint16_t distance = std::numeric_limits<uint16_t>::max();    // 65535, outside range of 0 to ~8990
-    Direction direction = DIRECTION_UNDEFINED;                   // Undefined, will differ from any real direction
-    float angle = NAN;                                           // NAN, safe sentinel for floats
-  } cached_target_data_[MAX_TARGETS];
-
-  struct CachedZoneData {
-    uint8_t still_count = std::numeric_limits<uint8_t>::max();   // 255, unlikely zone count
-    uint8_t moving_count = std::numeric_limits<uint8_t>::max();  // 255, unlikely zone count
-    uint8_t total_count = std::numeric_limits<uint8_t>::max();   // 255, unlikely zone count
-  } cached_zone_data_[MAX_ZONES];
-
-  struct CachedGlobalData {
-    uint8_t target_count = std::numeric_limits<uint8_t>::max();  // 255, max 3 targets possible
-    uint8_t still_count = std::numeric_limits<uint8_t>::max();   // 255, max 3 targets possible
-    uint8_t moving_count = std::numeric_limits<uint8_t>::max();  // 255, max 3 targets possible
-  } cached_global_data_;
-
+  std::string version_{};
+  std::string mac_{};
 #ifdef USE_NUMBER
   ESPPreferenceObject pref_;  // only used when numbers are in use
   ZoneOfNumbers zone_numbers_[MAX_ZONES];

esphome/components/libretiny/helpers.cpp

@@ -1,35 +0,0 @@
-#include "esphome/core/helpers.h"
-
-#ifdef USE_LIBRETINY
-
-#include "esphome/core/hal.h"
-
-#include <WiFi.h>  // for macAddress()
-
-namespace esphome {
-
-uint32_t random_uint32() { return rand(); }
-
-bool random_bytes(uint8_t *data, size_t len) {
-  lt_rand_bytes(data, len);
-  return true;
-}
-
-Mutex::Mutex() { handle_ = xSemaphoreCreateMutex(); }
-Mutex::~Mutex() {}
-void Mutex::lock() { xSemaphoreTake(this->handle_, portMAX_DELAY); }
-bool Mutex::try_lock() { return xSemaphoreTake(this->handle_, 0) == pdTRUE; }
-void Mutex::unlock() { xSemaphoreGive(this->handle_); }
-
-// only affects the executing core
-// so should not be used as a mutex lock, only to get accurate timing
-IRAM_ATTR InterruptLock::InterruptLock() { portDISABLE_INTERRUPTS(); }
-IRAM_ATTR InterruptLock::~InterruptLock() { portENABLE_INTERRUPTS(); }
-
-void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
-  WiFi.macAddress(mac);
-}
-
-}  // namespace esphome
-
-#endif  // USE_LIBRETINY

esphome/components/light/addressable_light.h

@@ -97,12 +97,12 @@ class AddressableLight : public LightOutput, public Component {
   }
   virtual ESPColorView get_view_internal(int32_t index) const = 0;
 
+  bool effect_active_{false};
   ESPColorCorrection correction_{};
-  LightState *state_parent_{nullptr};
 #ifdef USE_POWER_SUPPLY
   power_supply::PowerSupplyRequester power_;
 #endif
-  bool effect_active_{false};
+  LightState *state_parent_{nullptr};
 };
 
 class AddressableLightTransformer : public LightTransitionTransformer {
@@ -114,9 +114,9 @@ class AddressableLightTransformer : public LightTransitionTransformer {
 
  protected:
   AddressableLight &light_;
+  Color target_color_{};
   float last_transition_progress_{0.0f};
   float accumulated_alpha_{0.0f};
-  Color target_color_{};
 };
 
 }  // namespace light

esphome/components/light/esp_color_correction.h

@@ -69,8 +69,8 @@ class ESPColorCorrection {
  protected:
   uint8_t gamma_table_[256];
   uint8_t gamma_reverse_table_[256];
-  Color max_brightness_;
   uint8_t local_brightness_{255};
+  Color max_brightness_;
 };
 
 }  // namespace light

esphome/components/light/light_call.cpp

@@ -2,28 +2,12 @@
 #include "light_call.h"
 #include "light_state.h"
 #include "esphome/core/log.h"
-#include "esphome/core/optional.h"
 
 namespace esphome {
 namespace light {
 
 static const char *const TAG = "light";
 
-// Macro to reduce repetitive setter code
-#define IMPLEMENT_LIGHT_CALL_SETTER(name, type, flag) \
-  LightCall &LightCall::set_##name(optional<type>(name)) { \
-    if ((name).has_value()) { \
-      this->name##_ = (name).value(); \
-    } \
-    this->set_flag_(flag, (name).has_value()); \
-    return *this; \
-  } \
-  LightCall &LightCall::set_##name(type name) { \
-    this->name##_ = name; \
-    this->set_flag_(flag, true); \
-    return *this; \
-  }
-
 static const LogString *color_mode_to_human(ColorMode color_mode) {
   if (color_mode == ColorMode::UNKNOWN)
     return LOG_STR("Unknown");
@@ -48,43 +32,41 @@ void LightCall::perform() {
   const char *name = this->parent_->get_name().c_str();
   LightColorValues v = this->validate_();
 
-  if (this->get_publish_()) {
+  if (this->publish_) {
     ESP_LOGD(TAG, "'%s' Setting:", name);
 
     // Only print color mode when it's being changed
     ColorMode current_color_mode = this->parent_->remote_values.get_color_mode();
-    ColorMode target_color_mode = this->has_color_mode() ? this->color_mode_ : current_color_mode;
-    if (target_color_mode != current_color_mode) {
+    if (this->color_mode_.value_or(current_color_mode) != current_color_mode) {
       ESP_LOGD(TAG, "  Color mode: %s", LOG_STR_ARG(color_mode_to_human(v.get_color_mode())));
     }
 
     // Only print state when it's being changed
     bool current_state = this->parent_->remote_values.is_on();
-    bool target_state = this->has_state() ? this->state_ : current_state;
-    if (target_state != current_state) {
+    if (this->state_.value_or(current_state) != current_state) {
       ESP_LOGD(TAG, "  State: %s", ONOFF(v.is_on()));
     }
 
-    if (this->has_brightness()) {
+    if (this->brightness_.has_value()) {
       ESP_LOGD(TAG, "  Brightness: %.0f%%", v.get_brightness() * 100.0f);
     }
 
-    if (this->has_color_brightness()) {
+    if (this->color_brightness_.has_value()) {
       ESP_LOGD(TAG, "  Color brightness: %.0f%%", v.get_color_brightness() * 100.0f);
     }
-    if (this->has_red() || this->has_green() || this->has_blue()) {
+    if (this->red_.has_value() || this->green_.has_value() || this->blue_.has_value()) {
       ESP_LOGD(TAG, "  Red: %.0f%%, Green: %.0f%%, Blue: %.0f%%", v.get_red() * 100.0f, v.get_green() * 100.0f,
                v.get_blue() * 100.0f);
     }
 
-    if (this->has_white()) {
+    if (this->white_.has_value()) {
       ESP_LOGD(TAG, "  White: %.0f%%", v.get_white() * 100.0f);
     }
-    if (this->has_color_temperature()) {
+    if (this->color_temperature_.has_value()) {
       ESP_LOGD(TAG, "  Color temperature: %.1f mireds", v.get_color_temperature());
     }
 
-    if (this->has_cold_white() || this->has_warm_white()) {
+    if (this->cold_white_.has_value() || this->warm_white_.has_value()) {
       ESP_LOGD(TAG, "  Cold white: %.0f%%, warm white: %.0f%%", v.get_cold_white() * 100.0f,
                v.get_warm_white() * 100.0f);
     }
@@ -92,57 +74,58 @@ void LightCall::perform() {
 
   if (this->has_flash_()) {
     // FLASH
-    if (this->get_publish_()) {
-      ESP_LOGD(TAG, "  Flash length: %.1fs", this->flash_length_ / 1e3f);
+    if (this->publish_) {
+      ESP_LOGD(TAG, "  Flash length: %.1fs", *this->flash_length_ / 1e3f);
     }
 
-    this->parent_->start_flash_(v, this->flash_length_, this->get_publish_());
+    this->parent_->start_flash_(v, *this->flash_length_, this->publish_);
   } else if (this->has_transition_()) {
     // TRANSITION
-    if (this->get_publish_()) {
-      ESP_LOGD(TAG, "  Transition length: %.1fs", this->transition_length_ / 1e3f);
+    if (this->publish_) {
+      ESP_LOGD(TAG, "  Transition length: %.1fs", *this->transition_length_ / 1e3f);
     }
 
     // Special case: Transition and effect can be set when turning off
     if (this->has_effect_()) {
-      if (this->get_publish_()) {
+      if (this->publish_) {
         ESP_LOGD(TAG, "  Effect: 'None'");
       }
       this->parent_->stop_effect_();
     }
 
-    this->parent_->start_transition_(v, this->transition_length_, this->get_publish_());
+    this->parent_->start_transition_(v, *this->transition_length_, this->publish_);
 
   } else if (this->has_effect_()) {
     // EFFECT
+    auto effect = this->effect_;
     const char *effect_s;
-    if (this->effect_ == 0u) {
+    if (effect == 0u) {
       effect_s = "None";
     } else {
-      effect_s = this->parent_->effects_[this->effect_ - 1]->get_name().c_str();
+      effect_s = this->parent_->effects_[*this->effect_ - 1]->get_name().c_str();
     }
 
-    if (this->get_publish_()) {
+    if (this->publish_) {
       ESP_LOGD(TAG, "  Effect: '%s'", effect_s);
     }
 
-    this->parent_->start_effect_(this->effect_);
+    this->parent_->start_effect_(*this->effect_);
 
     // Also set light color values when starting an effect
     // For example to turn off the light
     this->parent_->set_immediately_(v, true);
   } else {
     // INSTANT CHANGE
-    this->parent_->set_immediately_(v, this->get_publish_());
+    this->parent_->set_immediately_(v, this->publish_);
   }
 
   if (!this->has_transition_()) {
     this->parent_->target_state_reached_callback_.call();
   }
-  if (this->get_publish_()) {
+  if (this->publish_) {
     this->parent_->publish_state();
   }
-  if (this->get_save_()) {
+  if (this->save_) {
     this->parent_->save_remote_values_();
   }
 }
@@ -152,80 +135,82 @@ LightColorValues LightCall::validate_() {
   auto traits = this->parent_->get_traits();
 
   // Color mode check
-  if (this->has_color_mode() && !traits.supports_color_mode(this->color_mode_)) {
-    ESP_LOGW(TAG, "'%s' does not support color mode %s", name, LOG_STR_ARG(color_mode_to_human(this->color_mode_)));
-    this->set_flag_(FLAG_HAS_COLOR_MODE, false);
+  if (this->color_mode_.has_value() && !traits.supports_color_mode(this->color_mode_.value())) {
+    ESP_LOGW(TAG, "'%s' does not support color mode %s", name,
+             LOG_STR_ARG(color_mode_to_human(this->color_mode_.value())));
+    this->color_mode_.reset();
   }
 
   // Ensure there is always a color mode set
-  if (!this->has_color_mode()) {
+  if (!this->color_mode_.has_value()) {
     this->color_mode_ = this->compute_color_mode_();
-    this->set_flag_(FLAG_HAS_COLOR_MODE, true);
   }
-  auto color_mode = this->color_mode_;
+  auto color_mode = *this->color_mode_;
 
   // Transform calls that use non-native parameters for the current mode.
   this->transform_parameters_();
 
   // Brightness exists check
-  if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) {
+  if (this->brightness_.has_value() && *this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) {
     ESP_LOGW(TAG, "'%s': setting brightness not supported", name);
-    this->set_flag_(FLAG_HAS_BRIGHTNESS, false);
+    this->brightness_.reset();
   }
 
   // Transition length possible check
-  if (this->has_transition_() && this->transition_length_ != 0 && !(color_mode & ColorCapability::BRIGHTNESS)) {
+  if (this->transition_length_.has_value() && *this->transition_length_ != 0 &&
+      !(color_mode & ColorCapability::BRIGHTNESS)) {
     ESP_LOGW(TAG, "'%s': transitions not supported", name);
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
+    this->transition_length_.reset();
   }
 
   // Color brightness exists check
-  if (this->has_color_brightness() && this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB)) {
+  if (this->color_brightness_.has_value() && *this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB)) {
     ESP_LOGW(TAG, "'%s': color mode does not support setting RGB brightness", name);
-    this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, false);
+    this->color_brightness_.reset();
   }
 
   // RGB exists check
-  if ((this->has_red() && this->red_ > 0.0f) || (this->has_green() && this->green_ > 0.0f) ||
-      (this->has_blue() && this->blue_ > 0.0f)) {
+  if ((this->red_.has_value() && *this->red_ > 0.0f) || (this->green_.has_value() && *this->green_ > 0.0f) ||
+      (this->blue_.has_value() && *this->blue_ > 0.0f)) {
     if (!(color_mode & ColorCapability::RGB)) {
       ESP_LOGW(TAG, "'%s': color mode does not support setting RGB color", name);
-      this->set_flag_(FLAG_HAS_RED, false);
-      this->set_flag_(FLAG_HAS_GREEN, false);
-      this->set_flag_(FLAG_HAS_BLUE, false);
+      this->red_.reset();
+      this->green_.reset();
+      this->blue_.reset();
     }
   }
 
   // White value exists check
-  if (this->has_white() && this->white_ > 0.0f &&
+  if (this->white_.has_value() && *this->white_ > 0.0f &&
       !(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
     ESP_LOGW(TAG, "'%s': color mode does not support setting white value", name);
-    this->set_flag_(FLAG_HAS_WHITE, false);
+    this->white_.reset();
   }
 
   // Color temperature exists check
-  if (this->has_color_temperature() &&
+  if (this->color_temperature_.has_value() &&
       !(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
     ESP_LOGW(TAG, "'%s': color mode does not support setting color temperature", name);
-    this->set_flag_(FLAG_HAS_COLOR_TEMPERATURE, false);
+    this->color_temperature_.reset();
   }
 
   // Cold/warm white value exists check
-  if ((this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f)) {
+  if ((this->cold_white_.has_value() && *this->cold_white_ > 0.0f) ||
+      (this->warm_white_.has_value() && *this->warm_white_ > 0.0f)) {
     if (!(color_mode & ColorCapability::COLD_WARM_WHITE)) {
       ESP_LOGW(TAG, "'%s': color mode does not support setting cold/warm white value", name);
-      this->set_flag_(FLAG_HAS_COLD_WHITE, false);
-      this->set_flag_(FLAG_HAS_WARM_WHITE, false);
+      this->cold_white_.reset();
+      this->warm_white_.reset();
     }
   }
 
 #define VALIDATE_RANGE_(name_, upper_name, min, max) \
-  if (this->has_##name_()) { \
-    auto val = this->name_##_; \
+  if (name_##_.has_value()) { \
+    auto val = *name_##_; \
     if (val < (min) || val > (max)) { \
       ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_LITERAL(upper_name), val, \
                (min), (max)); \
-      this->name_##_ = clamp(val, (min), (max)); \
+      name_##_ = clamp(val, (min), (max)); \
     } \
   }
 #define VALIDATE_RANGE(name, upper_name) VALIDATE_RANGE_(name, upper_name, 0.0f, 1.0f)
@@ -242,116 +227,110 @@ LightColorValues LightCall::validate_() {
   VALIDATE_RANGE_(color_temperature, "Color temperature", traits.get_min_mireds(), traits.get_max_mireds())
 
   // Flag whether an explicit turn off was requested, in which case we'll also stop the effect.
-  bool explicit_turn_off_request = this->has_state() && !this->state_;
+  bool explicit_turn_off_request = this->state_.has_value() && !*this->state_;
 
   // Turn off when brightness is set to zero, and reset brightness (so that it has nonzero brightness when turned on).
-  if (this->has_brightness() && this->brightness_ == 0.0f) {
-    this->state_ = false;
-    this->set_flag_(FLAG_HAS_STATE, true);
-    this->brightness_ = 1.0f;
+  if (this->brightness_.has_value() && *this->brightness_ == 0.0f) {
+    this->state_ = optional<float>(false);
+    this->brightness_ = optional<float>(1.0f);
   }
 
   // Set color brightness to 100% if currently zero and a color is set.
-  if (this->has_red() || this->has_green() || this->has_blue()) {
-    if (!this->has_color_brightness() && this->parent_->remote_values.get_color_brightness() == 0.0f) {
-      this->color_brightness_ = 1.0f;
-      this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, true);
-    }
+  if (this->red_.has_value() || this->green_.has_value() || this->blue_.has_value()) {
+    if (!this->color_brightness_.has_value() && this->parent_->remote_values.get_color_brightness() == 0.0f)
+      this->color_brightness_ = optional<float>(1.0f);
   }
 
   // Create color values for the light with this call applied.
   auto v = this->parent_->remote_values;
-  if (this->has_color_mode())
-    v.set_color_mode(this->color_mode_);
-  if (this->has_state())
-    v.set_state(this->state_);
-  if (this->has_brightness())
-    v.set_brightness(this->brightness_);
-  if (this->has_color_brightness())
-    v.set_color_brightness(this->color_brightness_);
-  if (this->has_red())
-    v.set_red(this->red_);
-  if (this->has_green())
-    v.set_green(this->green_);
-  if (this->has_blue())
-    v.set_blue(this->blue_);
-  if (this->has_white())
-    v.set_white(this->white_);
-  if (this->has_color_temperature())
-    v.set_color_temperature(this->color_temperature_);
-  if (this->has_cold_white())
-    v.set_cold_white(this->cold_white_);
-  if (this->has_warm_white())
-    v.set_warm_white(this->warm_white_);
+  if (this->color_mode_.has_value())
+    v.set_color_mode(*this->color_mode_);
+  if (this->state_.has_value())
+    v.set_state(*this->state_);
+  if (this->brightness_.has_value())
+    v.set_brightness(*this->brightness_);
+  if (this->color_brightness_.has_value())
+    v.set_color_brightness(*this->color_brightness_);
+  if (this->red_.has_value())
+    v.set_red(*this->red_);
+  if (this->green_.has_value())
+    v.set_green(*this->green_);
+  if (this->blue_.has_value())
+    v.set_blue(*this->blue_);
+  if (this->white_.has_value())
+    v.set_white(*this->white_);
+  if (this->color_temperature_.has_value())
+    v.set_color_temperature(*this->color_temperature_);
+  if (this->cold_white_.has_value())
+    v.set_cold_white(*this->cold_white_);
+  if (this->warm_white_.has_value())
+    v.set_warm_white(*this->warm_white_);
 
   v.normalize_color();
 
   // Flash length check
-  if (this->has_flash_() && this->flash_length_ == 0) {
+  if (this->has_flash_() && *this->flash_length_ == 0) {
     ESP_LOGW(TAG, "'%s': flash length must be greater than zero", name);
-    this->set_flag_(FLAG_HAS_FLASH, false);
+    this->flash_length_.reset();
   }
 
   // validate transition length/flash length/effect not used at the same time
   bool supports_transition = color_mode & ColorCapability::BRIGHTNESS;
 
   // If effect is already active, remove effect start
-  if (this->has_effect_() && this->effect_ == this->parent_->active_effect_index_) {
-    this->set_flag_(FLAG_HAS_EFFECT, false);
+  if (this->has_effect_() && *this->effect_ == this->parent_->active_effect_index_) {
+    this->effect_.reset();
   }
 
   // validate effect index
-  if (this->has_effect_() && this->effect_ > this->parent_->effects_.size()) {
-    ESP_LOGW(TAG, "'%s': invalid effect index %" PRIu32, name, this->effect_);
-    this->set_flag_(FLAG_HAS_EFFECT, false);
+  if (this->has_effect_() && *this->effect_ > this->parent_->effects_.size()) {
+    ESP_LOGW(TAG, "'%s': invalid effect index %" PRIu32, name, *this->effect_);
+    this->effect_.reset();
   }
 
   if (this->has_effect_() && (this->has_transition_() || this->has_flash_())) {
     ESP_LOGW(TAG, "'%s': effect cannot be used with transition/flash", name);
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
-    this->set_flag_(FLAG_HAS_FLASH, false);
+    this->transition_length_.reset();
+    this->flash_length_.reset();
   }
 
   if (this->has_flash_() && this->has_transition_()) {
     ESP_LOGW(TAG, "'%s': flash cannot be used with transition", name);
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
+    this->transition_length_.reset();
   }
 
-  if (!this->has_transition_() && !this->has_flash_() && (!this->has_effect_() || this->effect_ == 0) &&
+  if (!this->has_transition_() && !this->has_flash_() && (!this->has_effect_() || *this->effect_ == 0) &&
       supports_transition) {
     // nothing specified and light supports transitions, set default transition length
     this->transition_length_ = this->parent_->default_transition_length_;
-    this->set_flag_(FLAG_HAS_TRANSITION, true);
   }
 
-  if (this->has_transition_() && this->transition_length_ == 0) {
+  if (this->transition_length_.value_or(0) == 0) {
     // 0 transition is interpreted as no transition (instant change)
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
+    this->transition_length_.reset();
   }
 
   if (this->has_transition_() && !supports_transition) {
     ESP_LOGW(TAG, "'%s': transitions not supported", name);
-    this->set_flag_(FLAG_HAS_TRANSITION, false);
+    this->transition_length_.reset();
   }
 
   // If not a flash and turning the light off, then disable the light
   // Do not use light color values directly, so that effects can set 0% brightness
   // Reason: When user turns off the light in frontend, the effect should also stop
-  bool target_state = this->has_state() ? this->state_ : v.is_on();
-  if (!this->has_flash_() && !target_state) {
+  if (!this->has_flash_() && !this->state_.value_or(v.is_on())) {
     if (this->has_effect_()) {
       ESP_LOGW(TAG, "'%s': cannot start effect when turning off", name);
-      this->set_flag_(FLAG_HAS_EFFECT, false);
+      this->effect_.reset();
     } else if (this->parent_->active_effect_index_ != 0 && explicit_turn_off_request) {
       // Auto turn off effect
       this->effect_ = 0;
-      this->set_flag_(FLAG_HAS_EFFECT, true);
     }
   }
 
   // Disable saving for flashes
   if (this->has_flash_())
-    this->set_flag_(FLAG_SAVE, false);
+    this->save_ = false;
 
   return v;
 }
@@ -364,27 +343,24 @@ void LightCall::transform_parameters_() {
   // - RGBWW lights with color_interlock=true, which also sets "brightness" and
   //   "color_temperature" (without color_interlock, CW/WW are set directly)
   // - Legacy Home Assistant (pre-colormode), which sets "white" and "color_temperature"
-  if (((this->has_white() && this->white_ > 0.0f) || this->has_color_temperature()) &&  //
-      (this->color_mode_ & ColorCapability::COLD_WARM_WHITE) &&                         //
-      !(this->color_mode_ & ColorCapability::WHITE) &&                                  //
-      !(this->color_mode_ & ColorCapability::COLOR_TEMPERATURE) &&                      //
+  if (((this->white_.has_value() && *this->white_ > 0.0f) || this->color_temperature_.has_value()) &&  //
+      (*this->color_mode_ & ColorCapability::COLD_WARM_WHITE) &&                                       //
+      !(*this->color_mode_ & ColorCapability::WHITE) &&                                                //
+      !(*this->color_mode_ & ColorCapability::COLOR_TEMPERATURE) &&                                    //
       traits.get_min_mireds() > 0.0f && traits.get_max_mireds() > 0.0f) {
     ESP_LOGD(TAG, "'%s': setting cold/warm white channels using white/color temperature values",
              this->parent_->get_name().c_str());
-    if (this->has_color_temperature()) {
-      const float color_temp = clamp(this->color_temperature_, traits.get_min_mireds(), traits.get_max_mireds());
+    if (this->color_temperature_.has_value()) {
+      const float color_temp = clamp(*this->color_temperature_, traits.get_min_mireds(), traits.get_max_mireds());
       const float ww_fraction =
           (color_temp - traits.get_min_mireds()) / (traits.get_max_mireds() - traits.get_min_mireds());
       const float cw_fraction = 1.0f - ww_fraction;
       const float max_cw_ww = std::max(ww_fraction, cw_fraction);
       this->cold_white_ = gamma_uncorrect(cw_fraction / max_cw_ww, this->parent_->get_gamma_correct());
       this->warm_white_ = gamma_uncorrect(ww_fraction / max_cw_ww, this->parent_->get_gamma_correct());
-      this->set_flag_(FLAG_HAS_COLD_WHITE, true);
-      this->set_flag_(FLAG_HAS_WARM_WHITE, true);
     }
-    if (this->has_white()) {
-      this->brightness_ = this->white_;
-      this->set_flag_(FLAG_HAS_BRIGHTNESS, true);
+    if (this->white_.has_value()) {
+      this->brightness_ = *this->white_;
     }
   }
 }
@@ -402,7 +378,7 @@ ColorMode LightCall::compute_color_mode_() {
 
   // Don't change if the light is being turned off.
   ColorMode current_mode = this->parent_->remote_values.get_color_mode();
-  if (this->has_state() && !this->state_)
+  if (this->state_.has_value() && !*this->state_)
     return current_mode;
 
   // If no color mode is specified, we try to guess the color mode. This is needed for backward compatibility to
@@ -435,12 +411,12 @@ ColorMode LightCall::compute_color_mode_() {
   return color_mode;
 }
 std::set<ColorMode> LightCall::get_suitable_color_modes_() {
-  bool has_white = this->has_white() && this->white_ > 0.0f;
-  bool has_ct = this->has_color_temperature();
-  bool has_cwww =
-      (this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f);
-  bool has_rgb = (this->has_color_brightness() && this->color_brightness_ > 0.0f) ||
-                 (this->has_red() || this->has_green() || this->has_blue());
+  bool has_white = this->white_.has_value() && *this->white_ > 0.0f;
+  bool has_ct = this->color_temperature_.has_value();
+  bool has_cwww = (this->cold_white_.has_value() && *this->cold_white_ > 0.0f) ||
+                  (this->warm_white_.has_value() && *this->warm_white_ > 0.0f);
+  bool has_rgb = (this->color_brightness_.has_value() && *this->color_brightness_ > 0.0f) ||
+                 (this->red_.has_value() || this->green_.has_value() || this->blue_.has_value());
 
 #define KEY(white, ct, cwww, rgb) ((white) << 0 | (ct) << 1 | (cwww) << 2 | (rgb) << 3)
 #define ENTRY(white, ct, cwww, rgb, ...) \
@@ -515,7 +491,7 @@ LightCall &LightCall::from_light_color_values(const LightColorValues &values) {
   return *this;
 }
 ColorMode LightCall::get_active_color_mode_() {
-  return this->has_color_mode() ? this->color_mode_ : this->parent_->remote_values.get_color_mode();
+  return this->color_mode_.value_or(this->parent_->remote_values.get_color_mode());
 }
 LightCall &LightCall::set_transition_length_if_supported(uint32_t transition_length) {
   if (this->get_active_color_mode_() & ColorCapability::BRIGHTNESS)
@@ -529,7 +505,7 @@ LightCall &LightCall::set_brightness_if_supported(float brightness) {
 }
 LightCall &LightCall::set_color_mode_if_supported(ColorMode color_mode) {
   if (this->parent_->get_traits().supports_color_mode(color_mode))
-    this->set_color_mode(color_mode);
+    this->color_mode_ = color_mode;
   return *this;
 }
 LightCall &LightCall::set_color_brightness_if_supported(float brightness) {
@@ -573,19 +549,110 @@ LightCall &LightCall::set_warm_white_if_supported(float warm_white) {
     this->set_warm_white(warm_white);
   return *this;
 }
-IMPLEMENT_LIGHT_CALL_SETTER(state, bool, FLAG_HAS_STATE)
-IMPLEMENT_LIGHT_CALL_SETTER(transition_length, uint32_t, FLAG_HAS_TRANSITION)
-IMPLEMENT_LIGHT_CALL_SETTER(flash_length, uint32_t, FLAG_HAS_FLASH)
-IMPLEMENT_LIGHT_CALL_SETTER(brightness, float, FLAG_HAS_BRIGHTNESS)
-IMPLEMENT_LIGHT_CALL_SETTER(color_mode, ColorMode, FLAG_HAS_COLOR_MODE)
-IMPLEMENT_LIGHT_CALL_SETTER(color_brightness, float, FLAG_HAS_COLOR_BRIGHTNESS)
-IMPLEMENT_LIGHT_CALL_SETTER(red, float, FLAG_HAS_RED)
-IMPLEMENT_LIGHT_CALL_SETTER(green, float, FLAG_HAS_GREEN)
-IMPLEMENT_LIGHT_CALL_SETTER(blue, float, FLAG_HAS_BLUE)
-IMPLEMENT_LIGHT_CALL_SETTER(white, float, FLAG_HAS_WHITE)
-IMPLEMENT_LIGHT_CALL_SETTER(color_temperature, float, FLAG_HAS_COLOR_TEMPERATURE)
-IMPLEMENT_LIGHT_CALL_SETTER(cold_white, float, FLAG_HAS_COLD_WHITE)
-IMPLEMENT_LIGHT_CALL_SETTER(warm_white, float, FLAG_HAS_WARM_WHITE)
+LightCall &LightCall::set_state(optional<bool> state) {
+  this->state_ = state;
+  return *this;
+}
+LightCall &LightCall::set_state(bool state) {
+  this->state_ = state;
+  return *this;
+}
+LightCall &LightCall::set_transition_length(optional<uint32_t> transition_length) {
+  this->transition_length_ = transition_length;
+  return *this;
+}
+LightCall &LightCall::set_transition_length(uint32_t transition_length) {
+  this->transition_length_ = transition_length;
+  return *this;
+}
+LightCall &LightCall::set_flash_length(optional<uint32_t> flash_length) {
+  this->flash_length_ = flash_length;
+  return *this;
+}
+LightCall &LightCall::set_flash_length(uint32_t flash_length) {
+  this->flash_length_ = flash_length;
+  return *this;
+}
+LightCall &LightCall::set_brightness(optional<float> brightness) {
+  this->brightness_ = brightness;
+  return *this;
+}
+LightCall &LightCall::set_brightness(float brightness) {
+  this->brightness_ = brightness;
+  return *this;
+}
+LightCall &LightCall::set_color_mode(optional<ColorMode> color_mode) {
+  this->color_mode_ = color_mode;
+  return *this;
+}
+LightCall &LightCall::set_color_mode(ColorMode color_mode) {
+  this->color_mode_ = color_mode;
+  return *this;
+}
+LightCall &LightCall::set_color_brightness(optional<float> brightness) {
+  this->color_brightness_ = brightness;
+  return *this;
+}
+LightCall &LightCall::set_color_brightness(float brightness) {
+  this->color_brightness_ = brightness;
+  return *this;
+}
+LightCall &LightCall::set_red(optional<float> red) {
+  this->red_ = red;
+  return *this;
+}
+LightCall &LightCall::set_red(float red) {
+  this->red_ = red;
+  return *this;
+}
+LightCall &LightCall::set_green(optional<float> green) {
+  this->green_ = green;
+  return *this;
+}
+LightCall &LightCall::set_green(float green) {
+  this->green_ = green;
+  return *this;
+}
+LightCall &LightCall::set_blue(optional<float> blue) {
+  this->blue_ = blue;
+  return *this;
+}
+LightCall &LightCall::set_blue(float blue) {
+  this->blue_ = blue;
+  return *this;
+}
+LightCall &LightCall::set_white(optional<float> white) {
+  this->white_ = white;
+  return *this;
+}
+LightCall &LightCall::set_white(float white) {
+  this->white_ = white;
+  return *this;
+}
+LightCall &LightCall::set_color_temperature(optional<float> color_temperature) {
+  this->color_temperature_ = color_temperature;
+  return *this;
+}
+LightCall &LightCall::set_color_temperature(float color_temperature) {
+  this->color_temperature_ = color_temperature;
+  return *this;
+}
+LightCall &LightCall::set_cold_white(optional<float> cold_white) {
+  this->cold_white_ = cold_white;
+  return *this;
+}
+LightCall &LightCall::set_cold_white(float cold_white) {
+  this->cold_white_ = cold_white;
+  return *this;
+}
+LightCall &LightCall::set_warm_white(optional<float> warm_white) {
+  this->warm_white_ = warm_white;
+  return *this;
+}
+LightCall &LightCall::set_warm_white(float warm_white) {
+  this->warm_white_ = warm_white;
+  return *this;
+}
 LightCall &LightCall::set_effect(optional<std::string> effect) {
   if (effect.has_value())
     this->set_effect(*effect);
@@ -593,22 +660,18 @@ LightCall &LightCall::set_effect(optional<std::string> effect) {
 }
 LightCall &LightCall::set_effect(uint32_t effect_number) {
   this->effect_ = effect_number;
-  this->set_flag_(FLAG_HAS_EFFECT, true);
   return *this;
 }
 LightCall &LightCall::set_effect(optional<uint32_t> effect_number) {
-  if (effect_number.has_value()) {
-    this->effect_ = effect_number.value();
-  }
-  this->set_flag_(FLAG_HAS_EFFECT, effect_number.has_value());
+  this->effect_ = effect_number;
   return *this;
 }
 LightCall &LightCall::set_publish(bool publish) {
-  this->set_flag_(FLAG_PUBLISH, publish);
+  this->publish_ = publish;
   return *this;
 }
 LightCall &LightCall::set_save(bool save) {
-  this->set_flag_(FLAG_SAVE, save);
+  this->save_ = save;
   return *this;
 }
 LightCall &LightCall::set_rgb(float red, float green, float blue) {

esphome/components/light/light_call.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "esphome/core/optional.h"
 #include "light_color_values.h"
 #include <set>
 
@@ -9,11 +10,6 @@ namespace light {
 class LightState;
 
 /** This class represents a requested change in a light state.
- *
- * Light state changes are tracked using a bitfield flags_ to minimize memory usage.
- * Each possible light property has a flag indicating whether it has been set.
- * This design keeps LightCall at ~56 bytes to minimize heap fragmentation on
- * ESP8266 and other memory-constrained devices.
  */
 class LightCall {
  public:
@@ -135,19 +131,6 @@ class LightCall {
   /// Set whether this light call should trigger a save state to recover them at startup..
   LightCall &set_save(bool save);
 
-  // Getter methods to check if values are set
-  bool has_state() const { return (flags_ & FLAG_HAS_STATE) != 0; }
-  bool has_brightness() const { return (flags_ & FLAG_HAS_BRIGHTNESS) != 0; }
-  bool has_color_brightness() const { return (flags_ & FLAG_HAS_COLOR_BRIGHTNESS) != 0; }
-  bool has_red() const { return (flags_ & FLAG_HAS_RED) != 0; }
-  bool has_green() const { return (flags_ & FLAG_HAS_GREEN) != 0; }
-  bool has_blue() const { return (flags_ & FLAG_HAS_BLUE) != 0; }
-  bool has_white() const { return (flags_ & FLAG_HAS_WHITE) != 0; }
-  bool has_color_temperature() const { return (flags_ & FLAG_HAS_COLOR_TEMPERATURE) != 0; }
-  bool has_cold_white() const { return (flags_ & FLAG_HAS_COLD_WHITE) != 0; }
-  bool has_warm_white() const { return (flags_ & FLAG_HAS_WARM_WHITE) != 0; }
-  bool has_color_mode() const { return (flags_ & FLAG_HAS_COLOR_MODE) != 0; }
-
   /** Set the RGB color of the light by RGB values.
    *
    * Please note that this only changes the color of the light, not the brightness.
@@ -187,62 +170,27 @@ class LightCall {
   /// Some color modes also can be set using non-native parameters, transform those calls.
   void transform_parameters_();
 
-  // Bitfield flags - each flag indicates whether a corresponding value has been set.
-  enum FieldFlags : uint16_t {
-    FLAG_HAS_STATE = 1 << 0,
-    FLAG_HAS_TRANSITION = 1 << 1,
-    FLAG_HAS_FLASH = 1 << 2,
-    FLAG_HAS_EFFECT = 1 << 3,
-    FLAG_HAS_BRIGHTNESS = 1 << 4,
-    FLAG_HAS_COLOR_BRIGHTNESS = 1 << 5,
-    FLAG_HAS_RED = 1 << 6,
-    FLAG_HAS_GREEN = 1 << 7,
-    FLAG_HAS_BLUE = 1 << 8,
-    FLAG_HAS_WHITE = 1 << 9,
-    FLAG_HAS_COLOR_TEMPERATURE = 1 << 10,
-    FLAG_HAS_COLD_WHITE = 1 << 11,
-    FLAG_HAS_WARM_WHITE = 1 << 12,
-    FLAG_HAS_COLOR_MODE = 1 << 13,
-    FLAG_PUBLISH = 1 << 14,
-    FLAG_SAVE = 1 << 15,
-  };
-
-  bool has_transition_() { return (this->flags_ & FLAG_HAS_TRANSITION) != 0; }
-  bool has_flash_() { return (this->flags_ & FLAG_HAS_FLASH) != 0; }
-  bool has_effect_() { return (this->flags_ & FLAG_HAS_EFFECT) != 0; }
-  bool get_publish_() { return (this->flags_ & FLAG_PUBLISH) != 0; }
-  bool get_save_() { return (this->flags_ & FLAG_SAVE) != 0; }
-
-  // Helper to set flag
-  void set_flag_(FieldFlags flag, bool value) {
-    if (value) {
-      this->flags_ |= flag;
-    } else {
-      this->flags_ &= ~flag;
-    }
-  }
+  bool has_transition_() { return this->transition_length_.has_value(); }
+  bool has_flash_() { return this->flash_length_.has_value(); }
+  bool has_effect_() { return this->effect_.has_value(); }
 
   LightState *parent_;
-
-  // Light state values - use flags_ to check if a value has been set.
-  // Group 4-byte aligned members first
-  uint32_t transition_length_;
-  uint32_t flash_length_;
-  uint32_t effect_;
-  float brightness_;
-  float color_brightness_;
-  float red_;
-  float green_;
-  float blue_;
-  float white_;
-  float color_temperature_;
-  float cold_white_;
-  float warm_white_;
-
-  // Smaller members at the end for better packing
-  uint16_t flags_{FLAG_PUBLISH | FLAG_SAVE};  // Tracks which values are set
-  ColorMode color_mode_;
-  bool state_;
+  optional<bool> state_;
+  optional<uint32_t> transition_length_;
+  optional<uint32_t> flash_length_;
+  optional<ColorMode> color_mode_;
+  optional<float> brightness_;
+  optional<float> color_brightness_;
+  optional<float> red_;
+  optional<float> green_;
+  optional<float> blue_;
+  optional<float> white_;
+  optional<float> color_temperature_;
+  optional<float> cold_white_;
+  optional<float> warm_white_;
+  optional<uint32_t> effect_;
+  bool publish_{true};
+  bool save_{true};
 };
 
 }  // namespace light

esphome/components/light/light_color_values.h

@@ -46,7 +46,8 @@ class LightColorValues {
  public:
   /// Construct the LightColorValues with all attributes enabled, but state set to off.
   LightColorValues()
-      : state_(0.0f),
+      : color_mode_(ColorMode::UNKNOWN),
+        state_(0.0f),
         brightness_(1.0f),
         color_brightness_(1.0f),
         red_(1.0f),
@@ -55,8 +56,7 @@ class LightColorValues {
         white_(1.0f),
         color_temperature_{0.0f},
         cold_white_{1.0f},
-        warm_white_{1.0f},
-        color_mode_(ColorMode::UNKNOWN) {}
+        warm_white_{1.0f} {}
 
   LightColorValues(ColorMode color_mode, float state, float brightness, float color_brightness, float red, float green,
                    float blue, float white, float color_temperature, float cold_white, float warm_white) {
@@ -292,6 +292,7 @@ class LightColorValues {
   void set_warm_white(float warm_white) { this->warm_white_ = clamp(warm_white, 0.0f, 1.0f); }
 
  protected:
+  ColorMode color_mode_;
   float state_;  ///< ON / OFF, float for transition
   float brightness_;
   float color_brightness_;
@@ -302,7 +303,6 @@ class LightColorValues {
   float color_temperature_;  ///< Color Temperature in Mired
   float cold_white_;
   float warm_white_;
-  ColorMode color_mode_;
 };
 
 }  // namespace light

esphome/components/light/light_state.h

@@ -31,7 +31,9 @@ enum LightRestoreMode : uint8_t {
 struct LightStateRTCState {
   LightStateRTCState(ColorMode color_mode, bool state, float brightness, float color_brightness, float red, float green,
                      float blue, float white, float color_temp, float cold_white, float warm_white)
-      : brightness(brightness),
+      : color_mode(color_mode),
+        state(state),
+        brightness(brightness),
         color_brightness(color_brightness),
         red(red),
         green(green),
@@ -39,12 +41,10 @@ struct LightStateRTCState {
         white(white),
         color_temp(color_temp),
         cold_white(cold_white),
-        warm_white(warm_white),
-        effect(0),
-        color_mode(color_mode),
-        state(state) {}
+        warm_white(warm_white) {}
   LightStateRTCState() = default;
-  // Group 4-byte aligned members first
+  ColorMode color_mode{ColorMode::UNKNOWN};
+  bool state{false};
   float brightness{1.0f};
   float color_brightness{1.0f};
   float red{1.0f};
@@ -55,9 +55,6 @@ struct LightStateRTCState {
   float cold_white{1.0f};
   float warm_white{1.0f};
   uint32_t effect{0};
-  // Group smaller members at the end
-  ColorMode color_mode{ColorMode::UNKNOWN};
-  bool state{false};
 };
 
 /** This class represents the communication layer between the front-end MQTT layer and the
@@ -219,8 +216,6 @@ class LightState : public EntityBase, public Component {
   std::unique_ptr<LightTransformer> transformer_{nullptr};
   /// List of effects for this light.
   std::vector<LightEffect *> effects_;
-  /// Object used to store the persisted values of the light.
-  ESPPreferenceObject rtc_;
   /// Value for storing the index of the currently active effect. 0 if no effect is active
   uint32_t active_effect_index_{};
   /// Default transition length for all transitions in ms.
@@ -229,11 +224,15 @@ class LightState : public EntityBase, public Component {
   uint32_t flash_transition_length_{};
   /// Gamma correction factor for the light.
   float gamma_correct_{};
+
   /// Whether the light value should be written in the next cycle.
   bool next_write_{true};
   // for effects, true if a transformer (transition) is active.
   bool is_transformer_active_ = false;
 
+  /// Object used to store the persisted values of the light.
+  ESPPreferenceObject rtc_;
+
   /** Callback to call when new values for the frontend are available.
    *
    * "Remote values" are light color values that are reported to the frontend and have a lower

esphome/components/light/transformers.h

@@ -59,9 +59,9 @@ class LightTransitionTransformer : public LightTransformer {
   // transition from 0 to 1 on x = [0, 1]
   static float smoothed_progress(float x) { return x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f); }
 
+  bool changing_color_mode_{false};
   LightColorValues end_values_{};
   LightColorValues intermediate_values_{};
-  bool changing_color_mode_{false};
 };
 
 class LightFlashTransformer : public LightTransformer {
@@ -117,8 +117,8 @@ class LightFlashTransformer : public LightTransformer {
 
  protected:
   LightState &state_;
-  std::unique_ptr<LightTransformer> transformer_{nullptr};
   uint32_t transition_length_;
+  std::unique_ptr<LightTransformer> transformer_{nullptr};
   bool begun_lightstate_restore_;
 };
 

esphome/components/logger/__init__.py

@@ -21,7 +21,6 @@ from esphome.components.libretiny.const import (
     COMPONENT_LN882X,
     COMPONENT_RTL87XX,
 )
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ARGS,
@@ -43,7 +42,6 @@ from esphome.const import (
     PLATFORM_LN882X,
     PLATFORM_RP2040,
     PLATFORM_RTL87XX,
-    PlatformFramework,
 )
 from esphome.core import CORE, Lambda, coroutine_with_priority
 
@@ -446,25 +444,3 @@ async def logger_set_level_to_code(config, action_id, template_arg, args):
 
     lambda_ = await cg.process_lambda(Lambda(text), args, return_type=cg.void)
     return cg.new_Pvariable(action_id, template_arg, lambda_)
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "logger_esp32.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        "logger_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "logger_host.cpp": {PlatformFramework.HOST_NATIVE},
-        "logger_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
-        "logger_libretiny.cpp": {
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-        "task_log_buffer.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-    }
-)

esphome/components/logger/logger.cpp

@@ -121,8 +121,7 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
   if (this->baud_rate_ > 0) {
     this->write_msg_(this->tx_buffer_ + msg_start);
   }
-  size_t msg_length = this->tx_buffer_at_ - msg_start - 1;  // -1 to exclude null terminator
-  this->log_callback_.call(level, tag, this->tx_buffer_ + msg_start, msg_length);
+  this->log_callback_.call(level, tag, this->tx_buffer_ + msg_start);
 
   global_recursion_guard_ = false;
 }
@@ -186,8 +185,7 @@ void Logger::loop() {
                                   this->tx_buffer_size_);
       this->write_footer_to_buffer_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
       this->tx_buffer_[this->tx_buffer_at_] = '\0';
-      size_t msg_len = this->tx_buffer_at_;  // We already know the length from tx_buffer_at_
-      this->log_callback_.call(message->level, message->tag, this->tx_buffer_, msg_len);
+      this->log_callback_.call(message->level, message->tag, this->tx_buffer_);
       // At this point all the data we need from message has been transferred to the tx_buffer
       // so we can release the message to allow other tasks to use it as soon as possible.
       this->log_buffer_->release_message_main_loop(received_token);
@@ -216,7 +214,7 @@ void Logger::set_log_level(const std::string &tag, uint8_t log_level) { this->lo
 UARTSelection Logger::get_uart() const { return this->uart_; }
 #endif
 
-void Logger::add_on_log_callback(std::function<void(uint8_t, const char *, const char *, size_t)> &&callback) {
+void Logger::add_on_log_callback(std::function<void(uint8_t, const char *, const char *)> &&callback) {
   this->log_callback_.add(std::move(callback));
 }
 float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f; }

esphome/components/logger/logger.h

@@ -143,7 +143,7 @@ class Logger : public Component {
   inline uint8_t level_for(const char *tag);
 
   /// Register a callback that will be called for every log message sent
-  void add_on_log_callback(std::function<void(uint8_t, const char *, const char *, size_t)> &&callback);
+  void add_on_log_callback(std::function<void(uint8_t, const char *, const char *)> &&callback);
 
   // add a listener for log level changes
   void add_listener(std::function<void(uint8_t)> &&callback) { this->level_callback_.add(std::move(callback)); }
@@ -192,7 +192,7 @@ class Logger : public Component {
     if (this->baud_rate_ > 0) {
       this->write_msg_(this->tx_buffer_);  // If logging is enabled, write to console
     }
-    this->log_callback_.call(level, tag, this->tx_buffer_, this->tx_buffer_at_);
+    this->log_callback_.call(level, tag, this->tx_buffer_);
   }
 
   // Write the body of the log message to the buffer
@@ -246,7 +246,7 @@ class Logger : public Component {
 
   // Large objects (internally aligned)
   std::map<std::string, uint8_t> log_levels_{};
-  CallbackManager<void(uint8_t, const char *, const char *, size_t)> log_callback_{};
+  CallbackManager<void(uint8_t, const char *, const char *)> log_callback_{};
   CallbackManager<void(uint8_t)> level_callback_{};
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   std::unique_ptr<logger::TaskLogBuffer> log_buffer_;  // Will be initialized with init_log_buffer
@@ -355,7 +355,7 @@ class Logger : public Component {
   }
 
   inline void HOT write_footer_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
+    static const uint16_t RESET_COLOR_LEN = strlen(ESPHOME_LOG_RESET_COLOR);
     this->write_body_to_buffer_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN, buffer, buffer_at, buffer_size);
   }
 
@@ -385,7 +385,7 @@ class LoggerMessageTrigger : public Trigger<uint8_t, const char *, const char *>
  public:
   explicit LoggerMessageTrigger(Logger *parent, uint8_t level) {
     this->level_ = level;
-    parent->add_on_log_callback([this](uint8_t level, const char *tag, const char *message, size_t message_len) {
+    parent->add_on_log_callback([this](uint8_t level, const char *tag, const char *message) {
       if (level <= this->level_) {
         this->trigger(level, tag, message);
       }

esphome/components/logger/logger_esp32.cpp

@@ -184,9 +184,7 @@ void HOT Logger::write_msg_(const char *msg) {
   ) {
     puts(msg);
   } else {
-    // Use tx_buffer_at_ if msg points to tx_buffer_, otherwise fall back to strlen
-    size_t len = (msg == this->tx_buffer_) ? this->tx_buffer_at_ : strlen(msg);
-    uart_write_bytes(this->uart_num_, msg, len);
+    uart_write_bytes(this->uart_num_, msg, strlen(msg));
     uart_write_bytes(this->uart_num_, "\n", 1);
   }
 }

esphome/components/mdns/__init__.py

@@ -1,6 +1,5 @@
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_component
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DISABLED,
@@ -9,7 +8,6 @@ from esphome.const import (
     CONF_PROTOCOL,
     CONF_SERVICE,
     CONF_SERVICES,
-    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 
@@ -110,21 +108,3 @@ async def to_code(config):
         )
 
         cg.add(var.add_extra_service(exp))
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "mdns_esp32.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        "mdns_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "mdns_host.cpp": {PlatformFramework.HOST_NATIVE},
-        "mdns_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
-        "mdns_libretiny.cpp": {
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-    }
-)

esphome/components/modbus/modbus.cpp

@@ -204,49 +204,82 @@ void Modbus::send(uint8_t address, uint8_t function_code, uint16_t start_address
     return;
   }
 
-  std::vector<uint8_t> data;
-  data.push_back(address);
-  data.push_back(function_code);
+  // Calculate the expected message size
+  size_t msg_size = 4;  // address + function + CRC(2)
   if (this->role == ModbusRole::CLIENT) {
-    data.push_back(start_address >> 8);
-    data.push_back(start_address >> 0);
+    msg_size += 2;  // start_address
     if (function_code != 0x5 && function_code != 0x6) {
-      data.push_back(number_of_entities >> 8);
-      data.push_back(number_of_entities >> 0);
+      msg_size += 2;  // number_of_entities
+    }
+  }
+  if (payload != nullptr) {
+    if (this->role == ModbusRole::SERVER || function_code == 0xF || function_code == 0x10) {
+      msg_size += 1 + payload_len;  // byte count + payload
+    } else {
+      msg_size += 2;  // single register value
+    }
+  }
+
+  // Use stack buffer for small messages (most common case)
+  static constexpr size_t STACK_BUFFER_SIZE = 64;
+  uint8_t stack_buffer[STACK_BUFFER_SIZE];
+  std::vector<uint8_t> heap_buffer;
+
+  uint8_t *data;
+  if (msg_size <= STACK_BUFFER_SIZE) {
+    data = stack_buffer;
+  } else {
+    heap_buffer.resize(msg_size);
+    data = heap_buffer.data();
+  }
+
+  // Build the message
+  size_t pos = 0;
+  data[pos++] = address;
+  data[pos++] = function_code;
+
+  if (this->role == ModbusRole::CLIENT) {
+    data[pos++] = start_address >> 8;
+    data[pos++] = start_address >> 0;
+    if (function_code != 0x5 && function_code != 0x6) {
+      data[pos++] = number_of_entities >> 8;
+      data[pos++] = number_of_entities >> 0;
     }
   }
 
   if (payload != nullptr) {
     if (this->role == ModbusRole::SERVER || function_code == 0xF || function_code == 0x10) {  // Write multiple
-      data.push_back(payload_len);  // Byte count is required for write
+      data[pos++] = payload_len;  // Byte count is required for write
     } else {
       payload_len = 2;  // Write single register or coil
     }
     for (int i = 0; i < payload_len; i++) {
-      data.push_back(payload[i]);
+      data[pos++] = payload[i];
     }
   }
 
-  auto crc = crc16(data.data(), data.size());
-  data.push_back(crc >> 0);
-  data.push_back(crc >> 8);
+  auto crc = crc16(data, pos);
+  data[pos++] = crc >> 0;
+  data[pos++] = crc >> 8;
 
   if (this->flow_control_pin_ != nullptr)
     this->flow_control_pin_->digital_write(true);
 
-  this->write_array(data);
+  this->write_array(data, pos);
   this->flush();
 
   if (this->flow_control_pin_ != nullptr)
     this->flow_control_pin_->digital_write(false);
   waiting_for_response = address;
   last_send_ = millis();
-  ESP_LOGV(TAG, "Modbus write: %s", format_hex_pretty(data).c_str());
+  ESP_LOGV(TAG, "Modbus write: %s", format_hex_pretty(data, pos).c_str());
 }
 
 // Helper function for lambdas
 // Send raw command. Except CRC everything must be contained in payload
-void Modbus::send_raw(const std::vector<uint8_t> &payload) {
+void Modbus::send_raw(const std::vector<uint8_t> &payload) { send_raw(std::span<const uint8_t>(payload)); }
+
+void Modbus::send_raw(std::span<const uint8_t> payload) {
   if (payload.empty()) {
     return;
   }
@@ -255,14 +288,14 @@ void Modbus::send_raw(const std::vector<uint8_t> &payload) {
     this->flow_control_pin_->digital_write(true);
 
   auto crc = crc16(payload.data(), payload.size());
-  this->write_array(payload);
+  this->write_array(payload.data(), payload.size());
   this->write_byte(crc & 0xFF);
   this->write_byte((crc >> 8) & 0xFF);
   this->flush();
   if (this->flow_control_pin_ != nullptr)
     this->flow_control_pin_->digital_write(false);
   waiting_for_response = payload[0];
-  ESP_LOGV(TAG, "Modbus write raw: %s", format_hex_pretty(payload).c_str());
+  ESP_LOGV(TAG, "Modbus write raw: %s", format_hex_pretty(payload.data(), payload.size()).c_str());
   last_send_ = millis();
 }
 

esphome/components/modbus/modbus.h

@@ -3,6 +3,7 @@
 #include "esphome/core/component.h"
 #include "esphome/components/uart/uart.h"
 
+#include <span>
 #include <vector>
 
 namespace esphome {
@@ -32,6 +33,7 @@ class Modbus : public uart::UARTDevice, public Component {
   void send(uint8_t address, uint8_t function_code, uint16_t start_address, uint16_t number_of_entities,
             uint8_t payload_len = 0, const uint8_t *payload = nullptr);
   void send_raw(const std::vector<uint8_t> &payload);
+  void send_raw(std::span<const uint8_t> payload);
   void set_role(ModbusRole role) { this->role = role; }
   void set_flow_control_pin(GPIOPin *flow_control_pin) { this->flow_control_pin_ = flow_control_pin; }
   uint8_t waiting_for_response{0};
@@ -65,13 +67,10 @@ class ModbusDevice {
     this->parent_->send(this->address_, function, start_address, number_of_entities, payload_len, payload);
   }
   void send_raw(const std::vector<uint8_t> &payload) { this->parent_->send_raw(payload); }
+  void send_raw(std::span<const uint8_t> payload) { this->parent_->send_raw(payload); }
   void send_error(uint8_t function_code, uint8_t exception_code) {
-    std::vector<uint8_t> error_response;
-    error_response.reserve(3);
-    error_response.push_back(this->address_);
-    error_response.push_back(function_code | 0x80);
-    error_response.push_back(exception_code);
-    this->send_raw(error_response);
+    uint8_t error_response[3] = {this->address_, static_cast<uint8_t>(function_code | 0x80), exception_code};
+    this->send_raw(std::span<const uint8_t>(error_response, 3));
   }
   // If more than one device is connected block sending a new command before a response is received
   bool waiting_for_response() { return parent_->waiting_for_response != 0; }

esphome/components/modbus_controller/modbus_controller.cpp

@@ -224,12 +224,11 @@ void ModbusController::on_modbus_write_registers(uint8_t function_code, const st
     return;
   }
 
-  std::vector<uint8_t> response;
-  response.reserve(6);
-  response.push_back(this->address_);
-  response.push_back(function_code);
-  response.insert(response.end(), data.begin(), data.begin() + 4);
-  this->send_raw(response);
+  uint8_t response[6];
+  response[0] = this->address_;
+  response[1] = function_code;
+  std::copy(data.begin(), data.begin() + 4, response + 2);
+  this->send_raw(std::span<const uint8_t>(response, 6));
 }
 
 SensorSet ModbusController::find_sensors_(ModbusRegisterType register_type, uint16_t start_address) const {

esphome/components/mqtt/__init__.py

@@ -5,7 +5,6 @@ from esphome.automation import Condition
 import esphome.codegen as cg
 from esphome.components import logger
 from esphome.components.esp32 import add_idf_sdkconfig_option
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_AVAILABILITY,
@@ -55,7 +54,6 @@ from esphome.const import (
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
-    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 
@@ -598,13 +596,3 @@ async def mqtt_enable_to_code(config, action_id, template_arg, args):
 async def mqtt_disable_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_arg, paren)
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "mqtt_backend_esp32.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-    }
-)

esphome/components/mqtt/mqtt_backend_esp32.h

@@ -252,7 +252,7 @@ class MQTTBackendESP32 final : public MQTTBackend {
 #if defined(USE_MQTT_IDF_ENQUEUE)
   static void esphome_mqtt_task(void *params);
   EventPool<struct QueueElement, MQTT_QUEUE_LENGTH> mqtt_event_pool_;
-  NotifyingLockFreeQueue<struct QueueElement, MQTT_QUEUE_LENGTH> mqtt_queue_;
+  LockFreeQueue<struct QueueElement, MQTT_QUEUE_LENGTH> mqtt_queue_;
   TaskHandle_t task_handle_{nullptr};
   bool enqueue_(MqttQueueTypeT type, const char *topic, int qos = 0, bool retain = false, const char *payload = NULL,
                 size_t len = 0);

esphome/components/mqtt/mqtt_client.cpp

@@ -57,15 +57,14 @@ void MQTTClientComponent::setup() {
   });
 #ifdef USE_LOGGER
   if (this->is_log_message_enabled() && logger::global_logger != nullptr) {
-    logger::global_logger->add_on_log_callback(
-        [this](int level, const char *tag, const char *message, size_t message_len) {
-          if (level <= this->log_level_ && this->is_connected()) {
-            this->publish({.topic = this->log_message_.topic,
-                           .payload = std::string(message, message_len),
-                           .qos = this->log_message_.qos,
-                           .retain = this->log_message_.retain});
-          }
-        });
+    logger::global_logger->add_on_log_callback([this](int level, const char *tag, const char *message) {
+      if (level <= this->log_level_ && this->is_connected()) {
+        this->publish({.topic = this->log_message_.topic,
+                       .payload = message,
+                       .qos = this->log_message_.qos,
+                       .retain = this->log_message_.retain});
+      }
+    });
   }
 #endif
 

esphome/components/nextion/__init__.py

@@ -1,7 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import uart
-from esphome.config_helpers import filter_source_files_from_platform
-from esphome.const import PlatformFramework
 
 nextion_ns = cg.esphome_ns.namespace("nextion")
 Nextion = nextion_ns.class_("Nextion", cg.PollingComponent, uart.UARTDevice)
@@ -10,17 +8,3 @@ nextion_ref = Nextion.operator("ref")
 CONF_NEXTION_ID = "nextion_id"
 CONF_PUBLISH_STATE = "publish_state"
 CONF_SEND_TO_NEXTION = "send_to_nextion"
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "nextion_upload_arduino.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP8266_ARDUINO,
-            PlatformFramework.RP2040_ARDUINO,
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-        "nextion_upload_idf.cpp": {PlatformFramework.ESP32_IDF},
-    }
-)

esphome/components/nextion/display.py

@@ -167,7 +167,6 @@ async def to_code(config):
         cg.add(var.set_wake_up_page(config[CONF_WAKE_UP_PAGE]))
 
     if CONF_START_UP_PAGE in config:
-        cg.add_define("USE_NEXTION_CONF_START_UP_PAGE")
         cg.add(var.set_start_up_page(config[CONF_START_UP_PAGE]))
 
     cg.add(var.set_auto_wake_on_touch(config[CONF_AUTO_WAKE_ON_TOUCH]))

esphome/components/nextion/nextion.cpp

@@ -11,7 +11,7 @@ static const char *const TAG = "nextion";
 
 void Nextion::setup() {
   this->is_setup_ = false;
-  this->connection_state_.ignore_is_setup_ = true;
+  this->ignore_is_setup_ = true;
 
   // Wake up the nextion
   this->send_command_("bkcmd=0");
@@ -23,16 +23,16 @@ void Nextion::setup() {
   // Reboot it
   this->send_command_("rest");
 
-  this->connection_state_.ignore_is_setup_ = false;
+  this->ignore_is_setup_ = false;
 }
 
 bool Nextion::send_command_(const std::string &command) {
-  if (!this->connection_state_.ignore_is_setup_ && !this->is_setup()) {
+  if (!this->ignore_is_setup_ && !this->is_setup()) {
     return false;
   }
 
 #ifdef USE_NEXTION_COMMAND_SPACING
-  if (!this->connection_state_.ignore_is_setup_ && !this->command_pacer_.can_send()) {
+  if (!this->ignore_is_setup_ && !this->command_pacer_.can_send()) {
     ESP_LOGN(TAG, "Command spacing: delaying command '%s'", command.c_str());
     return false;
   }
@@ -48,7 +48,7 @@ bool Nextion::send_command_(const std::string &command) {
 }
 
 bool Nextion::check_connect_() {
-  if (this->connection_state_.is_connected_)
+  if (this->is_connected_)
     return true;
 
   // Check if the handshake should be skipped for the Nextion connection
@@ -56,7 +56,7 @@ bool Nextion::check_connect_() {
     // Log the connection status without handshake
     ESP_LOGW(TAG, "Connected (no handshake)");
     // Set the connection status to true
-    this->connection_state_.is_connected_ = true;
+    this->is_connected_ = true;
     // Return true indicating the connection is set
     return true;
   }
@@ -64,7 +64,7 @@ bool Nextion::check_connect_() {
   if (this->comok_sent_ == 0) {
     this->reset_(false);
 
-    this->connection_state_.ignore_is_setup_ = true;
+    this->ignore_is_setup_ = true;
     this->send_command_("boguscommand=0");  // bogus command. needed sometimes after updating
     if (this->exit_reparse_on_start_) {
       this->send_command_("DRAKJHSUYDGBNCJHGJKSHBDN");
@@ -72,7 +72,7 @@ bool Nextion::check_connect_() {
     this->send_command_("connect");
 
     this->comok_sent_ = App.get_loop_component_start_time();
-    this->connection_state_.ignore_is_setup_ = false;
+    this->ignore_is_setup_ = false;
 
     return false;
   }
@@ -101,9 +101,9 @@ bool Nextion::check_connect_() {
     return false;
   }
 
-  this->connection_state_.ignore_is_setup_ = true;
+  this->ignore_is_setup_ = true;
   ESP_LOGI(TAG, "Connected");
-  this->connection_state_.is_connected_ = true;
+  this->is_connected_ = true;
 
   ESP_LOGN(TAG, "connect: %s", response.c_str());
 
@@ -127,7 +127,7 @@ bool Nextion::check_connect_() {
     ESP_LOGE(TAG, "Bad connect value: '%s'", response.c_str());
   }
 
-  this->connection_state_.ignore_is_setup_ = false;
+  this->ignore_is_setup_ = false;
   this->dump_config();
   return true;
 }
@@ -158,7 +158,7 @@ void Nextion::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "  Wake On Touch:  %s\n"
                 "  Exit reparse:   %s",
-                YESNO(this->connection_state_.auto_wake_on_touch_), YESNO(this->exit_reparse_on_start_));
+                YESNO(this->auto_wake_on_touch_), YESNO(this->exit_reparse_on_start_));
 #ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP
   ESP_LOGCONFIG(TAG, "  Max commands per loop: %u", this->max_commands_per_loop_);
 #endif  // USE_NEXTION_MAX_COMMANDS_PER_LOOP
@@ -167,15 +167,13 @@ void Nextion::dump_config() {
     ESP_LOGCONFIG(TAG, "  Touch Timeout:  %" PRIu16, this->touch_sleep_timeout_);
   }
 
-  if (this->wake_up_page_ != 255) {
-    ESP_LOGCONFIG(TAG, "  Wake Up Page:   %u", this->wake_up_page_);
+  if (this->wake_up_page_ != -1) {
+    ESP_LOGCONFIG(TAG, "  Wake Up Page:   %d", this->wake_up_page_);
   }
 
-#ifdef USE_NEXTION_CONF_START_UP_PAGE
-  if (this->start_up_page_ != 255) {
-    ESP_LOGCONFIG(TAG, "  Start Up Page:  %u", this->start_up_page_);
+  if (this->start_up_page_ != -1) {
+    ESP_LOGCONFIG(TAG, "  Start Up Page:  %d", this->start_up_page_);
   }
-#endif  // USE_NEXTION_CONF_START_UP_PAGE
 
 #ifdef USE_NEXTION_COMMAND_SPACING
   ESP_LOGCONFIG(TAG, "  Cmd spacing:      %u ms", this->command_pacer_.get_spacing());
@@ -221,7 +219,7 @@ void Nextion::add_buffer_overflow_event_callback(std::function<void()> &&callbac
 }
 
 void Nextion::update_all_components() {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || this->is_sleeping())
+  if ((!this->is_setup() && !this->ignore_is_setup_) || this->is_sleeping())
     return;
 
   for (auto *binarysensortype : this->binarysensortype_) {
@@ -239,7 +237,7 @@ void Nextion::update_all_components() {
 }
 
 bool Nextion::send_command(const char *command) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || this->is_sleeping())
+  if ((!this->is_setup() && !this->ignore_is_setup_) || this->is_sleeping())
     return false;
 
   if (this->send_command_(command)) {
@@ -250,7 +248,7 @@ bool Nextion::send_command(const char *command) {
 }
 
 bool Nextion::send_command_printf(const char *format, ...) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || this->is_sleeping())
+  if ((!this->is_setup() && !this->ignore_is_setup_) || this->is_sleeping())
     return false;
 
   char buffer[256];
@@ -291,42 +289,40 @@ void Nextion::print_queue_members_() {
 #endif
 
 void Nextion::loop() {
-  if (!this->check_connect_() || this->connection_state_.is_updating_)
+  if (!this->check_connect_() || this->is_updating_)
     return;
 
-  if (this->connection_state_.nextion_reports_is_setup_ && !this->connection_state_.sent_setup_commands_) {
-    this->connection_state_.ignore_is_setup_ = true;
-    this->connection_state_.sent_setup_commands_ = true;
+  if (this->nextion_reports_is_setup_ && !this->sent_setup_commands_) {
+    this->ignore_is_setup_ = true;
+    this->sent_setup_commands_ = true;
     this->send_command_("bkcmd=3");  // Always, returns 0x00 to 0x23 result of serial command.
 
     if (this->brightness_.has_value()) {
       this->set_backlight_brightness(this->brightness_.value());
     }
 
-#ifdef USE_NEXTION_CONF_START_UP_PAGE
     // Check if a startup page has been set and send the command
-    if (this->start_up_page_ != 255) {
+    if (this->start_up_page_ >= 0) {
       this->goto_page(this->start_up_page_);
     }
-#endif  // USE_NEXTION_CONF_START_UP_PAGE
 
-    if (this->wake_up_page_ != 255) {
+    if (this->wake_up_page_ >= 0) {
       this->set_wake_up_page(this->wake_up_page_);
     }
 
-    this->connection_state_.ignore_is_setup_ = false;
+    this->ignore_is_setup_ = false;
   }
 
   this->process_serial_();            // Receive serial data
   this->process_nextion_commands_();  // Process nextion return commands
 
-  if (!this->connection_state_.nextion_reports_is_setup_) {
+  if (!this->nextion_reports_is_setup_) {
     if (this->started_ms_ == 0)
       this->started_ms_ = App.get_loop_component_start_time();
 
     if (this->started_ms_ + this->startup_override_ms_ < App.get_loop_component_start_time()) {
       ESP_LOGD(TAG, "Manual ready set");
-      this->connection_state_.nextion_reports_is_setup_ = true;
+      this->nextion_reports_is_setup_ = true;
     }
   }
 
@@ -669,7 +665,7 @@ void Nextion::process_nextion_commands_() {
       case 0x88:  // system successful start up
       {
         ESP_LOGD(TAG, "System start: %zu", to_process_length);
-        this->connection_state_.nextion_reports_is_setup_ = true;
+        this->nextion_reports_is_setup_ = true;
         break;
       }
       case 0x89: {  // start SD card upgrade
@@ -1052,7 +1048,7 @@ void Nextion::add_no_result_to_queue_(const std::string &variable_name) {
  * @param command
  */
 void Nextion::add_no_result_to_queue_with_command_(const std::string &variable_name, const std::string &command) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || command.empty())
+  if ((!this->is_setup() && !this->ignore_is_setup_) || command.empty())
     return;
 
   if (this->send_command_(command)) {
@@ -1095,7 +1091,7 @@ void Nextion::add_no_result_to_queue_with_pending_command_(const std::string &va
 
 bool Nextion::add_no_result_to_queue_with_ignore_sleep_printf_(const std::string &variable_name, const char *format,
                                                                ...) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_))
+  if ((!this->is_setup() && !this->ignore_is_setup_))
     return false;
 
   char buffer[256];
@@ -1120,7 +1116,7 @@ bool Nextion::add_no_result_to_queue_with_ignore_sleep_printf_(const std::string
  * @param ... The format arguments
  */
 bool Nextion::add_no_result_to_queue_with_printf_(const std::string &variable_name, const char *format, ...) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || this->is_sleeping())
+  if ((!this->is_setup() && !this->ignore_is_setup_) || this->is_sleeping())
     return false;
 
   char buffer[256];
@@ -1159,7 +1155,7 @@ void Nextion::add_no_result_to_queue_with_set(const std::string &variable_name,
 void Nextion::add_no_result_to_queue_with_set_internal_(const std::string &variable_name,
                                                         const std::string &variable_name_to_send, int32_t state_value,
                                                         bool is_sleep_safe) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || (!is_sleep_safe && this->is_sleeping()))
+  if ((!this->is_setup() && !this->ignore_is_setup_) || (!is_sleep_safe && this->is_sleeping()))
     return;
 
   this->add_no_result_to_queue_with_ignore_sleep_printf_(variable_name, "%s=%" PRId32, variable_name_to_send.c_str(),
@@ -1187,7 +1183,7 @@ void Nextion::add_no_result_to_queue_with_set(const std::string &variable_name,
 void Nextion::add_no_result_to_queue_with_set_internal_(const std::string &variable_name,
                                                         const std::string &variable_name_to_send,
                                                         const std::string &state_value, bool is_sleep_safe) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || (!is_sleep_safe && this->is_sleeping()))
+  if ((!this->is_setup() && !this->ignore_is_setup_) || (!is_sleep_safe && this->is_sleeping()))
     return;
 
   this->add_no_result_to_queue_with_printf_(variable_name, "%s=\"%s\"", variable_name_to_send.c_str(),
@@ -1204,7 +1200,7 @@ void Nextion::add_no_result_to_queue_with_set_internal_(const std::string &varia
  * @param component Pointer to the Nextion component that will handle the response.
  */
 void Nextion::add_to_get_queue(NextionComponentBase *component) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_))
+  if ((!this->is_setup() && !this->ignore_is_setup_))
     return;
 
 #ifdef USE_NEXTION_MAX_QUEUE_SIZE
@@ -1244,7 +1240,7 @@ void Nextion::add_to_get_queue(NextionComponentBase *component) {
  * @param buffer_size The buffer data
  */
 void Nextion::add_addt_command_to_queue(NextionComponentBase *component) {
-  if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || this->is_sleeping())
+  if ((!this->is_setup() && !this->ignore_is_setup_) || this->is_sleeping())
     return;
 
   RAMAllocator<nextion::NextionQueue> allocator;
@@ -1285,7 +1281,7 @@ void Nextion::set_writer(const nextion_writer_t &writer) { this->writer_ = write
 ESPDEPRECATED("set_wait_for_ack(bool) deprecated, no effect", "v1.20")
 void Nextion::set_wait_for_ack(bool wait_for_ack) { ESP_LOGE(TAG, "Deprecated"); }
 
-bool Nextion::is_updating() { return this->connection_state_.is_updating_; }
+bool Nextion::is_updating() { return this->is_updating_; }
 
 }  // namespace nextion
 }  // namespace esphome

esphome/components/nextion/nextion.h

@@ -1194,7 +1194,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
 
   /**
    * Sets which page Nextion loads when exiting sleep mode. Note this can be set even when Nextion is in sleep mode.
-   * @param wake_up_page The page id, from 0 to the last page in Nextion. Set 255 (not set to any existing page) to
+   * @param wake_up_page The page id, from 0 to the last page in Nextion. Set -1 (not set to any existing page) to
    * wakes up to current page.
    *
    * Example:
@@ -1204,12 +1204,11 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    *
    * The display will wake up to page 2.
    */
-  void set_wake_up_page(uint8_t wake_up_page = 255);
+  void set_wake_up_page(int16_t wake_up_page = -1);
 
-#ifdef USE_NEXTION_CONF_START_UP_PAGE
   /**
    * Sets which page Nextion loads when connecting to ESPHome.
-   * @param start_up_page The page id, from 0 to the last page in Nextion. Set 255 (not set to any existing page) to
+   * @param start_up_page The page id, from 0 to the last page in Nextion. Set -1 (not set to any existing page) to
    * wakes up to current page.
    *
    * Example:
@@ -1219,8 +1218,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    *
    * The display will go to page 2 when it establishes a connection to ESPHome.
    */
-  void set_start_up_page(uint8_t start_up_page = 255) { this->start_up_page_ = start_up_page; }
-#endif  // USE_NEXTION_CONF_START_UP_PAGE
+  void set_start_up_page(int16_t start_up_page = -1) { this->start_up_page_ = start_up_page; }
 
   /**
    * Sets if Nextion should auto-wake from sleep when touch press occurs.
@@ -1302,7 +1300,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * @return true if the Nextion display is connected and ready to receive commands
    * @return false if the display is not yet connected or connection was lost
    */
-  bool is_connected() { return this->connection_state_.is_connected_; }
+  bool is_connected() { return this->is_connected_; }
 
  protected:
 #ifdef USE_NEXTION_MAX_COMMANDS_PER_LOOP
@@ -1336,28 +1334,19 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   bool remove_from_q_(bool report_empty = true);
 
   /**
-   * @brief Status flags for Nextion display state management
-   *
-   * Uses bitfields to pack multiple boolean states into a single byte,
-   * saving 5 bytes of RAM compared to individual bool variables.
+   * @brief
+   * Sends commands ignoring of the Nextion has been setup.
    */
-  struct {
-    uint8_t is_connected_ : 1;              ///< Connection established with Nextion display
-    uint8_t sent_setup_commands_ : 1;       ///< Initial setup commands have been sent
-    uint8_t ignore_is_setup_ : 1;           ///< Temporarily ignore setup state for special operations
-    uint8_t nextion_reports_is_setup_ : 1;  ///< Nextion has reported successful initialization
-    uint8_t is_updating_ : 1;               ///< TFT firmware update is currently in progress
-    uint8_t auto_wake_on_touch_ : 1;        ///< Display should wake automatically on touch (default: true)
-    uint8_t reserved_ : 2;                  ///< Reserved bits for future flag additions
-  } connection_state_{};                    ///< Zero-initialized status flags (all start as false)
+  bool ignore_is_setup_ = false;
 
+  bool nextion_reports_is_setup_ = false;
   void process_nextion_commands_();
   void process_serial_();
+  bool is_updating_ = false;
   uint16_t touch_sleep_timeout_ = 0;
-  uint8_t wake_up_page_ = 255;
-#ifdef USE_NEXTION_CONF_START_UP_PAGE
-  uint8_t start_up_page_ = 255;
-#endif  // USE_NEXTION_CONF_START_UP_PAGE
+  int16_t wake_up_page_ = -1;
+  int16_t start_up_page_ = -1;
+  bool auto_wake_on_touch_ = true;
   bool exit_reparse_on_start_ = false;
   bool skip_connection_handshake_ = false;
 
@@ -1479,9 +1468,11 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   void reset_(bool reset_nextion = true);
 
   std::string command_data_;
+  bool is_connected_ = false;
   const uint16_t startup_override_ms_ = 8000;
   const uint16_t max_q_age_ms_ = 8000;
   uint32_t started_ms_ = 0;
+  bool sent_setup_commands_ = false;
 };
 
 }  // namespace nextion

esphome/components/nextion/nextion_commands.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "nextion";
 // Sleep safe commands
 void Nextion::soft_reset() { this->send_command_("rest"); }
 
-void Nextion::set_wake_up_page(uint8_t wake_up_page) {
+void Nextion::set_wake_up_page(int16_t wake_up_page) {
   this->wake_up_page_ = wake_up_page;
   this->add_no_result_to_queue_with_set_internal_("wake_up_page", "wup", wake_up_page, true);
 }
@@ -38,7 +38,7 @@ void Nextion::sleep(bool sleep) {
 // Protocol reparse mode
 bool Nextion::set_protocol_reparse_mode(bool active_mode) {
   ESP_LOGV(TAG, "Reparse mode: %s", YESNO(active_mode));
-  this->connection_state_.ignore_is_setup_ = true;  // if not in reparse mode setup will fail, so it should be ignored
+  this->ignore_is_setup_ = true;  // if not in reparse mode setup will fail, so it should be ignored
   bool all_commands_sent = true;
   if (active_mode) {  // Sets active protocol reparse mode
     all_commands_sent &= this->send_command_("recmod=1");
@@ -48,10 +48,10 @@ bool Nextion::set_protocol_reparse_mode(bool active_mode) {
     all_commands_sent &= this->send_command_("recmod=0");  // Sending recmode=0 twice is recommended
     all_commands_sent &= this->send_command_("recmod=0");
   }
-  if (!this->connection_state_.nextion_reports_is_setup_) {  // No need to connect if is already setup
+  if (!this->nextion_reports_is_setup_) {  // No need to connect if is already setup
     all_commands_sent &= this->send_command_("connect");
   }
-  this->connection_state_.ignore_is_setup_ = false;
+  this->ignore_is_setup_ = false;
   return all_commands_sent;
 }
 
@@ -191,7 +191,7 @@ void Nextion::set_backlight_brightness(float brightness) {
 }
 
 void Nextion::set_auto_wake_on_touch(bool auto_wake_on_touch) {
-  this->connection_state_.auto_wake_on_touch_ = auto_wake_on_touch;
+  this->auto_wake_on_touch_ = auto_wake_on_touch;
   this->add_no_result_to_queue_with_set("auto_wake_on_touch", "thup", auto_wake_on_touch ? 1 : 0);
 }
 

esphome/components/nextion/nextion_upload.cpp

@@ -16,8 +16,8 @@ bool Nextion::upload_end_(bool successful) {
   } else {
     ESP_LOGE(TAG, "Upload failed");
 
-    this->connection_state_.is_updating_ = false;
-    this->connection_state_.ignore_is_setup_ = false;
+    this->is_updating_ = false;
+    this->ignore_is_setup_ = false;
 
     uint32_t baud_rate = this->parent_->get_baud_rate();
     if (baud_rate != this->original_baud_rate_) {

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -152,7 +152,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   ESP_LOGD(TAG, "Exit reparse: %s", YESNO(exit_reparse));
   ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
 
-  if (this->connection_state_.is_updating_) {
+  if (this->is_updating_) {
     ESP_LOGW(TAG, "Upload in progress");
     return false;
   }
@@ -162,7 +162,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
     return false;
   }
 
-  this->connection_state_.is_updating_ = true;
+  this->is_updating_ = true;
 
   if (exit_reparse) {
     ESP_LOGD(TAG, "Exit reparse mode");
@@ -203,7 +203,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   begin_status = http_client.begin(*this->get_wifi_client_(), this->tft_url_.c_str());
 #endif  // USE_ESP8266
   if (!begin_status) {
-    this->connection_state_.is_updating_ = false;
+    this->is_updating_ = false;
     ESP_LOGD(TAG, "Connection failed");
     return false;
   } else {
@@ -254,7 +254,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // The Nextion will ignore the upload command if it is sleeping
   ESP_LOGV(TAG, "Wake-up");
-  this->connection_state_.ignore_is_setup_ = true;
+  this->ignore_is_setup_ = true;
   this->send_command_("sleep=0");
   this->send_command_("dim=100");
   delay(250);  // NOLINT

esphome/components/nextion/nextion_upload_idf.cpp

@@ -155,7 +155,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   ESP_LOGD(TAG, "Exit reparse: %s", YESNO(exit_reparse));
   ESP_LOGD(TAG, "URL: %s", this->tft_url_.c_str());
 
-  if (this->connection_state_.is_updating_) {
+  if (this->is_updating_) {
     ESP_LOGW(TAG, "Upload in progress");
     return false;
   }
@@ -165,7 +165,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
     return false;
   }
 
-  this->connection_state_.is_updating_ = true;
+  this->is_updating_ = true;
 
   if (exit_reparse) {
     ESP_LOGD(TAG, "Exit reparse mode");
@@ -246,7 +246,7 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
 
   // The Nextion will ignore the upload command if it is sleeping
   ESP_LOGV(TAG, "Wake-up");
-  this->connection_state_.ignore_is_setup_ = true;
+  this->ignore_is_setup_ = true;
   this->send_command_("sleep=0");
   this->send_command_("dim=100");
   vTaskDelay(pdMS_TO_TICKS(250));  // NOLINT

esphome/components/ota/__init__.py

@@ -1,6 +1,5 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ESPHOME,
@@ -8,7 +7,6 @@ from esphome.const import (
     CONF_OTA,
     CONF_PLATFORM,
     CONF_TRIGGER_ID,
-    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 
@@ -122,18 +120,3 @@ async def ota_to_code(var, config):
         use_state_callback = True
     if use_state_callback:
         cg.add_define("USE_OTA_STATE_CALLBACK")
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "ota_backend_arduino_esp32.cpp": {PlatformFramework.ESP32_ARDUINO},
-        "ota_backend_esp_idf.cpp": {PlatformFramework.ESP32_IDF},
-        "ota_backend_arduino_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "ota_backend_arduino_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
-        "ota_backend_arduino_libretiny.cpp": {
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-    }
-)

esphome/components/pzemac/pzemac.cpp

@@ -77,10 +77,8 @@ void PZEMAC::dump_config() {
 }
 
 void PZEMAC::reset_energy_() {
-  std::vector<uint8_t> cmd;
-  cmd.push_back(this->address_);
-  cmd.push_back(PZEM_CMD_RESET_ENERGY);
-  this->send_raw(cmd);
+  uint8_t cmd[2] = {this->address_, PZEM_CMD_RESET_ENERGY};
+  this->send_raw(std::span<const uint8_t>(cmd, 2));
 }
 
 }  // namespace pzemac

esphome/components/pzemdc/pzemdc.cpp

@@ -65,10 +65,8 @@ void PZEMDC::dump_config() {
 }
 
 void PZEMDC::reset_energy() {
-  std::vector<uint8_t> cmd;
-  cmd.push_back(this->address_);
-  cmd.push_back(PZEM_CMD_RESET_ENERGY);
-  this->send_raw(cmd);
+  uint8_t cmd[2] = {this->address_, PZEM_CMD_RESET_ENERGY};
+  this->send_raw(std::span<const uint8_t>(cmd, 2));
 }
 
 }  // namespace pzemdc

esphome/components/remote_receiver/__init__.py

@@ -1,7 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import esp32, esp32_rmt, remote_base
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BUFFER_SIZE,
@@ -16,7 +15,6 @@ from esphome.const import (
     CONF_TYPE,
     CONF_USE_DMA,
     CONF_VALUE,
-    PlatformFramework,
 )
 from esphome.core import CORE, TimePeriod
 
@@ -172,19 +170,3 @@ async def to_code(config):
     cg.add(var.set_buffer_size(config[CONF_BUFFER_SIZE]))
     cg.add(var.set_filter_us(config[CONF_FILTER]))
     cg.add(var.set_idle_us(config[CONF_IDLE]))
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "remote_receiver_esp32.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        "remote_receiver_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "remote_receiver_libretiny.cpp": {
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-    }
-)

esphome/components/remote_transmitter/__init__.py

@@ -1,7 +1,6 @@
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import esp32, esp32_rmt, remote_base
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CARRIER_DUTY_PERCENT,
@@ -13,7 +12,6 @@ from esphome.const import (
     CONF_PIN,
     CONF_RMT_SYMBOLS,
     CONF_USE_DMA,
-    PlatformFramework,
 )
 from esphome.core import CORE
 
@@ -97,19 +95,3 @@ async def to_code(config):
         await automation.build_automation(
             var.get_complete_trigger(), [], on_complete_config
         )
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "remote_transmitter_esp32.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        "remote_transmitter_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "remote_transmitter_libretiny.cpp": {
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-    }
-)

esphome/components/rp2040/helpers.cpp

@@ -1,55 +0,0 @@
-#include "esphome/core/helpers.h"
-#include "esphome/core/defines.h"
-
-#ifdef USE_RP2040
-
-#include "esphome/core/hal.h"
-
-#if defined(USE_WIFI)
-#include <WiFi.h>
-#endif
-#include <hardware/structs/rosc.h>
-#include <hardware/sync.h>
-
-namespace esphome {
-
-uint32_t random_uint32() {
-  uint32_t result = 0;
-  for (uint8_t i = 0; i < 32; i++) {
-    result <<= 1;
-    result |= rosc_hw->randombit;
-  }
-  return result;
-}
-
-bool random_bytes(uint8_t *data, size_t len) {
-  while (len-- != 0) {
-    uint8_t result = 0;
-    for (uint8_t i = 0; i < 8; i++) {
-      result <<= 1;
-      result |= rosc_hw->randombit;
-    }
-    *data++ = result;
-  }
-  return true;
-}
-
-// RP2040 doesn't have mutexes, but that shouldn't be an issue as it's single-core and non-preemptive OS.
-Mutex::Mutex() {}
-Mutex::~Mutex() {}
-void Mutex::lock() {}
-bool Mutex::try_lock() { return true; }
-void Mutex::unlock() {}
-
-IRAM_ATTR InterruptLock::InterruptLock() { state_ = save_and_disable_interrupts(); }
-IRAM_ATTR InterruptLock::~InterruptLock() { restore_interrupts(state_); }
-
-void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
-#ifdef USE_WIFI
-  WiFi.macAddress(mac);
-#endif
-}
-
-}  // namespace esphome
-
-#endif  // USE_RP2040

esphome/components/rtttl/__init__.py

@@ -57,14 +57,14 @@ def validate_parent_output_config(value):
     platform = value.get(CONF_PLATFORM)
     PWM_GOOD = ["esp8266_pwm", "ledc"]
     PWM_BAD = [
-        "ac_dimmer",
+        "ac_dimmer ",
         "esp32_dac",
-        "mcp4725",
-        "my9231",
-        "pca9685",
         "slow_pwm",
-        "sm16716",
+        "mcp4725",
+        "pca9685",
         "tlc59208f",
+        "my9231",
+        "sm16716",
     ]
 
     if platform in PWM_BAD:

esphome/components/runtime_stats/__init__.py

@@ -1,26 +0,0 @@
-"""
-Runtime statistics component for ESPHome.
-"""
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-
-DEPENDENCIES = []
-
-CONF_ENABLED = "enabled"
-CONF_LOG_INTERVAL = "log_interval"
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_ENABLED, default=True): cv.boolean,
-        cv.Optional(
-            CONF_LOG_INTERVAL, default=60000
-        ): cv.positive_time_period_milliseconds,
-    }
-)
-
-
-async def to_code(config):
-    """Generate code for the runtime statistics component."""
-    cg.add(cg.App.set_runtime_stats_enabled(config[CONF_ENABLED]))
-    cg.add(cg.App.set_runtime_stats_log_interval(config[CONF_LOG_INTERVAL]))

esphome/components/scd4x/scd4x.cpp

@@ -7,8 +7,6 @@ namespace scd4x {
 
 static const char *const TAG = "scd4x";
 
-static const uint16_t SCD41_ID = 0x1408;
-static const uint16_t SCD40_ID = 0x440;
 static const uint16_t SCD4X_CMD_GET_SERIAL_NUMBER = 0x3682;
 static const uint16_t SCD4X_CMD_TEMPERATURE_OFFSET = 0x241d;
 static const uint16_t SCD4X_CMD_ALTITUDE_COMPENSATION = 0x2427;
@@ -25,6 +23,8 @@ static const uint16_t SCD4X_CMD_STOP_MEASUREMENTS = 0x3f86;
 static const uint16_t SCD4X_CMD_FACTORY_RESET = 0x3632;
 static const uint16_t SCD4X_CMD_GET_FEATURESET = 0x202f;
 static const float SCD4X_TEMPERATURE_OFFSET_MULTIPLIER = (1 << 16) / 175.0f;
+static const uint16_t SCD41_ID = 0x1408;
+static const uint16_t SCD40_ID = 0x440;
 
 void SCD4XComponent::setup() {
   ESP_LOGCONFIG(TAG, "Running setup");
@@ -51,66 +51,47 @@ void SCD4XComponent::setup() {
 
       if (!this->write_command(SCD4X_CMD_TEMPERATURE_OFFSET,
                                (uint16_t) (temperature_offset_ * SCD4X_TEMPERATURE_OFFSET_MULTIPLIER))) {
-        ESP_LOGE(TAG, "Error setting temperature offset");
+        ESP_LOGE(TAG, "Error setting temperature offset.");
         this->error_code_ = MEASUREMENT_INIT_FAILED;
         this->mark_failed();
         return;
       }
 
-      // If pressure compensation available use it, else use altitude
-      if (this->ambient_pressure_) {
-        if (!this->update_ambient_pressure_compensation_(this->ambient_pressure_)) {
-          ESP_LOGE(TAG, "Error setting ambient pressure compensation");
+      // If pressure compensation available use it
+      // else use altitude
+      if (ambient_pressure_compensation_) {
+        if (!this->update_ambient_pressure_compensation_(ambient_pressure_)) {
+          ESP_LOGE(TAG, "Error setting ambient pressure compensation.");
           this->error_code_ = MEASUREMENT_INIT_FAILED;
           this->mark_failed();
           return;
         }
       } else {
-        if (!this->write_command(SCD4X_CMD_ALTITUDE_COMPENSATION, this->altitude_compensation_)) {
-          ESP_LOGE(TAG, "Error setting altitude compensation");
+        if (!this->write_command(SCD4X_CMD_ALTITUDE_COMPENSATION, altitude_compensation_)) {
+          ESP_LOGE(TAG, "Error setting altitude compensation.");
           this->error_code_ = MEASUREMENT_INIT_FAILED;
           this->mark_failed();
           return;
         }
       }
 
-      if (!this->write_command(SCD4X_CMD_AUTOMATIC_SELF_CALIBRATION, this->enable_asc_ ? 1 : 0)) {
-        ESP_LOGE(TAG, "Error setting automatic self calibration");
+      if (!this->write_command(SCD4X_CMD_AUTOMATIC_SELF_CALIBRATION, enable_asc_ ? 1 : 0)) {
+        ESP_LOGE(TAG, "Error setting automatic self calibration.");
         this->error_code_ = MEASUREMENT_INIT_FAILED;
         this->mark_failed();
         return;
       }
 
-      this->initialized_ = true;
+      initialized_ = true;
       // Finally start sensor measurements
       this->start_measurement_();
+      ESP_LOGD(TAG, "Sensor initialized");
     });
   });
 }
 
 void SCD4XComponent::dump_config() {
-  static const char *const MM_PERIODIC_STR = "Periodic (5s)";
-  static const char *const MM_LOW_POWER_PERIODIC_STR = "Low power periodic (30s)";
-  static const char *const MM_SINGLE_SHOT_STR = "Single shot";
-  static const char *const MM_SINGLE_SHOT_RHT_ONLY_STR = "Single shot rht only";
-  const char *measurement_mode_str = MM_PERIODIC_STR;
-
-  switch (this->measurement_mode_) {
-    case PERIODIC:
-      // measurement_mode_str = MM_PERIODIC_STR;
-      break;
-    case LOW_POWER_PERIODIC:
-      measurement_mode_str = MM_LOW_POWER_PERIODIC_STR;
-      break;
-    case SINGLE_SHOT:
-      measurement_mode_str = MM_SINGLE_SHOT_STR;
-      break;
-    case SINGLE_SHOT_RHT_ONLY:
-      measurement_mode_str = MM_SINGLE_SHOT_RHT_ONLY_STR;
-      break;
-  }
-
-  ESP_LOGCONFIG(TAG, "SCD4X:");
+  ESP_LOGCONFIG(TAG, "scd4x:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
     switch (this->error_code_) {
@@ -121,23 +102,19 @@ void SCD4XComponent::dump_config() {
         ESP_LOGW(TAG, "Measurement Initialization failed");
         break;
       case SERIAL_NUMBER_IDENTIFICATION_FAILED:
-        ESP_LOGW(TAG, "Unable to read firmware version");
+        ESP_LOGW(TAG, "Unable to read sensor firmware version");
         break;
       default:
         ESP_LOGW(TAG, "Unknown setup error");
         break;
     }
   }
-  ESP_LOGCONFIG(TAG,
-                "  Automatic self calibration: %s\n"
-                "  Measurement mode: %s\n"
-                "  Temperature offset: %.2f °C",
-                ONOFF(this->enable_asc_), measurement_mode_str, this->temperature_offset_);
+  ESP_LOGCONFIG(TAG, "  Automatic self calibration: %s", ONOFF(this->enable_asc_));
   if (this->ambient_pressure_source_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  Dynamic ambient pressure compensation using '%s'",
+    ESP_LOGCONFIG(TAG, "  Dynamic ambient pressure compensation using sensor '%s'",
                   this->ambient_pressure_source_->get_name().c_str());
   } else {
-    if (this->ambient_pressure_) {
+    if (this->ambient_pressure_compensation_) {
       ESP_LOGCONFIG(TAG,
                     "  Altitude compensation disabled\n"
                     "  Ambient pressure compensation: %dmBar",
@@ -149,6 +126,21 @@ void SCD4XComponent::dump_config() {
                     this->altitude_compensation_);
     }
   }
+  switch (this->measurement_mode_) {
+    case PERIODIC:
+      ESP_LOGCONFIG(TAG, "  Measurement mode: periodic (5s)");
+      break;
+    case LOW_POWER_PERIODIC:
+      ESP_LOGCONFIG(TAG, "  Measurement mode: low power periodic (30s)");
+      break;
+    case SINGLE_SHOT:
+      ESP_LOGCONFIG(TAG, "  Measurement mode: single shot");
+      break;
+    case SINGLE_SHOT_RHT_ONLY:
+      ESP_LOGCONFIG(TAG, "  Measurement mode: single shot rht only");
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "  Temperature offset: %.2f °C", this->temperature_offset_);
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
@@ -156,20 +148,20 @@ void SCD4XComponent::dump_config() {
 }
 
 void SCD4XComponent::update() {
-  if (!this->initialized_) {
+  if (!initialized_) {
     return;
   }
 
   if (this->ambient_pressure_source_ != nullptr) {
     float pressure = this->ambient_pressure_source_->state;
     if (!std::isnan(pressure)) {
-      this->set_ambient_pressure_compensation(pressure);
+      set_ambient_pressure_compensation(pressure);
     }
   }
 
   uint32_t wait_time = 0;
   if (this->measurement_mode_ == SINGLE_SHOT || this->measurement_mode_ == SINGLE_SHOT_RHT_ONLY) {
-    this->start_measurement_();
+    start_measurement_();
     wait_time =
         this->measurement_mode_ == SINGLE_SHOT ? 5000 : 50;  // Single shot measurement takes 5 secs rht mode 50 ms
   }
@@ -184,12 +176,12 @@ void SCD4XComponent::update() {
 
     if (!this->read_data(raw_read_status) || raw_read_status == 0x00) {
       this->status_set_warning();
-      ESP_LOGW(TAG, "Data not ready");
+      ESP_LOGW(TAG, "Data not ready yet!");
       return;
     }
 
     if (!this->write_command(SCD4X_CMD_READ_MEASUREMENT)) {
-      ESP_LOGW(TAG, "Error reading measurement");
+      ESP_LOGW(TAG, "Error reading measurement!");
       this->status_set_warning();
       return;  // NO RETRY
     }
@@ -226,19 +218,19 @@ bool SCD4XComponent::perform_forced_calibration(uint16_t current_co2_concentrati
   }
   this->set_timeout(500, [this, current_co2_concentration]() {
     if (this->write_command(SCD4X_CMD_PERFORM_FORCED_CALIBRATION, current_co2_concentration)) {
-      ESP_LOGD(TAG, "Setting forced calibration Co2 level %d ppm", current_co2_concentration);
+      ESP_LOGD(TAG, "setting forced calibration Co2 level %d ppm", current_co2_concentration);
       // frc takes 400 ms
       // because this method will be used very rarly
       // the simple approach with delay is ok
-      delay(400);  // NOLINT
+      delay(400);  // NOLINT'
       if (!this->start_measurement_()) {
         return false;
       } else {
-        ESP_LOGD(TAG, "Forced calibration complete");
+        ESP_LOGD(TAG, "forced calibration complete");
       }
       return true;
     } else {
-      ESP_LOGE(TAG, "Force calibration failed");
+      ESP_LOGE(TAG, "force calibration failed");
       this->error_code_ = FRC_FAILED;
       this->status_set_warning();
       return false;
@@ -267,26 +259,27 @@ bool SCD4XComponent::factory_reset() {
 }
 
 void SCD4XComponent::set_ambient_pressure_compensation(float pressure_in_hpa) {
-  uint16_t new_ambient_pressure = static_cast<uint16_t>(pressure_in_hpa);
-  if (!this->initialized_) {
-    this->ambient_pressure_ = new_ambient_pressure;
+  ambient_pressure_compensation_ = true;
+  uint16_t new_ambient_pressure = (uint16_t) pressure_in_hpa;
+  if (!initialized_) {
+    ambient_pressure_ = new_ambient_pressure;
     return;
   }
   // Only send pressure value if it has changed since last update
-  if (new_ambient_pressure != this->ambient_pressure_) {
-    this->update_ambient_pressure_compensation_(new_ambient_pressure);
-    this->ambient_pressure_ = new_ambient_pressure;
+  if (new_ambient_pressure != ambient_pressure_) {
+    update_ambient_pressure_compensation_(new_ambient_pressure);
+    ambient_pressure_ = new_ambient_pressure;
   } else {
-    ESP_LOGD(TAG, "Ambient pressure compensation skipped; no change required");
+    ESP_LOGD(TAG, "ambient pressure compensation skipped - no change required");
   }
 }
 
 bool SCD4XComponent::update_ambient_pressure_compensation_(uint16_t pressure_in_hpa) {
   if (this->write_command(SCD4X_CMD_AMBIENT_PRESSURE_COMPENSATION, pressure_in_hpa)) {
-    ESP_LOGD(TAG, "Setting ambient pressure compensation to %d hPa", pressure_in_hpa);
+    ESP_LOGD(TAG, "setting ambient pressure compensation to %d hPa", pressure_in_hpa);
     return true;
   } else {
-    ESP_LOGE(TAG, "Error setting ambient pressure compensation");
+    ESP_LOGE(TAG, "Error setting ambient pressure compensation.");
     return false;
   }
 }
@@ -311,7 +304,7 @@ bool SCD4XComponent::start_measurement_() {
   static uint8_t remaining_retries = 3;
   while (remaining_retries) {
     if (!this->write_command(measurement_command)) {
-      ESP_LOGE(TAG, "Error starting measurements");
+      ESP_LOGE(TAG, "Error starting measurements.");
       this->error_code_ = MEASUREMENT_INIT_FAILED;
       this->status_set_warning();
       if (--remaining_retries == 0)

esphome/components/scd4x/scd4x.h

@@ -8,20 +8,14 @@
 namespace esphome {
 namespace scd4x {
 
-enum ErrorCode : uint8_t {
+enum ERRORCODE {
   COMMUNICATION_FAILED,
   SERIAL_NUMBER_IDENTIFICATION_FAILED,
   MEASUREMENT_INIT_FAILED,
   FRC_FAILED,
-  UNKNOWN,
-};
-
-enum MeasurementMode : uint8_t {
-  PERIODIC,
-  LOW_POWER_PERIODIC,
-  SINGLE_SHOT,
-  SINGLE_SHOT_RHT_ONLY,
+  UNKNOWN
 };
+enum MeasurementMode { PERIODIC, LOW_POWER_PERIODIC, SINGLE_SHOT, SINGLE_SHOT_RHT_ONLY };
 
 class SCD4XComponent : public PollingComponent, public sensirion_common::SensirionI2CDevice {
  public:
@@ -45,18 +39,21 @@ class SCD4XComponent : public PollingComponent, public sensirion_common::Sensiri
  protected:
   bool update_ambient_pressure_compensation_(uint16_t pressure_in_hpa);
   bool start_measurement_();
+  ERRORCODE error_code_;
 
+  bool initialized_{false};
+
+  float temperature_offset_;
+  uint16_t altitude_compensation_;
+  bool ambient_pressure_compensation_;
+  uint16_t ambient_pressure_;
+  bool enable_asc_;
+  MeasurementMode measurement_mode_{PERIODIC};
   sensor::Sensor *co2_sensor_{nullptr};
   sensor::Sensor *temperature_sensor_{nullptr};
   sensor::Sensor *humidity_sensor_{nullptr};
-  sensor::Sensor *ambient_pressure_source_{nullptr};  // used for compensation
-  float temperature_offset_;
-  uint16_t altitude_compensation_{0};
-  uint16_t ambient_pressure_{0};  // Per datasheet, valid values are 700 to 1200 hPa; 0 is a valid sentinel value
-  bool initialized_{false};
-  bool enable_asc_{false};
-  ErrorCode error_code_;
-  MeasurementMode measurement_mode_{PERIODIC};
+  // used for compensation
+  sensor::Sensor *ambient_pressure_source_{nullptr};
 };
 
 }  // namespace scd4x

esphome/components/sensor/filter.cpp

@@ -118,7 +118,7 @@ optional<float> QuantileFilter::new_value(float value) {
       size_t queue_size = quantile_queue.size();
       if (queue_size) {
         size_t position = ceilf(queue_size * this->quantile_) - 1;
-        ESP_LOGVV(TAG, "QuantileFilter(%p)::position: %zu/%zu", this, position + 1, queue_size);
+        ESP_LOGVV(TAG, "QuantileFilter(%p)::position: %d/%d", this, position + 1, queue_size);
         result = quantile_queue[position];
       }
     }

esphome/components/socket/__init__.py

@@ -1,6 +1,5 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.core import CORE
 
 CODEOWNERS = ["@esphome/core"]
 
@@ -41,18 +40,3 @@ async def to_code(config):
     elif impl == IMPLEMENTATION_BSD_SOCKETS:
         cg.add_define("USE_SOCKET_IMPL_BSD_SOCKETS")
         cg.add_define("USE_SOCKET_SELECT_SUPPORT")
-
-
-def FILTER_SOURCE_FILES() -> list[str]:
-    """Return list of socket implementation files that aren't selected by the user."""
-    impl = CORE.config["socket"][CONF_IMPLEMENTATION]
-
-    # Build list of files to exclude based on selected implementation
-    excluded = []
-    if impl != IMPLEMENTATION_LWIP_TCP:
-        excluded.append("lwip_raw_tcp_impl.cpp")
-    if impl != IMPLEMENTATION_BSD_SOCKETS:
-        excluded.append("bsd_sockets_impl.cpp")
-    if impl != IMPLEMENTATION_LWIP_SOCKETS:
-        excluded.append("lwip_sockets_impl.cpp")
-    return excluded

esphome/components/spi/__init__.py

@@ -13,7 +13,6 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
 )
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CLK_PIN,
@@ -32,7 +31,6 @@ from esphome.const import (
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
     PLATFORM_RP2040,
-    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 import esphome.final_validate as fv
@@ -425,18 +423,3 @@ def final_validate_device_schema(name: str, *, require_mosi: bool, require_miso:
         {cv.Required(CONF_SPI_ID): fv.id_declaration_match_schema(hub_schema)},
         extra=cv.ALLOW_EXTRA,
     )
-
-
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "spi_arduino.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP8266_ARDUINO,
-            PlatformFramework.RP2040_ARDUINO,
-            PlatformFramework.BK72XX_ARDUINO,
-            PlatformFramework.RTL87XX_ARDUINO,
-            PlatformFramework.LN882X_ARDUINO,
-        },
-        "spi_esp_idf.cpp": {PlatformFramework.ESP32_IDF},
-    }
-)

esphome/components/sx126x/__init__.py

@@ -1,317 +0,0 @@
-from esphome import automation, pins
-import esphome.codegen as cg
-from esphome.components import spi
-import esphome.config_validation as cv
-from esphome.const import CONF_BUSY_PIN, CONF_DATA, CONF_FREQUENCY, CONF_ID
-from esphome.core import TimePeriod
-
-MULTI_CONF = True
-CODEOWNERS = ["@swoboda1337"]
-DEPENDENCIES = ["spi"]
-
-CONF_SX126X_ID = "sx126x_id"
-
-CONF_BANDWIDTH = "bandwidth"
-CONF_BITRATE = "bitrate"
-CONF_CODING_RATE = "coding_rate"
-CONF_CRC_ENABLE = "crc_enable"
-CONF_DEVIATION = "deviation"
-CONF_DIO1_PIN = "dio1_pin"
-CONF_HW_VERSION = "hw_version"
-CONF_MODULATION = "modulation"
-CONF_ON_PACKET = "on_packet"
-CONF_PA_POWER = "pa_power"
-CONF_PA_RAMP = "pa_ramp"
-CONF_PAYLOAD_LENGTH = "payload_length"
-CONF_PREAMBLE_DETECT = "preamble_detect"
-CONF_PREAMBLE_SIZE = "preamble_size"
-CONF_RST_PIN = "rst_pin"
-CONF_RX_START = "rx_start"
-CONF_RF_SWITCH = "rf_switch"
-CONF_SHAPING = "shaping"
-CONF_SPREADING_FACTOR = "spreading_factor"
-CONF_SYNC_VALUE = "sync_value"
-CONF_TCXO_VOLTAGE = "tcxo_voltage"
-CONF_TCXO_DELAY = "tcxo_delay"
-
-sx126x_ns = cg.esphome_ns.namespace("sx126x")
-SX126x = sx126x_ns.class_("SX126x", cg.Component, spi.SPIDevice)
-SX126xListener = sx126x_ns.class_("SX126xListener")
-SX126xBw = sx126x_ns.enum("SX126xBw")
-SX126xPacketType = sx126x_ns.enum("SX126xPacketType")
-SX126xTcxoCtrl = sx126x_ns.enum("SX126xTcxoCtrl")
-SX126xRampTime = sx126x_ns.enum("SX126xRampTime")
-SX126xPulseShape = sx126x_ns.enum("SX126xPulseShape")
-SX126xLoraCr = sx126x_ns.enum("SX126xLoraCr")
-
-BW = {
-    "4_8kHz": SX126xBw.SX126X_BW_4800,
-    "5_8kHz": SX126xBw.SX126X_BW_5800,
-    "7_3kHz": SX126xBw.SX126X_BW_7300,
-    "9_7kHz": SX126xBw.SX126X_BW_9700,
-    "11_7kHz": SX126xBw.SX126X_BW_11700,
-    "14_6kHz": SX126xBw.SX126X_BW_14600,
-    "19_5kHz": SX126xBw.SX126X_BW_19500,
-    "23_4kHz": SX126xBw.SX126X_BW_23400,
-    "29_3kHz": SX126xBw.SX126X_BW_29300,
-    "39_0kHz": SX126xBw.SX126X_BW_39000,
-    "46_9kHz": SX126xBw.SX126X_BW_46900,
-    "58_6kHz": SX126xBw.SX126X_BW_58600,
-    "78_2kHz": SX126xBw.SX126X_BW_78200,
-    "93_8kHz": SX126xBw.SX126X_BW_93800,
-    "117_3kHz": SX126xBw.SX126X_BW_117300,
-    "156_2kHz": SX126xBw.SX126X_BW_156200,
-    "187_2kHz": SX126xBw.SX126X_BW_187200,
-    "234_3kHz": SX126xBw.SX126X_BW_234300,
-    "312_0kHz": SX126xBw.SX126X_BW_312000,
-    "373_6kHz": SX126xBw.SX126X_BW_373600,
-    "467_0kHz": SX126xBw.SX126X_BW_467000,
-    "7_8kHz": SX126xBw.SX126X_BW_7810,
-    "10_4kHz": SX126xBw.SX126X_BW_10420,
-    "15_6kHz": SX126xBw.SX126X_BW_15630,
-    "20_8kHz": SX126xBw.SX126X_BW_20830,
-    "31_3kHz": SX126xBw.SX126X_BW_31250,
-    "41_7kHz": SX126xBw.SX126X_BW_41670,
-    "62_5kHz": SX126xBw.SX126X_BW_62500,
-    "125_0kHz": SX126xBw.SX126X_BW_125000,
-    "250_0kHz": SX126xBw.SX126X_BW_250000,
-    "500_0kHz": SX126xBw.SX126X_BW_500000,
-}
-
-CODING_RATE = {
-    "CR_4_5": SX126xLoraCr.LORA_CR_4_5,
-    "CR_4_6": SX126xLoraCr.LORA_CR_4_6,
-    "CR_4_7": SX126xLoraCr.LORA_CR_4_7,
-    "CR_4_8": SX126xLoraCr.LORA_CR_4_8,
-}
-
-MOD = {
-    "LORA": SX126xPacketType.PACKET_TYPE_LORA,
-    "FSK": SX126xPacketType.PACKET_TYPE_GFSK,
-}
-
-TCXO_VOLTAGE = {
-    "1_6V": SX126xTcxoCtrl.TCXO_CTRL_1_6V,
-    "1_7V": SX126xTcxoCtrl.TCXO_CTRL_1_7V,
-    "1_8V": SX126xTcxoCtrl.TCXO_CTRL_1_8V,
-    "2_2V": SX126xTcxoCtrl.TCXO_CTRL_2_2V,
-    "2_4V": SX126xTcxoCtrl.TCXO_CTRL_2_4V,
-    "2_7V": SX126xTcxoCtrl.TCXO_CTRL_2_7V,
-    "3_0V": SX126xTcxoCtrl.TCXO_CTRL_3_0V,
-    "3_3V": SX126xTcxoCtrl.TCXO_CTRL_3_3V,
-    "NONE": SX126xTcxoCtrl.TCXO_CTRL_NONE,
-}
-
-RAMP = {
-    "10us": SX126xRampTime.PA_RAMP_10,
-    "20us": SX126xRampTime.PA_RAMP_20,
-    "40us": SX126xRampTime.PA_RAMP_40,
-    "80us": SX126xRampTime.PA_RAMP_80,
-    "200us": SX126xRampTime.PA_RAMP_200,
-    "800us": SX126xRampTime.PA_RAMP_800,
-    "1700us": SX126xRampTime.PA_RAMP_1700,
-    "3400us": SX126xRampTime.PA_RAMP_3400,
-}
-
-SHAPING = {
-    "GAUSSIAN_BT_0_3": SX126xPulseShape.GAUSSIAN_BT_0_3,
-    "GAUSSIAN_BT_0_5": SX126xPulseShape.GAUSSIAN_BT_0_5,
-    "GAUSSIAN_BT_0_7": SX126xPulseShape.GAUSSIAN_BT_0_7,
-    "GAUSSIAN_BT_1_0": SX126xPulseShape.GAUSSIAN_BT_1_0,
-    "NONE": SX126xPulseShape.NO_FILTER,
-}
-
-RunImageCalAction = sx126x_ns.class_(
-    "RunImageCalAction", automation.Action, cg.Parented.template(SX126x)
-)
-SendPacketAction = sx126x_ns.class_(
-    "SendPacketAction", automation.Action, cg.Parented.template(SX126x)
-)
-SetModeTxAction = sx126x_ns.class_(
-    "SetModeTxAction", automation.Action, cg.Parented.template(SX126x)
-)
-SetModeRxAction = sx126x_ns.class_(
-    "SetModeRxAction", automation.Action, cg.Parented.template(SX126x)
-)
-SetModeSleepAction = sx126x_ns.class_(
-    "SetModeSleepAction", automation.Action, cg.Parented.template(SX126x)
-)
-SetModeStandbyAction = sx126x_ns.class_(
-    "SetModeStandbyAction", automation.Action, cg.Parented.template(SX126x)
-)
-
-
-def validate_raw_data(value):
-    if isinstance(value, str):
-        return value.encode("utf-8")
-    if isinstance(value, list):
-        return cv.Schema([cv.hex_uint8_t])(value)
-    raise cv.Invalid(
-        "data must either be a string wrapped in quotes or a list of bytes"
-    )
-
-
-def validate_config(config):
-    lora_bws = [
-        "7_8kHz",
-        "10_4kHz",
-        "15_6kHz",
-        "20_8kHz",
-        "31_3kHz",
-        "41_7kHz",
-        "62_5kHz",
-        "125_0kHz",
-        "250_0kHz",
-        "500_0kHz",
-    ]
-    if config[CONF_MODULATION] == "LORA":
-        if config[CONF_BANDWIDTH] not in lora_bws:
-            raise cv.Invalid(f"{config[CONF_BANDWIDTH]} is not available with LORA")
-        if config[CONF_PREAMBLE_SIZE] > 0 and config[CONF_PREAMBLE_SIZE] < 6:
-            raise cv.Invalid("Minimum preamble size is 6 with LORA")
-        if config[CONF_SPREADING_FACTOR] == 6 and config[CONF_PAYLOAD_LENGTH] == 0:
-            raise cv.Invalid("Payload length must be set when spreading factor is 6")
-    else:
-        if config[CONF_BANDWIDTH] in lora_bws:
-            raise cv.Invalid(f"{config[CONF_BANDWIDTH]} is not available with FSK")
-        if config[CONF_PREAMBLE_DETECT] > len(config[CONF_SYNC_VALUE]):
-            raise cv.Invalid("Preamble detection length must be <= sync value length")
-    return config
-
-
-CONFIG_SCHEMA = (
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(SX126x),
-            cv.Optional(CONF_BANDWIDTH, default="125_0kHz"): cv.enum(BW),
-            cv.Optional(CONF_BITRATE, default=4800): cv.int_range(min=600, max=300000),
-            cv.Required(CONF_BUSY_PIN): pins.internal_gpio_input_pin_schema,
-            cv.Optional(CONF_CODING_RATE, default="CR_4_5"): cv.enum(CODING_RATE),
-            cv.Optional(CONF_CRC_ENABLE, default=False): cv.boolean,
-            cv.Optional(CONF_DEVIATION, default=5000): cv.int_range(min=0, max=100000),
-            cv.Required(CONF_DIO1_PIN): pins.internal_gpio_input_pin_schema,
-            cv.Required(CONF_FREQUENCY): cv.int_range(min=137000000, max=1020000000),
-            cv.Required(CONF_HW_VERSION): cv.one_of(
-                "sx1261", "sx1262", "sx1268", "llcc68", lower=True
-            ),
-            cv.Required(CONF_MODULATION): cv.enum(MOD),
-            cv.Optional(CONF_ON_PACKET): automation.validate_automation(single=True),
-            cv.Optional(CONF_PA_POWER, default=17): cv.int_range(min=-3, max=22),
-            cv.Optional(CONF_PA_RAMP, default="40us"): cv.enum(RAMP),
-            cv.Optional(CONF_PAYLOAD_LENGTH, default=0): cv.int_range(min=0, max=256),
-            cv.Optional(CONF_PREAMBLE_DETECT, default=2): cv.int_range(min=0, max=4),
-            cv.Required(CONF_PREAMBLE_SIZE): cv.int_range(min=1, max=65535),
-            cv.Required(CONF_RST_PIN): pins.internal_gpio_output_pin_schema,
-            cv.Optional(CONF_RX_START, default=True): cv.boolean,
-            cv.Required(CONF_RF_SWITCH): cv.boolean,
-            cv.Optional(CONF_SHAPING, default="NONE"): cv.enum(SHAPING),
-            cv.Optional(CONF_SPREADING_FACTOR, default=7): cv.int_range(min=6, max=12),
-            cv.Optional(CONF_SYNC_VALUE, default=[]): cv.ensure_list(cv.hex_uint8_t),
-            cv.Optional(CONF_TCXO_VOLTAGE, default="NONE"): cv.enum(TCXO_VOLTAGE),
-            cv.Optional(CONF_TCXO_DELAY, default="5ms"): cv.All(
-                cv.positive_time_period_microseconds,
-                cv.Range(max=TimePeriod(microseconds=262144000)),
-            ),
-        },
-    )
-    .extend(cv.COMPONENT_SCHEMA)
-    .extend(spi.spi_device_schema(True, 8e6, "mode0"))
-    .add_extra(validate_config)
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await spi.register_spi_device(var, config)
-    if CONF_ON_PACKET in config:
-        await automation.build_automation(
-            var.get_packet_trigger(),
-            [
-                (cg.std_vector.template(cg.uint8), "x"),
-                (cg.float_, "rssi"),
-                (cg.float_, "snr"),
-            ],
-            config[CONF_ON_PACKET],
-        )
-    if CONF_DIO1_PIN in config:
-        dio1_pin = await cg.gpio_pin_expression(config[CONF_DIO1_PIN])
-        cg.add(var.set_dio1_pin(dio1_pin))
-    rst_pin = await cg.gpio_pin_expression(config[CONF_RST_PIN])
-    cg.add(var.set_rst_pin(rst_pin))
-    busy_pin = await cg.gpio_pin_expression(config[CONF_BUSY_PIN])
-    cg.add(var.set_busy_pin(busy_pin))
-    cg.add(var.set_bandwidth(config[CONF_BANDWIDTH]))
-    cg.add(var.set_frequency(config[CONF_FREQUENCY]))
-    cg.add(var.set_hw_version(config[CONF_HW_VERSION]))
-    cg.add(var.set_deviation(config[CONF_DEVIATION]))
-    cg.add(var.set_modulation(config[CONF_MODULATION]))
-    cg.add(var.set_pa_ramp(config[CONF_PA_RAMP]))
-    cg.add(var.set_pa_power(config[CONF_PA_POWER]))
-    cg.add(var.set_shaping(config[CONF_SHAPING]))
-    cg.add(var.set_bitrate(config[CONF_BITRATE]))
-    cg.add(var.set_crc_enable(config[CONF_CRC_ENABLE]))
-    cg.add(var.set_payload_length(config[CONF_PAYLOAD_LENGTH]))
-    cg.add(var.set_preamble_size(config[CONF_PREAMBLE_SIZE]))
-    cg.add(var.set_preamble_detect(config[CONF_PREAMBLE_DETECT]))
-    cg.add(var.set_coding_rate(config[CONF_CODING_RATE]))
-    cg.add(var.set_spreading_factor(config[CONF_SPREADING_FACTOR]))
-    cg.add(var.set_sync_value(config[CONF_SYNC_VALUE]))
-    cg.add(var.set_rx_start(config[CONF_RX_START]))
-    cg.add(var.set_rf_switch(config[CONF_RF_SWITCH]))
-    cg.add(var.set_tcxo_voltage(config[CONF_TCXO_VOLTAGE]))
-    cg.add(var.set_tcxo_delay(config[CONF_TCXO_DELAY]))
-
-
-NO_ARGS_ACTION_SCHEMA = automation.maybe_simple_id(
-    {
-        cv.GenerateID(): cv.use_id(SX126x),
-    }
-)
-
-
-@automation.register_action(
-    "sx126x.run_image_cal", RunImageCalAction, NO_ARGS_ACTION_SCHEMA
-)
-@automation.register_action(
-    "sx126x.set_mode_tx", SetModeTxAction, NO_ARGS_ACTION_SCHEMA
-)
-@automation.register_action(
-    "sx126x.set_mode_rx", SetModeRxAction, NO_ARGS_ACTION_SCHEMA
-)
-@automation.register_action(
-    "sx126x.set_mode_sleep", SetModeSleepAction, NO_ARGS_ACTION_SCHEMA
-)
-@automation.register_action(
-    "sx126x.set_mode_standby", SetModeStandbyAction, NO_ARGS_ACTION_SCHEMA
-)
-async def no_args_action_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
-    {
-        cv.GenerateID(): cv.use_id(SX126x),
-        cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
-    },
-    key=CONF_DATA,
-)
-
-
-@automation.register_action(
-    "sx126x.send_packet", SendPacketAction, SEND_PACKET_ACTION_SCHEMA
-)
-async def send_packet_action_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    data = config[CONF_DATA]
-    if isinstance(data, bytes):
-        data = list(data)
-    if cg.is_template(data):
-        templ = await cg.templatable(data, args, cg.std_vector.template(cg.uint8))
-        cg.add(var.set_data_template(templ))
-    else:
-        cg.add(var.set_data_static(data))
-    return var

esphome/components/sx126x/automation.h

@@ -1,62 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/core/automation.h"
-#include "esphome/components/sx126x/sx126x.h"
-
-namespace esphome {
-namespace sx126x {
-
-template<typename... Ts> class RunImageCalAction : public Action<Ts...>, public Parented<SX126x> {
- public:
-  void play(Ts... x) override { this->parent_->run_image_cal(); }
-};
-
-template<typename... Ts> class SendPacketAction : public Action<Ts...>, public Parented<SX126x> {
- public:
-  void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) {
-    this->data_func_ = func;
-    this->static_ = false;
-  }
-
-  void set_data_static(const std::vector<uint8_t> &data) {
-    this->data_static_ = data;
-    this->static_ = true;
-  }
-
-  void play(Ts... x) override {
-    if (this->static_) {
-      this->parent_->transmit_packet(this->data_static_);
-    } else {
-      this->parent_->transmit_packet(this->data_func_(x...));
-    }
-  }
-
- protected:
-  bool static_{false};
-  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
-  std::vector<uint8_t> data_static_{};
-};
-
-template<typename... Ts> class SetModeTxAction : public Action<Ts...>, public Parented<SX126x> {
- public:
-  void play(Ts... x) override { this->parent_->set_mode_tx(); }
-};
-
-template<typename... Ts> class SetModeRxAction : public Action<Ts...>, public Parented<SX126x> {
- public:
-  void play(Ts... x) override { this->parent_->set_mode_rx(); }
-};
-
-template<typename... Ts> class SetModeSleepAction : public Action<Ts...>, public Parented<SX126x> {
- public:
-  void play(Ts... x) override { this->parent_->set_mode_sleep(); }
-};
-
-template<typename... Ts> class SetModeStandbyAction : public Action<Ts...>, public Parented<SX126x> {
- public:
-  void play(Ts... x) override { this->parent_->set_mode_standby(STDBY_XOSC); }
-};
-
-}  // namespace sx126x
-}  // namespace esphome

esphome/components/sx126x/packet_transport/__init__.py

@@ -1,26 +0,0 @@
-import esphome.codegen as cg
-from esphome.components.packet_transport import (
-    PacketTransport,
-    new_packet_transport,
-    transport_schema,
-)
-import esphome.config_validation as cv
-from esphome.cpp_types import PollingComponent
-
-from .. import CONF_SX126X_ID, SX126x, SX126xListener, sx126x_ns
-
-SX126xTransport = sx126x_ns.class_(
-    "SX126xTransport", PacketTransport, PollingComponent, SX126xListener
-)
-
-CONFIG_SCHEMA = transport_schema(SX126xTransport).extend(
-    {
-        cv.GenerateID(CONF_SX126X_ID): cv.use_id(SX126x),
-    }
-)
-
-
-async def to_code(config):
-    var, _ = await new_packet_transport(config)
-    sx126x = await cg.get_variable(config[CONF_SX126X_ID])
-    cg.add(var.set_parent(sx126x))

esphome/components/sx126x/packet_transport/sx126x_transport.cpp

@@ -1,26 +0,0 @@
-#include "esphome/core/log.h"
-#include "esphome/core/application.h"
-#include "sx126x_transport.h"
-
-namespace esphome {
-namespace sx126x {
-
-static const char *const TAG = "sx126x_transport";
-
-void SX126xTransport::setup() {
-  PacketTransport::setup();
-  this->parent_->register_listener(this);
-}
-
-void SX126xTransport::update() {
-  PacketTransport::update();
-  this->updated_ = true;
-  this->resend_data_ = true;
-}
-
-void SX126xTransport::send_packet(const std::vector<uint8_t> &buf) const { this->parent_->transmit_packet(buf); }
-
-void SX126xTransport::on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) { this->process_(packet); }
-
-}  // namespace sx126x
-}  // namespace esphome

esphome/components/sx126x/packet_transport/sx126x_transport.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/sx126x/sx126x.h"
-#include "esphome/components/packet_transport/packet_transport.h"
-#include <vector>
-
-namespace esphome {
-namespace sx126x {
-
-class SX126xTransport : public packet_transport::PacketTransport, public Parented<SX126x>, public SX126xListener {
- public:
-  void setup() override;
-  void update() override;
-  void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) override;
-  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-
- protected:
-  void send_packet(const std::vector<uint8_t> &buf) const override;
-  bool should_send() override { return true; }
-  size_t get_max_packet_size() override { return this->parent_->get_max_packet_size(); }
-};
-
-}  // namespace sx126x
-}  // namespace esphome

esphome/components/sx126x/sx126x.cpp

@@ -1,523 +0,0 @@
-#include "sx126x.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace sx126x {
-
-static const char *const TAG = "sx126x";
-static const uint16_t RAMP[8] = {10, 20, 40, 80, 200, 800, 1700, 3400};
-static const uint32_t BW_HZ[31] = {4800,  5800,  7300,  9700,   11700,  14600,  19500,  23400,  29300,  39000,  46900,
-                                   58600, 78200, 93800, 117300, 156200, 187200, 234300, 312000, 373600, 467000, 7810,
-                                   10420, 15630, 20830, 31250,  41670,  62500,  125000, 250000, 500000};
-static const uint8_t BW_LORA[10] = {LORA_BW_7810,  LORA_BW_10420, LORA_BW_15630,  LORA_BW_20830,  LORA_BW_31250,
-                                    LORA_BW_41670, LORA_BW_62500, LORA_BW_125000, LORA_BW_250000, LORA_BW_500000};
-static const uint8_t BW_FSK[21] = {
-    FSK_BW_4800,   FSK_BW_5800,   FSK_BW_7300,   FSK_BW_9700,   FSK_BW_11700,  FSK_BW_14600,  FSK_BW_19500,
-    FSK_BW_23400,  FSK_BW_29300,  FSK_BW_39000,  FSK_BW_46900,  FSK_BW_58600,  FSK_BW_78200,  FSK_BW_93800,
-    FSK_BW_117300, FSK_BW_156200, FSK_BW_187200, FSK_BW_234300, FSK_BW_312000, FSK_BW_373600, FSK_BW_467000};
-
-static constexpr uint32_t RESET_DELAY_HIGH_US = 5000;
-static constexpr uint32_t RESET_DELAY_LOW_US = 2000;
-static constexpr uint32_t SWITCHING_DELAY_US = 1;
-static constexpr uint32_t TRANSMIT_TIMEOUT_MS = 4000;
-static constexpr uint32_t BUSY_TIMEOUT_MS = 20;
-
-// OCP (Over Current Protection) values
-static constexpr uint8_t OCP_80MA = 0x18;   // 80 mA max current
-static constexpr uint8_t OCP_140MA = 0x38;  // 140 mA max current
-
-// LoRa low data rate optimization threshold
-static constexpr float LOW_DATA_RATE_OPTIMIZE_THRESHOLD = 16.38f;  // 16.38 ms
-
-uint8_t SX126x::read_fifo_(uint8_t offset, std::vector<uint8_t> &packet) {
-  this->wait_busy_();
-  this->enable();
-  this->transfer_byte(RADIO_READ_BUFFER);
-  this->transfer_byte(offset);
-  uint8_t status = this->transfer_byte(0x00);
-  for (uint8_t &byte : packet) {
-    byte = this->transfer_byte(0x00);
-  }
-  this->disable();
-  return status;
-}
-
-void SX126x::write_fifo_(uint8_t offset, const std::vector<uint8_t> &packet) {
-  this->wait_busy_();
-  this->enable();
-  this->transfer_byte(RADIO_WRITE_BUFFER);
-  this->transfer_byte(offset);
-  for (const uint8_t &byte : packet) {
-    this->transfer_byte(byte);
-  }
-  this->disable();
-  delayMicroseconds(SWITCHING_DELAY_US);
-}
-
-uint8_t SX126x::read_opcode_(uint8_t opcode, uint8_t *data, uint8_t size) {
-  this->wait_busy_();
-  this->enable();
-  this->transfer_byte(opcode);
-  uint8_t status = this->transfer_byte(0x00);
-  for (int32_t i = 0; i < size; i++) {
-    data[i] = this->transfer_byte(0x00);
-  }
-  this->disable();
-  return status;
-}
-
-void SX126x::write_opcode_(uint8_t opcode, uint8_t *data, uint8_t size) {
-  this->wait_busy_();
-  this->enable();
-  this->transfer_byte(opcode);
-  for (int32_t i = 0; i < size; i++) {
-    this->transfer_byte(data[i]);
-  }
-  this->disable();
-  delayMicroseconds(SWITCHING_DELAY_US);
-}
-
-void SX126x::read_register_(uint16_t reg, uint8_t *data, uint8_t size) {
-  this->wait_busy_();
-  this->enable();
-  this->write_byte(RADIO_READ_REGISTER);
-  this->write_byte((reg >> 8) & 0xFF);
-  this->write_byte((reg >> 0) & 0xFF);
-  this->write_byte(0x00);
-  for (int32_t i = 0; i < size; i++) {
-    data[i] = this->transfer_byte(0x00);
-  }
-  this->disable();
-}
-
-void SX126x::write_register_(uint16_t reg, uint8_t *data, uint8_t size) {
-  this->wait_busy_();
-  this->enable();
-  this->write_byte(RADIO_WRITE_REGISTER);
-  this->write_byte((reg >> 8) & 0xFF);
-  this->write_byte((reg >> 0) & 0xFF);
-  for (int32_t i = 0; i < size; i++) {
-    this->transfer_byte(data[i]);
-  }
-  this->disable();
-  delayMicroseconds(SWITCHING_DELAY_US);
-}
-
-void SX126x::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
-  // setup pins
-  this->busy_pin_->setup();
-  this->rst_pin_->setup();
-  this->dio1_pin_->setup();
-
-  // start spi
-  this->spi_setup();
-
-  // configure rf
-  this->configure();
-}
-
-void SX126x::configure() {
-  uint8_t buf[8];
-
-  // toggle chip reset
-  this->rst_pin_->digital_write(true);
-  delayMicroseconds(RESET_DELAY_HIGH_US);
-  this->rst_pin_->digital_write(false);
-  delayMicroseconds(RESET_DELAY_LOW_US);
-  this->rst_pin_->digital_write(true);
-  delayMicroseconds(RESET_DELAY_HIGH_US);
-
-  // wakeup
-  this->read_opcode_(RADIO_GET_STATUS, nullptr, 0);
-
-  // config tcxo
-  if (this->tcxo_voltage_ != TCXO_CTRL_NONE) {
-    uint32_t delay = this->tcxo_delay_ >> 6;
-    buf[0] = this->tcxo_voltage_;
-    buf[1] = (delay >> 16) & 0xFF;
-    buf[2] = (delay >> 8) & 0xFF;
-    buf[3] = (delay >> 0) & 0xFF;
-    this->write_opcode_(RADIO_SET_TCXOMODE, buf, 4);
-    buf[0] = 0x7F;
-    this->write_opcode_(RADIO_CALIBRATE, buf, 1);
-  }
-
-  // clear errors
-  buf[0] = 0x00;
-  buf[1] = 0x00;
-  this->write_opcode_(RADIO_CLR_ERROR, buf, 2);
-
-  // rf switch
-  if (this->rf_switch_) {
-    buf[0] = 0x01;
-    this->write_opcode_(RADIO_SET_RFSWITCHMODE, buf, 1);
-  }
-
-  // check silicon version to make sure hw is ok
-  this->read_register_(REG_VERSION_STRING, (uint8_t *) this->version_, 16);
-  if (strncmp(this->version_, "SX126", 5) != 0 && strncmp(this->version_, "LLCC68", 6) != 0) {
-    this->mark_failed();
-    return;
-  }
-
-  // setup packet type
-  buf[0] = this->modulation_;
-  this->write_opcode_(RADIO_SET_PACKETTYPE, buf, 1);
-
-  // calibrate image
-  this->run_image_cal();
-
-  // set frequency
-  uint64_t freq = ((uint64_t) this->frequency_ << 25) / XTAL_FREQ;
-  buf[0] = (uint8_t) ((freq >> 24) & 0xFF);
-  buf[1] = (uint8_t) ((freq >> 16) & 0xFF);
-  buf[2] = (uint8_t) ((freq >> 8) & 0xFF);
-  buf[3] = (uint8_t) (freq & 0xFF);
-  this->write_opcode_(RADIO_SET_RFFREQUENCY, buf, 4);
-
-  // configure pa
-  int8_t pa_power = this->pa_power_;
-  if (this->hw_version_ == "sx1261") {
-    // the following values were taken from section 13.1.14.1 table 13-21
-    // in rev 2.1 of the datasheet
-    if (pa_power == 15) {
-      uint8_t cfg[4] = {0x06, 0x00, 0x01, 0x01};
-      this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
-    } else {
-      uint8_t cfg[4] = {0x04, 0x00, 0x01, 0x01};
-      this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
-    }
-    pa_power = std::max(pa_power, (int8_t) -3);
-    pa_power = std::min(pa_power, (int8_t) 14);
-    buf[0] = OCP_80MA;
-    this->write_register_(REG_OCP, buf, 1);
-  } else {
-    // the following values were taken from section 13.1.14.1 table 13-21
-    // in rev 2.1 of the datasheet
-    uint8_t cfg[4] = {0x04, 0x07, 0x00, 0x01};
-    this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
-    pa_power = std::max(pa_power, (int8_t) -3);
-    pa_power = std::min(pa_power, (int8_t) 22);
-    buf[0] = OCP_140MA;
-    this->write_register_(REG_OCP, buf, 1);
-  }
-  buf[0] = pa_power;
-  buf[1] = this->pa_ramp_;
-  this->write_opcode_(RADIO_SET_TXPARAMS, buf, 2);
-
-  // configure modem
-  if (this->modulation_ == PACKET_TYPE_LORA) {
-    // set modulation params
-    float duration = 1000.0f * std::pow(2, this->spreading_factor_) / BW_HZ[this->bandwidth_];
-    buf[0] = this->spreading_factor_;
-    buf[1] = BW_LORA[this->bandwidth_ - SX126X_BW_7810];
-    buf[2] = this->coding_rate_;
-    buf[3] = (duration > LOW_DATA_RATE_OPTIMIZE_THRESHOLD) ? 0x01 : 0x00;
-    this->write_opcode_(RADIO_SET_MODULATIONPARAMS, buf, 4);
-
-    // set packet params and sync word
-    this->set_packet_params_(this->payload_length_);
-    if (this->sync_value_.size() == 2) {
-      this->write_register_(REG_LORA_SYNCWORD, this->sync_value_.data(), this->sync_value_.size());
-    }
-  } else {
-    // set modulation params
-    uint32_t bitrate = ((uint64_t) XTAL_FREQ * 32) / this->bitrate_;
-    uint32_t fdev = ((uint64_t) this->deviation_ << 25) / XTAL_FREQ;
-    buf[0] = (bitrate >> 16) & 0xFF;
-    buf[1] = (bitrate >> 8) & 0xFF;
-    buf[2] = (bitrate >> 0) & 0xFF;
-    buf[3] = this->shaping_;
-    buf[4] = BW_FSK[this->bandwidth_ - SX126X_BW_4800];
-    buf[5] = (fdev >> 16) & 0xFF;
-    buf[6] = (fdev >> 8) & 0xFF;
-    buf[7] = (fdev >> 0) & 0xFF;
-    this->write_opcode_(RADIO_SET_MODULATIONPARAMS, buf, 8);
-
-    // set packet params and sync word
-    this->set_packet_params_(this->payload_length_);
-    if (!this->sync_value_.empty()) {
-      this->write_register_(REG_GFSK_SYNCWORD, this->sync_value_.data(), this->sync_value_.size());
-    }
-  }
-
-  // switch to rx or sleep
-  if (this->rx_start_) {
-    this->set_mode_rx();
-  } else {
-    this->set_mode_sleep();
-  }
-}
-
-size_t SX126x::get_max_packet_size() {
-  if (this->payload_length_ > 0) {
-    return this->payload_length_;
-  }
-  return 255;
-}
-
-void SX126x::set_packet_params_(uint8_t payload_length) {
-  uint8_t buf[9];
-  if (this->modulation_ == PACKET_TYPE_LORA) {
-    buf[0] = (this->preamble_size_ >> 8) & 0xFF;
-    buf[1] = (this->preamble_size_ >> 0) & 0xFF;
-    buf[2] = (this->payload_length_ > 0) ? 0x01 : 0x00;
-    buf[3] = payload_length;
-    buf[4] = (this->crc_enable_) ? 0x01 : 0x00;
-    buf[5] = 0x00;
-    this->write_opcode_(RADIO_SET_PACKETPARAMS, buf, 6);
-  } else {
-    uint16_t preamble_size = this->preamble_size_ * 8;
-    buf[0] = (preamble_size >> 8) & 0xFF;
-    buf[1] = (preamble_size >> 0) & 0xFF;
-    buf[2] = (this->preamble_detect_ > 0) ? ((this->preamble_detect_ - 1) | 0x04) : 0x00;
-    buf[3] = this->sync_value_.size() * 8;
-    buf[4] = 0x00;
-    buf[5] = 0x00;
-    buf[6] = payload_length;
-    buf[7] = this->crc_enable_ ? 0x06 : 0x01;
-    buf[8] = 0x00;
-    this->write_opcode_(RADIO_SET_PACKETPARAMS, buf, 9);
-  }
-}
-
-SX126xError SX126x::transmit_packet(const std::vector<uint8_t> &packet) {
-  if (this->payload_length_ > 0 && this->payload_length_ != packet.size()) {
-    ESP_LOGE(TAG, "Packet size does not match config");
-    return SX126xError::INVALID_PARAMS;
-  }
-  if (packet.empty() || packet.size() > this->get_max_packet_size()) {
-    ESP_LOGE(TAG, "Packet size out of range");
-    return SX126xError::INVALID_PARAMS;
-  }
-
-  SX126xError ret = SX126xError::NONE;
-  this->set_mode_standby(STDBY_XOSC);
-  if (this->payload_length_ == 0) {
-    this->set_packet_params_(packet.size());
-  }
-  this->write_fifo_(0x00, packet);
-  this->set_mode_tx();
-
-  // wait until transmit completes, typically the delay will be less than 100 ms
-  uint32_t start = millis();
-  while (!this->dio1_pin_->digital_read()) {
-    if (millis() - start > TRANSMIT_TIMEOUT_MS) {
-      ESP_LOGE(TAG, "Transmit packet failure");
-      ret = SX126xError::TIMEOUT;
-      break;
-    }
-  }
-
-  uint8_t buf[2];
-  buf[0] = 0xFF;
-  buf[1] = 0xFF;
-  this->write_opcode_(RADIO_CLR_IRQSTATUS, buf, 2);
-  if (this->rx_start_) {
-    this->set_mode_rx();
-  } else {
-    this->set_mode_sleep();
-  }
-  return ret;
-}
-
-void SX126x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr) {
-  for (auto &listener : this->listeners_) {
-    listener->on_packet(packet, rssi, snr);
-  }
-  this->packet_trigger_->trigger(packet, rssi, snr);
-}
-
-void SX126x::loop() {
-  if (!this->dio1_pin_->digital_read()) {
-    return;
-  }
-
-  uint16_t status;
-  uint8_t buf[3];
-  uint8_t rssi;
-  int8_t snr;
-  this->read_opcode_(RADIO_GET_IRQSTATUS, buf, 2);
-  this->write_opcode_(RADIO_CLR_IRQSTATUS, buf, 2);
-  status = (buf[0] << 8) | buf[1];
-  if ((status & IRQ_RX_DONE) == IRQ_RX_DONE) {
-    if ((status & IRQ_CRC_ERROR) != IRQ_CRC_ERROR) {
-      this->read_opcode_(RADIO_GET_PACKETSTATUS, buf, 3);
-      if (this->modulation_ == PACKET_TYPE_LORA) {
-        rssi = buf[0];
-        snr = buf[1];
-      } else {
-        rssi = buf[2];
-        snr = 0;
-      }
-      this->read_opcode_(RADIO_GET_RXBUFFERSTATUS, buf, 2);
-      this->packet_.resize(buf[0]);
-      this->read_fifo_(buf[1], this->packet_);
-      this->call_listeners_(this->packet_, (float) rssi / -2.0f, (float) snr / 4.0f);
-    }
-  }
-}
-
-void SX126x::run_image_cal() {
-  // the following values were taken from section 9.2.1 table 9-2
-  // in rev 2.1 of the datasheet
-  uint8_t buf[2] = {0, 0};
-  if (this->frequency_ > 900000000) {
-    buf[0] = 0xE1;
-    buf[1] = 0xE9;
-  } else if (this->frequency_ > 850000000) {
-    buf[0] = 0xD7;
-    buf[1] = 0xD8;
-  } else if (this->frequency_ > 770000000) {
-    buf[0] = 0xC1;
-    buf[1] = 0xC5;
-  } else if (this->frequency_ > 460000000) {
-    buf[0] = 0x75;
-    buf[1] = 0x81;
-  } else if (this->frequency_ > 425000000) {
-    buf[0] = 0x6B;
-    buf[1] = 0x6F;
-  }
-  if (buf[0] > 0 && buf[1] > 0) {
-    this->write_opcode_(RADIO_CALIBRATEIMAGE, buf, 2);
-  }
-}
-
-void SX126x::set_mode_rx() {
-  uint8_t buf[8];
-
-  // configure irq params
-  uint16_t irq = IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT | IRQ_CRC_ERROR;
-  buf[0] = (irq >> 8) & 0xFF;
-  buf[1] = (irq >> 0) & 0xFF;
-  buf[2] = (irq >> 8) & 0xFF;
-  buf[3] = (irq >> 0) & 0xFF;
-  buf[4] = (IRQ_RADIO_NONE >> 8) & 0xFF;
-  buf[5] = (IRQ_RADIO_NONE >> 0) & 0xFF;
-  buf[6] = (IRQ_RADIO_NONE >> 8) & 0xFF;
-  buf[7] = (IRQ_RADIO_NONE >> 0) & 0xFF;
-  this->write_opcode_(RADIO_SET_DIOIRQPARAMS, buf, 8);
-
-  // set timeout to 0
-  buf[0] = 0x00;
-  this->write_opcode_(RADIO_SET_LORASYMBTIMEOUT, buf, 1);
-
-  // switch to continuous mode rx
-  buf[0] = 0xFF;
-  buf[1] = 0xFF;
-  buf[2] = 0xFF;
-  this->write_opcode_(RADIO_SET_RX, buf, 3);
-}
-
-void SX126x::set_mode_tx() {
-  uint8_t buf[8];
-
-  // configure irq params
-  uint16_t irq = IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT;
-  buf[0] = (irq >> 8) & 0xFF;
-  buf[1] = (irq >> 0) & 0xFF;
-  buf[2] = (irq >> 8) & 0xFF;
-  buf[3] = (irq >> 0) & 0xFF;
-  buf[4] = (IRQ_RADIO_NONE >> 8) & 0xFF;
-  buf[5] = (IRQ_RADIO_NONE >> 0) & 0xFF;
-  buf[6] = (IRQ_RADIO_NONE >> 8) & 0xFF;
-  buf[7] = (IRQ_RADIO_NONE >> 0) & 0xFF;
-  this->write_opcode_(RADIO_SET_DIOIRQPARAMS, buf, 8);
-
-  // switch to single mode tx
-  buf[0] = 0x00;
-  buf[1] = 0x00;
-  buf[2] = 0x00;
-  this->write_opcode_(RADIO_SET_TX, buf, 3);
-}
-
-void SX126x::set_mode_sleep() {
-  uint8_t buf[1];
-  buf[0] = 0x05;
-  this->write_opcode_(RADIO_SET_SLEEP, buf, 1);
-}
-
-void SX126x::set_mode_standby(SX126xStandbyMode mode) {
-  uint8_t buf[1];
-  buf[0] = mode;
-  this->write_opcode_(RADIO_SET_STANDBY, buf, 1);
-}
-
-void SX126x::wait_busy_() {
-  // wait if the device is busy, the maximum delay is only be a few ms
-  // with most commands taking only a few us
-  uint32_t start = millis();
-  while (this->busy_pin_->digital_read()) {
-    if (millis() - start > BUSY_TIMEOUT_MS) {
-      ESP_LOGE(TAG, "Wait busy timeout");
-      this->mark_failed();
-      break;
-    }
-  }
-}
-
-void SX126x::dump_config() {
-  ESP_LOGCONFIG(TAG, "SX126x:");
-  LOG_PIN("  CS Pin: ", this->cs_);
-  LOG_PIN("  BUSY Pin: ", this->busy_pin_);
-  LOG_PIN("  RST Pin: ", this->rst_pin_);
-  LOG_PIN("  DIO1 Pin: ", this->dio1_pin_);
-  ESP_LOGCONFIG(TAG,
-                "  HW Version: %15s\n"
-                "  Frequency: %" PRIu32 " Hz\n"
-                "  Bandwidth: %" PRIu32 " Hz\n"
-                "  PA Power: %" PRId8 " dBm\n"
-                "  PA Ramp: %" PRIu16 " us\n"
-                "  Payload Length: %" PRIu32 "\n"
-                "  CRC Enable: %s\n"
-                "  Rx Start: %s",
-                this->version_, this->frequency_, BW_HZ[this->bandwidth_], this->pa_power_, RAMP[this->pa_ramp_],
-                this->payload_length_, TRUEFALSE(this->crc_enable_), TRUEFALSE(this->rx_start_));
-  if (this->modulation_ == PACKET_TYPE_GFSK) {
-    const char *shaping = "NONE";
-    if (this->shaping_ == GAUSSIAN_BT_0_3) {
-      shaping = "GAUSSIAN_BT_0_3";
-    } else if (this->shaping_ == GAUSSIAN_BT_0_5) {
-      shaping = "GAUSSIAN_BT_0_5";
-    } else if (this->shaping_ == GAUSSIAN_BT_0_7) {
-      shaping = "GAUSSIAN_BT_0_7";
-    } else if (this->shaping_ == GAUSSIAN_BT_1_0) {
-      shaping = "GAUSSIAN_BT_1_0";
-    }
-    ESP_LOGCONFIG(TAG,
-                  "  Modulation: FSK\n"
-                  "  Deviation: %" PRIu32 " Hz\n"
-                  "  Shaping: %s\n"
-                  "  Preamble Size: %" PRIu16 "\n"
-                  "  Preamble Detect: %" PRIu16 "\n"
-                  "  Bitrate: %" PRIu32 "b/s",
-                  this->deviation_, shaping, this->preamble_size_, this->preamble_detect_, this->bitrate_);
-  } else if (this->modulation_ == PACKET_TYPE_LORA) {
-    const char *cr = "4/8";
-    if (this->coding_rate_ == LORA_CR_4_5) {
-      cr = "4/5";
-    } else if (this->coding_rate_ == LORA_CR_4_6) {
-      cr = "4/6";
-    } else if (this->coding_rate_ == LORA_CR_4_7) {
-      cr = "4/7";
-    }
-    ESP_LOGCONFIG(TAG,
-                  "  Modulation: LORA\n"
-                  "  Spreading Factor: %" PRIu8 "\n"
-                  "  Coding Rate: %s\n"
-                  "  Preamble Size: %" PRIu16,
-                  this->spreading_factor_, cr, this->preamble_size_);
-  }
-  if (!this->sync_value_.empty()) {
-    ESP_LOGCONFIG(TAG, "  Sync Value: 0x%s", format_hex(this->sync_value_).c_str());
-  }
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, "Configuring SX126x failed");
-  }
-}
-
-}  // namespace sx126x
-}  // namespace esphome

esphome/components/sx126x/sx126x.h

@@ -1,140 +0,0 @@
-#pragma once
-
-#include "esphome/components/spi/spi.h"
-#include "esphome/core/automation.h"
-#include "esphome/core/component.h"
-#include "sx126x_reg.h"
-#include <utility>
-#include <vector>
-
-namespace esphome {
-namespace sx126x {
-
-enum SX126xBw : uint8_t {
-  // FSK
-  SX126X_BW_4800,
-  SX126X_BW_5800,
-  SX126X_BW_7300,
-  SX126X_BW_9700,
-  SX126X_BW_11700,
-  SX126X_BW_14600,
-  SX126X_BW_19500,
-  SX126X_BW_23400,
-  SX126X_BW_29300,
-  SX126X_BW_39000,
-  SX126X_BW_46900,
-  SX126X_BW_58600,
-  SX126X_BW_78200,
-  SX126X_BW_93800,
-  SX126X_BW_117300,
-  SX126X_BW_156200,
-  SX126X_BW_187200,
-  SX126X_BW_234300,
-  SX126X_BW_312000,
-  SX126X_BW_373600,
-  SX126X_BW_467000,
-  // LORA
-  SX126X_BW_7810,
-  SX126X_BW_10420,
-  SX126X_BW_15630,
-  SX126X_BW_20830,
-  SX126X_BW_31250,
-  SX126X_BW_41670,
-  SX126X_BW_62500,
-  SX126X_BW_125000,
-  SX126X_BW_250000,
-  SX126X_BW_500000,
-};
-
-enum class SX126xError { NONE = 0, TIMEOUT, INVALID_PARAMS };
-
-class SX126xListener {
- public:
-  virtual void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) = 0;
-};
-
-class SX126x : public Component,
-               public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
-                                     spi::DATA_RATE_8MHZ> {
- public:
-  size_t get_max_packet_size();
-  float get_setup_priority() const override { return setup_priority::PROCESSOR; }
-  void setup() override;
-  void loop() override;
-  void dump_config() override;
-  void set_bandwidth(SX126xBw bandwidth) { this->bandwidth_ = bandwidth; }
-  void set_bitrate(uint32_t bitrate) { this->bitrate_ = bitrate; }
-  void set_busy_pin(InternalGPIOPin *busy_pin) { this->busy_pin_ = busy_pin; }
-  void set_coding_rate(uint8_t coding_rate) { this->coding_rate_ = coding_rate; }
-  void set_crc_enable(bool crc_enable) { this->crc_enable_ = crc_enable; }
-  void set_deviation(uint32_t deviation) { this->deviation_ = deviation; }
-  void set_dio1_pin(InternalGPIOPin *dio1_pin) { this->dio1_pin_ = dio1_pin; }
-  void set_frequency(uint32_t frequency) { this->frequency_ = frequency; }
-  void set_hw_version(const std::string &hw_version) { this->hw_version_ = hw_version; }
-  void set_mode_rx();
-  void set_mode_tx();
-  void set_mode_standby(SX126xStandbyMode mode);
-  void set_mode_sleep();
-  void set_modulation(uint8_t modulation) { this->modulation_ = modulation; }
-  void set_pa_power(int8_t power) { this->pa_power_ = power; }
-  void set_pa_ramp(uint8_t ramp) { this->pa_ramp_ = ramp; }
-  void set_payload_length(uint8_t payload_length) { this->payload_length_ = payload_length; }
-  void set_preamble_detect(uint16_t preamble_detect) { this->preamble_detect_ = preamble_detect; }
-  void set_preamble_size(uint16_t preamble_size) { this->preamble_size_ = preamble_size; }
-  void set_rst_pin(InternalGPIOPin *rst_pin) { this->rst_pin_ = rst_pin; }
-  void set_rx_start(bool rx_start) { this->rx_start_ = rx_start; }
-  void set_rf_switch(bool rf_switch) { this->rf_switch_ = rf_switch; }
-  void set_shaping(uint8_t shaping) { this->shaping_ = shaping; }
-  void set_spreading_factor(uint8_t spreading_factor) { this->spreading_factor_ = spreading_factor; }
-  void set_sync_value(const std::vector<uint8_t> &sync_value) { this->sync_value_ = sync_value; }
-  void set_tcxo_voltage(uint8_t tcxo_voltage) { this->tcxo_voltage_ = tcxo_voltage; }
-  void set_tcxo_delay(uint32_t tcxo_delay) { this->tcxo_delay_ = tcxo_delay; }
-  void run_image_cal();
-  void configure();
-  SX126xError transmit_packet(const std::vector<uint8_t> &packet);
-  void register_listener(SX126xListener *listener) { this->listeners_.push_back(listener); }
-  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() const { return this->packet_trigger_; };
-
- protected:
-  void configure_fsk_ook_();
-  void configure_lora_();
-  void set_packet_params_(uint8_t payload_length);
-  uint8_t read_fifo_(uint8_t offset, std::vector<uint8_t> &packet);
-  void write_fifo_(uint8_t offset, const std::vector<uint8_t> &packet);
-  void write_opcode_(uint8_t opcode, uint8_t *data, uint8_t size);
-  uint8_t read_opcode_(uint8_t opcode, uint8_t *data, uint8_t size);
-  void write_register_(uint16_t reg, uint8_t *data, uint8_t size);
-  void read_register_(uint16_t reg, uint8_t *data, uint8_t size);
-  void call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr);
-  void wait_busy_();
-  Trigger<std::vector<uint8_t>, float, float> *packet_trigger_{new Trigger<std::vector<uint8_t>, float, float>()};
-  std::vector<SX126xListener *> listeners_;
-  std::vector<uint8_t> packet_;
-  std::vector<uint8_t> sync_value_;
-  InternalGPIOPin *busy_pin_{nullptr};
-  InternalGPIOPin *dio1_pin_{nullptr};
-  InternalGPIOPin *rst_pin_{nullptr};
-  std::string hw_version_;
-  char version_[16];
-  SX126xBw bandwidth_{SX126X_BW_125000};
-  uint32_t bitrate_{0};
-  uint32_t deviation_{0};
-  uint32_t frequency_{0};
-  uint32_t payload_length_{0};
-  uint32_t tcxo_delay_{0};
-  uint16_t preamble_detect_{0};
-  uint16_t preamble_size_{0};
-  uint8_t tcxo_voltage_{0};
-  uint8_t coding_rate_{0};
-  uint8_t modulation_{PACKET_TYPE_LORA};
-  uint8_t pa_ramp_{0};
-  uint8_t shaping_{0};
-  uint8_t spreading_factor_{0};
-  int8_t pa_power_{0};
-  bool crc_enable_{false};
-  bool rx_start_{false};
-  bool rf_switch_{false};
-};
-
-}  // namespace sx126x
-}  // namespace esphome

esphome/components/sx126x/sx126x_reg.h

@@ -1,163 +0,0 @@
-#pragma once
-
-#include "esphome/core/hal.h"
-
-namespace esphome {
-namespace sx126x {
-
-static const uint32_t XTAL_FREQ = 32000000;
-
-enum SX126xOpCode : uint8_t {
-  RADIO_GET_STATUS = 0xC0,
-  RADIO_WRITE_REGISTER = 0x0D,
-  RADIO_READ_REGISTER = 0x1D,
-  RADIO_WRITE_BUFFER = 0x0E,
-  RADIO_READ_BUFFER = 0x1E,
-  RADIO_SET_SLEEP = 0x84,
-  RADIO_SET_STANDBY = 0x80,
-  RADIO_SET_FS = 0xC1,
-  RADIO_SET_TX = 0x83,
-  RADIO_SET_RX = 0x82,
-  RADIO_SET_RXDUTYCYCLE = 0x94,
-  RADIO_SET_CAD = 0xC5,
-  RADIO_SET_TXCONTINUOUSWAVE = 0xD1,
-  RADIO_SET_TXCONTINUOUSPREAMBLE = 0xD2,
-  RADIO_SET_PACKETTYPE = 0x8A,
-  RADIO_GET_PACKETTYPE = 0x11,
-  RADIO_SET_RFFREQUENCY = 0x86,
-  RADIO_SET_TXPARAMS = 0x8E,
-  RADIO_SET_PACONFIG = 0x95,
-  RADIO_SET_CADPARAMS = 0x88,
-  RADIO_SET_BUFFERBASEADDRESS = 0x8F,
-  RADIO_SET_MODULATIONPARAMS = 0x8B,
-  RADIO_SET_PACKETPARAMS = 0x8C,
-  RADIO_GET_RXBUFFERSTATUS = 0x13,
-  RADIO_GET_PACKETSTATUS = 0x14,
-  RADIO_GET_RSSIINST = 0x15,
-  RADIO_GET_STATS = 0x10,
-  RADIO_RESET_STATS = 0x00,
-  RADIO_SET_DIOIRQPARAMS = 0x08,
-  RADIO_GET_IRQSTATUS = 0x12,
-  RADIO_CLR_IRQSTATUS = 0x02,
-  RADIO_CALIBRATE = 0x89,
-  RADIO_CALIBRATEIMAGE = 0x98,
-  RADIO_SET_REGULATORMODE = 0x96,
-  RADIO_GET_ERROR = 0x17,
-  RADIO_CLR_ERROR = 0x07,
-  RADIO_SET_TCXOMODE = 0x97,
-  RADIO_SET_TXFALLBACKMODE = 0x93,
-  RADIO_SET_RFSWITCHMODE = 0x9D,
-  RADIO_SET_STOPRXTIMERONPREAMBLE = 0x9F,
-  RADIO_SET_LORASYMBTIMEOUT = 0xA0,
-};
-
-enum SX126xRegister : uint16_t {
-  REG_VERSION_STRING = 0x0320,
-  REG_GFSK_SYNCWORD = 0x06C0,
-  REG_LORA_SYNCWORD = 0x0740,
-  REG_OCP = 0x08E7,
-};
-
-enum SX126xStandbyMode : uint8_t {
-  STDBY_RC = 0x00,
-  STDBY_XOSC = 0x01,
-};
-
-enum SX126xPacketType : uint8_t {
-  PACKET_TYPE_GFSK = 0x00,
-  PACKET_TYPE_LORA = 0x01,
-  PACKET_TYPE_LRHSS = 0x03,
-};
-
-enum SX126xFskBw : uint8_t {
-  FSK_BW_4800 = 0x1F,
-  FSK_BW_5800 = 0x17,
-  FSK_BW_7300 = 0x0F,
-  FSK_BW_9700 = 0x1E,
-  FSK_BW_11700 = 0x16,
-  FSK_BW_14600 = 0x0E,
-  FSK_BW_19500 = 0x1D,
-  FSK_BW_23400 = 0x15,
-  FSK_BW_29300 = 0x0D,
-  FSK_BW_39000 = 0x1C,
-  FSK_BW_46900 = 0x14,
-  FSK_BW_58600 = 0x0C,
-  FSK_BW_78200 = 0x1B,
-  FSK_BW_93800 = 0x13,
-  FSK_BW_117300 = 0x0B,
-  FSK_BW_156200 = 0x1A,
-  FSK_BW_187200 = 0x12,
-  FSK_BW_234300 = 0x0A,
-  FSK_BW_312000 = 0x19,
-  FSK_BW_373600 = 0x11,
-  FSK_BW_467000 = 0x09,
-};
-
-enum SX126xLoraBw : uint8_t {
-  LORA_BW_7810 = 0x00,
-  LORA_BW_10420 = 0x08,
-  LORA_BW_15630 = 0x01,
-  LORA_BW_20830 = 0x09,
-  LORA_BW_31250 = 0x02,
-  LORA_BW_41670 = 0x0A,
-  LORA_BW_62500 = 0x03,
-  LORA_BW_125000 = 0x04,
-  LORA_BW_250000 = 0x05,
-  LORA_BW_500000 = 0x06,
-};
-
-enum SX126xLoraCr : uint8_t {
-  LORA_CR_4_5 = 0x01,
-  LORA_CR_4_6 = 0x02,
-  LORA_CR_4_7 = 0x03,
-  LORA_CR_4_8 = 0x04,
-};
-
-enum SX126xIrqMasks : uint16_t {
-  IRQ_RADIO_NONE = 0x0000,
-  IRQ_TX_DONE = 0x0001,
-  IRQ_RX_DONE = 0x0002,
-  IRQ_PREAMBLE_DETECTED = 0x0004,
-  IRQ_SYNCWORD_VALID = 0x0008,
-  IRQ_HEADER_VALID = 0x0010,
-  IRQ_HEADER_ERROR = 0x0020,
-  IRQ_CRC_ERROR = 0x0040,
-  IRQ_CAD_DONE = 0x0080,
-  IRQ_CAD_ACTIVITY_DETECTED = 0x0100,
-  IRQ_RX_TX_TIMEOUT = 0x0200,
-  IRQ_RADIO_ALL = 0xFFFF,
-};
-
-enum SX126xTcxoCtrl : uint8_t {
-  TCXO_CTRL_1_6V = 0x00,
-  TCXO_CTRL_1_7V = 0x01,
-  TCXO_CTRL_1_8V = 0x02,
-  TCXO_CTRL_2_2V = 0x03,
-  TCXO_CTRL_2_4V = 0x04,
-  TCXO_CTRL_2_7V = 0x05,
-  TCXO_CTRL_3_0V = 0x06,
-  TCXO_CTRL_3_3V = 0x07,
-  TCXO_CTRL_NONE = 0xFF,
-};
-
-enum SX126xPulseShape : uint8_t {
-  NO_FILTER = 0x00,
-  GAUSSIAN_BT_0_3 = 0x08,
-  GAUSSIAN_BT_0_5 = 0x09,
-  GAUSSIAN_BT_0_7 = 0x0A,
-  GAUSSIAN_BT_1_0 = 0x0B,
-};
-
-enum SX126xRampTime : uint8_t {
-  PA_RAMP_10 = 0x00,
-  PA_RAMP_20 = 0x01,
-  PA_RAMP_40 = 0x02,
-  PA_RAMP_80 = 0x03,
-  PA_RAMP_200 = 0x04,
-  PA_RAMP_800 = 0x05,
-  PA_RAMP_1700 = 0x06,
-  PA_RAMP_3400 = 0x07,
-};
-
-}  // namespace sx126x
-}  // namespace esphome

esphome/components/sx127x/sx127x.cpp

@@ -252,17 +252,15 @@ size_t SX127x::get_max_packet_size() {
   }
 }
 
-SX127xError SX127x::transmit_packet(const std::vector<uint8_t> &packet) {
+void SX127x::transmit_packet(const std::vector<uint8_t> &packet) {
   if (this->payload_length_ > 0 && this->payload_length_ != packet.size()) {
     ESP_LOGE(TAG, "Packet size does not match config");
-    return SX127xError::INVALID_PARAMS;
+    return;
   }
   if (packet.empty() || packet.size() > this->get_max_packet_size()) {
     ESP_LOGE(TAG, "Packet size out of range");
-    return SX127xError::INVALID_PARAMS;
+    return;
   }
-
-  SX127xError ret = SX127xError::NONE;
   if (this->modulation_ == MOD_LORA) {
     this->set_mode_standby();
     if (this->payload_length_ == 0) {
@@ -280,13 +278,11 @@ SX127xError SX127x::transmit_packet(const std::vector<uint8_t> &packet) {
     this->write_fifo_(packet);
     this->set_mode_tx();
   }
-
   // wait until transmit completes, typically the delay will be less than 100 ms
   uint32_t start = millis();
   while (!this->dio0_pin_->digital_read()) {
     if (millis() - start > 4000) {
       ESP_LOGE(TAG, "Transmit packet failure");
-      ret = SX127xError::TIMEOUT;
       break;
     }
   }
@@ -295,7 +291,6 @@ SX127xError SX127x::transmit_packet(const std::vector<uint8_t> &packet) {
   } else {
     this->set_mode_sleep();
   }
-  return ret;
 }
 
 void SX127x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr) {
@@ -318,28 +313,35 @@ void SX127x::loop() {
       uint8_t addr = this->read_register_(REG_FIFO_RX_CURR_ADDR);
       uint8_t rssi = this->read_register_(REG_PKT_RSSI_VALUE);
       int8_t snr = (int8_t) this->read_register_(REG_PKT_SNR_VALUE);
-      this->packet_.resize(bytes);
+      std::vector<uint8_t> packet(bytes);
       this->write_register_(REG_FIFO_ADDR_PTR, addr);
-      this->read_fifo_(this->packet_);
+      this->read_fifo_(packet);
       if (this->frequency_ > 700000000) {
-        this->call_listeners_(this->packet_, (float) rssi - RSSI_OFFSET_HF, (float) snr / 4);
+        this->call_listeners_(packet, (float) rssi - RSSI_OFFSET_HF, (float) snr / 4);
       } else {
-        this->call_listeners_(this->packet_, (float) rssi - RSSI_OFFSET_LF, (float) snr / 4);
+        this->call_listeners_(packet, (float) rssi - RSSI_OFFSET_LF, (float) snr / 4);
       }
     }
   } else if (this->packet_mode_) {
+    std::vector<uint8_t> packet;
     uint8_t payload_length = this->payload_length_;
     if (payload_length == 0) {
       payload_length = this->read_register_(REG_FIFO);
     }
-    this->packet_.resize(payload_length);
-    this->read_fifo_(this->packet_);
-    this->call_listeners_(this->packet_, 0.0f, 0.0f);
+    packet.resize(payload_length);
+    this->read_fifo_(packet);
+    this->call_listeners_(packet, 0.0f, 0.0f);
   }
 }
 
 void SX127x::run_image_cal() {
-  if (this->modulation_ == MOD_LORA) {
+  uint32_t start = millis();
+  uint8_t mode = this->read_register_(REG_OP_MODE);
+  if ((mode & MODE_MASK) != MODE_STDBY) {
+    ESP_LOGE(TAG, "Need to be in standby for image cal");
+    return;
+  }
+  if (mode & MOD_LORA) {
     this->set_mode_(MOD_FSK, MODE_SLEEP);
     this->set_mode_(MOD_FSK, MODE_STDBY);
   }
@@ -348,15 +350,13 @@ void SX127x::run_image_cal() {
   } else {
     this->write_register_(REG_IMAGE_CAL, IMAGE_CAL_START);
   }
-  uint32_t start = millis();
   while (this->read_register_(REG_IMAGE_CAL) & IMAGE_CAL_RUNNING) {
     if (millis() - start > 20) {
       ESP_LOGE(TAG, "Image cal failure");
-      this->mark_failed();
       break;
     }
   }
-  if (this->modulation_ == MOD_LORA) {
+  if (mode & MOD_LORA) {
     this->set_mode_(this->modulation_, MODE_SLEEP);
     this->set_mode_(this->modulation_, MODE_STDBY);
   }
@@ -375,7 +375,6 @@ void SX127x::set_mode_(uint8_t modulation, uint8_t mode) {
     }
     if (millis() - start > 20) {
       ESP_LOGE(TAG, "Set mode failure");
-      this->mark_failed();
       break;
     }
   }
@@ -406,6 +405,18 @@ void SX127x::dump_config() {
   LOG_PIN("  CS Pin: ", this->cs_);
   LOG_PIN("  RST Pin: ", this->rst_pin_);
   LOG_PIN("  DIO0 Pin: ", this->dio0_pin_);
+  const char *shaping = "NONE";
+  if (this->shaping_ == CUTOFF_BR_X_2) {
+    shaping = "CUTOFF_BR_X_2";
+  } else if (this->shaping_ == CUTOFF_BR_X_1) {
+    shaping = "CUTOFF_BR_X_1";
+  } else if (this->shaping_ == GAUSSIAN_BT_0_3) {
+    shaping = "GAUSSIAN_BT_0_3";
+  } else if (this->shaping_ == GAUSSIAN_BT_0_5) {
+    shaping = "GAUSSIAN_BT_0_5";
+  } else if (this->shaping_ == GAUSSIAN_BT_1_0) {
+    shaping = "GAUSSIAN_BT_1_0";
+  }
   const char *pa_pin = "RFO";
   if (this->pa_pin_ == PA_PIN_BOOST) {
     pa_pin = "BOOST";
@@ -416,9 +427,10 @@ void SX127x::dump_config() {
                 "  Bandwidth: %" PRIu32 " Hz\n"
                 "  PA Pin: %s\n"
                 "  PA Power: %" PRIu8 " dBm\n"
-                "  PA Ramp: %" PRIu16 " us",
+                "  PA Ramp: %" PRIu16 " us\n"
+                "  Shaping: %s",
                 TRUEFALSE(this->auto_cal_), this->frequency_, BW_HZ[this->bandwidth_], pa_pin, this->pa_power_,
-                RAMP[this->pa_ramp_]);
+                RAMP[this->pa_ramp_], shaping);
   if (this->modulation_ == MOD_FSK) {
     ESP_LOGCONFIG(TAG, "  Deviation: %" PRIu32 " Hz", this->deviation_);
   }
@@ -445,31 +457,14 @@ void SX127x::dump_config() {
       ESP_LOGCONFIG(TAG, "  Sync Value: 0x%02x", this->sync_value_[0]);
     }
   } else {
-    const char *shaping = "NONE";
-    if (this->modulation_ == MOD_FSK) {
-      if (this->shaping_ == GAUSSIAN_BT_0_3) {
-        shaping = "GAUSSIAN_BT_0_3";
-      } else if (this->shaping_ == GAUSSIAN_BT_0_5) {
-        shaping = "GAUSSIAN_BT_0_5";
-      } else if (this->shaping_ == GAUSSIAN_BT_1_0) {
-        shaping = "GAUSSIAN_BT_1_0";
-      }
-    } else {
-      if (this->shaping_ == CUTOFF_BR_X_2) {
-        shaping = "CUTOFF_BR_X_2";
-      } else if (this->shaping_ == CUTOFF_BR_X_1) {
-        shaping = "CUTOFF_BR_X_1";
-      }
-    }
     ESP_LOGCONFIG(TAG,
-                  "  Shaping: %s\n"
                   "  Modulation: %s\n"
                   "  Bitrate: %" PRIu32 "b/s\n"
                   "  Bitsync: %s\n"
                   "  Rx Start: %s\n"
                   "  Rx Floor: %.1f dBm\n"
                   "  Packet Mode: %s",
-                  shaping, this->modulation_ == MOD_FSK ? "FSK" : "OOK", this->bitrate_, TRUEFALSE(this->bitsync_),
+                  this->modulation_ == MOD_FSK ? "FSK" : "OOK", this->bitrate_, TRUEFALSE(this->bitsync_),
                   TRUEFALSE(this->rx_start_), this->rx_floor_, TRUEFALSE(this->packet_mode_));
     if (this->packet_mode_) {
       ESP_LOGCONFIG(TAG, "  CRC Enable: %s", TRUEFALSE(this->crc_enable_));

esphome/components/sx127x/sx127x.h

@@ -34,8 +34,6 @@ enum SX127xBw : uint8_t {
   SX127X_BW_500_0,
 };
 
-enum class SX127xError { NONE = 0, TIMEOUT, INVALID_PARAMS };
-
 class SX127xListener {
  public:
   virtual void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) = 0;
@@ -81,7 +79,7 @@ class SX127x : public Component,
   void set_sync_value(const std::vector<uint8_t> &sync_value) { this->sync_value_ = sync_value; }
   void run_image_cal();
   void configure();
-  SX127xError transmit_packet(const std::vector<uint8_t> &packet);
+  void transmit_packet(const std::vector<uint8_t> &packet);
   void register_listener(SX127xListener *listener) { this->listeners_.push_back(listener); }
   Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() const { return this->packet_trigger_; };
 
@@ -96,7 +94,6 @@ class SX127x : public Component,
   uint8_t read_register_(uint8_t reg);
   Trigger<std::vector<uint8_t>, float, float> *packet_trigger_{new Trigger<std::vector<uint8_t>, float, float>()};
   std::vector<SX127xListener *> listeners_;
-  std::vector<uint8_t> packet_;
   std::vector<uint8_t> sync_value_;
   InternalGPIOPin *dio0_pin_{nullptr};
   InternalGPIOPin *rst_pin_{nullptr};

esphome/components/syslog/esphome_syslog.cpp

@@ -21,12 +21,10 @@ constexpr int LOG_LEVEL_TO_SYSLOG_SEVERITY[] = {
 
 void Syslog::setup() {
   logger::global_logger->add_on_log_callback(
-      [this](int level, const char *tag, const char *message, size_t message_len) {
-        this->log_(level, tag, message, message_len);
-      });
+      [this](int level, const char *tag, const char *message) { this->log_(level, tag, message); });
 }
 
-void Syslog::log_(const int level, const char *tag, const char *message, size_t message_len) const {
+void Syslog::log_(const int level, const char *tag, const char *message) const {
   if (level > this->log_level_)
     return;
   // Syslog PRI calculation: facility * 8 + severity
@@ -36,7 +34,7 @@ void Syslog::log_(const int level, const char *tag, const char *message, size_t
   }
   int pri = this->facility_ * 8 + severity;
   auto timestamp = this->time_->now().strftime("%b %d %H:%M:%S");
-  size_t len = message_len;
+  unsigned len = strlen(message);
   // remove color formatting
   if (this->strip_ && message[0] == 0x1B && len > 11) {
     message += 7;