esphome 2025.5.2__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/components/shtcx/shtcx.cpp

@@ -20,24 +20,18 @@ inline const char *to_string(SHTCXType type) {
     case SHTCX_TYPE_SHTC1:
       return "SHTC1";
     default:
-      return "[Unknown model]";
+      return "UNKNOWN";
   }
 }
 
 void SHTCXComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SHTCx...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->wake_up();
   this->soft_reset();
 
-  if (!this->write_command(SHTCX_COMMAND_READ_ID_REGISTER)) {
-    ESP_LOGE(TAG, "Error requesting Device ID");
-    this->mark_failed();
-    return;
-  }
-
   uint16_t device_id_register;
-  if (!this->read_data(&device_id_register, 1)) {
-    ESP_LOGE(TAG, "Error reading Device ID");
+  if (!this->write_command(SHTCX_COMMAND_READ_ID_REGISTER) || !this->read_data(&device_id_register, 1)) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->mark_failed();
     return;
   }
@@ -53,31 +47,33 @@ void SHTCXComponent::setup() {
   } else {
     this->type_ = SHTCX_TYPE_UNKNOWN;
   }
-  ESP_LOGCONFIG(TAG, "  Device identified: %s (%04x)", to_string(this->type_), device_id_register);
 }
+
 void SHTCXComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "SHTCx:");
   ESP_LOGCONFIG(TAG, "  Model: %s (%04x)", to_string(this->type_), this->sensor_id_);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with SHTCx failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
 
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
+
 float SHTCXComponent::get_setup_priority() const { return setup_priority::DATA; }
