diff --git a/CODEOWNERS b/CODEOWNERS
index c3d8f4350f..d6ec7b882e 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -72,6 +72,7 @@ esphome/components/bl0942/* @dbuezas @dwmw2
 esphome/components/ble_client/* @buxtronix @clydebarrow
 esphome/components/ble_nus/* @tomaszduda23
 esphome/components/bluetooth_proxy/* @bdraco @jesserockz
+esphome/components/bm8563/* @abmantis
 esphome/components/bme280_base/* @esphome/core
 esphome/components/bme280_spi/* @apbodrov
 esphome/components/bme680_bsec/* @trvrnrth
diff --git a/esphome/components/alpha3/alpha3.cpp b/esphome/components/alpha3/alpha3.cpp
index 344f2d5a03..55fd196822 100644
--- a/esphome/components/alpha3/alpha3.cpp
+++ b/esphome/components/alpha3/alpha3.cpp
@@ -56,13 +56,13 @@ bool Alpha3::is_current_response_type_(const uint8_t *response_type) {
 
 void Alpha3::handle_geni_response_(const uint8_t *response, uint16_t length) {
   if (this->response_offset_ >= this->response_length_) {
-    ESP_LOGD(TAG, "[%s] GENI response begin", this->parent_->address_str().c_str());
+    ESP_LOGD(TAG, "[%s] GENI response begin", this->parent_->address_str());
     if (length < GENI_RESPONSE_HEADER_LENGTH) {
-      ESP_LOGW(TAG, "[%s] response to short", this->parent_->address_str().c_str());
+      ESP_LOGW(TAG, "[%s] response to short", this->parent_->address_str());
       return;
     }
     if (response[0] != 36 || response[2] != 248 || response[3] != 231 || response[4] != 10) {
-      ESP_LOGW(TAG, "[%s] response bytes %d %d %d %d %d don't match GENI HEADER", this->parent_->address_str().c_str(),
+      ESP_LOGW(TAG, "[%s] response bytes %d %d %d %d %d don't match GENI HEADER", this->parent_->address_str(),
                response[0], response[1], response[2], response[3], response[4]);
       return;
     }
@@ -77,11 +77,11 @@ void Alpha3::handle_geni_response_(const uint8_t *response, uint16_t length) {
   };
 
   if (this->is_current_response_type_(GENI_RESPONSE_TYPE_FLOW_HEAD)) {
-    ESP_LOGD(TAG, "[%s] FLOW HEAD Response", this->parent_->address_str().c_str());
+    ESP_LOGD(TAG, "[%s] FLOW HEAD Response", this->parent_->address_str());
     extract_publish_sensor_value(GENI_RESPONSE_FLOW_OFFSET, this->flow_sensor_, 3600.0F);
     extract_publish_sensor_value(GENI_RESPONSE_HEAD_OFFSET, this->head_sensor_, .0001F);
   } else if (this->is_current_response_type_(GENI_RESPONSE_TYPE_POWER)) {
-    ESP_LOGD(TAG, "[%s] POWER Response", this->parent_->address_str().c_str());
+    ESP_LOGD(TAG, "[%s] POWER Response", this->parent_->address_str());
     extract_publish_sensor_value(GENI_RESPONSE_POWER_OFFSET, this->power_sensor_, 1.0F);
     extract_publish_sensor_value(GENI_RESPONSE_CURRENT_OFFSET, this->current_sensor_, 1.0F);
     extract_publish_sensor_value(GENI_RESPONSE_MOTOR_SPEED_OFFSET, this->speed_sensor_, 1.0F);
@@ -100,7 +100,7 @@ void Alpha3::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc
       if (param->open.status == ESP_GATT_OK) {
         this->response_offset_ = 0;
         this->response_length_ = 0;
-        ESP_LOGI(TAG, "[%s] connection open", this->parent_->address_str().c_str());
+        ESP_LOGI(TAG, "[%s] connection open", this->parent_->address_str());
       }
       break;
     }
@@ -132,7 +132,7 @@ void Alpha3::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto *chr = this->parent_->get_characteristic(ALPHA3_GENI_SERVICE_UUID, ALPHA3_GENI_CHARACTERISTIC_UUID);
       if (chr == nullptr) {
-        ESP_LOGE(TAG, "[%s] No GENI service found at device, not an Alpha3..?", this->parent_->address_str().c_str());
+        ESP_LOGE(TAG, "[%s] No GENI service found at device, not an Alpha3..?", this->parent_->address_str());
         break;
       }
       auto status = esp_ble_gattc_register_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
@@ -164,12 +164,12 @@ void Alpha3::send_request_(uint8_t *request, size_t len) {
       esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->geni_handle_, len,
                                request, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
   if (status)
-    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
 }
 
 void Alpha3::update() {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
-    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str());
     return;
   }
 
diff --git a/esphome/components/am43/sensor/am43_sensor.cpp b/esphome/components/am43/sensor/am43_sensor.cpp
index 4cc99001ae..b2bc3254e2 100644
--- a/esphome/components/am43/sensor/am43_sensor.cpp
+++ b/esphome/components/am43/sensor/am43_sensor.cpp
@@ -44,11 +44,9 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
       auto *chr = this->parent_->get_characteristic(AM43_SERVICE_UUID, AM43_CHARACTERISTIC_UUID);
       if (chr == nullptr) {
         if (this->parent_->get_characteristic(AM43_TUYA_SERVICE_UUID, AM43_TUYA_CHARACTERISTIC_UUID) != nullptr) {
-          ESP_LOGE(TAG, "[%s] Detected a Tuya AM43 which is not supported, sorry.",
-                   this->parent_->address_str().c_str());
+          ESP_LOGE(TAG, "[%s] Detected a Tuya AM43 which is not supported, sorry.", this->parent_->address_str());
         } else {
-          ESP_LOGE(TAG, "[%s] No control service found at device, not an AM43..?",
-                   this->parent_->address_str().c_str());
+          ESP_LOGE(TAG, "[%s] No control service found at device, not an AM43..?", this->parent_->address_str());
         }
         break;
       }
@@ -82,8 +80,7 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
                                                  this->char_handle_, packet->length, packet->data,
                                                  ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
           if (status) {
-            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
-                     status);
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
           }
         }
         this->current_sensor_ = 0;
@@ -97,7 +94,7 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
 
 void Am43::update() {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
-    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str());
     return;
   }
   if (this->current_sensor_ == 0) {
@@ -107,7 +104,7 @@ void Am43::update() {
           esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                    packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
       if (status) {
-        ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+        ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
       }
     }
     this->current_sensor_++;
diff --git a/esphome/components/anova/anova.cpp b/esphome/components/anova/anova.cpp
index d0e8f6827f..2693224a97 100644
--- a/esphome/components/anova/anova.cpp
+++ b/esphome/components/anova/anova.cpp
@@ -42,7 +42,7 @@ void Anova::control(const ClimateCall &call) {
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     if (status) {
-      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
     }
   }
   if (call.get_target_temperature().has_value()) {
@@ -51,7 +51,7 @@ void Anova::control(const ClimateCall &call) {
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     if (status) {
-      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
     }
   }
 }
@@ -124,8 +124,7 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
               esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                        pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
           if (status) {
-            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
-                     status);
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
           }
         }
       }
@@ -150,7 +149,7 @@ void Anova::update() {
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     if (status) {
-      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
     }
     this->current_request_++;
   }
diff --git a/esphome/components/api/__init__.py b/esphome/components/api/__init__.py
index a9286c531f..7f84f2f247 100644
--- a/esphome/components/api/__init__.py
+++ b/esphome/components/api/__init__.py
@@ -260,9 +260,9 @@ async def to_code(config):
         cg.add(var.set_max_connections(config[CONF_MAX_CONNECTIONS]))
     cg.add_define("API_MAX_SEND_QUEUE", config[CONF_MAX_SEND_QUEUE])
 
-    # Set USE_API_SERVICES if any services are enabled
+    # Set USE_API_USER_DEFINED_ACTIONS if any services are enabled
     if config.get(CONF_ACTIONS) or config[CONF_CUSTOM_SERVICES]:
-        cg.add_define("USE_API_SERVICES")
+        cg.add_define("USE_API_USER_DEFINED_ACTIONS")
 
     # Set USE_API_CUSTOM_SERVICES if external components need dynamic service registration
     if config[CONF_CUSTOM_SERVICES]:
diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index e115e4630d..26d1fa6876 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -855,21 +855,21 @@ enum ServiceArgType {
   SERVICE_ARG_TYPE_STRING_ARRAY = 7;
 }
 message ListEntitiesServicesArgument {
-  option (ifdef) = "USE_API_SERVICES";
+  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";
   string name = 1;
   ServiceArgType type = 2;
 }
 message ListEntitiesServicesResponse {
   option (id) = 41;
   option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_API_SERVICES";
+  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";
 
   string name = 1;
   fixed32 key = 2;
   repeated ListEntitiesServicesArgument args = 3 [(fixed_vector) = true];
 }
 message ExecuteServiceArgument {
-  option (ifdef) = "USE_API_SERVICES";
+  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";
   bool bool_ = 1;
   int32 legacy_int = 2;
   float float_ = 3;
@@ -885,7 +885,7 @@ message ExecuteServiceRequest {
   option (id) = 42;
   option (source) = SOURCE_CLIENT;
   option (no_delay) = true;
-  option (ifdef) = "USE_API_SERVICES";
+  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";
 
   fixed32 key = 1;
   repeated ExecuteServiceArgument args = 2 [(fixed_vector) = true];
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 4923d65431..e0a4c3b6b5 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -1550,7 +1550,7 @@ void APIConnection::on_home_assistant_state_response(const HomeAssistantStateRes
   }
 }
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
   bool found = false;
   for (auto *service : this->parent_->get_user_services()) {
diff --git a/esphome/components/api/api_connection.h b/esphome/components/api/api_connection.h
index 6cfd108927..af3a19909f 100644
--- a/esphome/components/api/api_connection.h
+++ b/esphome/components/api/api_connection.h
@@ -221,7 +221,7 @@ class APIConnection final : public APIServerConnection {
 #ifdef USE_API_HOMEASSISTANT_STATES
   void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) override;
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   void execute_service(const ExecuteServiceRequest &msg) override;
 #endif
 #ifdef USE_API_NOISE
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index 0a073fb662..d52135a566 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -995,7 +995,7 @@ bool GetTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
   }
   return true;
 }
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 void ListEntitiesServicesArgument::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->name_ref_);
   buffer.encode_uint32(2, static_cast<uint32_t>(this->type));
diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index 358049026e..b19e92d4ff 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -63,7 +63,7 @@ enum LogLevel : uint32_t {
   LOG_LEVEL_VERBOSE = 6,
   LOG_LEVEL_VERY_VERBOSE = 7,
 };
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 enum ServiceArgType : uint32_t {
   SERVICE_ARG_TYPE_BOOL = 0,
   SERVICE_ARG_TYPE_INT = 1,
@@ -1239,7 +1239,7 @@ class GetTimeResponse final : public ProtoDecodableMessage {
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
 };
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 class ListEntitiesServicesArgument final : public ProtoMessage {
  public:
   StringRef name_ref_{};
diff --git a/esphome/components/api/api_pb2_dump.cpp b/esphome/components/api/api_pb2_dump.cpp
index 127ef44cd8..ea752ba3ba 100644
--- a/esphome/components/api/api_pb2_dump.cpp
+++ b/esphome/components/api/api_pb2_dump.cpp
@@ -206,7 +206,7 @@ template<> const char *proto_enum_to_string<enums::LogLevel>(enums::LogLevel val
       return "UNKNOWN";
   }
 }
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 template<> const char *proto_enum_to_string<enums::ServiceArgType>(enums::ServiceArgType value) {
   switch (value) {
     case enums::SERVICE_ARG_TYPE_BOOL:
@@ -1177,7 +1177,7 @@ void GetTimeResponse::dump_to(std::string &out) const {
   out.append(format_hex_pretty(this->timezone, this->timezone_len));
   out.append("\n");
 }
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 void ListEntitiesServicesArgument::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "ListEntitiesServicesArgument");
   dump_field(out, "name", this->name_ref_);
diff --git a/esphome/components/api/api_pb2_service.cpp b/esphome/components/api/api_pb2_service.cpp
index 9d227af0a3..3d28a137c8 100644
--- a/esphome/components/api/api_pb2_service.cpp
+++ b/esphome/components/api/api_pb2_service.cpp
@@ -193,7 +193,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       break;
     }
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
     case ExecuteServiceRequest::MESSAGE_TYPE: {
       ExecuteServiceRequest msg;
       msg.decode(msg_data, msg_size);
@@ -670,7 +670,7 @@ void APIServerConnection::on_subscribe_home_assistant_states_request(const Subsc
   this->subscribe_home_assistant_states(msg);
 }
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 void APIServerConnection::on_execute_service_request(const ExecuteServiceRequest &msg) { this->execute_service(msg); }
 #endif
 #ifdef USE_API_NOISE
diff --git a/esphome/components/api/api_pb2_service.h b/esphome/components/api/api_pb2_service.h
index 549b00ee6a..827b89e23c 100644
--- a/esphome/components/api/api_pb2_service.h
+++ b/esphome/components/api/api_pb2_service.h
@@ -79,7 +79,7 @@ class APIServerConnectionBase : public ProtoService {
 
   virtual void on_get_time_response(const GetTimeResponse &value){};
 
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   virtual void on_execute_service_request(const ExecuteServiceRequest &value){};
 #endif
 
@@ -239,7 +239,7 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_API_HOMEASSISTANT_STATES
   virtual void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) = 0;
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   virtual void execute_service(const ExecuteServiceRequest &msg) = 0;
 #endif
 #ifdef USE_API_NOISE
@@ -368,7 +368,7 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_API_HOMEASSISTANT_STATES
   void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &msg) override;
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   void on_execute_service_request(const ExecuteServiceRequest &msg) override;
 #endif
 #ifdef USE_API_NOISE
diff --git a/esphome/components/api/api_server.h b/esphome/components/api/api_server.h
index 22af162980..12233399b2 100644
--- a/esphome/components/api/api_server.h
+++ b/esphome/components/api/api_server.h
@@ -12,7 +12,7 @@
 #include "esphome/core/log.h"
 #include "list_entities.h"
 #include "subscribe_state.h"
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 #include "user_services.h"
 #endif
 
@@ -124,7 +124,7 @@ class APIServer : public Component, public Controller {
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #endif  // USE_API_HOMEASSISTANT_SERVICES
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   void initialize_user_services(std::initializer_list<UserServiceDescriptor *> services) {
     this->user_services_.assign(services);
   }
@@ -177,7 +177,7 @@ class APIServer : public Component, public Controller {
 
   const std::vector<HomeAssistantStateSubscription> &get_state_subs() const;
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   const std::vector<UserServiceDescriptor *> &get_user_services() const { return this->user_services_; }
 #endif
 
@@ -224,7 +224,7 @@ class APIServer : public Component, public Controller {
 #ifdef USE_API_HOMEASSISTANT_STATES
   std::vector<HomeAssistantStateSubscription> state_subs_;
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   std::vector<UserServiceDescriptor *> user_services_;
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
diff --git a/esphome/components/api/custom_api_device.h b/esphome/components/api/custom_api_device.h
index 43ea644f0c..1006d07533 100644
--- a/esphome/components/api/custom_api_device.h
+++ b/esphome/components/api/custom_api_device.h
@@ -3,12 +3,12 @@
 #include <map>
 #include "api_server.h"
 #ifdef USE_API
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 #include "user_services.h"
 #endif
 namespace esphome::api {
 
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 template<typename T, typename... Ts> class CustomAPIDeviceService : public UserServiceDynamic<Ts...> {
  public:
   CustomAPIDeviceService(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names, T *obj,
@@ -21,7 +21,7 @@ template<typename T, typename... Ts> class CustomAPIDeviceService : public UserS
   T *obj_;
   void (T::*callback_)(Ts...);
 };
-#endif  // USE_API_SERVICES
+#endif  // USE_API_USER_DEFINED_ACTIONS
 
 class CustomAPIDevice {
  public:
@@ -49,7 +49,7 @@ class CustomAPIDevice {
    * @param name The name of the service to register.
    * @param arg_names The name of the arguments for the service, must match the arguments of the function.
    */
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   template<typename T, typename... Ts>
   void register_service(void (T::*callback)(Ts...), const std::string &name,
                         const std::array<std::string, sizeof...(Ts)> &arg_names) {
@@ -90,7 +90,7 @@ class CustomAPIDevice {
    * @param callback The member function to call when the service is triggered.
    * @param name The name of the arguments for the service, must match the arguments of the function.
    */
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   template<typename T> void register_service(void (T::*callback)(), const std::string &name) {
 #ifdef USE_API_CUSTOM_SERVICES
     auto *service = new CustomAPIDeviceService<T>(name, {}, (T *) this, callback);  // NOLINT
diff --git a/esphome/components/api/list_entities.cpp b/esphome/components/api/list_entities.cpp
index da4800a45e..e18fc17801 100644
--- a/esphome/components/api/list_entities.cpp
+++ b/esphome/components/api/list_entities.cpp
@@ -82,7 +82,7 @@ bool ListEntitiesIterator::on_end() { return this->client_->send_list_info_done(
 
 ListEntitiesIterator::ListEntitiesIterator(APIConnection *client) : client_(client) {}
 
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
   auto resp = service->encode_list_service_response();
   return this->client_->send_message(resp, ListEntitiesServicesResponse::MESSAGE_TYPE);
diff --git a/esphome/components/api/list_entities.h b/esphome/components/api/list_entities.h
index 769d7b9b6e..4c90dbbad8 100644
--- a/esphome/components/api/list_entities.h
+++ b/esphome/components/api/list_entities.h
@@ -43,7 +43,7 @@ class ListEntitiesIterator : public ComponentIterator {
 #ifdef USE_TEXT_SENSOR
   bool on_text_sensor(text_sensor::TextSensor *entity) override;
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   bool on_service(UserServiceDescriptor *service) override;
 #endif
 #ifdef USE_CAMERA
diff --git a/esphome/components/api/user_services.h b/esphome/components/api/user_services.h
index 2f753dfc6c..d9c13c520b 100644
--- a/esphome/components/api/user_services.h
+++ b/esphome/components/api/user_services.h
@@ -7,7 +7,7 @@
 #include "esphome/core/automation.h"
 #include "api_pb2.h"
 
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 namespace esphome::api {
 
 class UserServiceDescriptor {
@@ -124,4 +124,4 @@ template<typename... Ts> class UserServiceTrigger : public UserServiceBase<Ts...
 };
 
 }  // namespace esphome::api
-#endif  // USE_API_SERVICES
+#endif  // USE_API_USER_DEFINED_ACTIONS
diff --git a/esphome/components/ble_client/automation.h b/esphome/components/ble_client/automation.h
index bbc2dd05e0..788eac4a57 100644
--- a/esphome/components/ble_client/automation.h
+++ b/esphome/components/ble_client/automation.h
@@ -198,7 +198,7 @@ template<typename... Ts> class BLEClientWriteAction : public Action<Ts...>, publ
         }
         this->node_state = espbt::ClientState::ESTABLISHED;
         esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_string().c_str(),
-                   ble_client_->address_str().c_str());
+                   ble_client_->address_str());
         break;
       }
       default:
diff --git a/esphome/components/ble_client/ble_client.cpp b/esphome/components/ble_client/ble_client.cpp
index 5cf096c9d4..b8968fe4ba 100644
--- a/esphome/components/ble_client/ble_client.cpp
+++ b/esphome/components/ble_client/ble_client.cpp
@@ -39,7 +39,7 @@ void BLEClient::set_enabled(bool enabled) {
     return;
   this->enabled = enabled;
   if (!enabled) {
-    ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str().c_str());
+    ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str());
     this->disconnect();
   }
 }
