esphome 2024.12.4__py3-none-any.whl → 2025.2.0b2__py3-none-any.whl

esphome/components/speaker/media_player/speaker_media_player.h

@@ -0,0 +1,160 @@
+#pragma once
+
+#ifdef USE_ESP_IDF
+
+#include "audio_pipeline.h"
+
+#include "esphome/components/audio/audio.h"
+
+#include "esphome/components/media_player/media_player.h"
+#include "esphome/components/speaker/speaker.h"
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/core/preferences.h"
+
+#include <deque>
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+namespace esphome {
+namespace speaker {
+
+struct MediaCallCommand {
+  optional<media_player::MediaPlayerCommand> command;
+  optional<float> volume;
+  optional<bool> announce;
+  optional<bool> new_url;
+  optional<bool> new_file;
+  optional<bool> enqueue;
+};
+
+struct PlaylistItem {
+  optional<std::string> url;
+  optional<audio::AudioFile *> file;
+};
+
+struct VolumeRestoreState {
+  float volume;
+  bool is_muted;
+};
+
+class SpeakerMediaPlayer : public Component, public media_player::MediaPlayer {
+ public:
+  float get_setup_priority() const override { return esphome::setup_priority::PROCESSOR; }
+  void setup() override;
+  void loop() override;
+
+  // MediaPlayer implementations
+  media_player::MediaPlayerTraits get_traits() override;
+  bool is_muted() const override { return this->is_muted_; }
+
+  void set_buffer_size(size_t buffer_size) { this->buffer_size_ = buffer_size; }
+  void set_task_stack_in_psram(bool task_stack_in_psram) { this->task_stack_in_psram_ = task_stack_in_psram; }
+
+  // Percentage to increase or decrease the volume for volume up or volume down commands
+  void set_volume_increment(float volume_increment) { this->volume_increment_ = volume_increment; }
+
+  void set_volume_max(float volume_max) { this->volume_max_ = volume_max; }
+  void set_volume_min(float volume_min) { this->volume_min_ = volume_min; }
+
+  void set_announcement_speaker(Speaker *announcement_speaker) { this->announcement_speaker_ = announcement_speaker; }
+  void set_announcement_format(const media_player::MediaPlayerSupportedFormat &announcement_format) {
+    this->announcement_format_ = announcement_format;
+  }
+  void set_media_speaker(Speaker *media_speaker) { this->media_speaker_ = media_speaker; }
+  void set_media_format(const media_player::MediaPlayerSupportedFormat &media_format) {
+    this->media_format_ = media_format;
+  }
+
+  Trigger<> *get_mute_trigger() const { return this->mute_trigger_; }
+  Trigger<> *get_unmute_trigger() const { return this->unmute_trigger_; }
+  Trigger<float> *get_volume_trigger() const { return this->volume_trigger_; }
+
+  void play_file(audio::AudioFile *media_file, bool announcement, bool enqueue);
+
+  uint32_t get_playback_ms() const { return this->playback_ms_; }
+  uint32_t get_playback_us() const { return this->playback_us_; }
+  uint32_t get_decoded_playback_ms() const { return this->decoded_playback_ms_; }
+
+  void set_playlist_delay_ms(AudioPipelineType pipeline_type, uint32_t delay_ms);
+
+ protected:
+  // Receives commands from HA or from the voice assistant component
+  // Sends commands to the media_control_commanda_queue_
+  void control(const media_player::MediaPlayerCall &call) override;
+
+  /// @brief Updates this->volume and saves volume/mute state to flash for restortation if publish is true.
+  void set_volume_(float volume, bool publish = true);
+
+  /// @brief Sets the mute state. Restores previous volume if unmuting. Always saves volume/mute state to flash for
+  /// restoration.
+  /// @param mute_state If true, audio will be muted. If false, audio will be unmuted
+  void set_mute_state_(bool mute_state);
+
+  /// @brief Saves the current volume and mute state to the flash for restoration.
+  void save_volume_restore_state_();
+
+  /// Returns true if the media player has only the announcement pipeline defined, false if both the announcement and
+  /// media pipelines are defined.
+  inline bool single_pipeline_() { return (this->media_speaker_ == nullptr); }
+
+  // Processes commands from media_control_command_queue_.
+  void watch_media_commands_();
+
+  std::unique_ptr<AudioPipeline> announcement_pipeline_;
+  std::unique_ptr<AudioPipeline> media_pipeline_;
+  Speaker *media_speaker_{nullptr};
+  Speaker *announcement_speaker_{nullptr};
+
+  optional<media_player::MediaPlayerSupportedFormat> media_format_;
+  AudioPipelineState media_pipeline_state_{AudioPipelineState::STOPPED};
+  std::string media_url_{};         // only modified by control function
+  audio::AudioFile *media_file_{};  // only modified by play_file function
+  bool media_repeat_one_{false};
+  uint32_t media_playlist_delay_ms_{0};
+
+  optional<media_player::MediaPlayerSupportedFormat> announcement_format_;
+  AudioPipelineState announcement_pipeline_state_{AudioPipelineState::STOPPED};
+  std::string announcement_url_{};         // only modified by control function
+  audio::AudioFile *announcement_file_{};  // only modified by play_file function
+  bool announcement_repeat_one_{false};
+  uint32_t announcement_playlist_delay_ms_{0};
+
+  QueueHandle_t media_control_command_queue_;
+
+  std::deque<PlaylistItem> announcement_playlist_;
+  std::deque<PlaylistItem> media_playlist_;
+
+  size_t buffer_size_;
+
+  bool task_stack_in_psram_;
+
+  bool is_paused_{false};
+  bool is_muted_{false};
+
+  // The amount to change the volume on volume up/down commands
+  float volume_increment_;
+
+  float volume_max_;
+  float volume_min_;
+
+  // Used to save volume/mute state for restoration on reboot
+  ESPPreferenceObject pref_;
+
+  Trigger<> *mute_trigger_ = new Trigger<>();
+  Trigger<> *unmute_trigger_ = new Trigger<>();
+  Trigger<float> *volume_trigger_ = new Trigger<float>();
+
+  uint32_t decoded_playback_ms_{0};
+  uint32_t playback_us_{0};
+  uint32_t playback_ms_{0};
+  uint32_t remainder_us_{0};
+  uint32_t pending_ms_{0};
+  uint32_t last_audio_write_timestamp_{0};
+};
+
+}  // namespace speaker
+}  // namespace esphome
+
+#endif