+
 void SHTCXComponent::update() {
   if (this->status_has_warning()) {
-    ESP_LOGW(TAG, "Retrying to reconnect the sensor.");
+    ESP_LOGW(TAG, "Retrying communication");
     this->soft_reset();
   }
   if (this->type_ != SHTCX_TYPE_SHTC1) {
     this->wake_up();
   }
   if (!this->write_command(SHTCX_COMMAND_POLLING_H)) {
-    ESP_LOGE(TAG, "sensor polling failed");
+    ESP_LOGE(TAG, "Polling failed");
     if (this->temperature_sensor_ != nullptr)
       this->temperature_sensor_->publish_state(NAN);
     if (this->humidity_sensor_ != nullptr)
@@ -91,13 +87,13 @@ void SHTCXComponent::update() {
     float humidity = NAN;
     uint16_t raw_data[2];
     if (!this->read_data(raw_data, 2)) {
-      ESP_LOGE(TAG, "sensor read failed");
+      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
       this->status_set_warning();
     } else {
       temperature = 175.0f * float(raw_data[0]) / 65536.0f - 45.0f;
       humidity = 100.0f * float(raw_data[1]) / 65536.0f;
 
-      ESP_LOGD(TAG, "Got temperature=%.2f°C humidity=%.2f%%", temperature, humidity);
+      ESP_LOGD(TAG, "Temperature=%.2f°C Humidity=%.2f%%", temperature, humidity);
     }
     if (this->temperature_sensor_ != nullptr)
       this->temperature_sensor_->publish_state(temperature);
@@ -114,6 +110,7 @@ void SHTCXComponent::soft_reset() {
   this->write_command(SHTCX_COMMAND_SOFT_RESET);
   delayMicroseconds(200);
 }
+
 void SHTCXComponent::sleep() { this->write_command(SHTCX_COMMAND_SLEEP); }
 
 void SHTCXComponent::wake_up() {

esphome/components/shutdown/button/shutdown_button.cpp

@@ -17,7 +17,7 @@ static const char *const TAG = "shutdown.button";
 
 void ShutdownButton::dump_config() { LOG_BUTTON("", "Shutdown Button", this); }
 void ShutdownButton::press_action() {
-  ESP_LOGI(TAG, "Shutting down...");
+  ESP_LOGI(TAG, "Shutting down");
   // Let MQTT settle a bit
   delay(100);  // NOLINT
   App.run_safe_shutdown_hooks();

esphome/components/shutdown/switch/shutdown_switch.cpp

@@ -21,7 +21,7 @@ void ShutdownSwitch::write_state(bool state) {
   this->publish_state(false);
 
   if (state) {
-    ESP_LOGI(TAG, "Shutting down...");
+    ESP_LOGI(TAG, "Shutting down");
     delay(100);  // NOLINT
 
     App.run_safe_shutdown_hooks();

esphome/components/sim800l/sim800l.cpp

@@ -28,7 +28,7 @@ void Sim800LComponent::update() {
       this->state_ = STATE_DIALING1;
     } else if (this->registered_ && this->connect_pending_) {
       this->connect_pending_ = false;
-      ESP_LOGI(TAG, "Connecting...");
+      ESP_LOGI(TAG, "Connecting");
       this->send_cmd_("ATA");
       this->state_ = STATE_ATA_SENT;
     } else if (this->registered_ && this->send_ussd_pending_) {
@@ -36,7 +36,7 @@ void Sim800LComponent::update() {
       this->state_ = STATE_SEND_USSD1;
     } else if (this->registered_ && this->disconnect_pending_) {
       this->disconnect_pending_ = false;
-      ESP_LOGI(TAG, "Disconnecting...");
+      ESP_LOGI(TAG, "Disconnecting");
       this->send_cmd_("ATH");
     } else if (this->registered_ && this->call_state_ != 6) {
       send_cmd_("AT+CLCC");

esphome/components/slow_pwm/slow_pwm_output.cpp

@@ -63,8 +63,10 @@ void SlowPWMOutput::dump_config() {
   if (this->turn_off_trigger_) {
     ESP_LOGCONFIG(TAG, "  Turn off automation configured");
   }
-  ESP_LOGCONFIG(TAG, "  Period: %d ms", this->period_);
-  ESP_LOGCONFIG(TAG, "  Restart cycle on state change: %s", YESNO(this->restart_cycle_on_state_change_));
+  ESP_LOGCONFIG(TAG,
+                "  Period: %d ms\n"
+                "  Restart cycle on state change: %s",
+                this->period_, YESNO(this->restart_cycle_on_state_change_));
   LOG_FLOAT_OUTPUT(this);
 }
 

esphome/components/sm16716/sm16716.cpp

@@ -7,7 +7,7 @@ namespace sm16716 {
 static const char *const TAG = "sm16716";
 
 void SM16716::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SM16716OutputComponent...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   this->clock_pin_->setup();

esphome/components/sm2135/sm2135.cpp

@@ -20,7 +20,7 @@ static const uint8_t SM2135_RGB = 0x00;  // RGB channel
 static const uint8_t SM2135_CW = 0x80;   // CW channel (Chip default)
 
 void SM2135::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SM2135OutputComponent...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   this->data_pin_->pin_mode(gpio::FLAG_OUTPUT);

esphome/components/sm2235/sm2235.cpp

@@ -7,7 +7,7 @@ namespace sm2235 {
 static const char *const TAG = "sm2235";
 
 void SM2235::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up sm2235 Output Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(true);
   this->clock_pin_->setup();
@@ -19,8 +19,10 @@ void SM2235::dump_config() {
   ESP_LOGCONFIG(TAG, "sm2235:");
   LOG_PIN("  Data Pin: ", this->data_pin_);
   LOG_PIN("  Clock Pin: ", this->clock_pin_);
-  ESP_LOGCONFIG(TAG, "  Color Channels Max Power: %u", this->max_power_color_channels_);
-  ESP_LOGCONFIG(TAG, "  White Channels Max Power: %u", this->max_power_white_channels_);
+  ESP_LOGCONFIG(TAG,
+                "  Color Channels Max Power: %u\n"
+                "  White Channels Max Power: %u",
+                this->max_power_color_channels_, this->max_power_white_channels_);
 }
 
 }  // namespace sm2235

esphome/components/sm2335/sm2335.cpp

@@ -7,7 +7,7 @@ namespace sm2335 {
 static const char *const TAG = "sm2335";
 
 void SM2335::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up sm2335 Output Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(true);
   this->clock_pin_->setup();
@@ -19,8 +19,10 @@ void SM2335::dump_config() {
   ESP_LOGCONFIG(TAG, "sm2335:");
   LOG_PIN("  Data Pin: ", this->data_pin_);
   LOG_PIN("  Clock Pin: ", this->clock_pin_);
-  ESP_LOGCONFIG(TAG, "  Color Channels Max Power: %u", this->max_power_color_channels_);
-  ESP_LOGCONFIG(TAG, "  White Channels Max Power: %u", this->max_power_white_channels_);
+  ESP_LOGCONFIG(TAG,
+                "  Color Channels Max Power: %u\n"
+                "  White Channels Max Power: %u",
+                this->max_power_color_channels_, this->max_power_white_channels_);
 }
 
 }  // namespace sm2335

esphome/components/sml/sml.cpp

@@ -1,6 +1,6 @@
 #include "sml.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "sml_parser.h"
 
 namespace esphome {

esphome/components/sn74hc165/sn74hc165.cpp

@@ -7,8 +7,7 @@ namespace sn74hc165 {
 static const char *const TAG = "sn74hc165";
 
 void SN74HC165Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SN74HC165...");
-
+  ESP_LOGCONFIG(TAG, "Running setup");
   // initialize pins
   this->clock_pin_->setup();
   this->data_pin_->setup();

esphome/components/sn74hc595/sn74hc595.cpp

@@ -7,8 +7,7 @@ namespace sn74hc595 {
 static const char *const TAG = "sn74hc595";
 
 void SN74HC595Component::pre_setup_() {
-  ESP_LOGCONFIG(TAG, "Setting up SN74HC595...");
-
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->have_oe_pin_) {  // disable output
     this->oe_pin_->setup();
     this->oe_pin_->digital_write(true);

esphome/components/sntp/sntp_component.cpp

@@ -15,7 +15,7 @@ namespace sntp {
 static const char *const TAG = "sntp";
 
 void SNTPComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SNTP...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 #if defined(USE_ESP_IDF)
   if (esp_sntp_enabled()) {
     esp_sntp_stop();

esphome/components/socket/__init__.py

@@ -35,5 +35,7 @@ async def to_code(config):
         cg.add_define("USE_SOCKET_IMPL_LWIP_TCP")
     elif impl == IMPLEMENTATION_LWIP_SOCKETS:
         cg.add_define("USE_SOCKET_IMPL_LWIP_SOCKETS")
+        cg.add_define("USE_SOCKET_SELECT_SUPPORT")
     elif impl == IMPLEMENTATION_BSD_SOCKETS:
         cg.add_define("USE_SOCKET_IMPL_BSD_SOCKETS")
+        cg.add_define("USE_SOCKET_SELECT_SUPPORT")

esphome/components/socket/bsd_sockets_impl.cpp

@@ -5,6 +5,7 @@
 #ifdef USE_SOCKET_IMPL_BSD_SOCKETS
 
 #include <cstring>
+#include "esphome/core/application.h"
 
 #ifdef USE_ESP32
 #include <esp_idf_version.h>
@@ -40,7 +41,20 @@ std::string format_sockaddr(const struct sockaddr_storage &storage) {
 
 class BSDSocketImpl : public Socket {
  public:
-  BSDSocketImpl(int fd) : fd_(fd) {}
+  BSDSocketImpl(int fd, bool monitor_loop = false) : fd_(fd) {
+#ifdef USE_SOCKET_SELECT_SUPPORT
+    // Register new socket with the application for select() if monitoring requested
+    if (monitor_loop && fd_ >= 0) {
+      // Only set loop_monitored_ to true if registration succeeds
+      loop_monitored_ = App.register_socket_fd(fd_);
+    } else {
+      loop_monitored_ = false;
+    }
+#else
+    // Without select support, ignore monitor_loop parameter
+    (void) monitor_loop;
+#endif
+  }
   ~BSDSocketImpl() override {
     if (!closed_) {
       close();  // NOLINT(clang-analyzer-optin.cplusplus.VirtualCall)
@@ -48,16 +62,35 @@ class BSDSocketImpl : public Socket {
   }
   int connect(const struct sockaddr *addr, socklen_t addrlen) override { return ::connect(fd_, addr, addrlen); }
   std::unique_ptr<Socket> accept(struct sockaddr *addr, socklen_t *addrlen) override {
+    return accept_impl_(addr, addrlen, false);
+  }
+  std::unique_ptr<Socket> accept_loop_monitored(struct sockaddr *addr, socklen_t *addrlen) override {
+    return accept_impl_(addr, addrlen, true);
+  }
+
+ private:
+  std::unique_ptr<Socket> accept_impl_(struct sockaddr *addr, socklen_t *addrlen, bool loop_monitored) {
     int fd = ::accept(fd_, addr, addrlen);
     if (fd == -1)
       return {};
-    return make_unique<BSDSocketImpl>(fd);
+    return make_unique<BSDSocketImpl>(fd, loop_monitored);
   }
+
+ public:
   int bind(const struct sockaddr *addr, socklen_t addrlen) override { return ::bind(fd_, addr, addrlen); }
   int close() override {
-    int ret = ::close(fd_);
-    closed_ = true;
-    return ret;
+    if (!closed_) {
+#ifdef USE_SOCKET_SELECT_SUPPORT
+      // Unregister from select() before closing if monitored
+      if (loop_monitored_) {
+        App.unregister_socket_fd(fd_);
+      }
+#endif
+      int ret = ::close(fd_);
+      closed_ = true;
+      return ret;
+    }
+    return 0;
   }
   int shutdown(int how) override { return ::shutdown(fd_, how); }
 
@@ -126,16 +159,27 @@ class BSDSocketImpl : public Socket {
     return 0;
   }
 
+  int get_fd() const override { return fd_; }
+
  protected:
   int fd_;
   bool closed_ = false;
 };
 
-std::unique_ptr<Socket> socket(int domain, int type, int protocol) {
+// Helper to create a socket with optional monitoring
+static std::unique_ptr<Socket> create_socket(int domain, int type, int protocol, bool loop_monitored = false) {
   int ret = ::socket(domain, type, protocol);
   if (ret == -1)
     return nullptr;
-  return std::unique_ptr<Socket>{new BSDSocketImpl(ret)};
+  return std::unique_ptr<Socket>{new BSDSocketImpl(ret, loop_monitored)};
+}
+
+std::unique_ptr<Socket> socket(int domain, int type, int protocol) {
+  return create_socket(domain, type, protocol, false);
+}
+
+std::unique_ptr<Socket> socket_loop_monitored(int domain, int type, int protocol) {
+  return create_socket(domain, type, protocol, true);
 }
 
 }  // namespace socket

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -606,6 +606,11 @@ std::unique_ptr<Socket> socket(int domain, int type, int protocol) {
   return std::unique_ptr<Socket>{sock};
 }
 
+std::unique_ptr<Socket> socket_loop_monitored(int domain, int type, int protocol) {
+  // LWIPRawImpl doesn't use file descriptors, so monitoring is not applicable
+  return socket(domain, type, protocol);
+}
+
 }  // namespace socket
 }  // namespace esphome
 

esphome/components/socket/lwip_sockets_impl.cpp

@@ -5,6 +5,7 @@
 #ifdef USE_SOCKET_IMPL_LWIP_SOCKETS
 
 #include <cstring>
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace socket {
@@ -33,7 +34,20 @@ std::string format_sockaddr(const struct sockaddr_storage &storage) {
 
 class LwIPSocketImpl : public Socket {
  public:
-  LwIPSocketImpl(int fd) : fd_(fd) {}
+  LwIPSocketImpl(int fd, bool monitor_loop = false) : fd_(fd) {
+#ifdef USE_SOCKET_SELECT_SUPPORT
+    // Register new socket with the application for select() if monitoring requested
+    if (monitor_loop && fd_ >= 0) {
+      // Only set loop_monitored_ to true if registration succeeds
+      loop_monitored_ = App.register_socket_fd(fd_);
+    } else {
+      loop_monitored_ = false;
+    }
+#else
+    // Without select support, ignore monitor_loop parameter
+    (void) monitor_loop;
+#endif
+  }
   ~LwIPSocketImpl() override {
     if (!closed_) {
       close();  // NOLINT(clang-analyzer-optin.cplusplus.VirtualCall)
@@ -41,16 +55,35 @@ class LwIPSocketImpl : public Socket {
   }
   int connect(const struct sockaddr *addr, socklen_t addrlen) override { return lwip_connect(fd_, addr, addrlen); }
   std::unique_ptr<Socket> accept(struct sockaddr *addr, socklen_t *addrlen) override {
+    return accept_impl_(addr, addrlen, false);
+  }
+  std::unique_ptr<Socket> accept_loop_monitored(struct sockaddr *addr, socklen_t *addrlen) override {
+    return accept_impl_(addr, addrlen, true);
+  }
+
+ private:
+  std::unique_ptr<Socket> accept_impl_(struct sockaddr *addr, socklen_t *addrlen, bool loop_monitored) {
     int fd = lwip_accept(fd_, addr, addrlen);
     if (fd == -1)
       return {};
-    return make_unique<LwIPSocketImpl>(fd);
+    return make_unique<LwIPSocketImpl>(fd, loop_monitored);
   }
+
+ public:
   int bind(const struct sockaddr *addr, socklen_t addrlen) override { return lwip_bind(fd_, addr, addrlen); }
   int close() override {
-    int ret = lwip_close(fd_);
-    closed_ = true;
-    return ret;
+    if (!closed_) {
+#ifdef USE_SOCKET_SELECT_SUPPORT
+      // Unregister from select() before closing if monitored
+      if (loop_monitored_) {
+        App.unregister_socket_fd(fd_);
+      }
+#endif
+      int ret = lwip_close(fd_);
+      closed_ = true;
+      return ret;
+    }
+    return 0;
   }
   int shutdown(int how) override { return lwip_shutdown(fd_, how); }
 
@@ -98,16 +131,27 @@ class LwIPSocketImpl : public Socket {
     return 0;
   }
 
+  int get_fd() const override { return fd_; }
+
  protected:
   int fd_;
   bool closed_ = false;
 };
 
-std::unique_ptr<Socket> socket(int domain, int type, int protocol) {
+// Helper to create a socket with optional monitoring
+static std::unique_ptr<Socket> create_socket(int domain, int type, int protocol, bool loop_monitored = false) {
   int ret = lwip_socket(domain, type, protocol);
   if (ret == -1)
     return nullptr;
-  return std::unique_ptr<Socket>{new LwIPSocketImpl(ret)};
+  return std::unique_ptr<Socket>{new LwIPSocketImpl(ret, loop_monitored)};
+}
+
+std::unique_ptr<Socket> socket(int domain, int type, int protocol) {
+  return create_socket(domain, type, protocol, false);
+}
+
+std::unique_ptr<Socket> socket_loop_monitored(int domain, int type, int protocol) {
+  return create_socket(domain, type, protocol, true);
 }
 
 }  // namespace socket

esphome/components/socket/socket.cpp

@@ -4,12 +4,35 @@
 #include <cstring>
 #include <string>
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace socket {
 
 Socket::~Socket() {}
 
+bool Socket::ready() const {
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  if (!loop_monitored_) {
+    // Non-monitored sockets always return true (assume data may be available)
+    return true;
+  }
+
+  // For loop-monitored sockets, check with the Application's select() results
+  int fd = this->get_fd();
+  if (fd < 0) {
+    // No valid file descriptor, assume ready (fallback behavior)
+    return true;
+  }
+
+  return App.is_socket_ready(fd);
+#else
+  // Without select() support, we can't monitor sockets in the loop
+  // Always return true (assume data may be available)
+  return true;
+#endif
+}
+
 std::unique_ptr<Socket> socket_ip(int type, int protocol) {
 #if USE_NETWORK_IPV6
   return socket(AF_INET6, type, protocol);
@@ -18,6 +41,14 @@ std::unique_ptr<Socket> socket_ip(int type, int protocol) {
 #endif /* USE_NETWORK_IPV6 */
 }
 
+std::unique_ptr<Socket> socket_ip_loop_monitored(int type, int protocol) {
+#if USE_NETWORK_IPV6
+  return socket_loop_monitored(AF_INET6, type, protocol);
+#else
+  return socket_loop_monitored(AF_INET, type, protocol);
+#endif /* USE_NETWORK_IPV6 */
+}
+
 socklen_t set_sockaddr(struct sockaddr *addr, socklen_t addrlen, const std::string &ip_address, uint16_t port) {
 #if USE_NETWORK_IPV6
   if (ip_address.find(':') != std::string::npos) {

esphome/components/socket/socket.h

@@ -17,6 +17,11 @@ class Socket {
   Socket &operator=(const Socket &) = delete;
 
   virtual std::unique_ptr<Socket> accept(struct sockaddr *addr, socklen_t *addrlen) = 0;
+  /// Accept a connection and monitor it in the main loop
+  /// NOTE: This function is NOT thread-safe and must only be called from the main loop
+  virtual std::unique_ptr<Socket> accept_loop_monitored(struct sockaddr *addr, socklen_t *addrlen) {
+    return accept(addr, addrlen);  // Default implementation for backward compatibility
+  }
   virtual int bind(const struct sockaddr *addr, socklen_t addrlen) = 0;
   virtual int close() = 0;
   // not supported yet:
@@ -44,14 +49,35 @@ class Socket {
 
   virtual int setblocking(bool blocking) = 0;
   virtual int loop() { return 0; };
+
+  /// Get the underlying file descriptor (returns -1 if not supported)
+  virtual int get_fd() const { return -1; }
+
+  /// Check if socket has data ready to read
+  /// For loop-monitored sockets, checks with the Application's select() results
+  /// For non-monitored sockets, always returns true (assumes data may be available)
+  bool ready() const;
+
+ protected:
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  bool loop_monitored_{false};  ///< Whether this socket is monitored by the event loop
+#endif
 };
 
 /// Create a socket of the given domain, type and protocol.
 std::unique_ptr<Socket> socket(int domain, int type, int protocol);
-
 /// Create a socket in the newest available IP domain (IPv6 or IPv4) of the given type and protocol.
 std::unique_ptr<Socket> socket_ip(int type, int protocol);
 
+/// Create a socket and monitor it for data in the main loop.
+/// Like socket() but also registers the socket with the Application's select() loop.
+/// WARNING: These functions are NOT thread-safe. They must only be called from the main loop
+/// as they register the socket file descriptor with the global Application instance.
+/// NOTE: On ESP platforms, FD_SETSIZE is typically 10, limiting the number of monitored sockets.
+/// File descriptors >= FD_SETSIZE will not be monitored and will log an error.
+std::unique_ptr<Socket> socket_loop_monitored(int domain, int type, int protocol);
+std::unique_ptr<Socket> socket_ip_loop_monitored(int type, int protocol);
+
 /// Set a sockaddr to the specified address and port for the IP version used by socket_ip().
 socklen_t set_sockaddr(struct sockaddr *addr, socklen_t addrlen, const std::string &ip_address, uint16_t port);
 

esphome/components/sonoff_d1/sonoff_d1.cpp

@@ -286,10 +286,13 @@ void SonoffD1Output::write_state(light::LightState *state) {
 }
 
 void SonoffD1Output::dump_config() {
-  ESP_LOGCONFIG(TAG, "Sonoff D1 Dimmer: '%s'", this->light_state_ ? this->light_state_->get_name().c_str() : "");
-  ESP_LOGCONFIG(TAG, "  Use RM433 Remote: %s", ONOFF(this->use_rm433_remote_));
-  ESP_LOGCONFIG(TAG, "  Minimal brightness: %d", this->min_value_);
-  ESP_LOGCONFIG(TAG, "  Maximal brightness: %d", this->max_value_);
+  ESP_LOGCONFIG(TAG,
+                "Sonoff D1 Dimmer: '%s'\n"
+                "  Use RM433 Remote: %s\n"
+                "  Minimal brightness: %d\n"
+                "  Maximal brightness: %d",
+                this->light_state_ ? this->light_state_->get_name().c_str() : "", ONOFF(this->use_rm433_remote_),
+                this->min_value_, this->max_value_);
 }
 
 void SonoffD1Output::loop() {

esphome/components/sonoff_d1/sonoff_d1.h

@@ -31,9 +31,9 @@
   -----
 */
 
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "esphome/components/uart/uart.h"
 #include "esphome/components/light/light_output.h"
 #include "esphome/components/light/light_state.h"

esphome/components/sound_level/sound_level.cpp

@@ -19,8 +19,10 @@ static const uint32_t RING_BUFFER_DURATION_MS = 120;
 static const double MAX_SAMPLE_SQUARED_DENOMINATOR = INT16_MIN * INT16_MIN;
 
 void SoundLevelComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Sound Level Component:");
-  ESP_LOGCONFIG(TAG, "  Measurement Duration: %" PRIu32 " ms", measurement_duration_ms_);
+  ESP_LOGCONFIG(TAG,
+                "Sound Level Component:\n"
+                "  Measurement Duration: %" PRIu32 " ms",
+                measurement_duration_ms_);
   LOG_SENSOR("  ", "Peak:", this->peak_sensor_);
 
   LOG_SENSOR("  ", "RMS:", this->rms_sensor_);

esphome/components/speaker/media_player/__init__.py

@@ -48,6 +48,7 @@ CONF_ON_UNMUTE = "on_unmute"
 CONF_ON_VOLUME = "on_volume"
 CONF_STREAM = "stream"
 CONF_VOLUME_INCREMENT = "volume_increment"
+CONF_VOLUME_INITIAL = "volume_initial"
 CONF_VOLUME_MIN = "volume_min"
 CONF_VOLUME_MAX = "volume_max"
 
@@ -282,6 +283,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_FILES): cv.ensure_list(MEDIA_FILE_TYPE_SCHEMA),
             cv.Optional(CONF_TASK_STACK_IN_PSRAM, default=False): cv.boolean,
             cv.Optional(CONF_VOLUME_INCREMENT, default=0.05): cv.percentage,
+            cv.Optional(CONF_VOLUME_INITIAL, default=0.5): cv.percentage,
             cv.Optional(CONF_VOLUME_MAX, default=1.0): cv.percentage,
             cv.Optional(CONF_VOLUME_MIN, default=0.0): cv.percentage,
             cv.Optional(CONF_ON_MUTE): automation.validate_automation(single=True),
@@ -356,6 +358,7 @@ async def to_code(config):
         )
 
     cg.add(var.set_volume_increment(config[CONF_VOLUME_INCREMENT]))
+    cg.add(var.set_volume_initial(config[CONF_VOLUME_INITIAL]))
     cg.add(var.set_volume_max(config[CONF_VOLUME_MAX]))
     cg.add(var.set_volume_min(config[CONF_VOLUME_MIN]))
 

esphome/components/speaker/media_player/speaker_media_player.cpp

@@ -48,8 +48,6 @@ static const uint32_t MEDIA_CONTROLS_QUEUE_LENGTH = 20;
 static const UBaseType_t MEDIA_PIPELINE_TASK_PRIORITY = 1;
 static const UBaseType_t ANNOUNCEMENT_PIPELINE_TASK_PRIORITY = 1;
 
-static const float FIRST_BOOT_DEFAULT_VOLUME = 0.5f;
-
 static const char *const TAG = "speaker_media_player";
 
 void SpeakerMediaPlayer::setup() {
@@ -64,7 +62,7 @@ void SpeakerMediaPlayer::setup() {
     this->set_volume_(volume_restore_state.volume);
     this->set_mute_state_(volume_restore_state.is_muted);
   } else {
-    this->set_volume_(FIRST_BOOT_DEFAULT_VOLUME);
+    this->set_volume_(this->volume_initial_);
     this->set_mute_state_(false);
   }