diff --git a/esphome/components/ble_client/output/ble_binary_output.cpp b/esphome/components/ble_client/output/ble_binary_output.cpp
index ce67193be7..84558717f8 100644
--- a/esphome/components/ble_client/output/ble_binary_output.cpp
+++ b/esphome/components/ble_client/output/ble_binary_output.cpp
@@ -14,7 +14,7 @@ void BLEBinaryOutput::dump_config() {
                 "  MAC address        : %s\n"
                 "  Service UUID       : %s\n"
                 "  Characteristic UUID: %s",
-                this->parent_->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->parent_->address_str(), this->service_uuid_.to_string().c_str(),
                 this->char_uuid_.to_string().c_str());
   LOG_BINARY_OUTPUT(this);
 }
@@ -44,7 +44,7 @@ void BLEBinaryOutput::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
       }
       this->node_state = espbt::ClientState::ESTABLISHED;
       ESP_LOGD(TAG, "Found characteristic %s on device %s", this->char_uuid_.to_string().c_str(),
-               this->parent()->address_str().c_str());
+               this->parent()->address_str());
       this->node_state = espbt::ClientState::ESTABLISHED;
       break;
     }
diff --git a/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp b/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
index 663c52ac10..4edcbd3877 100644
--- a/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
+++ b/esphome/components/ble_client/sensor/ble_rssi_sensor.cpp
@@ -19,7 +19,7 @@ void BLEClientRSSISensor::loop() {
 
 void BLEClientRSSISensor::dump_config() {
   LOG_SENSOR("", "BLE Client RSSI Sensor", this);
-  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str());
   LOG_UPDATE_INTERVAL(this);
 }
 
