esphome 2024.11.2__py3-none-any.whl → 2024.12.0__py3-none-any.whl

esphome/components/hbridge/switch/__init__.py

@@ -0,0 +1,44 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_OPTIMISTIC, CONF_PULSE_LENGTH, CONF_WAIT_TIME
+
+from .. import hbridge_ns
+
+HBridgeSwitch = hbridge_ns.class_("HBridgeSwitch", switch.Switch, cg.Component)
+
+CODEOWNERS = ["@dwmw2"]
+
+CONF_OFF_PIN = "off_pin"
+CONF_ON_PIN = "on_pin"
+
+CONFIG_SCHEMA = (
+    switch.switch_schema(HBridgeSwitch)
+    .extend(
+        {
+            cv.Required(CONF_ON_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_OFF_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(
+                CONF_PULSE_LENGTH, default="100ms"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_WAIT_TIME): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = await switch.new_switch(config)
+    await cg.register_component(var, config)
+
+    on_pin = await cg.gpio_pin_expression(config[CONF_ON_PIN])
+    cg.add(var.set_on_pin(on_pin))
+    off_pin = await cg.gpio_pin_expression(config[CONF_OFF_PIN])
+    cg.add(var.set_off_pin(off_pin))
+    cg.add(var.set_pulse_length(config[CONF_PULSE_LENGTH]))
+    cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
+    if wait_time := config.get(CONF_WAIT_TIME):
+        cg.add(var.set_wait_time(wait_time))

esphome/components/hbridge/switch/hbridge_switch.cpp

@@ -0,0 +1,95 @@
+#include "hbridge_switch.h"
+#include "esphome/core/log.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace hbridge {
+
+static const char *const TAG = "switch.hbridge";
+
+float HBridgeSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
+void HBridgeSwitch::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up H-Bridge Switch '%s'...", this->name_.c_str());
+
+  optional<bool> initial_state = this->get_initial_state_with_restore_mode().value_or(false);
+
+  // Like GPIOSwitch does, set the pin state both before and after pin setup()
+  this->on_pin_->digital_write(false);
+  this->on_pin_->setup();
+  this->on_pin_->digital_write(false);
+
+  this->off_pin_->digital_write(false);
+  this->off_pin_->setup();
+  this->off_pin_->digital_write(false);
+
+  if (initial_state.has_value())
+    this->write_state(initial_state);
+}
+
+void HBridgeSwitch::dump_config() {
+  LOG_SWITCH("", "H-Bridge Switch", this);
+  LOG_PIN("  On Pin: ", this->on_pin_);
+  LOG_PIN("  Off Pin: ", this->off_pin_);
+  ESP_LOGCONFIG(TAG, "  Pulse length: %" PRId32 " ms", this->pulse_length_);
+  if (this->wait_time_)
+    ESP_LOGCONFIG(TAG, "  Wait time %" PRId32 " ms", this->wait_time_);
+}
+
+void HBridgeSwitch::write_state(bool state) {
+  this->desired_state_ = state;
+  if (!this->timer_running_)
+    this->timer_fn_();
+}
+
+void HBridgeSwitch::timer_fn_() {
+  uint32_t next_timeout = 0;
+
+  while ((uint8_t) this->desired_state_ != this->relay_state_) {
+    switch (this->relay_state_) {
+      case RELAY_STATE_ON:
+      case RELAY_STATE_OFF:
+      case RELAY_STATE_UNKNOWN:
+        if (this->desired_state_) {
+          this->on_pin_->digital_write(true);
+          this->relay_state_ = RELAY_STATE_SWITCHING_ON;
+        } else {
+          this->off_pin_->digital_write(true);
+          this->relay_state_ = RELAY_STATE_SWITCHING_OFF;
+        }
+        next_timeout = this->pulse_length_;
+        if (!this->optimistic_)
+          this->publish_state(this->desired_state_);
+        break;
+
+      case RELAY_STATE_SWITCHING_ON:
+        this->on_pin_->digital_write(false);
+        this->relay_state_ = RELAY_STATE_ON;
+        if (this->optimistic_)
+          this->publish_state(true);
+        next_timeout = this->wait_time_;
+        break;
+
+      case RELAY_STATE_SWITCHING_OFF:
+        this->off_pin_->digital_write(false);
+        this->relay_state_ = RELAY_STATE_OFF;
+        if (this->optimistic_)
+          this->publish_state(false);
+        next_timeout = this->wait_time_;
+        break;
+    }
+
+    if (next_timeout) {
+      this->timer_running_ = true;
+      this->set_timeout(next_timeout, [this]() { this->timer_fn_(); });
+      return;
+    }
+
+    // In the case where ON/OFF state has been reached but we need to
+    // immediately change back again to reach desired_state_, we loop.
+  }
+  this->timer_running_ = false;
+}
+
+}  // namespace hbridge
+}  // namespace esphome

esphome/components/hbridge/switch/hbridge_switch.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+#include "esphome/components/switch/switch.h"
+
+#include <vector>
+
+namespace esphome {
+namespace hbridge {
+
+enum RelayState : uint8_t {
+  RELAY_STATE_OFF = 0,
+  RELAY_STATE_ON = 1,
+  RELAY_STATE_SWITCHING_ON = 2,
+  RELAY_STATE_SWITCHING_OFF = 3,
+  RELAY_STATE_UNKNOWN = 4,
+};
+
+class HBridgeSwitch : public switch_::Switch, public Component {
+ public:
+  void set_on_pin(GPIOPin *pin) { this->on_pin_ = pin; }
+  void set_off_pin(GPIOPin *pin) { this->off_pin_ = pin; }
+  void set_pulse_length(uint32_t pulse_length) { this->pulse_length_ = pulse_length; }
+  void set_wait_time(uint32_t wait_time) { this->wait_time_ = wait_time; }
+  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+
+  // ========== INTERNAL METHODS ==========
+  // (In most use cases you won't need these)
+  float get_setup_priority() const override;
+
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  void write_state(bool state) override;
+  void timer_fn_();
+
+  bool timer_running_{false};
+  bool desired_state_{false};
+  RelayState relay_state_{RELAY_STATE_UNKNOWN};
+  GPIOPin *on_pin_{nullptr};
+  GPIOPin *off_pin_{nullptr};
+  uint32_t pulse_length_{0};
+  uint32_t wait_time_{0};
+  bool optimistic_{false};
+};
+
+}  // namespace hbridge
+}  // namespace esphome

esphome/components/hitachi_ac344/hitachi_ac344.cpp

@@ -133,8 +133,10 @@ bool HitachiClimate::get_swing_v_() {
 }
 
 void HitachiClimate::set_swing_h_(uint8_t position) {
-  if (position > HITACHI_AC344_SWINGH_LEFT_MAX)
-    return set_swing_h_(HITACHI_AC344_SWINGH_MIDDLE);
+  if (position > HITACHI_AC344_SWINGH_LEFT_MAX) {
+    set_swing_h_(HITACHI_AC344_SWINGH_MIDDLE);
+    return;
+  }
   set_bits(&remote_state_[HITACHI_AC344_SWINGH_BYTE], HITACHI_AC344_SWINGH_OFFSET, HITACHI_AC344_SWINGH_SIZE, position);
   set_button_(HITACHI_AC344_BUTTON_SWINGH);
 }

esphome/components/hitachi_ac424/hitachi_ac424.cpp

@@ -133,8 +133,10 @@ bool HitachiClimate::get_swing_v_() {
 }
 
 void HitachiClimate::set_swing_h_(uint8_t position) {
-  if (position > HITACHI_AC424_SWINGH_LEFT_MAX)
-    return set_swing_h_(HITACHI_AC424_SWINGH_MIDDLE);
+  if (position > HITACHI_AC424_SWINGH_LEFT_MAX) {
+    set_swing_h_(HITACHI_AC424_SWINGH_MIDDLE);
+    return;
+  }
   set_bits(&remote_state_[HITACHI_AC424_SWINGH_BYTE], HITACHI_AC424_SWINGH_OFFSET, HITACHI_AC424_SWINGH_SIZE, position);
   set_button_(HITACHI_AC424_BUTTON_SWINGH);
 }

esphome/components/homeassistant/number/homeassistant_number.cpp

@@ -27,6 +27,7 @@ void HomeassistantNumber::min_retrieved_(const std::string &min) {
   auto min_value = parse_number<float>(min);
   if (!min_value.has_value()) {
     ESP_LOGE(TAG, "'%s': Can't convert 'min' value '%s' to number!", this->entity_id_.c_str(), min.c_str());
+    return;
   }
   ESP_LOGD(TAG, "'%s': Min retrieved: %s", get_name().c_str(), min.c_str());
   this->traits.set_min_value(min_value.value());
@@ -36,6 +37,7 @@ void HomeassistantNumber::max_retrieved_(const std::string &max) {
   auto max_value = parse_number<float>(max);
   if (!max_value.has_value()) {
     ESP_LOGE(TAG, "'%s': Can't convert 'max' value '%s' to number!", this->entity_id_.c_str(), max.c_str());
+    return;
   }
   ESP_LOGD(TAG, "'%s': Max retrieved: %s", get_name().c_str(), max.c_str());
   this->traits.set_max_value(max_value.value());
@@ -45,6 +47,7 @@ void HomeassistantNumber::step_retrieved_(const std::string &step) {
   auto step_value = parse_number<float>(step);
   if (!step_value.has_value()) {
     ESP_LOGE(TAG, "'%s': Can't convert 'step' value '%s' to number!", this->entity_id_.c_str(), step.c_str());
+    return;
   }
   ESP_LOGD(TAG, "'%s': Step Retrieved %s", get_name().c_str(), step.c_str());
   this->traits.set_step(step_value.value());

esphome/components/hx711/hx711.cpp

@@ -53,7 +53,7 @@ bool HX711Sensor::read_sensor_(uint32_t *result) {
     }
 
     // Cycle clock pin for gain setting
-    for (uint8_t i = 0; i < this->gain_; i++) {
+    for (uint8_t i = 0; i < static_cast<uint8_t>(this->gain_); i++) {
       this->sck_pin_->digital_write(true);
       delayMicroseconds(1);
       this->sck_pin_->digital_write(false);

esphome/components/hx711/hx711.h

@@ -9,7 +9,7 @@
 namespace esphome {
 namespace hx711 {
 
-enum HX711Gain {
+enum HX711Gain : uint8_t {
   HX711_GAIN_128 = 1,
   HX711_GAIN_32 = 2,
   HX711_GAIN_64 = 3,

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -17,14 +17,14 @@ void IDFI2CBus::setup() {
   ESP_LOGCONFIG(TAG, "Setting up I2C bus...");
   static i2c_port_t next_port = I2C_NUM_0;
   port_ = next_port;
-#if I2C_NUM_MAX > 1
+#if SOC_I2C_NUM > 1
   next_port = (next_port == I2C_NUM_0) ? I2C_NUM_1 : I2C_NUM_MAX;
 #else
   next_port = I2C_NUM_MAX;
 #endif
 
   if (port_ == I2C_NUM_MAX) {
-    ESP_LOGE(TAG, "Too many I2C buses configured");
+    ESP_LOGE(TAG, "Too many I2C buses configured. Max %u supported.", SOC_I2C_NUM);
     this->mark_failed();
     return;
   }

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -33,14 +33,15 @@ enum SpeakerEventGroupBits : uint32_t {
   STATE_RUNNING = (1 << 11),
   STATE_STOPPING = (1 << 12),
   STATE_STOPPED = (1 << 13),
-  ERR_INVALID_FORMAT = (1 << 14),
-  ERR_TASK_FAILED_TO_START = (1 << 15),
-  ERR_ESP_INVALID_STATE = (1 << 16),
+  ERR_TASK_FAILED_TO_START = (1 << 14),
+  ERR_ESP_INVALID_STATE = (1 << 15),
+  ERR_ESP_NOT_SUPPORTED = (1 << 16),
   ERR_ESP_INVALID_ARG = (1 << 17),
   ERR_ESP_INVALID_SIZE = (1 << 18),
   ERR_ESP_NO_MEM = (1 << 19),
   ERR_ESP_FAIL = (1 << 20),
-  ALL_ERR_ESP_BITS = ERR_ESP_INVALID_STATE | ERR_ESP_INVALID_ARG | ERR_ESP_INVALID_SIZE | ERR_ESP_NO_MEM | ERR_ESP_FAIL,
+  ALL_ERR_ESP_BITS = ERR_ESP_INVALID_STATE | ERR_ESP_NOT_SUPPORTED | ERR_ESP_INVALID_ARG | ERR_ESP_INVALID_SIZE |
+                     ERR_ESP_NO_MEM | ERR_ESP_FAIL,
   ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
 };
 
@@ -55,6 +56,8 @@ static esp_err_t err_bit_to_esp_err(uint32_t bit) {
       return ESP_ERR_INVALID_SIZE;
     case SpeakerEventGroupBits::ERR_ESP_NO_MEM:
       return ESP_ERR_NO_MEM;
+    case SpeakerEventGroupBits::ERR_ESP_NOT_SUPPORTED:
+      return ESP_ERR_NOT_SUPPORTED;
     default:
       return ESP_FAIL;
   }
@@ -135,19 +138,19 @@ void I2SAudioSpeaker::loop() {
     xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ERR_TASK_FAILED_TO_START);
   }
 
-  if (event_group_bits & SpeakerEventGroupBits::ERR_INVALID_FORMAT) {
+  if (event_group_bits & SpeakerEventGroupBits::ALL_ERR_ESP_BITS) {
+    uint32_t error_bits = event_group_bits & SpeakerEventGroupBits::ALL_ERR_ESP_BITS;
+    ESP_LOGW(TAG, "Error writing to I2S: %s", esp_err_to_name(err_bit_to_esp_err(error_bits)));
+    this->status_set_warning();
+  }
+
+  if (event_group_bits & SpeakerEventGroupBits::ERR_ESP_NOT_SUPPORTED) {
     this->status_set_error("Failed to adjust I2S bus to match the incoming audio");
     ESP_LOGE(TAG,
              "Incompatible audio format: sample rate = %" PRIu32 ", channels = %" PRIu8 ", bits per sample = %" PRIu8,
              this->audio_stream_info_.sample_rate, this->audio_stream_info_.channels,
              this->audio_stream_info_.bits_per_sample);
   }
-
-  if (event_group_bits & SpeakerEventGroupBits::ALL_ERR_ESP_BITS) {
-    uint32_t error_bits = event_group_bits & SpeakerEventGroupBits::ALL_ERR_ESP_BITS;
-    ESP_LOGW(TAG, "Error writing to I2S: %s", esp_err_to_name(err_bit_to_esp_err(error_bits)));
-    this->status_set_warning();
-  }
 }
 
 void I2SAudioSpeaker::set_volume(float volume) {
@@ -236,13 +239,15 @@ void I2SAudioSpeaker::speaker_task(void *params) {
   xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::STATE_STARTING);
 
   audio::AudioStreamInfo audio_stream_info = this_speaker->audio_stream_info_;
-  const ssize_t bytes_per_sample = audio_stream_info.get_bytes_per_sample();
-  const uint8_t number_of_channels = audio_stream_info.channels;
 
-  const size_t dma_buffers_size = DMA_BUFFERS_COUNT * DMA_BUFFER_DURATION_MS * this_speaker->sample_rate_ / 1000 *
-                                  bytes_per_sample * number_of_channels;
+  const uint32_t bytes_per_ms =
+      audio_stream_info.channels * audio_stream_info.get_bytes_per_sample() * audio_stream_info.sample_rate / 1000;
+
+  const size_t dma_buffers_size = DMA_BUFFERS_COUNT * DMA_BUFFER_DURATION_MS * bytes_per_ms;
+
+  // Ensure ring buffer is at least as large as the total size of the DMA buffers
   const size_t ring_buffer_size =
-      this_speaker->buffer_duration_ms_ * this_speaker->sample_rate_ / 1000 * bytes_per_sample * number_of_channels;
+      std::max((uint32_t) dma_buffers_size, this_speaker->buffer_duration_ms_ * bytes_per_ms);
 
   if (this_speaker->send_esp_err_to_event_group_(this_speaker->allocate_buffers_(dma_buffers_size, ring_buffer_size))) {
     // Failed to allocate buffers
@@ -250,14 +255,7 @@ void I2SAudioSpeaker::speaker_task(void *params) {
     this_speaker->delete_task_(dma_buffers_size);
   }
 
-  if (this_speaker->send_esp_err_to_event_group_(this_speaker->start_i2s_driver_())) {
-    // Failed to start I2S driver
-    this_speaker->delete_task_(dma_buffers_size);
-  }
-
-  if (!this_speaker->send_esp_err_to_event_group_(this_speaker->reconfigure_i2s_stream_info_(audio_stream_info))) {
-    // Successfully set the I2S stream info, ready to write audio data to the I2S port
-
+  if (!this_speaker->send_esp_err_to_event_group_(this_speaker->start_i2s_driver_(audio_stream_info))) {
     xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::STATE_RUNNING);
 
     bool stop_gracefully = false;
@@ -275,6 +273,12 @@ void I2SAudioSpeaker::speaker_task(void *params) {
         stop_gracefully = true;
       }
 
+      if (this_speaker->audio_stream_info_ != audio_stream_info) {
+        // Audio stream info has changed, stop the speaker task so it will restart with the proper settings.
+
+        break;
+      }
+
       i2s_event_t i2s_event;
       while (xQueueReceive(this_speaker->i2s_event_queue_, &i2s_event, 0)) {
         if (i2s_event.type == I2S_EVENT_TX_Q_OVF) {
@@ -316,17 +320,14 @@ void I2SAudioSpeaker::speaker_task(void *params) {
         }
       }
     }
-  } else {
-    // Couldn't configure the I2S port to be compatible with the incoming audio
-    xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::ERR_INVALID_FORMAT);
-  }
-  i2s_zero_dma_buffer(this_speaker->parent_->get_port());
 
-  xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::STATE_STOPPING);
+    xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::STATE_STOPPING);
+
+    i2s_driver_uninstall(this_speaker->parent_->get_port());
 
-  i2s_driver_uninstall(this_speaker->parent_->get_port());
+    this_speaker->parent_->unlock();
+  }
 
-  this_speaker->parent_->unlock();
   this_speaker->delete_task_(dma_buffers_size);
 }
 
@@ -382,6 +383,9 @@ bool I2SAudioSpeaker::send_esp_err_to_event_group_(esp_err_t err) {
     case ESP_ERR_NO_MEM:
       xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_ESP_NO_MEM);
       return true;
+    case ESP_ERR_NOT_SUPPORTED:
+      xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_ESP_NOT_SUPPORTED);
+      return true;
     default:
       xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_ESP_FAIL);
       return true;
@@ -411,18 +415,40 @@ esp_err_t I2SAudioSpeaker::allocate_buffers_(size_t data_buffer_size, size_t rin
   return ESP_OK;
 }
 
-esp_err_t I2SAudioSpeaker::start_i2s_driver_() {
+esp_err_t I2SAudioSpeaker::start_i2s_driver_(audio::AudioStreamInfo &audio_stream_info) {
+  if ((this->i2s_mode_ & I2S_MODE_SLAVE) && (this->sample_rate_ != audio_stream_info.sample_rate)) {  // NOLINT
+    //  Can't reconfigure I2S bus, so the sample rate must match the configured value
+    return ESP_ERR_NOT_SUPPORTED;
+  }
+
+  if ((i2s_bits_per_sample_t) audio_stream_info.bits_per_sample > this->bits_per_sample_) {
+    // Currently can't handle the case when the incoming audio has more bits per sample than the configured value
+    return ESP_ERR_NOT_SUPPORTED;
+  }
+
   if (!this->parent_->try_lock()) {
     return ESP_ERR_INVALID_STATE;
   }
 
+  i2s_channel_fmt_t channel = this->channel_;
+
+  if (audio_stream_info.channels == 1) {
+    if (this->channel_ == I2S_CHANNEL_FMT_ONLY_LEFT) {
+      channel = I2S_CHANNEL_FMT_ONLY_LEFT;
+    } else {
+      channel = I2S_CHANNEL_FMT_ONLY_RIGHT;
+    }
+  } else if (audio_stream_info.channels == 2) {
+    channel = I2S_CHANNEL_FMT_RIGHT_LEFT;
+  }
+
   int dma_buffer_length = DMA_BUFFER_DURATION_MS * this->sample_rate_ / 1000;
 
   i2s_driver_config_t config = {
     .mode = (i2s_mode_t) (this->i2s_mode_ | I2S_MODE_TX),
-    .sample_rate = this->sample_rate_,
+    .sample_rate = audio_stream_info.sample_rate,
     .bits_per_sample = this->bits_per_sample_,
-    .channel_format = this->channel_,
+    .channel_format = channel,
     .communication_format = this->i2s_comm_fmt_,
     .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
     .dma_buf_count = DMA_BUFFERS_COUNT,
@@ -477,30 +503,6 @@ esp_err_t I2SAudioSpeaker::start_i2s_driver_() {
   return err;
 }
 
-esp_err_t I2SAudioSpeaker::reconfigure_i2s_stream_info_(audio::AudioStreamInfo &audio_stream_info) {
-  if (this->i2s_mode_ & I2S_MODE_MASTER) {
-    // ESP controls for the the I2S bus, so adjust the sample rate and bits per sample to match the incoming audio
-    this->sample_rate_ = audio_stream_info.sample_rate;
-    this->bits_per_sample_ = (i2s_bits_per_sample_t) audio_stream_info.bits_per_sample;
-  } else if (this->sample_rate_ != audio_stream_info.sample_rate) {
-    // Can't reconfigure I2S bus, so the sample rate must match the configured value
-    return ESP_ERR_INVALID_ARG;
-  }
-
-  if ((i2s_bits_per_sample_t) audio_stream_info.bits_per_sample > this->bits_per_sample_) {
-    // Currently can't handle the case when the incoming audio has more bits per sample than the configured value
-    return ESP_ERR_INVALID_ARG;
-  }
-
-  if (audio_stream_info.channels == 1) {
-    return i2s_set_clk(this->parent_->get_port(), this->sample_rate_, this->bits_per_sample_, I2S_CHANNEL_MONO);
-  } else if (audio_stream_info.channels == 2) {
-    return i2s_set_clk(this->parent_->get_port(), this->sample_rate_, this->bits_per_sample_, I2S_CHANNEL_STEREO);
-  }
-
-  return ESP_ERR_INVALID_ARG;
-}
-
 void I2SAudioSpeaker::delete_task_(size_t buffer_size) {
   this->audio_ring_buffer_.reset();  // Releases onwership of the shared_ptr
 

esphome/components/i2s_audio/speaker/i2s_audio_speaker.h

@@ -91,24 +91,15 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
   esp_err_t allocate_buffers_(size_t data_buffer_size, size_t ring_buffer_size);
 
   /// @brief Starts the ESP32 I2S driver.
-  /// Attempts to lock the I2S port, starts the I2S driver, and sets the data out pin. If it fails, it will unlock
-  /// the I2S port and uninstall the driver, if necessary.
-  /// @return ESP_ERR_INVALID_STATE if the I2S port is already locked.
-  ///         ESP_ERR_INVALID_ARG if installing the driver or setting the data out pin fails due to a parameter error.
+  /// Attempts to lock the I2S port, starts the I2S driver using the passed in stream information, and sets the data out
+  /// pin. If it fails, it will unlock the I2S port and uninstall the driver, if necessary.
+  /// @param audio_stream_info Stream information for the I2S driver.
+  /// @return ESP_ERR_NOT_ALLOWED if the I2S port can't play the incoming audio stream.
+  ///         ESP_ERR_INVALID_STATE if the I2S port is already locked.
+  ///         ESP_ERR_INVALID_ARG if nstalling the driver or setting the data outpin fails due to a parameter error.
   ///         ESP_ERR_NO_MEM if the driver fails to install due to a memory allocation error.
-  ///         ESP_FAIL if setting the data out pin fails due to an IO error
-  ///         ESP_OK if successful
-  esp_err_t start_i2s_driver_();
-
-  /// @brief Adjusts the I2S driver configuration to match the incoming audio stream.
-  /// Modifies I2S driver's sample rate, bits per sample, and number of channel settings. If the I2S is in secondary
-  /// mode, it only modifies the number of channels.
-  /// @param audio_stream_info  Describes the incoming audio stream
-  /// @return ESP_ERR_INVALID_ARG if there is a parameter error, if there is more than 2 channels in the stream, or if
-  ///           the audio settings are incompatible with the configuration.
-  ///         ESP_ERR_NO_MEM if the driver fails to reconfigure due to a memory allocation error.
-  ///         ESP_OK if successful.
-  esp_err_t reconfigure_i2s_stream_info_(audio::AudioStreamInfo &audio_stream_info);
+  ///         ESP_FAIL if setting the data out pin fails due to an IO error ESP_OK if successful
+  esp_err_t start_i2s_driver_(audio::AudioStreamInfo &audio_stream_info);
 
   /// @brief Deletes the speaker's task.
   /// Deallocates the data_buffer_ and audio_ring_buffer_, if necessary, and deletes the task. Should only be called by

esphome/components/ili9xxx/display.py

@@ -1,6 +1,6 @@
 from esphome import core, pins
 import esphome.codegen as cg
-from esphome.components import display, font, spi
+from esphome.components import display, spi
 from esphome.components.display import validate_rotation
 import esphome.config_validation as cv
 from esphome.const import (
@@ -147,7 +147,6 @@ def _validate(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    font.validate_pillow_installed,
     display.FULL_DISPLAY_SCHEMA.extend(
         {
             cv.GenerateID(): cv.declare_id(ILI9XXXDisplay),

esphome/components/ili9xxx/ili9xxx_display.cpp

@@ -313,8 +313,9 @@ void ILI9XXXDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, cons
   // do color conversion pixel-by-pixel into the buffer and draw it later. If this is happening the user has not
   // configured the renderer well.
   if (this->rotation_ != display::DISPLAY_ROTATION_0_DEGREES || bitness != display::COLOR_BITNESS_565 || !big_endian) {
-    return display::Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset,
-                                            x_pad);
+    display::Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset,
+                                     x_pad);
+    return;
   }
   this->set_addr_window_(x_start, y_start, x_start + w - 1, y_start + h - 1);
   // x_ and y_offset are offsets into the source buffer, unrelated to our own offsets into the display.

esphome/components/image/__init__.py

@@ -10,7 +10,6 @@ import puremagic
 
 from esphome import core, external_files
 import esphome.codegen as cg
-from esphome.components import font
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DITHER,
@@ -233,7 +232,7 @@ IMAGE_SCHEMA = cv.Schema(
     )
 )
 
-CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, IMAGE_SCHEMA)
+CONFIG_SCHEMA = IMAGE_SCHEMA
 
 
 def load_svg_image(file: bytes, resize: tuple[int, int]):

esphome/components/logger/logger.cpp

@@ -47,7 +47,7 @@ void Logger::write_header_(int level, const char *tag, int line) {
   if (current_task == main_task_) {
     this->printf_to_buffer_("%s[%s][%s:%03u]: ", color, letter, tag, line);
   } else {
-    const char *thread_name = "";
+    const char *thread_name = "";  // NOLINT(clang-analyzer-deadcode.DeadStores)
 #if defined(USE_ESP32)
     thread_name = pcTaskGetName(current_task);
 #elif defined(USE_LIBRETINY)

esphome/components/ltr501/ltr501.cpp

@@ -23,7 +23,7 @@ bool operator==(const GainTimePair &lhs, const GainTimePair &rhs) {
 }
 
 bool operator!=(const GainTimePair &lhs, const GainTimePair &rhs) {
-  return !(lhs.gain == rhs.gain && lhs.time == rhs.time);
+  return lhs.gain != rhs.gain || lhs.time != rhs.time;
 }
 
 template<typename T, size_t size> T get_next(const T (&array)[size], const T val) {

esphome/components/lvgl/defines.py

@@ -8,7 +8,7 @@ import logging
 
 from esphome import codegen as cg, config_validation as cv
 from esphome.const import CONF_ITEMS
-from esphome.core import Lambda
+from esphome.core import ID, Lambda
 from esphome.cpp_generator import LambdaExpression, MockObj
 from esphome.cpp_types import uint32
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
@@ -38,7 +38,7 @@ def literal(arg):
 def call_lambda(lamb: LambdaExpression):
     expr = lamb.content.strip()
     if expr.startswith("return") and expr.endswith(";"):
-        return expr[7:][:-1]
+        return expr[6:][:-1].strip()
     return f"{lamb}()"
 
 
@@ -72,6 +72,12 @@ class LValidator:
             )
         if self.retmapper is not None:
             return self.retmapper(value)
+        if isinstance(value, ID):
+            return await cg.get_variable(value)
+        if isinstance(value, list):
+            value = [
+                await cg.get_variable(x) if isinstance(x, ID) else x for x in value
+            ]
         return cg.safe_exp(value)
 
 
@@ -162,6 +168,7 @@ LV_EVENT_MAP = {
     "READY": "READY",
     "CANCEL": "CANCEL",
     "ALL_EVENTS": "ALL",
+    "CHANGE": "VALUE_CHANGED",
 }
 
 LV_EVENT_TRIGGERS = tuple(f"on_{x.lower()}" for x in LV_EVENT_MAP)

esphome/components/lvgl/lv_validation.py

@@ -1,6 +1,7 @@
 from typing import Union
 
 import esphome.codegen as cg
+from esphome.components import image
 from esphome.components.color import CONF_HEX, ColorStruct, from_rgbw
 from esphome.components.font import Font
 from esphome.components.image import Image_
@@ -31,7 +32,7 @@ from .defines import (
     literal,
 )
 from .helpers import add_lv_use, esphome_fonts_used, lv_fonts_used, requires_component
-from .types import lv_font_t, lv_gradient_t, lv_img_t
+from .types import lv_font_t, lv_gradient_t
 
 opacity_consts = LvConstant("LV_OPA_", "TRANSP", "COVER")
 
@@ -332,8 +333,12 @@ def image_validator(value):
 
 lv_image = LValidator(
     image_validator,
-    lv_img_t,
-    retmapper=lambda x: MockObj(x, "->").get_lv_img_dsc(),
+    image.Image_.operator("ptr"),
+    requires="image",
+)
+lv_image_list = LValidator(
+    cv.ensure_list(image_validator),
+    cg.std_vector.template(image.Image_.operator("ptr")),
     requires="image",
 )
 lv_bool = LValidator(cv.boolean, cg.bool_, retmapper=literal)