esphome/components/speaker/speaker.h

@@ -9,6 +9,7 @@
 #endif
 
 #include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
 
 #include "esphome/components/audio/audio.h"
 #ifdef USE_AUDIO_DAC
@@ -56,6 +57,10 @@ class Speaker {
   // When finish() is not implemented on the platform component it should just do a normal stop.
   virtual void finish() { this->stop(); }
 
+  // Pauses processing incoming audio. Needs to be implemented specifically per speaker component
+  virtual void set_pause_state(bool pause_state) {}
+  virtual bool get_pause_state() const { return false; }
+
   virtual bool has_buffered_data() const = 0;
 
   bool is_running() const { return this->state_ == STATE_RUNNING; }
@@ -95,6 +100,19 @@ class Speaker {
     this->audio_stream_info_ = audio_stream_info;
   }
 
+  audio::AudioStreamInfo &get_audio_stream_info() { return this->audio_stream_info_; }
+
+  /// Callback function for sending the duration of the audio written to the speaker since the last callback.
+  /// Parameters:
+  ///   - Duration in milliseconds. Never rounded and should always be less than or equal to the actual duration.
+  ///   - Remainder duration in microseconds. Rounded duration after subtracting the previous parameter from the actual
+  ///     duration.
+  ///   - Duration of remaining, unwritten audio buffered in the speaker in milliseconds.
+  ///   - System time in microseconds when the last write was completed.
+  void add_audio_output_callback(std::function<void(uint32_t, uint32_t, uint32_t, uint32_t)> &&callback) {
+    this->audio_output_callback_.add(std::move(callback));
+  }
+
  protected:
   State state_{STATE_STOPPED};
   audio::AudioStreamInfo audio_stream_info_;
@@ -104,6 +122,8 @@ class Speaker {
 #ifdef USE_AUDIO_DAC
   audio_dac::AudioDac *audio_dac_{nullptr};
 #endif
+
+  CallbackManager<void(uint32_t, uint32_t, uint32_t, uint32_t)> audio_output_callback_{};
 };
 
 }  // namespace speaker

esphome/components/spi/__init__.py