@@ -69,10 +69,10 @@ void BLEClientRSSISensor::update() {
   this->get_rssi_();
 }
 void BLEClientRSSISensor::get_rssi_() {
-  ESP_LOGV(TAG, "requesting rssi from %s", this->parent()->address_str().c_str());
+  ESP_LOGV(TAG, "requesting rssi from %s", this->parent()->address_str());
   auto status = esp_ble_gap_read_rssi(this->parent()->get_remote_bda());
   if (status != ESP_OK) {
-    ESP_LOGW(TAG, "esp_ble_gap_read_rssi error, address=%s, status=%d", this->parent()->address_str().c_str(), status);
+    ESP_LOGW(TAG, "esp_ble_gap_read_rssi error, address=%s, status=%d", this->parent()->address_str(), status);
     this->status_set_warning();
     this->publish_state(NAN);
   }
diff --git a/esphome/components/ble_client/sensor/ble_sensor.cpp b/esphome/components/ble_client/sensor/ble_sensor.cpp
index 61685c0566..8e3e483003 100644
--- a/esphome/components/ble_client/sensor/ble_sensor.cpp
+++ b/esphome/components/ble_client/sensor/ble_sensor.cpp
@@ -25,7 +25,7 @@ void BLESensor::dump_config() {
                 "  Characteristic UUID: %s\n"
                 "  Descriptor UUID    : %s\n"
                 "  Notifications      : %s",
-                this->parent()->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->parent()->address_str(), this->service_uuid_.to_string().c_str(),
                 this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
diff --git a/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp b/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
index b7a6d154db..bb771aed99 100644
--- a/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
+++ b/esphome/components/ble_client/text_sensor/ble_text_sensor.cpp
@@ -28,7 +28,7 @@ void BLETextSensor::dump_config() {
                 "  Characteristic UUID: %s\n"
                 "  Descriptor UUID    : %s\n"
                 "  Notifications      : %s",
-                this->parent()->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->parent()->address_str(), this->service_uuid_.to_string().c_str(),
                 this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
diff --git a/esphome/components/bluetooth_proxy/bluetooth_connection.cpp b/esphome/components/bluetooth_proxy/bluetooth_connection.cpp
index fcc344dda9..1d6f7e23b3 100644
--- a/esphome/components/bluetooth_proxy/bluetooth_connection.cpp
+++ b/esphome/components/bluetooth_proxy/bluetooth_connection.cpp
@@ -196,8 +196,8 @@ void BluetoothConnection::send_service_for_discovery_() {
 
     if (service_status != ESP_GATT_OK || service_count == 0) {
       ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service %s, status=%d, service_count=%d, offset=%d",
-               this->connection_index_, this->address_str().c_str(),
-               service_status != ESP_GATT_OK ? "error" : "missing", service_status, service_count, this->send_service_);
+               this->connection_index_, this->address_str(), service_status != ESP_GATT_OK ? "error" : "missing",
+               service_status, service_count, this->send_service_);
       this->send_service_ = DONE_SENDING_SERVICES;
       return;
     }
@@ -312,13 +312,13 @@ void BluetoothConnection::send_service_for_discovery_() {
       if (resp.services.size() > 1) {
         resp.services.pop_back();
         ESP_LOGD(TAG, "[%d] [%s] Service %d would exceed limit (current: %d + service: %d > %d), sending current batch",
-                 this->connection_index_, this->address_str().c_str(), this->send_service_, current_size, service_size,
+                 this->connection_index_, this->address_str(), this->send_service_, current_size, service_size,
                  MAX_PACKET_SIZE);
         // Don't increment send_service_ - we'll retry this service in next batch
       } else {
         // This single service is too large, but we have to send it anyway
         ESP_LOGV(TAG, "[%d] [%s] Service %d is too large (%d bytes) but sending anyway", this->connection_index_,
-                 this->address_str().c_str(), this->send_service_, service_size);
+                 this->address_str(), this->send_service_, service_size);
         // Increment so we don't get stuck
         this->send_service_++;
       }
@@ -337,21 +337,20 @@ void BluetoothConnection::send_service_for_discovery_() {
 }
 
 void BluetoothConnection::log_connection_error_(const char *operation, esp_gatt_status_t status) {
-  ESP_LOGE(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str().c_str(), operation,
-           status);
+  ESP_LOGE(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str(), operation, status);
 }
 
 void BluetoothConnection::log_connection_warning_(const char *operation, esp_err_t err) {
-  ESP_LOGW(TAG, "[%d] [%s] %s failed, err=%d", this->connection_index_, this->address_str().c_str(), operation, err);
+  ESP_LOGW(TAG, "[%d] [%s] %s failed, err=%d", this->connection_index_, this->address_str(), operation, err);
 }
 
 void BluetoothConnection::log_gatt_not_connected_(const char *action, const char *type) {
-  ESP_LOGW(TAG, "[%d] [%s] Cannot %s GATT %s, not connected.", this->connection_index_, this->address_str().c_str(),
-           action, type);
+  ESP_LOGW(TAG, "[%d] [%s] Cannot %s GATT %s, not connected.", this->connection_index_, this->address_str(), action,
+           type);
 }
 
 void BluetoothConnection::log_gatt_operation_error_(const char *operation, uint16_t handle, esp_gatt_status_t status) {
-  ESP_LOGW(TAG, "[%d] [%s] Error %s for handle 0x%2X, status=%d", this->connection_index_, this->address_str().c_str(),
+  ESP_LOGW(TAG, "[%d] [%s] Error %s for handle 0x%2X, status=%d", this->connection_index_, this->address_str(),
            operation, handle, status);
 }
 
@@ -372,14 +371,14 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
     case ESP_GATTC_DISCONNECT_EVT: {
       // Don't reset connection yet - wait for CLOSE_EVT to ensure controller has freed resources
       // This prevents race condition where we mark slot as free before controller cleanup is complete
-      ESP_LOGD(TAG, "[%d] [%s] Disconnect, reason=0x%02x", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGD(TAG, "[%d] [%s] Disconnect, reason=0x%02x", this->connection_index_, this->address_str_,
                param->disconnect.reason);
       // Send disconnection notification but don't free the slot yet
       this->proxy_->send_device_connection(this->address_, false, 0, param->disconnect.reason);
       break;
     }
     case ESP_GATTC_CLOSE_EVT: {
-      ESP_LOGD(TAG, "[%d] [%s] Close, reason=0x%02x, freeing slot", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGD(TAG, "[%d] [%s] Close, reason=0x%02x, freeing slot", this->connection_index_, this->address_str_,
                param->close.reason);
       // Now the GATT connection is fully closed and controller resources are freed
       // Safe to mark the connection slot as available
@@ -463,7 +462,7 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       break;
     }
     case ESP_GATTC_NOTIFY_EVT: {
-      ESP_LOGV(TAG, "[%d] [%s] ESP_GATTC_NOTIFY_EVT: handle=0x%2X", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGV(TAG, "[%d] [%s] ESP_GATTC_NOTIFY_EVT: handle=0x%2X", this->connection_index_, this->address_str_,
                param->notify.handle);
       api::BluetoothGATTNotifyDataResponse resp;
       resp.address = this->address_;
@@ -502,8 +501,7 @@ esp_err_t BluetoothConnection::read_characteristic(uint16_t handle) {
     return ESP_GATT_NOT_CONNECTED;
   }
 
-  ESP_LOGV(TAG, "[%d] [%s] Reading GATT characteristic handle %d", this->connection_index_, this->address_str_.c_str(),
-           handle);
+  ESP_LOGV(TAG, "[%d] [%s] Reading GATT characteristic handle %d", this->connection_index_, this->address_str_, handle);
 
   esp_err_t err = esp_ble_gattc_read_char(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE);
   return this->check_and_log_error_("esp_ble_gattc_read_char", err);
@@ -515,8 +513,7 @@ esp_err_t BluetoothConnection::write_characteristic(uint16_t handle, const uint8
     this->log_gatt_not_connected_("write", "characteristic");
     return ESP_GATT_NOT_CONNECTED;
   }
-  ESP_LOGV(TAG, "[%d] [%s] Writing GATT characteristic handle %d", this->connection_index_, this->address_str_.c_str(),
-           handle);
+  ESP_LOGV(TAG, "[%d] [%s] Writing GATT characteristic handle %d", this->connection_index_, this->address_str_, handle);
 
   // ESP-IDF's API requires a non-const uint8_t* but it doesn't modify the data
   // The BTC layer immediately copies the data to its own buffer (see btc_gattc.c)
@@ -532,8 +529,7 @@ esp_err_t BluetoothConnection::read_descriptor(uint16_t handle) {
     this->log_gatt_not_connected_("read", "descriptor");
     return ESP_GATT_NOT_CONNECTED;
   }
-  ESP_LOGV(TAG, "[%d] [%s] Reading GATT descriptor handle %d", this->connection_index_, this->address_str_.c_str(),
-           handle);
+  ESP_LOGV(TAG, "[%d] [%s] Reading GATT descriptor handle %d", this->connection_index_, this->address_str_, handle);
 
   esp_err_t err = esp_ble_gattc_read_char_descr(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE);
   return this->check_and_log_error_("esp_ble_gattc_read_char_descr", err);
@@ -544,8 +540,7 @@ esp_err_t BluetoothConnection::write_descriptor(uint16_t handle, const uint8_t *
     this->log_gatt_not_connected_("write", "descriptor");
     return ESP_GATT_NOT_CONNECTED;
   }
-  ESP_LOGV(TAG, "[%d] [%s] Writing GATT descriptor handle %d", this->connection_index_, this->address_str_.c_str(),
-           handle);
+  ESP_LOGV(TAG, "[%d] [%s] Writing GATT descriptor handle %d", this->connection_index_, this->address_str_, handle);
 
   // ESP-IDF's API requires a non-const uint8_t* but it doesn't modify the data
   // The BTC layer immediately copies the data to its own buffer (see btc_gattc.c)
@@ -564,13 +559,13 @@ esp_err_t BluetoothConnection::notify_characteristic(uint16_t handle, bool enabl
 
   if (enable) {
     ESP_LOGV(TAG, "[%d] [%s] Registering for GATT characteristic notifications handle %d", this->connection_index_,
-             this->address_str_.c_str(), handle);
+             this->address_str_, handle);
     esp_err_t err = esp_ble_gattc_register_for_notify(this->gattc_if_, this->remote_bda_, handle);
     return this->check_and_log_error_("esp_ble_gattc_register_for_notify", err);
   }
 
   ESP_LOGV(TAG, "[%d] [%s] Unregistering for GATT characteristic notifications handle %d", this->connection_index_,
-           this->address_str_.c_str(), handle);
+           this->address_str_, handle);
   esp_err_t err = esp_ble_gattc_unregister_for_notify(this->gattc_if_, this->remote_bda_, handle);
   return this->check_and_log_error_("esp_ble_gattc_unregister_for_notify", err);
 }
diff --git a/esphome/components/bluetooth_proxy/bluetooth_proxy.cpp b/esphome/components/bluetooth_proxy/bluetooth_proxy.cpp
index 34e0aa93a3..71f8da75a7 100644
--- a/esphome/components/bluetooth_proxy/bluetooth_proxy.cpp
+++ b/esphome/components/bluetooth_proxy/bluetooth_proxy.cpp
@@ -47,12 +47,11 @@ void BluetoothProxy::send_bluetooth_scanner_state_(esp32_ble_tracker::ScannerSta
 
 void BluetoothProxy::log_connection_request_ignored_(BluetoothConnection *connection, espbt::ClientState state) {
   ESP_LOGW(TAG, "[%d] [%s] Connection request ignored, state: %s", connection->get_connection_index(),
-           connection->address_str().c_str(), espbt::client_state_to_string(state));
+           connection->address_str(), espbt::client_state_to_string(state));
 }
 
 void BluetoothProxy::log_connection_info_(BluetoothConnection *connection, const char *message) {
-  ESP_LOGI(TAG, "[%d] [%s] Connecting %s", connection->get_connection_index(), connection->address_str().c_str(),
-           message);
+  ESP_LOGI(TAG, "[%d] [%s] Connecting %s", connection->get_connection_index(), connection->address_str(), message);
 }
 
 void BluetoothProxy::log_not_connected_gatt_(const char *action, const char *type) {
@@ -186,7 +185,7 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
       }
       if (!msg.has_address_type) {
         ESP_LOGE(TAG, "[%d] [%s] Missing address type in connect request", connection->get_connection_index(),
-                 connection->address_str().c_str());
+                 connection->address_str());
         this->send_device_connection(msg.address, false);
         return;
       }
@@ -199,7 +198,7 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
       } else if (connection->state() == espbt::ClientState::CONNECTING) {
         if (connection->disconnect_pending()) {
           ESP_LOGW(TAG, "[%d] [%s] Connection request while pending disconnect, cancelling pending disconnect",
-                   connection->get_connection_index(), connection->address_str().c_str());
+                   connection->get_connection_index(), connection->address_str());
           connection->cancel_pending_disconnect();
           return;
         }
@@ -339,7 +338,7 @@ void BluetoothProxy::bluetooth_gatt_send_services(const api::BluetoothGATTGetSer
     return;
   }
   if (!connection->service_count_) {
-    ESP_LOGW(TAG, "[%d] [%s] No GATT services found", connection->connection_index_, connection->address_str().c_str());
+    ESP_LOGW(TAG, "[%d] [%s] No GATT services found", connection->connection_index_, connection->address_str());
     this->send_gatt_services_done(msg.address);
     return;
   }
diff --git a/esphome/components/bm8563/__init__.py b/esphome/components/bm8563/__init__.py
new file mode 100644
index 0000000000..20254a8b00
--- /dev/null
+++ b/esphome/components/bm8563/__init__.py
@@ -0,0 +1 @@
+CODEOWNERS = ["@abmantis"]
diff --git a/esphome/components/bm8563/bm8563.cpp b/esphome/components/bm8563/bm8563.cpp
new file mode 100644
index 0000000000..07831485c1
--- /dev/null
+++ b/esphome/components/bm8563/bm8563.cpp
@@ -0,0 +1,198 @@
+#include "bm8563.h"
+#include "esphome/core/log.h"
+
+namespace esphome::bm8563 {
+
+static const char *const TAG = "bm8563";
+
+static constexpr uint8_t CONTROL_STATUS_1_REG = 0x00;
+static constexpr uint8_t CONTROL_STATUS_2_REG = 0x01;
+static constexpr uint8_t TIME_FIRST_REG = 0x02;  // Time uses reg 2, 3, 4
+static constexpr uint8_t DATE_FIRST_REG = 0x05;  // Date uses reg 5, 6, 7, 8
+static constexpr uint8_t TIMER_CONTROL_REG = 0x0E;
+static constexpr uint8_t TIMER_VALUE_REG = 0x0F;
+static constexpr uint8_t CLOCK_1_HZ = 0x82;
+static constexpr uint8_t CLOCK_1_60_HZ = 0x83;
+// Maximum duration: 255 minutes (at 1/60 Hz) = 15300 seconds
+static constexpr uint32_t MAX_TIMER_DURATION_S = 255 * 60;
+
+void BM8563::setup() {
+  if (!this->write_byte_16(CONTROL_STATUS_1_REG, 0)) {
+    this->mark_failed();
+    return;
+  }
+}
+
+void BM8563::update() { this->read_time(); }
+
+void BM8563::dump_config() {
+  ESP_LOGCONFIG(TAG, "BM8563:");
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+  }
+}
+
+void BM8563::start_timer(uint32_t duration_s) {
+  this->clear_irq_();
+  this->set_timer_irq_(duration_s);
+}
+
+void BM8563::write_time() {
+  auto now = time::RealTimeClock::utcnow();
+  if (!now.is_valid()) {
+    ESP_LOGE(TAG, "Invalid system time, not syncing to RTC.");
+    return;
+  }
+
+  ESP_LOGD(TAG, "Writing time: %i-%i-%i %i, %i:%i:%i", now.year, now.month, now.day_of_month, now.day_of_week, now.hour,
+           now.minute, now.second);
+
+  this->set_time_(now);
+  this->set_date_(now);
+}
+
+void BM8563::read_time() {
+  ESPTime rtc_time;
+  this->get_time_(rtc_time);
+  this->get_date_(rtc_time);
+  rtc_time.day_of_year = 1;  // unused by recalc_timestamp_utc, but needs to be valid
+  ESP_LOGD(TAG, "Read time: %i-%i-%i %i, %i:%i:%i", rtc_time.year, rtc_time.month, rtc_time.day_of_month,
+           rtc_time.day_of_week, rtc_time.hour, rtc_time.minute, rtc_time.second);
+
+  rtc_time.recalc_timestamp_utc(false);
+  if (!rtc_time.is_valid()) {
+    ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
+    return;
+  }
+  time::RealTimeClock::synchronize_epoch_(rtc_time.timestamp);
+}
+
+uint8_t BM8563::bcd2_to_byte_(uint8_t value) {
+  const uint8_t tmp = ((value & 0xF0) >> 0x4) * 10;
+  return tmp + (value & 0x0F);
+}
+
+uint8_t BM8563::byte_to_bcd2_(uint8_t value) {
+  const uint8_t bcdhigh = value / 10;
+  value -= bcdhigh * 10;
+  return (bcdhigh << 4) | value;
+}
+
+void BM8563::get_time_(ESPTime &time) {
+  uint8_t buf[3] = {0};
+  this->read_register(TIME_FIRST_REG, buf, 3);
+
+  time.second = this->bcd2_to_byte_(buf[0] & 0x7f);
+  time.minute = this->bcd2_to_byte_(buf[1] & 0x7f);
+  time.hour = this->bcd2_to_byte_(buf[2] & 0x3f);
+}
+
+void BM8563::set_time_(const ESPTime &time) {
+  uint8_t buf[3] = {this->byte_to_bcd2_(time.second), this->byte_to_bcd2_(time.minute), this->byte_to_bcd2_(time.hour)};
+  this->write_register_(TIME_FIRST_REG, buf, 3);
+}
+
+void BM8563::get_date_(ESPTime &time) {
+  uint8_t buf[4] = {0};
+  this->read_register(DATE_FIRST_REG, buf, sizeof(buf));
+
+  time.day_of_month = this->bcd2_to_byte_(buf[0] & 0x3f);
+  time.day_of_week = this->bcd2_to_byte_(buf[1] & 0x07);
+  time.month = this->bcd2_to_byte_(buf[2] & 0x1f);
+
+  uint8_t year_byte = this->bcd2_to_byte_(buf[3] & 0xff);
+
+  if (buf[2] & 0x80) {
+    time.year = 1900 + year_byte;
+  } else {
+    time.year = 2000 + year_byte;
+  }
+}
+
+void BM8563::set_date_(const ESPTime &time) {
+  uint8_t buf[4] = {
+      this->byte_to_bcd2_(time.day_of_month),
+      this->byte_to_bcd2_(time.day_of_week),
+      this->byte_to_bcd2_(time.month),
+      this->byte_to_bcd2_(time.year % 100),
+  };
+
+  if (time.year < 2000) {
+    buf[2] = buf[2] | 0x80;
+  }
+
+  this->write_register_(DATE_FIRST_REG, buf, 4);
+}
+
+void BM8563::write_byte_(uint8_t reg, uint8_t value) {
+  if (!this->write_byte(reg, value)) {
+    ESP_LOGE(TAG, "Failed to write byte 0x%02X with value 0x%02X", reg, value);
+  }
+}
+
+void BM8563::write_register_(uint8_t reg, const uint8_t *data, size_t len) {
+  if (auto error = this->write_register(reg, data, len); error != i2c::ErrorCode::NO_ERROR) {
+    ESP_LOGE(TAG, "Failed to write register 0x%02X with %zu bytes", reg, len);
+  }
+}
+
+optional<uint8_t> BM8563::read_register_(uint8_t reg) {
+  uint8_t data;
+  if (auto error = this->read_register(reg, &data, 1); error != i2c::ErrorCode::NO_ERROR) {
+    ESP_LOGE(TAG, "Failed to read register 0x%02X", reg);
+    return {};
+  }
+  return data;
+}
+
+void BM8563::set_timer_irq_(uint32_t duration_s) {
+  ESP_LOGI(TAG, "Timer Duration: %u s", duration_s);
+
+  if (duration_s > MAX_TIMER_DURATION_S) {
+    ESP_LOGW(TAG, "Timer duration %u s exceeds maximum %u s", duration_s, MAX_TIMER_DURATION_S);
+    return;
+  }
+
+  if (duration_s > 255) {
+    uint8_t duration_minutes = duration_s / 60;
+    this->write_byte_(TIMER_VALUE_REG, duration_minutes);
+    this->write_byte_(TIMER_CONTROL_REG, CLOCK_1_60_HZ);
+  } else {
+    this->write_byte_(TIMER_VALUE_REG, duration_s);
+    this->write_byte_(TIMER_CONTROL_REG, CLOCK_1_HZ);
+  }
+
+  auto maybe_ctrl_status_2 = this->read_register_(CONTROL_STATUS_2_REG);
+  if (!maybe_ctrl_status_2.has_value()) {
+    ESP_LOGE(TAG, "Failed to read CONTROL_STATUS_2_REG");
+    return;
+  }
+  uint8_t ctrl_status_2_reg_value = maybe_ctrl_status_2.value();
+  ctrl_status_2_reg_value |= (1 << 0);
+  ctrl_status_2_reg_value &= ~(1 << 7);
+  this->write_byte_(CONTROL_STATUS_2_REG, ctrl_status_2_reg_value);
+}
+
+void BM8563::clear_irq_() {
+  auto maybe_data = this->read_register_(CONTROL_STATUS_2_REG);
+  if (!maybe_data.has_value()) {
+    ESP_LOGE(TAG, "Failed to read CONTROL_STATUS_2_REG");
+    return;
+  }
+  uint8_t data = maybe_data.value();
+  this->write_byte_(CONTROL_STATUS_2_REG, data & 0xf3);
+}
+
+void BM8563::disable_irq_() {
+  this->clear_irq_();
+  auto maybe_data = this->read_register_(CONTROL_STATUS_2_REG);
+  if (!maybe_data.has_value()) {
+    ESP_LOGE(TAG, "Failed to read CONTROL_STATUS_2_REG");
+    return;
+  }
+  uint8_t data = maybe_data.value();
+  this->write_byte_(CONTROL_STATUS_2_REG, data & 0xfc);
+}
+
+}  // namespace esphome::bm8563
diff --git a/esphome/components/bm8563/bm8563.h b/esphome/components/bm8563/bm8563.h
new file mode 100644
index 0000000000..eda2d1b3c0
--- /dev/null
+++ b/esphome/components/bm8563/bm8563.h
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/time/real_time_clock.h"
+
+namespace esphome::bm8563 {
+
+class BM8563 : public time::RealTimeClock, public i2c::I2CDevice {
+ public:
+  void setup() override;
+  void update() override;
+  void dump_config() override;
+
+  void write_time();
+  void read_time();
+  void start_timer(uint32_t duration_s);
+
+ private:
+  void get_time_(ESPTime &time);
+  void get_date_(ESPTime &time);
+
+  void set_time_(const ESPTime &time);
+  void set_date_(const ESPTime &time);
+
+  void set_timer_irq_(uint32_t duration_s);
+  void clear_irq_();
+  void disable_irq_();
+
+  void write_byte_(uint8_t reg, uint8_t value);
+  void write_register_(uint8_t reg, const uint8_t *data, size_t len);
+  optional<uint8_t> read_register_(uint8_t reg);
+
+  uint8_t bcd2_to_byte_(uint8_t value);
+  uint8_t byte_to_bcd2_(uint8_t value);
+};
+
+template<typename... Ts> class WriteAction : public Action<Ts...>, public Parented<BM8563> {
+ public:
+  void play(const Ts &...x) override { this->parent_->write_time(); }
+};
+
+template<typename... Ts> class ReadAction : public Action<Ts...>, public Parented<BM8563> {
+ public:
+  void play(const Ts &...x) override { this->parent_->read_time(); }
+};
+
+template<typename... Ts> class TimerAction : public Action<Ts...>, public Parented<BM8563> {
+ public:
+  TEMPLATABLE_VALUE(uint32_t, duration)
+
+  void play(const Ts &...x) override {
+    auto duration = this->duration_.value(x...);
+    this->parent_->start_timer(duration);
+  }
+};
+
+}  // namespace esphome::bm8563
diff --git a/esphome/components/bm8563/time.py b/esphome/components/bm8563/time.py
new file mode 100644
index 0000000000..2785315af2
--- /dev/null
+++ b/esphome/components/bm8563/time.py
@@ -0,0 +1,80 @@
+from esphome import automation
+import esphome.codegen as cg
+from esphome.components import i2c, time
+import esphome.config_validation as cv
+from esphome.const import CONF_DURATION, CONF_ID
+
+DEPENDENCIES = ["i2c"]
+
+I2C_ADDR = 0x51
+
+bm8563_ns = cg.esphome_ns.namespace("bm8563")
+BM8563 = bm8563_ns.class_("BM8563", time.RealTimeClock, i2c.I2CDevice)
+WriteAction = bm8563_ns.class_("WriteAction", automation.Action)
+ReadAction = bm8563_ns.class_("ReadAction", automation.Action)
+TimerAction = bm8563_ns.class_("TimerAction", automation.Action)
+
+CONFIG_SCHEMA = (
+    time.TIME_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(BM8563),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(I2C_ADDR))
+)
+
+
+@automation.register_action(
+    "bm8563.write_time",
+    WriteAction,
+    automation.maybe_simple_id(
+        {
+            cv.GenerateID(): cv.use_id(BM8563),
+        }
+    ),
+)
+async def bm8563_write_time_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
+
+
+@automation.register_action(
+    "bm8563.start_timer",
+    TimerAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(BM8563),
+            cv.Required(CONF_DURATION): cv.templatable(cv.positive_time_period_seconds),
+        }
+    ),
+)
+async def bm8563_start_timer_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_DURATION], args, cg.uint32)
+    cg.add(var.set_duration(template_))
+    return var
+
+
+@automation.register_action(
+    "bm8563.read_time",
+    ReadAction,
+    automation.maybe_simple_id(
+        {
+            cv.GenerateID(): cv.use_id(BM8563),
+        }
+    ),
+)
+async def bm8563_read_time_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
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+    await time.register_time(var, config)
diff --git a/esphome/components/cst816/touchscreen/cst816_touchscreen.cpp b/esphome/components/cst816/touchscreen/cst816_touchscreen.cpp
index 8ed9fa3f87..0560f1b475 100644
--- a/esphome/components/cst816/touchscreen/cst816_touchscreen.cpp
+++ b/esphome/components/cst816/touchscreen/cst816_touchscreen.cpp
@@ -19,7 +19,8 @@ void CST816Touchscreen::continue_setup_() {
       case CST816T_CHIP_ID:
         break;
       default:
-        this->status_set_error(str_sprintf("Unknown chip ID 0x%02X", this->chip_id_).c_str());
+        ESP_LOGE(TAG, "Unknown chip ID: 0x%02X", this->chip_id_);
+        this->status_set_error("Unknown chip ID");
         this->mark_failed();
         return;
     }
diff --git a/esphome/components/esp32_ble_client/ble_characteristic.cpp b/esphome/components/esp32_ble_client/ble_characteristic.cpp
index 36229c23c3..e0d0174c57 100644
--- a/esphome/components/esp32_ble_client/ble_characteristic.cpp
+++ b/esphome/components/esp32_ble_client/ble_characteristic.cpp
@@ -38,7 +38,7 @@ void BLECharacteristic::parse_descriptors() {
     }
     if (status != ESP_GATT_OK) {
       ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_get_all_descr error, status=%d",
-               this->service->client->get_connection_index(), this->service->client->address_str().c_str(), status);
+               this->service->client->get_connection_index(), this->service->client->address_str(), status);
       break;
     }
     if (count == 0) {
@@ -51,7 +51,7 @@ void BLECharacteristic::parse_descriptors() {
     desc->characteristic = this;
     this->descriptors.push_back(desc);
     ESP_LOGV(TAG, "[%d] [%s]    descriptor %s, handle 0x%x", this->service->client->get_connection_index(),
-             this->service->client->address_str().c_str(), desc->uuid.to_string().c_str(), desc->handle);
+             this->service->client->address_str(), desc->uuid.to_string().c_str(), desc->handle);
     offset++;
   }
 }
@@ -84,7 +84,7 @@ esp_err_t BLECharacteristic::write_value(uint8_t *new_val, int16_t new_val_size,
                                          new_val, write_type, ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     ESP_LOGW(TAG, "[%d] [%s] Error sending write value to BLE gattc server, status=%d",
-             this->service->client->get_connection_index(), this->service->client->address_str().c_str(), status);
+             this->service->client->get_connection_index(), this->service->client->address_str(), status);
   }
   return status;
 }