@@ -97,11 +97,7 @@ RP_SPI_PINSETS = [
 
 
 def get_target_platform():
-    return (
-        CORE.data[KEY_CORE][KEY_TARGET_PLATFORM]
-        if KEY_TARGET_PLATFORM in CORE.data[KEY_CORE]
-        else ""
-    )
+    return CORE.data[KEY_CORE][KEY_TARGET_PLATFORM]
 
 
 def get_target_variant():

esphome/components/spi/spi.cpp

@@ -7,6 +7,10 @@ namespace spi {
 
 const char *const TAG = "spi";
 
+SPIDelegate *const SPIDelegate::NULL_DELEGATE =  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+    new SPIDelegateDummy();
+// https://bugs.llvm.org/show_bug.cgi?id=48040
+
 bool SPIDelegate::is_ready() { return true; }
 
 GPIOPin *const NullPin::NULL_PIN = new NullPin();  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -75,6 +79,8 @@ void SPIComponent::dump_config() {
   }
 }
 
+void SPIDelegateDummy::begin_transaction() { ESP_LOGE(TAG, "SPIDevice not initialised - did you call spi_setup()?"); }
+
 uint8_t SPIDelegateBitBash::transfer(uint8_t data) { return this->transfer_(data, 8); }
 
 void SPIDelegateBitBash::write(uint16_t data, size_t num_bits) { this->transfer_(data, num_bits); }
@@ -82,7 +88,7 @@ void SPIDelegateBitBash::write(uint16_t data, size_t num_bits) { this->transfer_
 uint16_t SPIDelegateBitBash::transfer_(uint16_t data, size_t num_bits) {
   // Clock starts out at idle level
   this->clk_pin_->digital_write(clock_polarity_);
-  uint8_t out_data = 0;
+  uint16_t out_data = 0;
 
   for (uint8_t i = 0; i != num_bits; i++) {
     uint8_t shift;

esphome/components/spi/spi.h

@@ -114,6 +114,8 @@ class NullPin : public GPIOPin {
 
   void pin_mode(gpio::Flags flags) override {}
 
+  gpio::Flags get_flags() const override { return gpio::Flags::FLAG_NONE; }
+
   bool digital_read() override { return false; }
 
   void digital_write(bool value) override {}
@@ -163,6 +165,8 @@ class Utility {
   }
 };
 
+class SPIDelegateDummy;
+
 // represents a device attached to an SPI bus, with a defined clock rate, mode and bit order. On Arduino this is
 // a thin wrapper over SPIClass.
 class SPIDelegate {
@@ -248,6 +252,21 @@ class SPIDelegate {
   uint32_t data_rate_{1000000};
   SPIMode mode_{MODE0};
   GPIOPin *cs_pin_{NullPin::NULL_PIN};
+  static SPIDelegate *const NULL_DELEGATE;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+};
+
+/**
+ * A dummy SPIDelegate that complains if it's used.
+ */
+
+class SPIDelegateDummy : public SPIDelegate {
+ public:
+  SPIDelegateDummy() = default;
+
+  uint8_t transfer(uint8_t data) override { return 0; }
+  void end_transaction() override{};
+
+  void begin_transaction() override;
 };
 
 /**
@@ -365,7 +384,7 @@ class SPIClient {
 
   virtual void spi_teardown() {
     this->parent_->unregister_device(this);
-    this->delegate_ = nullptr;
+    this->delegate_ = SPIDelegate::NULL_DELEGATE;
   }
 
   bool spi_is_ready() { return this->delegate_->is_ready(); }
@@ -376,7 +395,7 @@ class SPIClient {
   uint32_t data_rate_{1000000};
   SPIComponent *parent_{nullptr};
   GPIOPin *cs_{nullptr};
-  SPIDelegate *delegate_{nullptr};
+  SPIDelegate *delegate_{SPIDelegate::NULL_DELEGATE};
 };
 
 /**

esphome/components/spi_led_strip/light.py

@@ -1,8 +1,7 @@
 import esphome.codegen as cg
+from esphome.components import light, spi
 import esphome.config_validation as cv
-from esphome.components import light
-from esphome.components import spi
-from esphome.const import CONF_OUTPUT_ID, CONF_NUM_LEDS
+from esphome.const import CONF_NUM_LEDS, CONF_OUTPUT_ID
 
 spi_led_strip_ns = cg.esphome_ns.namespace("spi_led_strip")
 SpiLedStrip = spi_led_strip_ns.class_(
@@ -18,8 +17,7 @@ CONFIG_SCHEMA = light.ADDRESSABLE_LIGHT_SCHEMA.extend(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
-    cg.add(var.set_num_leds(config[CONF_NUM_LEDS]))
+    var = cg.new_Pvariable(config[CONF_OUTPUT_ID], config[CONF_NUM_LEDS])
     await light.register_light(var, config)
     await spi.register_spi_device(var, config)
     await cg.register_component(var, config)

esphome/components/spi_led_strip/spi_led_strip.cpp

@@ -0,0 +1,67 @@
+#include "spi_led_strip.h"
+
+namespace esphome {
+namespace spi_led_strip {
+
+SpiLedStrip::SpiLedStrip(uint16_t num_leds) {
+  this->num_leds_ = num_leds;
+  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  this->buffer_size_ = num_leds * 4 + 8;
+  this->buf_ = allocator.allocate(this->buffer_size_);
+  if (this->buf_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to allocate buffer of size %u", this->buffer_size_);
+    return;
+  }
+
+  this->effect_data_ = allocator.allocate(num_leds);
+  if (this->effect_data_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to allocate effect data of size %u", num_leds);
+    return;
+  }
+  memset(this->buf_, 0xFF, this->buffer_size_);
+  memset(this->buf_, 0, 4);
+}
+void SpiLedStrip::setup() {
+  if (this->effect_data_ == nullptr || this->buf_ == nullptr) {
+    this->mark_failed();
+    return;
+  }
+  this->spi_setup();
+}
+light::LightTraits SpiLedStrip::get_traits() {
+  auto traits = light::LightTraits();
+  traits.set_supported_color_modes({light::ColorMode::RGB});
+  return traits;
+}
+void SpiLedStrip::dump_config() {
+  esph_log_config(TAG, "SPI LED Strip:");
+  esph_log_config(TAG, "  LEDs: %d", this->num_leds_);
+  if (this->data_rate_ >= spi::DATA_RATE_1MHZ) {
+    esph_log_config(TAG, "  Data rate: %uMHz", (unsigned) (this->data_rate_ / 1000000));
+  } else {
+    esph_log_config(TAG, "  Data rate: %ukHz", (unsigned) (this->data_rate_ / 1000));
+  }
+}
+void SpiLedStrip::write_state(light::LightState *state) {
+  if (this->is_failed())
+    return;
+  if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE) {
+    char strbuf[49];
+    size_t len = std::min(this->buffer_size_, (size_t) (sizeof(strbuf) - 1) / 3);
+    memset(strbuf, 0, sizeof(strbuf));
+    for (size_t i = 0; i != len; i++) {
+      sprintf(strbuf + i * 3, "%02X ", this->buf_[i]);
+    }
+    esph_log_v(TAG, "write_state: buf = %s", strbuf);
+  }
+  this->enable();
+  this->write_array(this->buf_, this->buffer_size_);
+  this->disable();
+}
+light::ESPColorView SpiLedStrip::get_view_internal(int32_t index) const {
+  size_t pos = index * 4 + 5;
+  return {this->buf_ + pos + 2,       this->buf_ + pos + 1, this->buf_ + pos + 0, nullptr,
+          this->effect_data_ + index, &this->correction_};
+}
+}  // namespace spi_led_strip
+}  // namespace esphome

esphome/components/spi_led_strip/spi_led_strip.h

@@ -13,74 +13,22 @@ class SpiLedStrip : public light::AddressableLight,
                     public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH, spi::CLOCK_PHASE_TRAILING,
                                           spi::DATA_RATE_1MHZ> {
  public:
-  void setup() override { this->spi_setup(); }
+  SpiLedStrip(uint16_t num_leds);
+  void setup() override;
+  float get_setup_priority() const override { return setup_priority::IO; }
 
   int32_t size() const override { return this->num_leds_; }
 
-  light::LightTraits get_traits() override {
-    auto traits = light::LightTraits();
-    traits.set_supported_color_modes({light::ColorMode::RGB});
-    return traits;
-  }
-  void set_num_leds(uint16_t num_leds) {
-    this->num_leds_ = num_leds;
-    ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
-    this->buffer_size_ = num_leds * 4 + 8;
-    this->buf_ = allocator.allocate(this->buffer_size_);
-    if (this->buf_ == nullptr) {
-      esph_log_e(TAG, "Failed to allocate buffer of size %u", this->buffer_size_);
-      this->mark_failed();
-      return;
-    }
+  light::LightTraits get_traits() override;
 
-    this->effect_data_ = allocator.allocate(num_leds);
-    if (this->effect_data_ == nullptr) {
-      esph_log_e(TAG, "Failed to allocate effect data of size %u", num_leds);
-      this->mark_failed();
-      return;
-    }
-    memset(this->buf_, 0xFF, this->buffer_size_);
-    memset(this->buf_, 0, 4);
-  }
+  void dump_config() override;
 
-  void dump_config() override {
-    esph_log_config(TAG, "SPI LED Strip:");
-    esph_log_config(TAG, "  LEDs: %d", this->num_leds_);
-    if (this->data_rate_ >= spi::DATA_RATE_1MHZ) {
-      esph_log_config(TAG, "  Data rate: %uMHz", (unsigned) (this->data_rate_ / 1000000));
-    } else {
-      esph_log_config(TAG, "  Data rate: %ukHz", (unsigned) (this->data_rate_ / 1000));
-    }
-  }
+  void write_state(light::LightState *state) override;
 
-  void write_state(light::LightState *state) override {
-    if (this->is_failed())
-      return;
-    if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE) {
-      char strbuf[49];
-      size_t len = std::min(this->buffer_size_, (size_t) (sizeof(strbuf) - 1) / 3);
-      memset(strbuf, 0, sizeof(strbuf));
-      for (size_t i = 0; i != len; i++) {
-        sprintf(strbuf + i * 3, "%02X ", this->buf_[i]);
-      }
-      esph_log_v(TAG, "write_state: buf = %s", strbuf);
-    }
-    this->enable();
-    this->write_array(this->buf_, this->buffer_size_);
-    this->disable();
-  }
-
-  void clear_effect_data() override {
-    for (int i = 0; i < this->size(); i++)
-      this->effect_data_[i] = 0;
-  }
+  void clear_effect_data() override { memset(this->effect_data_, 0, this->num_leds_ * sizeof(this->effect_data_[0])); }
 
  protected:
-  light::ESPColorView get_view_internal(int32_t index) const override {
-    size_t pos = index * 4 + 5;
-    return {this->buf_ + pos + 2,       this->buf_ + pos + 1, this->buf_ + pos + 0, nullptr,
-            this->effect_data_ + index, &this->correction_};
-  }
+  light::ESPColorView get_view_internal(int32_t index) const override;
 
   size_t buffer_size_{};
   uint8_t *effect_data_{nullptr};

esphome/components/sprinkler/sprinkler.cpp

@@ -184,11 +184,13 @@ void SprinklerValveOperator::set_controller(Sprinkler *controller) {
 
 void SprinklerValveOperator::set_valve(SprinklerValve *valve) {
   if (valve != nullptr) {
+    if (this->state_ != IDLE) {  // Only kill if not already idle
+      this->kill_();             // ensure everything is off before we let go!
+    }
     this->state_ = IDLE;      // reset state
     this->run_duration_ = 0;  // reset to ensure the valve isn't started without updating it
     this->start_millis_ = 0;  // reset because (new) valve has not been started yet
     this->stop_millis_ = 0;   // reset because (new) valve has not been started yet
-    this->kill_();            // ensure everything is off before we let go!
     this->valve_ = valve;     // finally, set the pointer to the new valve
   }
 }

esphome/components/sx1509/sx1509_gpio_pin.h

@@ -20,6 +20,8 @@ class SX1509GPIOPin : public GPIOPin {
   void set_inverted(bool inverted) { this->inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { this->flags_ = flags; }
 
+  gpio::Flags get_flags() const override { return this->flags_; }
+
  protected:
   SX1509Component *parent_;
   uint8_t pin_;

esphome/components/tca9555/tca9555.h

@@ -54,6 +54,8 @@ class TCA9555GPIOPin : public GPIOPin, public Parented<TCA9555Component> {
   void set_inverted(bool inverted) { this->inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { this->flags_ = flags; }
 
+  gpio::Flags get_flags() const override { return this->flags_; }
+
  protected:
   uint8_t pin_;
   bool inverted_;

esphome/components/toshiba/toshiba.cpp

@@ -106,8 +106,9 @@ void ToshibaClimate::setup() {
       this->publish_state();
     });
     this->current_temperature = this->sensor_->state;
-  } else
+  } else {
     this->current_temperature = NAN;
+  }
   // restore set points
   auto restore = this->restore_state_();
   if (restore.has_value()) {

esphome/components/tuya/light/tuya_light.cpp

@@ -120,8 +120,9 @@ light::LightTraits TuyaLight::get_traits() {
         traits.set_supported_color_modes(
             {light::ColorMode::RGB_COLOR_TEMPERATURE, light::ColorMode::COLOR_TEMPERATURE});
       }
-    } else
+    } else {
       traits.set_supported_color_modes({light::ColorMode::COLOR_TEMPERATURE});
+    }
     traits.set_min_mireds(this->cold_white_temperature_);
     traits.set_max_mireds(this->warm_white_temperature_);
   } else if (this->color_id_.has_value()) {
@@ -131,8 +132,9 @@ light::LightTraits TuyaLight::get_traits() {
       } else {
         traits.set_supported_color_modes({light::ColorMode::RGB_WHITE});
       }
-    } else
+    } else {
       traits.set_supported_color_modes({light::ColorMode::RGB});
+    }
   } else if (this->dimmer_id_.has_value()) {
     traits.set_supported_color_modes({light::ColorMode::BRIGHTNESS});
   } else {

esphome/components/uart/uart_component_esp32_arduino.cpp

@@ -1,9 +1,9 @@
 #ifdef USE_ESP32_FRAMEWORK_ARDUINO
+#include "uart_component_esp32_arduino.h"
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "uart_component_esp32_arduino.h"
 
 #ifdef USE_LOGGER
 #include "esphome/components/logger/logger.h"
@@ -118,7 +118,7 @@ void ESP32ArduinoUARTComponent::setup() {
     }
 #endif  // USE_LOGGER
 
-    if (next_uart_num >= UART_NUM_MAX) {
+    if (next_uart_num >= SOC_UART_NUM) {
       ESP_LOGW(TAG, "Maximum number of UART components created already.");
       this->mark_failed();
       return;

esphome/components/uart/uart_component_esp_idf.cpp

@@ -1,11 +1,11 @@
 #ifdef USE_ESP_IDF
 
 #include "uart_component_esp_idf.h"
+#include <cinttypes>
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include <cinttypes>
 
 #ifdef USE_LOGGER
 #include "esphome/components/logger/logger.h"
@@ -84,7 +84,7 @@ void IDFUARTComponent::setup() {
   }
 #endif  // USE_LOGGER
 
-  if (next_uart_num >= UART_NUM_MAX) {
+  if (next_uart_num >= SOC_UART_NUM) {
     ESP_LOGW(TAG, "Maximum number of UART components created already.");
     this->mark_failed();
     return;

esphome/components/udp/__init__.py

@@ -18,7 +18,7 @@ from esphome.cpp_generator import MockObjClass
 
 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
-AUTO_LOAD = ["socket"]
+AUTO_LOAD = ["socket", "xxtea"]
 MULTI_CONF = True
 
 udp_ns = cg.esphome_ns.namespace("udp")
@@ -27,6 +27,7 @@ UDPComponent = udp_ns.class_("UDPComponent", cg.PollingComponent)
 CONF_BROADCAST = "broadcast"
 CONF_BROADCAST_ID = "broadcast_id"
 CONF_ADDRESSES = "addresses"
+CONF_LISTEN_ADDRESS = "listen_address"
 CONF_PROVIDER = "provider"
 CONF_PROVIDERS = "providers"
 CONF_REMOTE_ID = "remote_id"
@@ -84,8 +85,11 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(UDPComponent),
             cv.Optional(CONF_PORT, default=18511): cv.port,
+            cv.Optional(
+                CONF_LISTEN_ADDRESS, default="255.255.255.255"
+            ): cv.ipv4address_multi_broadcast,
             cv.Optional(CONF_ADDRESSES, default=["255.255.255.255"]): cv.ensure_list(
-                cv.ipv4
+                cv.ipv4address,
             ),
             cv.Optional(CONF_ROLLING_CODE_ENABLE, default=False): cv.boolean,
             cv.Optional(CONF_PING_PONG_ENABLE, default=False): cv.boolean,
@@ -154,5 +158,7 @@ async def to_code(config):
     for provider in config.get(CONF_PROVIDERS, ()):
         name = provider[CONF_NAME]
         cg.add(var.add_provider(name))
+        if (listen_address := str(config[CONF_LISTEN_ADDRESS])) != "255.255.255.255":
+            cg.add(var.set_listen_address(listen_address))
         if encryption := provider.get(CONF_ENCRYPTION):
             cg.add(var.set_provider_encryption(name, hash_encryption_key(encryption)))