diff --git a/esphome/components/esp32_ble_client/ble_client_base.cpp b/esphome/components/esp32_ble_client/ble_client_base.cpp
index 3a86a3cbf8..327de4ca0f 100644
--- a/esphome/components/esp32_ble_client/ble_client_base.cpp
+++ b/esphome/components/esp32_ble_client/ble_client_base.cpp
@@ -41,7 +41,7 @@ void BLEClientBase::setup() {
 }
 
 void BLEClientBase::set_state(espbt::ClientState st) {
-  ESP_LOGV(TAG, "[%d] [%s] Set state %d", this->connection_index_, this->address_str_.c_str(), (int) st);
+  ESP_LOGV(TAG, "[%d] [%s] Set state %d", this->connection_index_, this->address_str_, (int) st);
   ESPBTClient::set_state(st);
 }
 
@@ -71,7 +71,7 @@ void BLEClientBase::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "  Address: %s\n"
                 "  Auto-Connect: %s",
-                this->address_str().c_str(), TRUEFALSE(this->auto_connect_));
+                this->address_str(), TRUEFALSE(this->auto_connect_));
   ESP_LOGCONFIG(TAG, "  State: %s", espbt::client_state_to_string(this->state()));
   if (this->status_ == ESP_GATT_NO_RESOURCES) {
     ESP_LOGE(TAG, "  Failed due to no resources. Try to reduce number of BLE clients in config.");
@@ -104,12 +104,11 @@ void BLEClientBase::connect() {
   // Prevent duplicate connection attempts
   if (this->state_ == espbt::ClientState::CONNECTING || this->state_ == espbt::ClientState::CONNECTED ||
       this->state_ == espbt::ClientState::ESTABLISHED) {
-    ESP_LOGW(TAG, "[%d] [%s] Connection already in progress, state=%s", this->connection_index_,
-             this->address_str_.c_str(), espbt::client_state_to_string(this->state_));
+    ESP_LOGW(TAG, "[%d] [%s] Connection already in progress, state=%s", this->connection_index_, this->address_str_,
+             espbt::client_state_to_string(this->state_));
     return;
   }
-  ESP_LOGI(TAG, "[%d] [%s] 0x%02x Connecting", this->connection_index_, this->address_str_.c_str(),
-           this->remote_addr_type_);
+  ESP_LOGI(TAG, "[%d] [%s] 0x%02x Connecting", this->connection_index_, this->address_str_, this->remote_addr_type_);
   this->paired_ = false;
   // Enable loop for state processing
   this->enable_loop();
@@ -135,13 +134,13 @@ esp_err_t BLEClientBase::pair() { return esp_ble_set_encryption(this->remote_bda
 
 void BLEClientBase::disconnect() {
   if (this->state_ == espbt::ClientState::IDLE || this->state_ == espbt::ClientState::DISCONNECTING) {
-    ESP_LOGI(TAG, "[%d] [%s] Disconnect requested, but already %s", this->connection_index_, this->address_str_.c_str(),
+    ESP_LOGI(TAG, "[%d] [%s] Disconnect requested, but already %s", this->connection_index_, this->address_str_,
              espbt::client_state_to_string(this->state_));
     return;
   }
   if (this->state_ == espbt::ClientState::CONNECTING || this->conn_id_ == UNSET_CONN_ID) {
     ESP_LOGD(TAG, "[%d] [%s] Disconnect before connected, disconnect scheduled", this->connection_index_,
-             this->address_str_.c_str());
+             this->address_str_);
     this->want_disconnect_ = true;
     return;
   }
@@ -150,8 +149,7 @@ void BLEClientBase::disconnect() {
 
 void BLEClientBase::unconditional_disconnect() {
   // Disconnect without checking the state.
-  ESP_LOGI(TAG, "[%d] [%s] Disconnecting (conn_id: %d).", this->connection_index_, this->address_str_.c_str(),
-           this->conn_id_);
+  ESP_LOGI(TAG, "[%d] [%s] Disconnecting (conn_id: %d).", this->connection_index_, this->address_str_, this->conn_id_);
   if (this->state_ == espbt::ClientState::DISCONNECTING) {
     this->log_error_("Already disconnecting");
     return;
@@ -192,24 +190,23 @@ void BLEClientBase::release_services() {
 }
 
 void BLEClientBase::log_event_(const char *name) {
-  ESP_LOGD(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_.c_str(), name);
+  ESP_LOGD(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_, name);
 }
 
 void BLEClientBase::log_gattc_event_(const char *name) {
-  ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_%s_EVT", this->connection_index_, this->address_str_.c_str(), name);
+  ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_%s_EVT", this->connection_index_, this->address_str_, name);
 }
 
 void BLEClientBase::log_gattc_warning_(const char *operation, esp_gatt_status_t status) {
-  ESP_LOGW(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str_.c_str(), operation,
-           status);
+  ESP_LOGW(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str_, operation, status);
 }
 
 void BLEClientBase::log_gattc_warning_(const char *operation, esp_err_t err) {
-  ESP_LOGW(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str_.c_str(), operation, err);
+  ESP_LOGW(TAG, "[%d] [%s] %s error, status=%d", this->connection_index_, this->address_str_, operation, err);
 }
 
 void BLEClientBase::log_connection_params_(const char *param_type) {
-  ESP_LOGD(TAG, "[%d] [%s] %s conn params", this->connection_index_, this->address_str_.c_str(), param_type);
+  ESP_LOGD(TAG, "[%d] [%s] %s conn params", this->connection_index_, this->address_str_, param_type);
 }
 
 void BLEClientBase::handle_connection_result_(esp_err_t ret) {
@@ -220,15 +217,15 @@ void BLEClientBase::handle_connection_result_(esp_err_t ret) {
 }
 
 void BLEClientBase::log_error_(const char *message) {
-  ESP_LOGE(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_.c_str(), message);
+  ESP_LOGE(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_, message);
 }
 
 void BLEClientBase::log_error_(const char *message, int code) {
-  ESP_LOGE(TAG, "[%d] [%s] %s=%d", this->connection_index_, this->address_str_.c_str(), message, code);
+  ESP_LOGE(TAG, "[%d] [%s] %s=%d", this->connection_index_, this->address_str_, message, code);
 }
 
 void BLEClientBase::log_warning_(const char *message) {
-  ESP_LOGW(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_.c_str(), message);
+  ESP_LOGW(TAG, "[%d] [%s] %s", this->connection_index_, this->address_str_, message);
 }
 
 void BLEClientBase::update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency,
@@ -264,13 +261,13 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
   if (event != ESP_GATTC_REG_EVT && esp_gattc_if != ESP_GATT_IF_NONE && esp_gattc_if != this->gattc_if_)
     return false;
 
-  ESP_LOGV(TAG, "[%d] [%s] gattc_event_handler: event=%d gattc_if=%d", this->connection_index_,
-           this->address_str_.c_str(), event, esp_gattc_if);
+  ESP_LOGV(TAG, "[%d] [%s] gattc_event_handler: event=%d gattc_if=%d", this->connection_index_, this->address_str_,
+           event, esp_gattc_if);
 
   switch (event) {
     case ESP_GATTC_REG_EVT: {
       if (param->reg.status == ESP_GATT_OK) {
-        ESP_LOGV(TAG, "[%d] [%s] gattc registered app id %d", this->connection_index_, this->address_str_.c_str(),
+        ESP_LOGV(TAG, "[%d] [%s] gattc registered app id %d", this->connection_index_, this->address_str_,
                  this->app_id);
         this->gattc_if_ = esp_gattc_if;
       } else {
@@ -292,7 +289,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       // arriving after we've already transitioned to IDLE state.
       if (this->state_ == espbt::ClientState::IDLE) {
         ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in IDLE state (status=%d), ignoring", this->connection_index_,
-                 this->address_str_.c_str(), param->open.status);
+                 this->address_str_, param->open.status);
         break;
       }
 
@@ -301,7 +298,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         // because it means we have a bad assumption about how the
         // ESP BT stack works.
         ESP_LOGE(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in %s state (status=%d)", this->connection_index_,
-                 this->address_str_.c_str(), espbt::client_state_to_string(this->state_), param->open.status);
+                 this->address_str_, espbt::client_state_to_string(this->state_), param->open.status);
       }
       if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
         this->log_gattc_warning_("Connection open", param->open.status);
@@ -318,7 +315,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       }
       // MTU negotiation already started in ESP_GATTC_CONNECT_EVT
       this->set_state(espbt::ClientState::CONNECTED);
-      ESP_LOGI(TAG, "[%d] [%s] Connection open", this->connection_index_, this->address_str_.c_str());
+      ESP_LOGI(TAG, "[%d] [%s] Connection open", this->connection_index_, this->address_str_);
       if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
         // Cached connections already connected with medium parameters, no update needed
         // only set our state, subclients might have more stuff to do yet.
@@ -354,8 +351,8 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
           this->state_ == espbt::ClientState::CONNECTED) {
         this->log_warning_("Remote closed during discovery");
       } else {
-        ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason 0x%02x", this->connection_index_,
-                 this->address_str_.c_str(), param->disconnect.reason);
+        ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason 0x%02x", this->connection_index_, this->address_str_,
+                 param->disconnect.reason);
       }
       this->release_services();
       this->set_state(espbt::ClientState::IDLE);
@@ -366,12 +363,12 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       if (this->conn_id_ != param->cfg_mtu.conn_id)
         return false;
       if (param->cfg_mtu.status != ESP_GATT_OK) {
-        ESP_LOGW(TAG, "[%d] [%s] cfg_mtu failed, mtu %d, status %d", this->connection_index_,
-                 this->address_str_.c_str(), param->cfg_mtu.mtu, param->cfg_mtu.status);
+        ESP_LOGW(TAG, "[%d] [%s] cfg_mtu failed, mtu %d, status %d", this->connection_index_, this->address_str_,
+                 param->cfg_mtu.mtu, param->cfg_mtu.status);
         // No state change required here - disconnect event will follow if needed.
         break;
       }
-      ESP_LOGD(TAG, "[%d] [%s] cfg_mtu status %d, mtu %d", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGD(TAG, "[%d] [%s] cfg_mtu status %d, mtu %d", this->connection_index_, this->address_str_,
                param->cfg_mtu.status, param->cfg_mtu.mtu);
       this->mtu_ = param->cfg_mtu.mtu;
       break;
@@ -416,14 +413,14 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       } else if (this->connection_type_ != espbt::ConnectionType::V3_WITH_CACHE) {
 #ifdef USE_ESP32_BLE_DEVICE
         for (auto &svc : this->services_) {
-          ESP_LOGV(TAG, "[%d] [%s] Service UUID: %s", this->connection_index_, this->address_str_.c_str(),
+          ESP_LOGV(TAG, "[%d] [%s] Service UUID: %s", this->connection_index_, this->address_str_,
                    svc->uuid.to_string().c_str());
-          ESP_LOGV(TAG, "[%d] [%s]  start_handle: 0x%x  end_handle: 0x%x", this->connection_index_,
-                   this->address_str_.c_str(), svc->start_handle, svc->end_handle);
+          ESP_LOGV(TAG, "[%d] [%s]  start_handle: 0x%x  end_handle: 0x%x", this->connection_index_, this->address_str_,
+                   svc->start_handle, svc->end_handle);
         }
 #endif
       }
-      ESP_LOGI(TAG, "[%d] [%s] Service discovery complete", this->connection_index_, this->address_str_.c_str());
+      ESP_LOGI(TAG, "[%d] [%s] Service discovery complete", this->connection_index_, this->address_str_);
       this->state_ = espbt::ClientState::ESTABLISHED;
       break;
     }
@@ -504,7 +501,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
 
     default:
       // ideally would check all other events for matching conn_id
-      ESP_LOGD(TAG, "[%d] [%s] Event %d", this->connection_index_, this->address_str_.c_str(), event);
+      ESP_LOGD(TAG, "[%d] [%s] Event %d", this->connection_index_, this->address_str_, event);
       break;
   }
   return true;
@@ -521,7 +518,7 @@ void BLEClientBase::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_
     case ESP_GAP_BLE_SEC_REQ_EVT:
       if (!this->check_addr(param->ble_security.auth_cmpl.bd_addr))
         return;
-      ESP_LOGV(TAG, "[%d] [%s] ESP_GAP_BLE_SEC_REQ_EVT %x", this->connection_index_, this->address_str_.c_str(), event);
+      ESP_LOGV(TAG, "[%d] [%s] ESP_GAP_BLE_SEC_REQ_EVT %x", this->connection_index_, this->address_str_, event);
       esp_ble_gap_security_rsp(param->ble_security.ble_req.bd_addr, true);
       break;
     // This event is sent once authentication has completed
@@ -530,13 +527,13 @@ void BLEClientBase::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_
         return;
       esp_bd_addr_t bd_addr;
       memcpy(bd_addr, param->ble_security.auth_cmpl.bd_addr, sizeof(esp_bd_addr_t));
-      ESP_LOGI(TAG, "[%d] [%s] auth complete addr: %s", this->connection_index_, this->address_str_.c_str(),
+      ESP_LOGI(TAG, "[%d] [%s] auth complete addr: %s", this->connection_index_, this->address_str_,
                format_hex(bd_addr, 6).c_str());
       if (!param->ble_security.auth_cmpl.success) {
         this->log_error_("auth fail reason", param->ble_security.auth_cmpl.fail_reason);
       } else {
         this->paired_ = true;
-        ESP_LOGD(TAG, "[%d] [%s] auth success type = %d mode = %d", this->connection_index_, this->address_str_.c_str(),
+        ESP_LOGD(TAG, "[%d] [%s] auth success type = %d mode = %d", this->connection_index_, this->address_str_,
                  param->ble_security.auth_cmpl.addr_type, param->ble_security.auth_cmpl.auth_mode);
       }
       break;
@@ -599,7 +596,7 @@ float BLEClientBase::parse_char_value(uint8_t *value, uint16_t length) {
       }
   }
   ESP_LOGW(TAG, "[%d] [%s] Cannot parse characteristic value of type 0x%x length %d", this->connection_index_,
-           this->address_str_.c_str(), value[0], length);
+           this->address_str_, value[0], length);
   return NAN;
 }
 
diff --git a/esphome/components/esp32_ble_client/ble_client_base.h b/esphome/components/esp32_ble_client/ble_client_base.h
index 7f0ae3b83e..7786495915 100644
--- a/esphome/components/esp32_ble_client/ble_client_base.h
+++ b/esphome/components/esp32_ble_client/ble_client_base.h
@@ -10,7 +10,6 @@
 #endif
 
 #include <array>
-#include <string>
 #include <vector>
 
 #include <esp_bt_defs.h>
@@ -23,6 +22,7 @@ namespace esphome::esp32_ble_client {
 namespace espbt = esphome::esp32_ble_tracker;
 
 static const int UNSET_CONN_ID = 0xFFFF;
+static constexpr size_t MAC_ADDR_STR_LEN = 18;  // "AA:BB:CC:DD:EE:FF\0"
 
 class BLEClientBase : public espbt::ESPBTClient, public Component {
  public:
@@ -58,14 +58,12 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
     this->remote_bda_[4] = (address >> 8) & 0xFF;
     this->remote_bda_[5] = (address >> 0) & 0xFF;
     if (address == 0) {
-      this->address_str_ = "";
+      this->address_str_[0] = '\0';
     } else {
-      char buf[18];
-      format_mac_addr_upper(this->remote_bda_, buf);
-      this->address_str_ = buf;
+      format_mac_addr_upper(this->remote_bda_, this->address_str_);
     }
   }
-  const std::string &address_str() const { return this->address_str_; }
+  const char *address_str() const { return this->address_str_; }
 
 #ifdef USE_ESP32_BLE_DEVICE
   BLEService *get_service(espbt::ESPBTUUID uuid);
@@ -104,7 +102,6 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   uint64_t address_{0};
 
   // Group 2: Container types (grouped for memory optimization)
-  std::string address_str_{};
 #ifdef USE_ESP32_BLE_DEVICE
   std::vector<BLEService *> services_;
 #endif
@@ -113,8 +110,9 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   int gattc_if_;
   esp_gatt_status_t status_{ESP_GATT_OK};
 
-  // Group 4: Arrays (6 bytes)
-  esp_bd_addr_t remote_bda_;
+  // Group 4: Arrays
+  char address_str_[MAC_ADDR_STR_LEN]{};  // 18 bytes: "AA:BB:CC:DD:EE:FF\0"
+  esp_bd_addr_t remote_bda_;              // 6 bytes
 
   // Group 5: 2-byte types
   uint16_t conn_id_{UNSET_CONN_ID};
diff --git a/esphome/components/esp32_ble_client/ble_service.cpp b/esphome/components/esp32_ble_client/ble_service.cpp
index accaad15e1..deaaa3de02 100644
--- a/esphome/components/esp32_ble_client/ble_service.cpp
+++ b/esphome/components/esp32_ble_client/ble_service.cpp
@@ -51,7 +51,7 @@ void BLEService::parse_characteristics() {
     }
     if (status != ESP_GATT_OK) {
       ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_get_all_char error, status=%d", this->client->get_connection_index(),
-               this->client->address_str().c_str(), status);
+               this->client->address_str(), status);
       break;
     }
     if (count == 0) {
@@ -65,7 +65,7 @@ void BLEService::parse_characteristics() {
     characteristic->service = this;
     this->characteristics.push_back(characteristic);
     ESP_LOGV(TAG, "[%d] [%s]  characteristic %s, handle 0x%x, properties 0x%x", this->client->get_connection_index(),
-             this->client->address_str().c_str(), characteristic->uuid.to_string().c_str(), characteristic->handle,
+             this->client->address_str(), characteristic->uuid.to_string().c_str(), characteristic->handle,
              characteristic->properties);
     offset++;
   }
diff --git a/esphome/components/http_request/update/http_request_update.cpp b/esphome/components/http_request/update/http_request_update.cpp
index 06aa6da6a4..9dbf8d181a 100644
--- a/esphome/components/http_request/update/http_request_update.cpp
+++ b/esphome/components/http_request/update/http_request_update.cpp
@@ -49,18 +49,18 @@ void HttpRequestUpdate::update_task(void *params) {
   auto container = this_update->request_parent_->get(this_update->source_url_);
 
   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());
+    ESP_LOGE(TAG, "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->defer([this_update]() { this_update->status_set_error("Failed to fetch manifest"); });
     UPDATE_RETURN;
   }
 
   RAMAllocator<uint8_t> allocator;
   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);
+    ESP_LOGE(TAG, "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->defer([this_update]() { this_update->status_set_error("Failed to allocate memory for manifest"); });
     container->end();
     UPDATE_RETURN;
   }
@@ -121,9 +121,9 @@ 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());
+    ESP_LOGE(TAG, "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->defer([this_update]() { this_update->status_set_error("Failed to parse manifest JSON"); });
     UPDATE_RETURN;
   }
 
diff --git a/esphome/components/jsn_sr04t/jsn_sr04t.cpp b/esphome/components/jsn_sr04t/jsn_sr04t.cpp
index 077d4e58ea..84181dac48 100644
--- a/esphome/components/jsn_sr04t/jsn_sr04t.cpp
+++ b/esphome/components/jsn_sr04t/jsn_sr04t.cpp
@@ -10,7 +10,7 @@ namespace jsn_sr04t {
 static const char *const TAG = "jsn_sr04t.sensor";
 
 void Jsnsr04tComponent::update() {
-  this->write_byte(0x55);
+  this->write_byte((this->model_ == AJ_SR04M) ? 0x01 : 0x55);
   ESP_LOGV(TAG, "Request read out from sensor");
 }
 
@@ -31,19 +31,10 @@ void Jsnsr04tComponent::loop() {
 }
 
 void Jsnsr04tComponent::check_buffer_() {
-  uint8_t checksum = 0;
-  switch (this->model_) {
-    case JSN_SR04T:
-      checksum = this->buffer_[0] + this->buffer_[1] + this->buffer_[2];
-      break;
-    case AJ_SR04M:
-      checksum = this->buffer_[1] + this->buffer_[2];
-      break;
-  }
-
+  uint8_t checksum = this->buffer_[0] + this->buffer_[1] + this->buffer_[2];
   if (this->buffer_[3] == checksum) {
     uint16_t distance = encode_uint16(this->buffer_[1], this->buffer_[2]);
-    if (distance > 250) {
+    if (distance > ((this->model_ == AJ_SR04M) ? 200 : 250)) {
       float meters = distance / 1000.0f;
       ESP_LOGV(TAG, "Distance from sensor: %umm, %.3fm", distance, meters);
       this->publish_state(meters);
diff --git a/esphome/components/mcp3204/mcp3204.cpp b/esphome/components/mcp3204/mcp3204.cpp
index 4bb0cbed76..f0dd171a14 100644
--- a/esphome/components/mcp3204/mcp3204.cpp
+++ b/esphome/components/mcp3204/mcp3204.cpp
@@ -16,16 +16,21 @@ void MCP3204::dump_config() {
   ESP_LOGCONFIG(TAG, "  Reference Voltage: %.2fV", this->reference_voltage_);
 }
 
-float MCP3204::read_data(uint8_t pin) {
-  uint8_t adc_primary_config = 0b00000110 | (pin >> 2);
-  uint8_t adc_secondary_config = pin << 6;
+float MCP3204::read_data(uint8_t pin, bool differential) {
+  uint8_t command, b0, b1;
+
+  command = (1 << 6) |                       // start bit
+            ((differential ? 0 : 1) << 5) |  // single or differential bit
+            ((pin & 0x07) << 2);             // pin
+
   this->enable();
-  this->transfer_byte(adc_primary_config);
-  uint8_t adc_primary_byte = this->transfer_byte(adc_secondary_config);
-  uint8_t adc_secondary_byte = this->transfer_byte(0x00);
+  this->transfer_byte(command);
+  b0 = this->transfer_byte(0x00);
+  b1 = this->transfer_byte(0x00);
   this->disable();
-  uint16_t digital_value = (adc_primary_byte << 8 | adc_secondary_byte) & 0b111111111111;
-  return float(digital_value) / 4096.000 * this->reference_voltage_;
+
+  uint16_t digital_value = encode_uint16(b0, b1) >> 4;
+  return float(digital_value) / 4096.000 * this->reference_voltage_;  // in V
 }
 
 }  // namespace mcp3204
diff --git a/esphome/components/mcp3204/mcp3204.h b/esphome/components/mcp3204/mcp3204.h
index 27261aa373..6287263a2a 100644
--- a/esphome/components/mcp3204/mcp3204.h
+++ b/esphome/components/mcp3204/mcp3204.h
@@ -18,7 +18,7 @@ class MCP3204 : public Component,
   void setup() override;
   void dump_config() override;
   float get_setup_priority() const override;
-  float read_data(uint8_t pin);
+  float read_data(uint8_t pin, bool differential);
 
  protected:
   float reference_voltage_;
diff --git a/esphome/components/mcp3204/sensor/__init__.py b/esphome/components/mcp3204/sensor/__init__.py
index a4b177cbcf..5f9aa9fdb6 100644
--- a/esphome/components/mcp3204/sensor/__init__.py
+++ b/esphome/components/mcp3204/sensor/__init__.py
@@ -13,6 +13,7 @@ MCP3204Sensor = mcp3204_ns.class_(
     "MCP3204Sensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
 )
 CONF_MCP3204_ID = "mcp3204_id"
+CONF_DIFF_MODE = "diff_mode"
 
 CONFIG_SCHEMA = (
     sensor.sensor_schema(MCP3204Sensor)
@@ -20,6 +21,7 @@ CONFIG_SCHEMA = (
         {
             cv.GenerateID(CONF_MCP3204_ID): cv.use_id(MCP3204),
             cv.Required(CONF_NUMBER): cv.int_range(min=0, max=7),
+            cv.Optional(CONF_DIFF_MODE, default=False): cv.boolean,
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -30,6 +32,7 @@ async def to_code(config):
     var = cg.new_Pvariable(
         config[CONF_ID],
         config[CONF_NUMBER],
+        config[CONF_DIFF_MODE],
     )
     await cg.register_parented(var, config[CONF_MCP3204_ID])
     await cg.register_component(var, config)
diff --git a/esphome/components/mcp3204/sensor/mcp3204_sensor.cpp b/esphome/components/mcp3204/sensor/mcp3204_sensor.cpp
index ce0fd25462..4c4abef4a7 100644
--- a/esphome/components/mcp3204/sensor/mcp3204_sensor.cpp
+++ b/esphome/components/mcp3204/sensor/mcp3204_sensor.cpp
@@ -7,16 +7,15 @@ namespace mcp3204 {
 
 static const char *const TAG = "mcp3204.sensor";
 
-MCP3204Sensor::MCP3204Sensor(uint8_t pin) : pin_(pin) {}
-
 float MCP3204Sensor::get_setup_priority() const { return setup_priority::DATA; }
 
 void MCP3204Sensor::dump_config() {
   LOG_SENSOR("", "MCP3204 Sensor", this);
   ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
+  ESP_LOGCONFIG(TAG, "  Differential Mode: %s", YESNO(this->differential_mode_));
   LOG_UPDATE_INTERVAL(this);
 }
-float MCP3204Sensor::sample() { return this->parent_->read_data(this->pin_); }
+float MCP3204Sensor::sample() { return this->parent_->read_data(this->pin_, this->differential_mode_); }
 void MCP3204Sensor::update() { this->publish_state(this->sample()); }
 
 }  // namespace mcp3204
diff --git a/esphome/components/mcp3204/sensor/mcp3204_sensor.h b/esphome/components/mcp3204/sensor/mcp3204_sensor.h
index 21c45590ab..5665b80b98 100644
--- a/esphome/components/mcp3204/sensor/mcp3204_sensor.h
+++ b/esphome/components/mcp3204/sensor/mcp3204_sensor.h
@@ -15,7 +15,7 @@ class MCP3204Sensor : public PollingComponent,
                       public sensor::Sensor,
                       public voltage_sampler::VoltageSampler {
  public:
-  MCP3204Sensor(uint8_t pin);
+  MCP3204Sensor(uint8_t pin, bool differential_mode) : pin_(pin), differential_mode_(differential_mode) {}
 
   void update() override;
   void dump_config() override;
@@ -24,6 +24,7 @@ class MCP3204Sensor : public PollingComponent,
 
  protected:
   uint8_t pin_;
+  bool differential_mode_;
 };
 
 }  // namespace mcp3204
diff --git a/esphome/components/pvvx_mithermometer/display/pvvx_display.cpp b/esphome/components/pvvx_mithermometer/display/pvvx_display.cpp
index b6916ad68f..8436633619 100644
--- a/esphome/components/pvvx_mithermometer/display/pvvx_display.cpp
+++ b/esphome/components/pvvx_mithermometer/display/pvvx_display.cpp
@@ -14,7 +14,7 @@ void PVVXDisplay::dump_config() {
                 "  Service UUID          : %s\n"
                 "  Characteristic UUID   : %s\n"
                 "  Auto clear            : %s",
-                this->parent_->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->parent_->address_str(), this->service_uuid_.to_string().c_str(),
                 this->char_uuid_.to_string().c_str(), YESNO(this->auto_clear_enabled_));
 #ifdef USE_TIME
   ESP_LOGCONFIG(TAG, "  Set time on connection: %s", YESNO(this->time_ != nullptr));
@@ -28,12 +28,12 @@ void PVVXDisplay::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t
   switch (event) {
     case ESP_GATTC_OPEN_EVT:
       if (param->open.status == ESP_GATT_OK) {
-        ESP_LOGV(TAG, "[%s] Connected successfully!", this->parent_->address_str().c_str());
+        ESP_LOGV(TAG, "[%s] Connected successfully!", this->parent_->address_str());
         this->delayed_disconnect_();
       }
       break;
     case ESP_GATTC_DISCONNECT_EVT:
-      ESP_LOGV(TAG, "[%s] Disconnected", this->parent_->address_str().c_str());
+      ESP_LOGV(TAG, "[%s] Disconnected", this->parent_->address_str());
       this->connection_established_ = false;
       this->cancel_timeout("disconnect");
       this->char_handle_ = 0;
@@ -41,7 +41,7 @@ void PVVXDisplay::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto *chr = this->parent_->get_characteristic(this->service_uuid_, this->char_uuid_);
       if (chr == nullptr) {
-        ESP_LOGW(TAG, "[%s] Characteristic not found.", this->parent_->address_str().c_str());
+        ESP_LOGW(TAG, "[%s] Characteristic not found.", this->parent_->address_str());
         break;
       }
       this->connection_established_ = true;
@@ -66,11 +66,11 @@ void PVVXDisplay::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb
         return;
 
       if (param->ble_security.auth_cmpl.success) {
-        ESP_LOGD(TAG, "[%s] Authentication successful, performing writes.", this->parent_->address_str().c_str());
+        ESP_LOGD(TAG, "[%s] Authentication successful, performing writes.", this->parent_->address_str());
         // Now that pairing is complete, perform the pending writes
         this->sync_time_and_display_();
       } else {
-        ESP_LOGW(TAG, "[%s] Authentication failed.", this->parent_->address_str().c_str());
+        ESP_LOGW(TAG, "[%s] Authentication failed.", this->parent_->address_str());
       }
       break;
     }
@@ -89,22 +89,20 @@ void PVVXDisplay::update() {
 
 void PVVXDisplay::display() {
   if (!this->parent_->enabled) {
-    ESP_LOGD(TAG, "[%s] BLE client not enabled.  Init connection.", this->parent_->address_str().c_str());
+    ESP_LOGD(TAG, "[%s] BLE client not enabled.  Init connection.", this->parent_->address_str());
     this->parent_->set_enabled(true);
     return;
   }
   if (!this->connection_established_) {
-    ESP_LOGW(TAG, "[%s] Not connected to BLE client.  State update can not be written.",
-             this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Not connected to BLE client.  State update can not be written.", this->parent_->address_str());
     return;
   }
   if (!this->char_handle_) {
-    ESP_LOGW(TAG, "[%s] No ble handle to BLE client.  State update can not be written.",
-             this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] No ble handle to BLE client.  State update can not be written.", this->parent_->address_str());
     return;
   }
   ESP_LOGD(TAG, "[%s] Send to display: bignum %d, smallnum: %d, cfg: 0x%02x, validity period: %u.",
-           this->parent_->address_str().c_str(), this->bignum_, this->smallnum_, this->cfg_, this->validity_period_);
+           this->parent_->address_str(), this->bignum_, this->smallnum_, this->cfg_, this->validity_period_);
   uint8_t blk[8] = {};
   blk[0] = 0x22;
   blk[1] = this->bignum_ & 0xff;
@@ -128,16 +126,16 @@ void PVVXDisplay::setcfgbit_(uint8_t bit, bool value) {
 
 void PVVXDisplay::send_to_setup_char_(uint8_t *blk, size_t size) {
   if (!this->connection_established_) {
-    ESP_LOGW(TAG, "[%s] Not connected to BLE client.", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Not connected to BLE client.", this->parent_->address_str());
     return;
   }
   auto status =
       esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_, size,
                                blk, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
   if (status) {
-    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
   } else {
-    ESP_LOGV(TAG, "[%s] send %u bytes", this->parent_->address_str().c_str(), size);
+    ESP_LOGV(TAG, "[%s] send %u bytes", this->parent_->address_str(), size);
     this->delayed_disconnect_();
   }
 }
@@ -161,21 +159,21 @@ void PVVXDisplay::sync_time_() {
   if (this->time_ == nullptr)
     return;
   if (!this->connection_established_) {
-    ESP_LOGW(TAG, "[%s] Not connected to BLE client.  Time can not be synced.", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Not connected to BLE client.  Time can not be synced.", this->parent_->address_str());
     return;
   }
   if (!this->char_handle_) {
-    ESP_LOGW(TAG, "[%s] No ble handle to BLE client.  Time can not be synced.", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] No ble handle to BLE client.  Time can not be synced.", this->parent_->address_str());
     return;
   }
   auto time = this->time_->now();
   if (!time.is_valid()) {
-    ESP_LOGW(TAG, "[%s] Time is not yet valid.  Time can not be synced.", this->parent_->address_str().c_str());
+    ESP_LOGW(TAG, "[%s] Time is not yet valid.  Time can not be synced.", this->parent_->address_str());
     return;
   }
   time.recalc_timestamp_utc(true);  // calculate timestamp of local time
   uint8_t blk[5] = {};
-  ESP_LOGD(TAG, "[%s] Sync time with timestamp %" PRIu64 ".", this->parent_->address_str().c_str(), time.timestamp);
+  ESP_LOGD(TAG, "[%s] Sync time with timestamp %" PRIu64 ".", this->parent_->address_str(), time.timestamp);
   blk[0] = 0x23;
   blk[1] = time.timestamp & 0xff;
   blk[2] = (time.timestamp >> 8) & 0xff;
diff --git a/esphome/config.py b/esphome/config.py
index 4c8019de75..1c4cdd93c6 100644
--- a/esphome/config.py
+++ b/esphome/config.py
@@ -355,6 +355,8 @@ def _get_item_id(item: Any) -> str | Extend | Remove | None:
     if isinstance(item_id, Extend):
         # Remove instances of Extend so they don't overwrite the original item when merging:
         del item[CONF_ID]
+    elif not isinstance(item_id, (str, Remove)):
+        return None
     return item_id
 
 
diff --git a/esphome/core/component_iterator.cpp b/esphome/core/component_iterator.cpp
index 668c4a1fda..8c6a7b95b5 100644
--- a/esphome/core/component_iterator.cpp
+++ b/esphome/core/component_iterator.cpp
@@ -5,7 +5,7 @@
 #ifdef USE_API
 #include "esphome/components/api/api_server.h"
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 #include "esphome/components/api/user_services.h"
 #endif
 
@@ -81,7 +81,7 @@ void ComponentIterator::advance() {
       break;
 #endif
 
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
     case IteratorState::SERVICE:
       this->process_platform_item_(api::global_api_server->get_user_services(), &ComponentIterator::on_service);
       break;
@@ -185,7 +185,7 @@ void ComponentIterator::advance() {
 
 bool ComponentIterator::on_end() { return true; }
 bool ComponentIterator::on_begin() { return true; }
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 bool ComponentIterator::on_service(api::UserServiceDescriptor *service) { return true; }
 #endif
 #ifdef USE_CAMERA
diff --git a/esphome/core/component_iterator.h b/esphome/core/component_iterator.h
index 641d42898a..1b1bd80ac5 100644
--- a/esphome/core/component_iterator.h
+++ b/esphome/core/component_iterator.h
@@ -10,7 +10,7 @@
 
 namespace esphome {
 
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
 namespace api {
 class UserServiceDescriptor;
 }  // namespace api
@@ -45,7 +45,7 @@ class ComponentIterator {
 #ifdef USE_TEXT_SENSOR
   virtual bool on_text_sensor(text_sensor::TextSensor *text_sensor) = 0;
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
   virtual bool on_service(api::UserServiceDescriptor *service);
 #endif
 #ifdef USE_CAMERA
@@ -122,7 +122,7 @@ class ComponentIterator {
 #ifdef USE_TEXT_SENSOR
     TEXT_SENSOR,
 #endif
-#ifdef USE_API_SERVICES
+#ifdef USE_API_USER_DEFINED_ACTIONS
     SERVICE,
 #endif
 #ifdef USE_CAMERA
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index 54818ffdae..5e7f51e04c 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -124,7 +124,7 @@
 #define USE_API_HOMEASSISTANT_STATES
 #define USE_API_NOISE
 #define USE_API_PLAINTEXT
-#define USE_API_SERVICES
+#define USE_API_USER_DEFINED_ACTIONS
 #define USE_API_CUSTOM_SERVICES
 #define API_MAX_SEND_QUEUE 8
 #define USE_MD5
diff --git a/tests/component_tests/mipi_spi/test_init.py b/tests/component_tests/mipi_spi/test_init.py
index e68f6fbfba..56a52df2ab 100644
--- a/tests/component_tests/mipi_spi/test_init.py
+++ b/tests/component_tests/mipi_spi/test_init.py
@@ -220,7 +220,7 @@ def test_esp32s3_specific_errors(
 
     set_core_config(
         PlatformFramework.ESP32_IDF,
-        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32S3},
+        platform_data={KEY_BOARD: "esp32-s3-devkitc-1", KEY_VARIANT: VARIANT_ESP32S3},
     )
 
     with pytest.raises(cv.Invalid, match=error_match):
@@ -250,7 +250,7 @@ def test_custom_model_with_all_options(
     """Test custom model configuration with all available options."""
     set_core_config(
         PlatformFramework.ESP32_IDF,
-        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32S3},
+        platform_data={KEY_BOARD: "esp32-s3-devkitc-1", KEY_VARIANT: VARIANT_ESP32S3},
     )
 
     run_schema_validation(
@@ -293,7 +293,7 @@ def test_all_predefined_models(
     """Test all predefined display models validate successfully with appropriate defaults."""
     set_core_config(
         PlatformFramework.ESP32_IDF,
-        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32S3},
+        platform_data={KEY_BOARD: "esp32-s3-devkitc-1", KEY_VARIANT: VARIANT_ESP32S3},
     )
 
     # Enable PSRAM which is required for some models
diff --git a/tests/components/bm8563/common.yaml b/tests/components/bm8563/common.yaml
new file mode 100644
index 0000000000..ec3fdd1518
--- /dev/null
+++ b/tests/components/bm8563/common.yaml
@@ -0,0 +1,10 @@
+esphome:
+  on_boot:
+    - bm8563.read_time
+    - bm8563.write_time
+    - bm8563.start_timer:
+        duration: 300s
+
+time:
+  - platform: bm8563
+    i2c_id: i2c_bus
diff --git a/tests/components/bm8563/test.esp32-ard.yaml b/tests/components/bm8563/test.esp32-ard.yaml
new file mode 100644
index 0000000000..7c503b0ccb
--- /dev/null
+++ b/tests/components/bm8563/test.esp32-ard.yaml
@@ -0,0 +1,4 @@
+packages:
+  i2c: !include ../../test_build_components/common/i2c/esp32-ard.yaml
+
+<<: !include common.yaml
diff --git a/tests/components/bm8563/test.esp32-idf.yaml b/tests/components/bm8563/test.esp32-idf.yaml
new file mode 100644
index 0000000000..b47e39c389
--- /dev/null
+++ b/tests/components/bm8563/test.esp32-idf.yaml
@@ -0,0 +1,4 @@
+packages:
+  i2c: !include ../../test_build_components/common/i2c/esp32-idf.yaml
+
+<<: !include common.yaml
diff --git a/tests/components/bm8563/test.esp8266-ard.yaml b/tests/components/bm8563/test.esp8266-ard.yaml
new file mode 100644
index 0000000000..4a98b9388a
--- /dev/null
+++ b/tests/components/bm8563/test.esp8266-ard.yaml
@@ -0,0 +1,4 @@
+packages:
+  i2c: !include ../../test_build_components/common/i2c/esp8266-ard.yaml
+
+<<: !include common.yaml
diff --git a/tests/components/bm8563/test.rp2040-ard.yaml b/tests/components/bm8563/test.rp2040-ard.yaml
new file mode 100644
index 0000000000..319a7c71a6
--- /dev/null
+++ b/tests/components/bm8563/test.rp2040-ard.yaml
@@ -0,0 +1,4 @@
+packages:
+  i2c: !include ../../test_build_components/common/i2c/rp2040-ard.yaml
+
+<<: !include common.yaml
diff --git a/tests/components/mcp3204/common.yaml b/tests/components/mcp3204/common.yaml
index eca6ec44f4..9750f0af8e 100644
--- a/tests/components/mcp3204/common.yaml
+++ b/tests/components/mcp3204/common.yaml
@@ -4,7 +4,21 @@ mcp3204:
 
 sensor:
   - platform: mcp3204
-    id: mcp3204_sensor
+    id: mcp3204_default_single_0
     mcp3204_id: mcp3204_hub
     number: 0
     update_interval: 5s
+
+  - platform: mcp3204
+    id: mcp3204_single_0
+    mcp3204_id: mcp3204_hub
+    number: 0
+    diff_mode: false
+    update_interval: 5s
+
+  - platform: mcp3204
+    id: mcp3204_diff_0_1
+    mcp3204_id: mcp3204_hub
+    number: 0
+    diff_mode: true
+    update_interval: 5s
diff --git a/tests/components/stts22h/test.nrf52.yaml b/tests/components/stts22h/test.nrf52-adafruit.yaml
similarity index 100%
rename from tests/components/stts22h/test.nrf52.yaml
rename to tests/components/stts22h/test.nrf52-adafruit.yaml
diff --git a/tests/unit_tests/fixtures/substitutions/05-extend-remove.approved.yaml b/tests/unit_tests/fixtures/substitutions/05-extend-remove.approved.yaml
index 35e3e6258f..773a124f25 100644
--- a/tests/unit_tests/fixtures/substitutions/05-extend-remove.approved.yaml
+++ b/tests/unit_tests/fixtures/substitutions/05-extend-remove.approved.yaml
@@ -31,3 +31,9 @@ lvgl:
             id: object5
             x: 10
             y: 11
+        - obj:
+            id:
+              - Invalid ID
+        - obj:
+            id:
+              invalid: id
diff --git a/tests/unit_tests/fixtures/substitutions/05-extend-remove.input.yaml b/tests/unit_tests/fixtures/substitutions/05-extend-remove.input.yaml
index 617f09c31c..e6d46d6dc4 100644
--- a/tests/unit_tests/fixtures/substitutions/05-extend-remove.input.yaml
+++ b/tests/unit_tests/fixtures/substitutions/05-extend-remove.input.yaml
@@ -37,6 +37,10 @@ packages:
                 id: object5
                 x: 10
                 y: 11
+            - obj:
+                id: ["Invalid ID"]
+            - obj:
+                id: {"invalid": "id"}
 
 some_component:
   - id: !extend ${A}