Merge branch 'dev' of https://github.com/esphome/esphome into add-cse-7766-reactive-power

2024-11-10 01:07:45 +01:00 · 2024-08-16 19:20:28 -07:00 · 2024-08-16 19:20:28 -07:00 · f9f5baab9b
commit f9f5baab9b
parent a81cac474f 75899162b3
175 changed files with 2013 additions and 324 deletions
--- a/.github/actions/build-image/action.yaml
+++ b/.github/actions/build-image/action.yaml
@ -46,7 +46,7 @@ runs:

    - name: Build and push to ghcr by digest
      id: build-ghcr
-      uses: docker/build-push-action@v6.6.1
+      uses: docker/build-push-action@v6.7.0
      with:
        context: .
        file: ./docker/Dockerfile
@ -69,7 +69,7 @@ runs:

    - name: Build and push to dockerhub by digest
      id: build-dockerhub
-      uses: docker/build-push-action@v6.6.1
+      uses: docker/build-push-action@v6.7.0
      with:
        context: .
        file: ./docker/Dockerfile
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -9,6 +9,7 @@ on:
    paths:
      - "**"
      - "!.github/workflows/*.yml"
+      - "!.github/actions/build-image/*"
      - ".github/workflows/ci.yml"
      - "!.yamllint"
      - "!.github/dependabot.yml"
@ -396,7 +397,7 @@ jobs:
        file: ${{ fromJson(needs.list-components.outputs.components) }}
    steps:
      - name: Install dependencies
-        run: sudo apt-get install libsodium-dev libsdl2-dev
+        run: sudo apt-get install libsdl2-dev

      - name: Check out code from GitHub
        uses: actions/checkout@v4.1.7
@ -450,7 +451,7 @@ jobs:
        run: echo ${{ matrix.components }}

      - name: Install dependencies
-        run: sudo apt-get install libsodium-dev libsdl2-dev
+        run: sudo apt-get install libsdl2-dev

      - name: Check out code from GitHub
        uses: actions/checkout@v4.1.7
--- a/7
+++ b/7
@ -46,6 +46,7 @@ esphome/components/async_tcp/* @OttoWinter
 esphome/components/at581x/* @X-Ryl669
 esphome/components/atc_mithermometer/* @ahpohl
 esphome/components/atm90e26/* @danieltwagner
+esphome/components/atm90e32/* @circuitsetup @descipher
 esphome/components/b_parasite/* @rbaron
 esphome/components/ballu/* @bazuchan
 esphome/components/bang_bang/* @OttoWinter
@ -168,7 +169,10 @@ esphome/components/he60r/* @clydebarrow
 esphome/components/heatpumpir/* @rob-deutsch
 esphome/components/hitachi_ac424/* @sourabhjaiswal
 esphome/components/hm3301/* @freekode
-esphome/components/homeassistant/* @OttoWinter
+esphome/components/hmac_md5/* @dwmw2
+esphome/components/homeassistant/* @OttoWinter @esphome/core
+esphome/components/homeassistant/number/* @landonr
+esphome/components/homeassistant/switch/* @Links2004
 esphome/components/honeywell_hih_i2c/* @Benichou34
 esphome/components/honeywellabp/* @RubyBailey
 esphome/components/honeywellabp2_i2c/* @jpfaff
@ -453,6 +457,7 @@ esphome/components/wl_134/* @hobbypunk90
 esphome/components/x9c/* @EtienneMD
 esphome/components/xgzp68xx/* @gcormier
 esphome/components/xiaomi_hhccjcy10/* @fariouche
+esphome/components/xiaomi_lywsd02mmc/* @juanluss31
 esphome/components/xiaomi_lywsd03mmc/* @ahpohl
 esphome/components/xiaomi_mhoc303/* @drug123
 esphome/components/xiaomi_mhoc401/* @vevsvevs
--- a/esphome/components/airthings_wave_plus/airthings_wave_plus.cpp
+++ b/esphome/components/airthings_wave_plus/airthings_wave_plus.cpp
@ -14,8 +14,6 @@ void AirthingsWavePlus::read_sensors(uint8_t *raw_value, uint16_t value_len) {
    ESP_LOGD(TAG, "version = %d", value->version);

    if (value->version == 1) {
-      ESP_LOGD(TAG, "ambient light = %d", value->ambientLight);
-
      if (this->humidity_sensor_ != nullptr) {
        this->humidity_sensor_->publish_state(value->humidity / 2.0f);
      }
@ -43,6 +41,10 @@ void AirthingsWavePlus::read_sensors(uint8_t *raw_value, uint16_t value_len) {
      if ((this->tvoc_sensor_ != nullptr) && this->is_valid_voc_value_(value->voc)) {
        this->tvoc_sensor_->publish_state(value->voc);
      }
+
+      if (this->illuminance_sensor_ != nullptr) {
+        this->illuminance_sensor_->publish_state(value->ambientLight);
+      }
    } else {
      ESP_LOGE(TAG, "Invalid payload version (%d != 1, newer version or not a Wave Plus?)", value->version);
    }
@ -68,6 +70,7 @@ void AirthingsWavePlus::dump_config() {
  LOG_SENSOR("  ", "Radon", this->radon_sensor_);
  LOG_SENSOR("  ", "Radon Long Term", this->radon_long_term_sensor_);
  LOG_SENSOR("  ", "CO2", this->co2_sensor_);
+  LOG_SENSOR("  ", "Illuminance", this->illuminance_sensor_);
 }

 AirthingsWavePlus::AirthingsWavePlus() {
--- a/esphome/components/airthings_wave_plus/airthings_wave_plus.h
+++ b/esphome/components/airthings_wave_plus/airthings_wave_plus.h
@ -22,6 +22,7 @@ class AirthingsWavePlus : public airthings_wave_base::AirthingsWaveBase {
  void set_radon(sensor::Sensor *radon) { radon_sensor_ = radon; }
  void set_radon_long_term(sensor::Sensor *radon_long_term) { radon_long_term_sensor_ = radon_long_term; }
  void set_co2(sensor::Sensor *co2) { co2_sensor_ = co2; }
+  void set_illuminance(sensor::Sensor *illuminance) { illuminance_sensor_ = illuminance; }

 protected:
  bool is_valid_radon_value_(uint16_t radon);
@ -32,6 +33,7 @@ class AirthingsWavePlus : public airthings_wave_base::AirthingsWaveBase {
  sensor::Sensor *radon_sensor_{nullptr};
  sensor::Sensor *radon_long_term_sensor_{nullptr};
  sensor::Sensor *co2_sensor_{nullptr};
+  sensor::Sensor *illuminance_sensor_{nullptr};

  struct WavePlusReadings {
    uint8_t version;
--- a/esphome/components/airthings_wave_plus/sensor.py
+++ b/esphome/components/airthings_wave_plus/sensor.py
@ -12,6 +12,9 @@ from esphome.const import (
    CONF_CO2,
    UNIT_BECQUEREL_PER_CUBIC_METER,
    UNIT_PARTS_PER_MILLION,
+    CONF_ILLUMINANCE,
+    UNIT_LUX,
+    DEVICE_CLASS_ILLUMINANCE,
 )

 DEPENDENCIES = airthings_wave_base.DEPENDENCIES
@ -45,6 +48,12 @@ CONFIG_SCHEMA = airthings_wave_base.BASE_SCHEMA.extend(
            device_class=DEVICE_CLASS_CARBON_DIOXIDE,
            state_class=STATE_CLASS_MEASUREMENT,
        ),
+        cv.Optional(CONF_ILLUMINANCE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_LUX,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ILLUMINANCE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
    }
 )

@ -62,3 +71,6 @@ async def to_code(config):
    if config_co2 := config.get(CONF_CO2):
        sens = await sensor.new_sensor(config_co2)
        cg.add(var.set_co2(sens))
+    if config_illuminance := config.get(CONF_ILLUMINANCE):
+        sens = await sensor.new_sensor(config_illuminance)
+        cg.add(var.set_illuminance(sens))
--- a/esphome/components/api/init.py
+++ b/esphome/components/api/init.py
@ -155,7 +155,7 @@ async def to_code(config):
        decoded = base64.b64decode(encryption_config[CONF_KEY])
        cg.add(var.set_noise_psk(list(decoded)))
        cg.add_define("USE_API_NOISE")
-        cg.add_library("esphome/noise-c", "0.1.4")
+        cg.add_library("esphome/noise-c", "0.1.6")
    else:
        cg.add_define("USE_API_PLAINTEXT")

--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@ -686,6 +686,7 @@ message SubscribeHomeAssistantStateResponse {
  option (source) = SOURCE_SERVER;
  string entity_id = 1;
  string attribute = 2;
+  bool once = 3;
 }

 message HomeAssistantStateResponse {
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@ -1335,6 +1335,9 @@ void APIConnection::update_command(const UpdateCommandRequest &msg) {
    case enums::UPDATE_COMMAND_CHECK:
      update->check();
      break;
+    case enums::UPDATE_COMMAND_NONE:
+      ESP_LOGE(TAG, "UPDATE_COMMAND_NONE not handled. Check client is sending the correct command");
+      break;
    default:
      ESP_LOGW(TAG, "Unknown update command: %" PRIu32, msg.command);
      break;
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@ -3109,6 +3109,16 @@ void SubscribeHomeAssistantStatesRequest::dump_to(std::string &out) const {
  out.append("SubscribeHomeAssistantStatesRequest {}");
 }
 #endif
+bool SubscribeHomeAssistantStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 3: {
+      this->once = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
 bool SubscribeHomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
  switch (field_id) {
    case 1: {
@ -3126,6 +3136,7 @@ bool SubscribeHomeAssistantStateResponse::decode_length(uint32_t field_id, Proto
 void SubscribeHomeAssistantStateResponse::encode(ProtoWriteBuffer buffer) const {
  buffer.encode_string(1, this->entity_id);
  buffer.encode_string(2, this->attribute);
+  buffer.encode_bool(3, this->once);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeAssistantStateResponse::dump_to(std::string &out) const {
@ -3138,6 +3149,10 @@ void SubscribeHomeAssistantStateResponse::dump_to(std::string &out) const {
  out.append("  attribute: ");
  out.append("'").append(this->attribute).append("'");
  out.append("\n");
+
+  out.append("  once: ");
+  out.append(YESNO(this->once));
+  out.append("\n");
  out.append("}");
 }
 #endif
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@ -836,6 +836,7 @@ class SubscribeHomeAssistantStateResponse : public ProtoMessage {
 public:
  std::string entity_id{};
  std::string attribute{};
+  bool once{false};
  void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
  void dump_to(std::string &out) const override;
@ -843,6 +844,7 @@ class SubscribeHomeAssistantStateResponse : public ProtoMessage {

 protected:
  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 class HomeAssistantStateResponse : public ProtoMessage {
 public:
--- a/esphome/components/api/api_server.cpp
+++ b/esphome/components/api/api_server.cpp
@ -359,8 +359,18 @@ void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<s
      .entity_id = std::move(entity_id),
      .attribute = std::move(attribute),
      .callback = std::move(f),
+      .once = false,
  });
 }
+void APIServer::get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                         std::function<void(std::string)> f) {
+  this->state_subs_.push_back(HomeAssistantStateSubscription{
+      .entity_id = std::move(entity_id),
+      .attribute = std::move(attribute),
+      .callback = std::move(f),
+      .once = true,
+  });
+};
 const std::vector<APIServer::HomeAssistantStateSubscription> &APIServer::get_state_subs() const {
  return this->state_subs_;
 }
--- a/esphome/components/api/api_server.h
+++ b/esphome/components/api/api_server.h
@ -112,10 +112,13 @@ class APIServer : public Component, public Controller {
    std::string entity_id;
    optional<std::string> attribute;
    std::function<void(std::string)> callback;
+    bool once;
  };

  void subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
                                      std::function<void(std::string)> f);
+  void get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                std::function<void(std::string)> f);
  const std::vector<HomeAssistantStateSubscription> &get_state_subs() const;
  const std::vector<UserServiceDescriptor *> &get_user_services() const { return this->user_services_; }

--- a/esphome/components/atm90e32/init.py
+++ b/esphome/components/atm90e32/init.py
@ -0,0 +1,7 @@
+import esphome.codegen as cg
+
+CODEOWNERS = ["@circuitsetup", "@descipher"]
+
+atm90e32_ns = cg.esphome_ns.namespace("atm90e32")
+
+CONF_ATM90E32_ID = "atm90e32_id"
--- a/esphome/components/atm90e32/atm90e32.cpp
+++ b/esphome/components/atm90e32/atm90e32.cpp
@ -132,10 +132,77 @@ void ATM90E32Component::update() {
  this->status_clear_warning();
 }

+void ATM90E32Component::restore_calibrations_() {
+  if (enable_offset_calibration_) {
+    this->pref_.load(&this->offset_phase_);
+  }
+};
+
+void ATM90E32Component::run_offset_calibrations() {
+  // Run the calibrations and
+  // Setup voltage and current calibration offsets for PHASE A
+  this->offset_phase_[PHASEA].voltage_offset_ = calibrate_voltage_offset_phase(PHASEA);
+  this->phase_[PHASEA].voltage_offset_ = this->offset_phase_[PHASEA].voltage_offset_;
+  this->write16_(ATM90E32_REGISTER_UOFFSETA, this->phase_[PHASEA].voltage_offset_);  // C Voltage offset
+  this->offset_phase_[PHASEA].current_offset_ = calibrate_current_offset_phase(PHASEA);
+  this->phase_[PHASEA].current_offset_ = this->offset_phase_[PHASEA].current_offset_;
+  this->write16_(ATM90E32_REGISTER_IOFFSETA, this->phase_[PHASEA].current_offset_);  // C Current offset
+  // Setup voltage and current calibration offsets for PHASE B
+  this->offset_phase_[PHASEB].voltage_offset_ = calibrate_voltage_offset_phase(PHASEB);
+  this->phase_[PHASEB].voltage_offset_ = this->offset_phase_[PHASEB].voltage_offset_;
+  this->write16_(ATM90E32_REGISTER_UOFFSETB, this->phase_[PHASEB].voltage_offset_);  // C Voltage offset
+  this->offset_phase_[PHASEB].current_offset_ = calibrate_current_offset_phase(PHASEB);
+  this->phase_[PHASEB].current_offset_ = this->offset_phase_[PHASEB].current_offset_;
+  this->write16_(ATM90E32_REGISTER_IOFFSETB, this->phase_[PHASEB].current_offset_);  // C Current offset
+  // Setup voltage and current calibration offsets for PHASE C
+  this->offset_phase_[PHASEC].voltage_offset_ = calibrate_voltage_offset_phase(PHASEC);
+  this->phase_[PHASEC].voltage_offset_ = this->offset_phase_[PHASEC].voltage_offset_;
+  this->write16_(ATM90E32_REGISTER_UOFFSETC, this->phase_[PHASEC].voltage_offset_);  // C Voltage offset
+  this->offset_phase_[PHASEC].current_offset_ = calibrate_current_offset_phase(PHASEC);
+  this->phase_[PHASEC].current_offset_ = this->offset_phase_[PHASEC].current_offset_;
+  this->write16_(ATM90E32_REGISTER_IOFFSETC, this->phase_[PHASEC].current_offset_);  // C Current offset
+  this->pref_.save(&this->offset_phase_);
+  ESP_LOGI(TAG, "PhaseA Vo=%5d PhaseB Vo=%5d PhaseC Vo=%5d", this->offset_phase_[PHASEA].voltage_offset_,
+           this->offset_phase_[PHASEB].voltage_offset_, this->offset_phase_[PHASEC].voltage_offset_);
+  ESP_LOGI(TAG, "PhaseA Io=%5d PhaseB Io=%5d PhaseC Io=%5d", this->offset_phase_[PHASEA].current_offset_,
+           this->offset_phase_[PHASEB].current_offset_, this->offset_phase_[PHASEC].current_offset_);
+}
+
+void ATM90E32Component::clear_offset_calibrations() {
+  // Clear the calibrations and
+  this->offset_phase_[PHASEA].voltage_offset_ = 0;
+  this->phase_[PHASEA].voltage_offset_ = this->offset_phase_[PHASEA].voltage_offset_;
+  this->write16_(ATM90E32_REGISTER_UOFFSETA, this->phase_[PHASEA].voltage_offset_);  // C Voltage offset
+  this->offset_phase_[PHASEA].current_offset_ = 0;
+  this->phase_[PHASEA].current_offset_ = this->offset_phase_[PHASEA].current_offset_;
+  this->write16_(ATM90E32_REGISTER_IOFFSETA, this->phase_[PHASEA].current_offset_);  // C Current offset
+  this->offset_phase_[PHASEB].voltage_offset_ = 0;
+  this->phase_[PHASEB].voltage_offset_ = this->offset_phase_[PHASEB].voltage_offset_;
+  this->write16_(ATM90E32_REGISTER_UOFFSETB, this->phase_[PHASEB].voltage_offset_);  // C Voltage offset
+  this->offset_phase_[PHASEB].current_offset_ = 0;
+  this->phase_[PHASEB].current_offset_ = this->offset_phase_[PHASEB].current_offset_;
+  this->write16_(ATM90E32_REGISTER_IOFFSETB, this->phase_[PHASEB].current_offset_);  // C Current offset
+  this->offset_phase_[PHASEC].voltage_offset_ = 0;
+  this->phase_[PHASEC].voltage_offset_ = this->offset_phase_[PHASEC].voltage_offset_;
+  this->write16_(ATM90E32_REGISTER_UOFFSETC, this->phase_[PHASEC].voltage_offset_);  // C Voltage offset
+  this->offset_phase_[PHASEC].current_offset_ = 0;
+  this->phase_[PHASEC].current_offset_ = this->offset_phase_[PHASEC].current_offset_;
+  this->write16_(ATM90E32_REGISTER_IOFFSETC, this->phase_[PHASEC].current_offset_);  // C Current offset
+  this->pref_.save(&this->offset_phase_);
+  ESP_LOGI(TAG, "PhaseA Vo=%5d PhaseB Vo=%5d PhaseC Vo=%5d", this->offset_phase_[PHASEA].voltage_offset_,
+           this->offset_phase_[PHASEB].voltage_offset_, this->offset_phase_[PHASEC].voltage_offset_);
+  ESP_LOGI(TAG, "PhaseA Io=%5d PhaseB Io=%5d PhaseC Io=%5d", this->offset_phase_[PHASEA].current_offset_,
+           this->offset_phase_[PHASEB].current_offset_, this->offset_phase_[PHASEC].current_offset_);
+}
+
 void ATM90E32Component::setup() {
  ESP_LOGCONFIG(TAG, "Setting up ATM90E32 Component...");
  this->spi_setup();
-
+  if (this->enable_offset_calibration_) {
+    uint32_t hash = fnv1_hash(App.get_friendly_name());
+    this->pref_ = global_preferences->make_preference<Calibration[3]>(hash, true);
+    this->restore_calibrations_();
+  }
  uint16_t mmode0 = 0x87;  // 3P4W 50Hz
  if (line_freq_ == 60) {
    mmode0 |= 1 << 12;  // sets 12th bit to 1, 60Hz
@ -167,27 +234,12 @@ void ATM90E32Component::setup() {
  this->write16_(ATM90E32_REGISTER_SSTARTTH, 0x1D4C);       // All Reactive Startup Power Threshold - 50%
  this->write16_(ATM90E32_REGISTER_PPHASETH, 0x02EE);       // Each Phase Active Phase Threshold - 0.002A/0.00032 = 750
  this->write16_(ATM90E32_REGISTER_QPHASETH, 0x02EE);       // Each phase Reactive Phase Threshold - 10%
-  // Setup voltage and current calibration offsets for PHASE A
-  this->phase_[PHASEA].voltage_offset_ = calibrate_voltage_offset_phase(PHASEA);
-  this->write16_(ATM90E32_REGISTER_UOFFSETA, this->phase_[PHASEA].voltage_offset_);  // A Voltage offset
-  this->phase_[PHASEA].current_offset_ = calibrate_current_offset_phase(PHASEA);
-  this->write16_(ATM90E32_REGISTER_IOFFSETA, this->phase_[PHASEA].current_offset_);  // A Current offset
  // Setup voltage and current gain for PHASE A
  this->write16_(ATM90E32_REGISTER_UGAINA, this->phase_[PHASEA].voltage_gain_);  // A Voltage rms gain
  this->write16_(ATM90E32_REGISTER_IGAINA, this->phase_[PHASEA].ct_gain_);       // A line current gain
-  // Setup voltage and current calibration offsets for PHASE B
-  this->phase_[PHASEB].voltage_offset_ = calibrate_voltage_offset_phase(PHASEB);
-  this->write16_(ATM90E32_REGISTER_UOFFSETB, this->phase_[PHASEB].voltage_offset_);  // B Voltage offset
-  this->phase_[PHASEB].current_offset_ = calibrate_current_offset_phase(PHASEB);
-  this->write16_(ATM90E32_REGISTER_IOFFSETB, this->phase_[PHASEB].current_offset_);  // B Current offset
  // Setup voltage and current gain for PHASE B
  this->write16_(ATM90E32_REGISTER_UGAINB, this->phase_[PHASEB].voltage_gain_);  // B Voltage rms gain
  this->write16_(ATM90E32_REGISTER_IGAINB, this->phase_[PHASEB].ct_gain_);       // B line current gain
-  // Setup voltage and current calibration offsets for PHASE C
-  this->phase_[PHASEC].voltage_offset_ = calibrate_voltage_offset_phase(PHASEC);
-  this->write16_(ATM90E32_REGISTER_UOFFSETC, this->phase_[PHASEC].voltage_offset_);  // C Voltage offset
-  this->phase_[PHASEC].current_offset_ = calibrate_current_offset_phase(PHASEC);
-  this->write16_(ATM90E32_REGISTER_IOFFSETC, this->phase_[PHASEC].current_offset_);  // C Current offset
  // Setup voltage and current gain for PHASE C
  this->write16_(ATM90E32_REGISTER_UGAINC, this->phase_[PHASEC].voltage_gain_);  // C Voltage rms gain
  this->write16_(ATM90E32_REGISTER_IGAINC, this->phase_[PHASEC].ct_gain_);       // C line current gain
--- a/esphome/components/atm90e32/atm90e32.h
+++ b/esphome/components/atm90e32/atm90e32.h
@ -1,9 +1,12 @@
 #pragma once

-#include "esphome/core/component.h"
+#include "atm90e32_reg.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/spi/spi.h"
-#include "atm90e32_reg.h"
+#include "esphome/core/application.h"
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/preferences.h"

 namespace esphome {
 namespace atm90e32 {
@ -20,7 +23,6 @@ class ATM90E32Component : public PollingComponent,
  void dump_config() override;
  float get_setup_priority() const override;
  void update() override;
-
  void set_voltage_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].voltage_sensor_ = obj; }
  void set_current_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].current_sensor_ = obj; }
  void set_power_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].power_sensor_ = obj; }
@ -48,9 +50,11 @@ class ATM90E32Component : public PollingComponent,
  void set_line_freq(int freq) { line_freq_ = freq; }
  void set_current_phases(int phases) { current_phases_ = phases; }
  void set_pga_gain(uint16_t gain) { pga_gain_ = gain; }
+  void run_offset_calibrations();
+  void clear_offset_calibrations();
+  void set_enable_offset_calibration(bool flag) { enable_offset_calibration_ = flag; }
  uint16_t calibrate_voltage_offset_phase(uint8_t /*phase*/);
  uint16_t calibrate_current_offset_phase(uint8_t /*phase*/);
-
  int32_t last_periodic_millis = millis();

 protected:
@ -83,10 +87,11 @@ class ATM90E32Component : public PollingComponent,
  float get_chip_temperature_();
  bool get_publish_interval_flag_() { return publish_interval_flag_; };
  void set_publish_interval_flag_(bool flag) { publish_interval_flag_ = flag; };
+  void restore_calibrations_();

  struct ATM90E32Phase {
-    uint16_t voltage_gain_{7305};
-    uint16_t ct_gain_{27961};
+    uint16_t voltage_gain_{0};
+    uint16_t ct_gain_{0};
    uint16_t voltage_offset_{0};
    uint16_t current_offset_{0};
    float voltage_{0};
@ -114,13 +119,21 @@ class ATM90E32Component : public PollingComponent,
    uint32_t cumulative_reverse_active_energy_{0};
  } phase_[3];

+  struct Calibration {
+    uint16_t voltage_offset_{0};
+    uint16_t current_offset_{0};
+  } offset_phase_[3];
+
+  ESPPreferenceObject pref_;
+
  sensor::Sensor *freq_sensor_{nullptr};
  sensor::Sensor *chip_temperature_sensor_{nullptr};
  uint16_t pga_gain_{0x15};
  int line_freq_{60};
  int current_phases_{3};
-  bool publish_interval_flag_{true};
+  bool publish_interval_flag_{false};
  bool peak_current_signed_{false};
+  bool enable_offset_calibration_{false};
 };

 }  // namespace atm90e32
--- a/esphome/components/atm90e32/atm90e32_reg.h
+++ b/esphome/components/atm90e32/atm90e32_reg.h
@ -1,5 +1,7 @@
 #pragma once

+#include <cinttypes>
+
 namespace esphome {
 namespace atm90e32 {

--- a/esphome/components/atm90e32/button/init.py
+++ b/esphome/components/atm90e32/button/init.py
@ -0,0 +1,43 @@
+import esphome.codegen as cg
+from esphome.components import button
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, ENTITY_CATEGORY_CONFIG, ICON_CHIP, ICON_SCALE
+
+from .. import atm90e32_ns
+from ..sensor import ATM90E32Component
+
+CONF_RUN_OFFSET_CALIBRATION = "run_offset_calibration"
+CONF_CLEAR_OFFSET_CALIBRATION = "clear_offset_calibration"
+
+ATM90E32CalibrationButton = atm90e32_ns.class_(
+    "ATM90E32CalibrationButton",
+    button.Button,
+)
+ATM90E32ClearCalibrationButton = atm90e32_ns.class_(
+    "ATM90E32ClearCalibrationButton",
+    button.Button,
+)
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_ID): cv.use_id(ATM90E32Component),
+    cv.Optional(CONF_RUN_OFFSET_CALIBRATION): button.button_schema(
+        ATM90E32CalibrationButton,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_SCALE,
+    ),
+    cv.Optional(CONF_CLEAR_OFFSET_CALIBRATION): button.button_schema(
+        ATM90E32ClearCalibrationButton,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_CHIP,
+    ),
+}
+
+
+async def to_code(config):
+    parent = await cg.get_variable(config[CONF_ID])
+    if run_offset := config.get(CONF_RUN_OFFSET_CALIBRATION):
+        b = await button.new_button(run_offset)
+        await cg.register_parented(b, parent)
+    if clear_offset := config.get(CONF_CLEAR_OFFSET_CALIBRATION):
+        b = await button.new_button(clear_offset)
+        await cg.register_parented(b, parent)
--- a/esphome/components/atm90e32/button/atm90e32_button.cpp
+++ b/esphome/components/atm90e32/button/atm90e32_button.cpp
@ -0,0 +1,20 @@
+#include "atm90e32_button.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace atm90e32 {
+
+static const char *const TAG = "atm90e32.button";
+
+void ATM90E32CalibrationButton::press_action() {
+  ESP_LOGI(TAG, "Running offset calibrations, Note: CTs and ACVs must be 0 during this process...");
+  this->parent_->run_offset_calibrations();
+}
+
+void ATM90E32ClearCalibrationButton::press_action() {
+  ESP_LOGI(TAG, "Offset calibrations cleared.");
+  this->parent_->clear_offset_calibrations();
+}
+
+}  // namespace atm90e32
+}  // namespace esphome
--- a/esphome/components/atm90e32/button/atm90e32_button.h
+++ b/esphome/components/atm90e32/button/atm90e32_button.h
@ -0,0 +1,27 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/atm90e32/atm90e32.h"
+#include "esphome/components/button/button.h"
+
+namespace esphome {
+namespace atm90e32 {
+
+class ATM90E32CalibrationButton : public button::Button, public Parented<ATM90E32Component> {
+ public:
+  ATM90E32CalibrationButton() = default;
+
+ protected:
+  void press_action() override;
+};
+
+class ATM90E32ClearCalibrationButton : public button::Button, public Parented<ATM90E32Component> {
+ public:
+  ATM90E32ClearCalibrationButton() = default;
+
+ protected:
+  void press_action() override;
+};
+
+}  // namespace atm90e32
+}  // namespace esphome
--- a/esphome/components/atm90e32/sensor.py
+++ b/esphome/components/atm90e32/sensor.py
@ -1,21 +1,21 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import sensor, spi
+import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ID,
-    CONF_REACTIVE_POWER,
-    CONF_VOLTAGE,
+    CONF_APPARENT_POWER,
    CONF_CURRENT,
+    CONF_FORWARD_ACTIVE_ENERGY,
+    CONF_FREQUENCY,
+    CONF_ID,
    CONF_PHASE_A,
+    CONF_PHASE_ANGLE,
    CONF_PHASE_B,
    CONF_PHASE_C,
-    CONF_PHASE_ANGLE,
    CONF_POWER,
    CONF_POWER_FACTOR,
-    CONF_APPARENT_POWER,
-    CONF_FREQUENCY,
-    CONF_FORWARD_ACTIVE_ENERGY,
+    CONF_REACTIVE_POWER,
    CONF_REVERSE_ACTIVE_ENERGY,
+    CONF_VOLTAGE,
    DEVICE_CLASS_CURRENT,
    DEVICE_CLASS_ENERGY,
    DEVICE_CLASS_POWER,
@ -23,13 +23,13 @@ from esphome.const import (
    DEVICE_CLASS_TEMPERATURE,
    DEVICE_CLASS_VOLTAGE,
    ENTITY_CATEGORY_DIAGNOSTIC,
-    ICON_LIGHTBULB,
    ICON_CURRENT_AC,
+    ICON_LIGHTBULB,
    STATE_CLASS_MEASUREMENT,
    STATE_CLASS_TOTAL_INCREASING,
    UNIT_AMPERE,
-    UNIT_DEGREES,
    UNIT_CELSIUS,
+    UNIT_DEGREES,
    UNIT_HERTZ,
    UNIT_VOLT,
    UNIT_VOLT_AMPS_REACTIVE,
@ -37,6 +37,8 @@ from esphome.const import (
    UNIT_WATT_HOURS,
 )

+from . import atm90e32_ns
+
 CONF_LINE_FREQUENCY = "line_frequency"
 CONF_CHIP_TEMPERATURE = "chip_temperature"
 CONF_GAIN_PGA = "gain_pga"
@ -46,6 +48,7 @@ CONF_GAIN_CT = "gain_ct"
 CONF_HARMONIC_POWER = "harmonic_power"
 CONF_PEAK_CURRENT = "peak_current"
 CONF_PEAK_CURRENT_SIGNED = "peak_current_signed"
+CONF_ENABLE_OFFSET_CALIBRATION = "enable_offset_calibration"
 UNIT_DEG = "degrees"
 LINE_FREQS = {
    "50HZ": 50,
@ -61,7 +64,6 @@ PGA_GAINS = {
    "4X": 0x2A,
 }

-atm90e32_ns = cg.esphome_ns.namespace("atm90e32")
 ATM90E32Component = atm90e32_ns.class_(
    "ATM90E32Component", cg.PollingComponent, spi.SPIDevice
 )
@ -164,6 +166,7 @@ CONFIG_SCHEMA = (
            ),
            cv.Optional(CONF_GAIN_PGA, default="2X"): cv.enum(PGA_GAINS, upper=True),
            cv.Optional(CONF_PEAK_CURRENT_SIGNED, default=False): cv.boolean,
+            cv.Optional(CONF_ENABLE_OFFSET_CALIBRATION, default=False): cv.boolean,
        }
    )
    .extend(cv.polling_component_schema("60s"))
@ -227,3 +230,4 @@ async def to_code(config):
    cg.add(var.set_current_phases(config[CONF_CURRENT_PHASES]))
    cg.add(var.set_pga_gain(config[CONF_GAIN_PGA]))
    cg.add(var.set_peak_current_signed(config[CONF_PEAK_CURRENT_SIGNED]))
+    cg.add(var.set_enable_offset_calibration(config[CONF_ENABLE_OFFSET_CALIBRATION]))
--- a/esphome/components/bedjet/bedjet_codec.h
+++ b/esphome/components/bedjet/bedjet_codec.h
@ -90,7 +90,7 @@ struct BedjetStatusPacket {
    int unused_6 : 1;       // 0x4
    bool is_dual_zone : 1;  /// Is part of a Dual Zone configuration
    int unused_7 : 1;       // 0x1
-  } dual_zone_flags;
+  } dual_zone_flags;        // NOLINT(clang-diagnostic-unaligned-access)

  uint8_t unused_4 : 8;  // Unknown 23-24 = 0x1310
  uint8_t unused_5 : 8;  // Unknown 23-24 = 0x1310
--- a/esphome/components/binary/light/binary_light_output.h
+++ b/esphome/components/binary/light/binary_light_output.h
@ -18,10 +18,11 @@ class BinaryLightOutput : public light::LightOutput {
  void write_state(light::LightState *state) override {
    bool binary;
    state->current_values_as_binary(&binary);
-    if (binary)
+    if (binary) {
      this->output_->turn_on();
-    else
+    } else {
      this->output_->turn_off();
+    }
  }

 protected:
--- a/esphome/components/captive_portal/captive_portal.cpp
+++ b/esphome/components/captive_portal/captive_portal.cpp
@ -1,4 +1,5 @@
 #include "captive_portal.h"
+#ifdef USE_CAPTIVE_PORTAL
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/components/wifi/wifi_component.h"
@ -91,3 +92,4 @@ CaptivePortal *global_captive_portal = nullptr;  // NOLINT(cppcoreguidelines-avo

 }  // namespace captive_portal
 }  // namespace esphome
+#endif
--- a/esphome/components/captive_portal/captive_portal.h
+++ b/esphome/components/captive_portal/captive_portal.h
@ -1,5 +1,6 @@
 #pragma once
-
+#include "esphome/core/defines.h"
+#ifdef USE_CAPTIVE_PORTAL
 #include <memory>
 #ifdef USE_ARDUINO
 #include <DNSServer.h>
@ -71,3 +72,4 @@ extern CaptivePortal *global_captive_portal;  // NOLINT(cppcoreguidelines-avoid-

 }  // namespace captive_portal
 }  // namespace esphome
+#endif
--- a/esphome/components/demo/demo_sensor.h
+++ b/esphome/components/demo/demo_sensor.h
@ -16,10 +16,11 @@ class DemoSensor : public sensor::Sensor, public PollingComponent {
      float base = std::isnan(this->state) ? 0.0f : this->state;
      this->publish_state(base + val * 10);
    } else {
-      if (val < 0.1)
+      if (val < 0.1) {
        this->publish_state(NAN);
-      else
+      } else {
        this->publish_state(val * 100);
+      }
    }
  }
 };
--- a/esphome/components/e131/e131.cpp
+++ b/esphome/components/e131/e131.cpp
@ -1,4 +1,5 @@
 #include "e131.h"
+#ifdef USE_NETWORK
 #include "e131_addressable_light_effect.h"
 #include "esphome/core/log.h"

@ -118,3 +119,4 @@ bool E131Component::process_(int universe, const E131Packet &packet) {

 }  // namespace e131
 }  // namespace esphome
+#endif
--- a/esphome/components/e131/e131.h
+++ b/esphome/components/e131/e131.h
@ -1,5 +1,6 @@
 #pragma once
-
+#include "esphome/core/defines.h"
+#ifdef USE_NETWORK
 #include "esphome/components/socket/socket.h"
 #include "esphome/core/component.h"

@ -53,3 +54,4 @@ class E131Component : public esphome::Component {

 }  // namespace e131
 }  // namespace esphome
+#endif
--- a/esphome/components/e131/e131_addressable_light_effect.cpp
+++ b/esphome/components/e131/e131_addressable_light_effect.cpp
@ -1,5 +1,6 @@
 #include "e131_addressable_light_effect.h"
 #include "e131.h"
+#ifdef USE_NETWORK
 #include "esphome/core/log.h"

 namespace esphome {
@ -90,3 +91,4 @@ bool E131AddressableLightEffect::process_(int universe, const E131Packet &packet

 }  // namespace e131
 }  // namespace esphome
+#endif
--- a/esphome/components/e131/e131_addressable_light_effect.h
+++ b/esphome/components/e131/e131_addressable_light_effect.h
@ -2,7 +2,7 @@

 #include "esphome/core/component.h"
 #include "esphome/components/light/addressable_light_effect.h"
-
+#ifdef USE_NETWORK
 namespace esphome {
 namespace e131 {

@ -42,3 +42,4 @@ class E131AddressableLightEffect : public light::AddressableLightEffect {

 }  // namespace e131
 }  // namespace esphome
+#endif
--- a/esphome/components/e131/e131_packet.cpp
+++ b/esphome/components/e131/e131_packet.cpp
@ -1,5 +1,6 @@
 #include <cstring>
 #include "e131.h"
+#ifdef USE_NETWORK
 #include "esphome/components/network/ip_address.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
@ -137,3 +138,4 @@ bool E131Component::packet_(const std::vector<uint8_t> &data, int &universe, E13

 }  // namespace e131
 }  // namespace esphome
+#endif
--- a/esphome/components/esphome/ota/ota_esphome.cpp
+++ b/esphome/components/esphome/ota/ota_esphome.cpp
@ -1,5 +1,5 @@
 #include "ota_esphome.h"
-
+#ifdef USE_OTA
 #include "esphome/components/md5/md5.h"
 #include "esphome/components/network/util.h"
 #include "esphome/components/ota/ota_backend.h"
@ -410,3 +410,4 @@ float ESPHomeOTAComponent::get_setup_priority() const { return setup_priority::A
 uint16_t ESPHomeOTAComponent::get_port() const { return this->port_; }
 void ESPHomeOTAComponent::set_port(uint16_t port) { this->port_ = port; }
 }  // namespace esphome
+#endif
--- a/esphome/components/esphome/ota/ota_esphome.h
+++ b/esphome/components/esphome/ota/ota_esphome.h
@ -1,6 +1,7 @@
 #pragma once

 #include "esphome/core/defines.h"
+#ifdef USE_OTA
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
 #include "esphome/components/ota/ota_backend.h"
@ -41,3 +42,4 @@ class ESPHomeOTAComponent : public ota::OTAComponent {
 };

 }  // namespace esphome
+#endif
--- a/esphome/components/fingerprint_grow/fingerprint_grow.cpp
+++ b/esphome/components/fingerprint_grow/fingerprint_grow.cpp
@ -307,7 +307,7 @@ void FingerprintGrowComponent::delete_fingerprint(uint16_t finger_id) {

 void FingerprintGrowComponent::delete_all_fingerprints() {
  ESP_LOGI(TAG, "Deleting all stored fingerprints");
-  this->data_ = {EMPTY};
+  this->data_ = {DELETE_ALL};
  switch (this->send_command_()) {
    case OK:
      ESP_LOGI(TAG, "Deleted all fingerprints");
--- a/esphome/components/fingerprint_grow/fingerprint_grow.h
+++ b/esphome/components/fingerprint_grow/fingerprint_grow.h
@ -36,7 +36,7 @@ enum GrowCommand {
  LOAD = 0x07,
  UPLOAD = 0x08,
  DELETE = 0x0C,
-  EMPTY = 0x0D,
+  DELETE_ALL = 0x0D,  // aka EMPTY
  READ_SYS_PARAM = 0x0F,
  SET_PASSWORD = 0x12,
  VERIFY_PASSWORD = 0x13,
--- a/esphome/components/haier/haier_base.h
+++ b/esphome/components/haier/haier_base.h
@ -80,8 +80,8 @@ class HaierClimateBase : public esphome::Component,
  const char *phase_to_string_(ProtocolPhases phase);
  virtual void set_handlers() = 0;
  virtual void process_phase(std::chrono::steady_clock::time_point now) = 0;
-  virtual haier_protocol::HaierMessage get_control_message() = 0;
-  virtual haier_protocol::HaierMessage get_power_message(bool state) = 0;
+  virtual haier_protocol::HaierMessage get_control_message() = 0;          // NOLINT(readability-identifier-naming)
+  virtual haier_protocol::HaierMessage get_power_message(bool state) = 0;  // NOLINT(readability-identifier-naming)
  virtual void initialization(){};
  virtual bool prepare_pending_action();
  virtual void process_protocol_reset();
--- a/esphome/components/hmac_md5/init.py
+++ b/esphome/components/hmac_md5/init.py
@ -0,0 +1,2 @@
+AUTO_LOAD = ["md5"]
+CODEOWNERS = ["@dwmw2"]
--- a/esphome/components/hmac_md5/hmac_md5.cpp
+++ b/esphome/components/hmac_md5/hmac_md5.cpp
@ -0,0 +1,56 @@
+#include <cstdio>
+#include <cstring>
+#include "hmac_md5.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace hmac_md5 {
+void HmacMD5::init(const uint8_t *key, size_t len) {
+  uint8_t ipad[64], opad[64];
+
+  memset(ipad, 0, sizeof(ipad));
+  if (len > 64) {
+    md5::MD5Digest keymd5;
+    keymd5.init();
+    keymd5.add(key, len);
+    keymd5.calculate();
+    keymd5.get_bytes(ipad);
+  } else {
+    memcpy(ipad, key, len);
+  }
+  memcpy(opad, ipad, sizeof(opad));
+
+  for (int i = 0; i < 64; i++) {
+    ipad[i] ^= 0x36;
+    opad[i] ^= 0x5c;
+  }
+
+  this->ihash_.init();
+  this->ihash_.add(ipad, sizeof(ipad));
+
+  this->ohash_.init();
+  this->ohash_.add(opad, sizeof(opad));
+}
+
+void HmacMD5::add(const uint8_t *data, size_t len) { this->ihash_.add(data, len); }
+
+void HmacMD5::calculate() {
+  uint8_t ibytes[16];
+
+  this->ihash_.calculate();
+  this->ihash_.get_bytes(ibytes);
+
+  this->ohash_.add(ibytes, sizeof(ibytes));
+  this->ohash_.calculate();
+}
+
+void HmacMD5::get_bytes(uint8_t *output) { this->ohash_.get_bytes(output); }
+
+void HmacMD5::get_hex(char *output) { this->ohash_.get_hex(output); }
+
+bool HmacMD5::equals_bytes(const uint8_t *expected) { return this->ohash_.equals_bytes(expected); }
+
+bool HmacMD5::equals_hex(const char *expected) { return this->ohash_.equals_hex(expected); }
+
+}  // namespace hmac_md5
+}  // namespace esphome
--- a/esphome/components/hmac_md5/hmac_md5.h
+++ b/esphome/components/hmac_md5/hmac_md5.h
@ -0,0 +1,48 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#include "esphome/components/md5/md5.h"
+
+#include <string>
+
+namespace esphome {
+namespace hmac_md5 {
+
+class HmacMD5 {
+ public:
+  HmacMD5() = default;
+  ~HmacMD5() = default;
+
+  /// Initialize a new MD5 digest computation.
+  void init(const uint8_t *key, size_t len);
+  void init(const char *key, size_t len) { this->init((const uint8_t *) key, len); }
+  void init(const std::string &key) { this->init(key.c_str(), key.length()); }
+
+  /// Add bytes of data for the digest.
+  void add(const uint8_t *data, size_t len);
+  void add(const char *data, size_t len) { this->add((const uint8_t *) data, len); }
+
+  /// Compute the digest, based on the provided data.
+  void calculate();
+
+  /// Retrieve the HMAC-MD5 digest as bytes.
+  /// The output must be able to hold 16 bytes or more.
+  void get_bytes(uint8_t *output);
+
+  /// Retrieve the HMAC-MD5 digest as hex characters.
+  /// The output must be able to hold 32 bytes or more.
+  void get_hex(char *output);
+
+  /// Compare the digest against a provided byte-encoded digest (16 bytes).
+  bool equals_bytes(const uint8_t *expected);
+
+  /// Compare the digest against a provided hex-encoded digest (32 bytes).
+  bool equals_hex(const char *expected);
+
+ protected:
+  md5::MD5Digest ihash_;
+  md5::MD5Digest ohash_;
+};
+
+}  // namespace hmac_md5
+}  // namespace esphome
--- a/esphome/components/homeassistant/init.py
+++ b/esphome/components/homeassistant/init.py
@ -2,7 +2,7 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ATTRIBUTE, CONF_ENTITY_ID, CONF_INTERNAL

-CODEOWNERS = ["@OttoWinter"]
+CODEOWNERS = ["@OttoWinter", "@esphome/core"]
 homeassistant_ns = cg.esphome_ns.namespace("homeassistant")

 HOME_ASSISTANT_IMPORT_SCHEMA = cv.Schema(
@ -13,6 +13,13 @@ HOME_ASSISTANT_IMPORT_SCHEMA = cv.Schema(
    }
 )

+HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ENTITY_ID): cv.entity_id,
+        cv.Optional(CONF_INTERNAL, default=True): cv.boolean,
+    }
+)
+

 def setup_home_assistant_entity(var, config):
    cg.add(var.set_entity_id(config[CONF_ENTITY_ID]))
--- a/esphome/components/homeassistant/number/init.py
+++ b/esphome/components/homeassistant/number/init.py
@ -0,0 +1,33 @@
+import esphome.codegen as cg
+from esphome.components import number
+import esphome.config_validation as cv
+
+from .. import (
+    HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA,
+    homeassistant_ns,
+    setup_home_assistant_entity,
+)
+
+CODEOWNERS = ["@landonr"]
+DEPENDENCIES = ["api"]
+
+HomeassistantNumber = homeassistant_ns.class_(
+    "HomeassistantNumber", number.Number, cg.Component
+)
+
+CONFIG_SCHEMA = (
+    number.number_schema(HomeassistantNumber)
+    .extend(HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = await number.new_number(
+        config,
+        min_value=0,
+        max_value=0,
+        step=0,
+    )
+    await cg.register_component(var, config)
+    setup_home_assistant_entity(var, config)
--- a/esphome/components/homeassistant/number/homeassistant_number.cpp
+++ b/esphome/components/homeassistant/number/homeassistant_number.cpp
@ -0,0 +1,100 @@
+#include "homeassistant_number.h"
+
+#include "esphome/components/api/api_pb2.h"
+#include "esphome/components/api/api_server.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace homeassistant {
+
+static const char *const TAG = "homeassistant.number";
+
+void HomeassistantNumber::state_changed_(const std::string &state) {
+  auto number_value = parse_number<float>(state);
+  if (!number_value.has_value()) {
+    ESP_LOGW(TAG, "'%s': Can't convert '%s' to number!", this->entity_id_.c_str(), state.c_str());
+    this->publish_state(NAN);
+    return;
+  }
+  if (this->state == number_value.value()) {
+    return;
+  }
+  ESP_LOGD(TAG, "'%s': Got state %s", this->entity_id_.c_str(), state.c_str());
+  this->publish_state(number_value.value());
+}
+
+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());
+  }
+  ESP_LOGD(TAG, "'%s': Min retrieved: %s", get_name().c_str(), min.c_str());
+  this->traits.set_min_value(min_value.value());
+}
+
+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());
+  }
+  ESP_LOGD(TAG, "'%s': Max retrieved: %s", get_name().c_str(), max.c_str());
+  this->traits.set_max_value(max_value.value());
+}
+
+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());
+  }
+  ESP_LOGD(TAG, "'%s': Step Retrieved %s", get_name().c_str(), step.c_str());
+  this->traits.set_step(step_value.value());
+}
+
+void HomeassistantNumber::setup() {
+  api::global_api_server->subscribe_home_assistant_state(
+      this->entity_id_, nullopt, std::bind(&HomeassistantNumber::state_changed_, this, std::placeholders::_1));
+
+  api::global_api_server->get_home_assistant_state(
+      this->entity_id_, optional<std::string>("min"),
+      std::bind(&HomeassistantNumber::min_retrieved_, this, std::placeholders::_1));
+  api::global_api_server->get_home_assistant_state(
+      this->entity_id_, optional<std::string>("max"),
+      std::bind(&HomeassistantNumber::max_retrieved_, this, std::placeholders::_1));
+  api::global_api_server->get_home_assistant_state(
+      this->entity_id_, optional<std::string>("step"),
+      std::bind(&HomeassistantNumber::step_retrieved_, this, std::placeholders::_1));
+}
+
+void HomeassistantNumber::dump_config() {
+  LOG_NUMBER("", "Homeassistant Number", this);
+  ESP_LOGCONFIG(TAG, "  Entity ID: '%s'", this->entity_id_.c_str());
+}
+
+float HomeassistantNumber::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
+
+void HomeassistantNumber::control(float value) {
+  if (!api::global_api_server->is_connected()) {
+    ESP_LOGE(TAG, "No clients connected to API server");
+    return;
+  }
+
+  this->publish_state(value);
+
+  api::HomeassistantServiceResponse resp;
+  resp.service = "number.set_value";
+
+  api::HomeassistantServiceMap entity_id;
+  entity_id.key = "entity_id";
+  entity_id.value = this->entity_id_;
+  resp.data.push_back(entity_id);
+
+  api::HomeassistantServiceMap entity_value;
+  entity_value.key = "value";
+  entity_value.value = to_string(value);
+  resp.data.push_back(entity_value);
+
+  api::global_api_server->send_homeassistant_service_call(resp);
+}
+
+}  // namespace homeassistant
+}  // namespace esphome
--- a/esphome/components/homeassistant/number/homeassistant_number.h
+++ b/esphome/components/homeassistant/number/homeassistant_number.h
@ -0,0 +1,31 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "esphome/components/number/number.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace homeassistant {
+
+class HomeassistantNumber : public number::Number, public Component {
+ public:
+  void set_entity_id(const std::string &entity_id) { this->entity_id_ = entity_id; }
+
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+
+ protected:
+  void state_changed_(const std::string &state);
+  void min_retrieved_(const std::string &min);
+  void max_retrieved_(const std::string &max);
+  void step_retrieved_(const std::string &step);
+
+  void control(float value) override;
+
+  std::string entity_id_;
+};
+}  // namespace homeassistant
+}  // namespace esphome
--- a/esphome/components/homeassistant/switch/init.py
+++ b/esphome/components/homeassistant/switch/init.py
@ -0,0 +1,30 @@
+import esphome.codegen as cg
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+
+from .. import (
+    HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA,
+    homeassistant_ns,
+    setup_home_assistant_entity,
+)
+
+CODEOWNERS = ["@Links2004"]
+DEPENDENCIES = ["api"]
+
+HomeassistantSwitch = homeassistant_ns.class_(
+    "HomeassistantSwitch", switch.Switch, cg.Component
+)
+
+CONFIG_SCHEMA = (
+    switch.switch_schema(HomeassistantSwitch)
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await switch.register_switch(var, config)
+    setup_home_assistant_entity(var, config)
--- a/esphome/components/homeassistant/switch/homeassistant_switch.cpp
+++ b/esphome/components/homeassistant/switch/homeassistant_switch.cpp
@ -0,0 +1,59 @@
+#include "homeassistant_switch.h"
+#include "esphome/components/api/api_server.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace homeassistant {
+
+static const char *const TAG = "homeassistant.switch";
+
+using namespace esphome::switch_;
+
+void HomeassistantSwitch::setup() {
+  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, nullopt, [this](const std::string &state) {
+    auto val = parse_on_off(state.c_str());
+    switch (val) {
+      case PARSE_NONE:
+      case PARSE_TOGGLE:
+        ESP_LOGW(TAG, "Can't convert '%s' to binary state!", state.c_str());
+        break;
+      case PARSE_ON:
+      case PARSE_OFF:
+        bool new_state = val == PARSE_ON;
+        ESP_LOGD(TAG, "'%s': Got state %s", this->entity_id_.c_str(), ONOFF(new_state));
+        this->publish_state(new_state);
+        break;
+    }
+  });
+}
+
+void HomeassistantSwitch::dump_config() {
+  LOG_SWITCH("", "Homeassistant Switch", this);
+  ESP_LOGCONFIG(TAG, "  Entity ID: '%s'", this->entity_id_.c_str());
+}
+
+float HomeassistantSwitch::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
+
+void HomeassistantSwitch::write_state(bool state) {
+  if (!api::global_api_server->is_connected()) {
+    ESP_LOGE(TAG, "No clients connected to API server");
+    return;
+  }
+
+  api::HomeassistantServiceResponse resp;
+  if (state) {
+    resp.service = "switch.turn_on";
+  } else {
+    resp.service = "switch.turn_off";
+  }
+
+  api::HomeassistantServiceMap entity_id_kv;
+  entity_id_kv.key = "entity_id";
+  entity_id_kv.value = this->entity_id_;
+  resp.data.push_back(entity_id_kv);
+
+  api::global_api_server->send_homeassistant_service_call(resp);
+}
+
+}  // namespace homeassistant
+}  // namespace esphome
--- a/esphome/components/homeassistant/switch/homeassistant_switch.h
+++ b/esphome/components/homeassistant/switch/homeassistant_switch.h
@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace homeassistant {
+
+class HomeassistantSwitch : public switch_::Switch, public Component {
+ public:
+  void set_entity_id(const std::string &entity_id) { this->entity_id_ = entity_id; }
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+
+ protected:
+  void write_state(bool state) override;
+  std::string entity_id_;
+};
+
+}  // namespace homeassistant
+}  // namespace esphome
--- a/esphome/components/host/init.py
+++ b/esphome/components/host/init.py
@ -1,15 +1,14 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
 from esphome.const import (
+    CONF_MAC_ADDRESS,
    KEY_CORE,
    KEY_FRAMEWORK_VERSION,
    KEY_TARGET_FRAMEWORK,
    KEY_TARGET_PLATFORM,
    PLATFORM_HOST,
-    CONF_MAC_ADDRESS,
 )
 from esphome.core import CORE
-from esphome.helpers import IS_MACOS
-import esphome.config_validation as cv
-import esphome.codegen as cg

 from .const import KEY_HOST

@ -42,8 +41,5 @@ async def to_code(config):
    cg.add_build_flag("-DUSE_HOST")
    cg.add_define("USE_ESPHOME_HOST_MAC_ADDRESS", config[CONF_MAC_ADDRESS].parts)
    cg.add_build_flag("-std=c++17")
-    cg.add_build_flag("-lsodium")
-    if IS_MACOS:
-        cg.add_build_flag("-L/opt/homebrew/lib")
    cg.add_define("ESPHOME_BOARD", "host")
    cg.add_platformio_option("platform", "platformio/native")
--- a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp
@ -180,7 +180,11 @@ void I2SAudioSpeaker::player_task(void *params) {
  }
 }

-void I2SAudioSpeaker::stop() {
+void I2SAudioSpeaker::stop() { this->stop_(false); }
+
+void I2SAudioSpeaker::finish() { this->stop_(true); }
+
+void I2SAudioSpeaker::stop_(bool wait_on_empty) {
  if (this->is_failed())
    return;
  if (this->state_ == speaker::STATE_STOPPED)
@ -192,7 +196,11 @@ void I2SAudioSpeaker::stop() {
  this->state_ = speaker::STATE_STOPPING;
  DataEvent data;
  data.stop = true;
-  xQueueSendToFront(this->buffer_queue_, &data, portMAX_DELAY);
+  if (wait_on_empty) {
+    xQueueSend(this->buffer_queue_, &data, portMAX_DELAY);
+  } else {
+    xQueueSendToFront(this->buffer_queue_, &data, portMAX_DELAY);
+  }
 }

 void I2SAudioSpeaker::watch_() {
--- a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
@ -53,6 +53,7 @@ class I2SAudioSpeaker : public Component, public speaker::Speaker, public I2SAud

  void start() override;
  void stop() override;
+  void finish() override;

  size_t play(const uint8_t *data, size_t length) override;

@ -60,6 +61,7 @@ class I2SAudioSpeaker : public Component, public speaker::Speaker, public I2SAud

 protected:
  void start_();
+  void stop_(bool wait_on_empty);
  void watch_();

  static void player_task(void *params);
--- a/esphome/components/improv_serial/improv_serial_component.cpp
+++ b/esphome/components/improv_serial/improv_serial_component.cpp
@ -1,5 +1,5 @@
 #include "improv_serial_component.h"
-
+#ifdef USE_WIFI
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
@ -313,3 +313,4 @@ ImprovSerialComponent *global_improv_serial_component =  // NOLINT(cppcoreguidel

 }  // namespace improv_serial
 }  // namespace esphome
+#endif
--- a/esphome/components/improv_serial/improv_serial_component.h
+++ b/esphome/components/improv_serial/improv_serial_component.h
@ -5,7 +5,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
-
+#ifdef USE_WIFI
 #include <improv.h>
 #include <vector>

@ -78,3 +78,4 @@ extern ImprovSerialComponent

 }  // namespace improv_serial
 }  // namespace esphome
+#endif
--- a/esphome/components/light/addressable_light_effect.h
+++ b/esphome/components/light/addressable_light_effect.h
@ -114,10 +114,11 @@ class AddressableColorWipeEffect : public AddressableLightEffect {
    if (now - this->last_add_ < this->add_led_interval_)
      return;
    this->last_add_ = now;
-    if (this->reverse_)
+    if (this->reverse_) {
      it.shift_left(1);
-    else
+    } else {
      it.shift_right(1);
+    }
    const AddressableColorWipeEffectColor &color = this->colors_[this->at_color_];
    Color esp_color = Color(color.r, color.g, color.b, color.w);
    if (color.gradient) {
@ -127,10 +128,11 @@ class AddressableColorWipeEffect : public AddressableLightEffect {
      uint8_t gradient = 255 * ((float) this->leds_added_ / color.num_leds);
      esp_color = esp_color.gradient(next_esp_color, gradient);
    }
-    if (this->reverse_)
+    if (this->reverse_) {
      it[-1] = esp_color;
-    else
+    } else {
      it[0] = esp_color;
+    }
    if (++this->leds_added_ >= color.num_leds) {
      this->leds_added_ = 0;
      this->at_color_ = (this->at_color_ + 1) % this->colors_.size();
@ -207,10 +209,11 @@ class AddressableTwinkleEffect : public AddressableLightEffect {
        const uint8_t sine = half_sin8(view.get_effect_data());
        view = current_color * sine;
        const uint8_t new_pos = view.get_effect_data() + pos_add;
-        if (new_pos < view.get_effect_data())
+        if (new_pos < view.get_effect_data()) {
          view.set_effect_data(0);
-        else
+        } else {
          view.set_effect_data(new_pos);
+        }
      } else {
        view = Color::BLACK;
      }
@ -254,10 +257,11 @@ class AddressableRandomTwinkleEffect : public AddressableLightEffect {
          view = Color(((color >> 2) & 1) * sine, ((color >> 1) & 1) * sine, ((color >> 0) & 1) * sine);
        }
        const uint8_t new_x = x + pos_add;
-        if (new_x > 0b11111)
+        if (new_x > 0b11111) {
          view.set_effect_data(0);
-        else
+        } else {
          view.set_effect_data((new_x << 3) | color);
+        }
      } else {
        view = Color(0, 0, 0, 0);
      }
--- a/esphome/components/light/automation.h
+++ b/esphome/components/light/automation.h
@ -7,6 +7,8 @@
 namespace esphome {
 namespace light {

+enum class LimitMode { CLAMP, DO_NOTHING };
+
 template<typename... Ts> class ToggleAction : public Action<Ts...> {
 public:
  explicit ToggleAction(LightState *state) : state_(state) {}
@ -77,7 +79,10 @@ template<typename... Ts> class DimRelativeAction : public Action<Ts...> {
    float rel = this->relative_brightness_.value(x...);
    float cur;
    this->parent_->remote_values.as_brightness(&cur);
-    float new_brightness = clamp(cur + rel, 0.0f, 1.0f);
+    if ((limit_mode_ == LimitMode::DO_NOTHING) && ((cur < min_brightness_) || (cur > max_brightness_))) {
+      return;
+    }
+    float new_brightness = clamp(cur + rel, min_brightness_, max_brightness_);
    call.set_state(new_brightness != 0.0f);
    call.set_brightness(new_brightness);

@ -85,8 +90,18 @@ template<typename... Ts> class DimRelativeAction : public Action<Ts...> {
    call.perform();
  }

+  void set_min_max_brightness(float min, float max) {
+    this->min_brightness_ = min;
+    this->max_brightness_ = max;
+  }
+
+  void set_limit_mode(LimitMode limit_mode) { this->limit_mode_ = limit_mode; }
+
 protected:
  LightState *parent_;
+  float min_brightness_{0.0};
+  float max_brightness_{1.0};
+  LimitMode limit_mode_{LimitMode::CLAMP};
 };

 template<typename... Ts> class LightIsOnCondition : public Condition<Ts...> {
--- a/esphome/components/light/automation.py
+++ b/esphome/components/light/automation.py
@ -19,10 +19,15 @@ from esphome.const import (
    CONF_WARM_WHITE,
    CONF_RANGE_FROM,
    CONF_RANGE_TO,
+    CONF_BRIGHTNESS_LIMITS,
+    CONF_LIMIT_MODE,
+    CONF_MIN_BRIGHTNESS,
+    CONF_MAX_BRIGHTNESS,
 )
 from .types import (
    ColorMode,
    COLOR_MODES,
+    LIMIT_MODES,
    DimRelativeAction,
    ToggleAction,
    LightState,
@ -167,6 +172,15 @@ LIGHT_DIM_RELATIVE_ACTION_SCHEMA = cv.Schema(
        cv.Optional(CONF_TRANSITION_LENGTH): cv.templatable(
            cv.positive_time_period_milliseconds
        ),
+        cv.Optional(CONF_BRIGHTNESS_LIMITS): cv.Schema(
+            {
+                cv.Optional(CONF_MIN_BRIGHTNESS, default="0%"): cv.percentage,
+                cv.Optional(CONF_MAX_BRIGHTNESS, default="100%"): cv.percentage,
+                cv.Optional(CONF_LIMIT_MODE, default="CLAMP"): cv.enum(
+                    LIMIT_MODES, upper=True, space="_"
+                ),
+            }
+        ),
    }
 )

@ -182,6 +196,13 @@ async def light_dim_relative_to_code(config, action_id, template_arg, args):
    if CONF_TRANSITION_LENGTH in config:
        templ = await cg.templatable(config[CONF_TRANSITION_LENGTH], args, cg.uint32)
        cg.add(var.set_transition_length(templ))
+    if conf := config.get(CONF_BRIGHTNESS_LIMITS):
+        cg.add(
+            var.set_min_max_brightness(
+                conf[CONF_MIN_BRIGHTNESS], conf[CONF_MAX_BRIGHTNESS]
+            )
+        )
+        cg.add(var.set_limit_mode(conf[CONF_LIMIT_MODE]))
    return var


--- a/esphome/components/light/base_light_effects.h
+++ b/esphome/components/light/base_light_effects.h
@ -25,7 +25,7 @@ class PulseLightEffect : public LightEffect {
      return;
    }
    auto call = this->state_->turn_on();
-    float out = this->on_ ? this->max_brightness : this->min_brightness;
+    float out = this->on_ ? this->max_brightness_ : this->min_brightness_;
    call.set_brightness_if_supported(out);
    call.set_transition_length_if_supported(this->on_ ? this->transition_on_length_ : this->transition_off_length_);
    this->on_ = !this->on_;
@ -43,8 +43,8 @@ class PulseLightEffect : public LightEffect {
  void set_update_interval(uint32_t update_interval) { this->update_interval_ = update_interval; }

  void set_min_max_brightness(float min, float max) {
-    this->min_brightness = min;
-    this->max_brightness = max;
+    this->min_brightness_ = min;
+    this->max_brightness_ = max;
  }

 protected:
@ -53,8 +53,8 @@ class PulseLightEffect : public LightEffect {
  uint32_t transition_on_length_{};
  uint32_t transition_off_length_{};
  uint32_t update_interval_{};
-  float min_brightness{0.0};
-  float max_brightness{1.0};
+  float min_brightness_{0.0};
+  float max_brightness_{1.0};
 };

 /// Random effect. Sets random colors every 10 seconds and slowly transitions between them.
--- a/esphome/components/light/esp_color_correction.h
+++ b/esphome/components/light/esp_color_correction.h
@ -41,29 +41,29 @@ class ESPColorCorrection {
    if (this->max_brightness_.red == 0 || this->local_brightness_ == 0)
      return 0;
    uint16_t uncorrected = this->gamma_reverse_table_[red] * 255UL;
-    uint8_t res = ((uncorrected / this->max_brightness_.red) * 255UL) / this->local_brightness_;
-    return res;
+    uint16_t res = ((uncorrected / this->max_brightness_.red) * 255UL) / this->local_brightness_;
+    return (uint8_t) std::min(res, uint16_t(255));
  }
  inline uint8_t color_uncorrect_green(uint8_t green) const ESPHOME_ALWAYS_INLINE {
    if (this->max_brightness_.green == 0 || this->local_brightness_ == 0)
      return 0;
    uint16_t uncorrected = this->gamma_reverse_table_[green] * 255UL;
-    uint8_t res = ((uncorrected / this->max_brightness_.green) * 255UL) / this->local_brightness_;
-    return res;
+    uint16_t res = ((uncorrected / this->max_brightness_.green) * 255UL) / this->local_brightness_;
+    return (uint8_t) std::min(res, uint16_t(255));
  }
  inline uint8_t color_uncorrect_blue(uint8_t blue) const ESPHOME_ALWAYS_INLINE {
    if (this->max_brightness_.blue == 0 || this->local_brightness_ == 0)
      return 0;
    uint16_t uncorrected = this->gamma_reverse_table_[blue] * 255UL;
-    uint8_t res = ((uncorrected / this->max_brightness_.blue) * 255UL) / this->local_brightness_;
-    return res;
+    uint16_t res = ((uncorrected / this->max_brightness_.blue) * 255UL) / this->local_brightness_;
+    return (uint8_t) std::min(res, uint16_t(255));
  }
  inline uint8_t color_uncorrect_white(uint8_t white) const ESPHOME_ALWAYS_INLINE {
    if (this->max_brightness_.white == 0 || this->local_brightness_ == 0)
      return 0;
    uint16_t uncorrected = this->gamma_reverse_table_[white] * 255UL;
-    uint8_t res = ((uncorrected / this->max_brightness_.white) * 255UL) / this->local_brightness_;
-    return res;
+    uint16_t res = ((uncorrected / this->max_brightness_.white) * 255UL) / this->local_brightness_;
+    return (uint8_t) std::min(res, uint16_t(255));
  }

 protected:
--- a/esphome/components/light/types.py
+++ b/esphome/components/light/types.py
@ -26,6 +26,13 @@ COLOR_MODES = {
    "RGB_COLD_WARM_WHITE": ColorMode.RGB_COLD_WARM_WHITE,
 }

+# Limit modes
+LimitMode = light_ns.enum("LimitMode", is_class=True)
+LIMIT_MODES = {
+    "CLAMP": LimitMode.CLAMP,
+    "DO_NOTHING": LimitMode.DO_NOTHING,
+}
+
 # Actions
 ToggleAction = light_ns.class_("ToggleAction", automation.Action)
 LightControlAction = light_ns.class_("LightControlAction", automation.Action)
--- a/esphome/components/lvgl/init.py
+++ b/esphome/components/lvgl/init.py
@ -23,7 +23,7 @@ from esphome.helpers import write_file_if_changed
 from . import defines as df, helpers, lv_validation as lvalid
 from .automation import disp_update, update_to_code
 from .defines import CONF_SKIP
-from .encoders import ENCODERS_CONFIG, encoders_to_code
+from .encoders import ENCODERS_CONFIG, encoders_to_code, initial_focus_to_code
 from .lv_validation import lv_bool, lv_images_used
 from .lvcode import LvContext, LvglComponent
 from .schemas import (
@ -272,6 +272,7 @@ async def to_code(config):
            templ = await cg.templatable(conf[CONF_TIMEOUT], [], cg.uint32)
            idle_trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], lv_component, templ)
            await build_automation(idle_trigger, [], conf)
+        await initial_focus_to_code(config)

    for comp in helpers.lvgl_components_required:
        CORE.add_define(f"USE_LVGL_{comp.upper()}")
--- a/esphome/components/lvgl/automation.py
+++ b/esphome/components/lvgl/automation.py
@ -17,6 +17,7 @@ from .defines import (
 from .lv_validation import lv_bool, lv_color, lv_image
 from .lvcode import (
    LVGL_COMP_ARG,
+    UPDATE_EVENT,
    LambdaContext,
    LocalVariable,
    LvConditional,
@ -30,7 +31,6 @@ from .lvcode import (
 )
 from .schemas import DISP_BG_SCHEMA, LIST_ACTION_SCHEMA, LVGL_SCHEMA
 from .types import (
-    LV_EVENT,
    LV_STATE,
    LvglAction,
    LvglCondition,
@ -64,7 +64,7 @@ async def update_to_code(config, action_id, template_arg, args):
            widget.type.w_type.value_property is not None
            and widget.type.w_type.value_property in config
        ):
-            lv.event_send(widget.obj, LV_EVENT.VALUE_CHANGED, nullptr)
+            lv.event_send(widget.obj, UPDATE_EVENT, nullptr)

    widgets = await get_widgets(config[CONF_ID])
    return await action_to_code(widgets, do_update, action_id, template_arg, args)
--- a/esphome/components/lvgl/defines.py
+++ b/esphome/components/lvgl/defines.py
@ -413,6 +413,7 @@ CONF_GRID_ROW_ALIGN = "grid_row_align"
 CONF_GRID_ROWS = "grid_rows"
 CONF_HEADER_MODE = "header_mode"
 CONF_HOME = "home"
+CONF_INITIAL_FOCUS = "initial_focus"
 CONF_KEY_CODE = "key_code"
 CONF_LAYOUT = "layout"
 CONF_LEFT_BUTTON = "left_button"
@ -469,6 +470,7 @@ CONF_TOP_LAYER = "top_layer"
 CONF_TOUCHSCREENS = "touchscreens"
 CONF_TRANSPARENCY_KEY = "transparency_key"
 CONF_THEME = "theme"
+CONF_UPDATE_ON_RELEASE = "update_on_release"
 CONF_VISIBLE_ROW_COUNT = "visible_row_count"
 CONF_WIDGET = "widget"
 CONF_WIDGETS = "widgets"
--- a/esphome/components/lvgl/encoders.py
+++ b/esphome/components/lvgl/encoders.py
@ -8,6 +8,7 @@ from .defines import (
    CONF_DEFAULT_GROUP,
    CONF_ENCODERS,
    CONF_ENTER_BUTTON,
+    CONF_INITIAL_FOCUS,
    CONF_LEFT_BUTTON,
    CONF_LONG_PRESS_REPEAT_TIME,
    CONF_LONG_PRESS_TIME,
@ -67,3 +68,10 @@ async def encoders_to_code(var, config):
        else:
            group = default_group
        lv.indev_set_group(lv_expr.indev_drv_register(listener.get_drv()), group)
+
+
+async def initial_focus_to_code(config):
+    for enc_conf in config[CONF_ENCODERS]:
+        if default_focus := enc_conf.get(CONF_INITIAL_FOCUS):
+            obj = await cg.get_variable(default_focus)
+            lv.group_focus_obj(obj)
--- a/esphome/components/lvgl/light/lvgl_light.h
+++ b/esphome/components/lvgl/light/lvgl_light.h
@ -38,7 +38,7 @@ class LVLight : public light::LightOutput {
  void set_value_(lv_color_t value) {
    lv_led_set_color(this->obj_, value);
    lv_led_on(this->obj_);
-    lv_event_send(this->obj_, lv_custom_event, nullptr);
+    lv_event_send(this->obj_, lv_api_event, nullptr);
  }
  lv_obj_t *obj_{};
  optional<lv_color_t> initial_value_{};
--- a/esphome/components/lvgl/lvcode.py
+++ b/esphome/components/lvgl/lvcode.py
@ -29,7 +29,11 @@ LvglComponent = lvgl_ns.class_("LvglComponent", cg.PollingComponent)
 LVGL_COMP_ARG = [(LvglComponent.operator("ptr"), LVGL_COMP)]
 lv_event_t_ptr = cg.global_ns.namespace("lv_event_t").operator("ptr")
 EVENT_ARG = [(lv_event_t_ptr, "ev")]
-CUSTOM_EVENT = literal("lvgl::lv_custom_event")
+# Two custom events; API_EVENT is fired when an entity is updated remotely by an API interaction;
+# UPDATE_EVENT is fired when an entity is programmatically updated locally.
+# VALUE_CHANGED is the event generated by LVGL when an entity's value changes through user interaction.
+API_EVENT = literal("lvgl::lv_api_event")
+UPDATE_EVENT = literal("lvgl::lv_update_event")


 def get_line_marks(value) -> list:
--- a/esphome/components/lvgl/lvgl_esphome.cpp
+++ b/esphome/components/lvgl/lvgl_esphome.cpp
@ -27,7 +27,8 @@ static void rounder_cb(lv_disp_drv_t *disp_drv, lv_area_t *area) {
    area->y2++;
 }

-lv_event_code_t lv_custom_event;  // NOLINT
+lv_event_code_t lv_api_event;     // NOLINT
+lv_event_code_t lv_update_event;  // NOLINT
 void LvglComponent::dump_config() { ESP_LOGCONFIG(TAG, "LVGL:"); }
 void LvglComponent::set_paused(bool paused, bool show_snow) {
  this->paused_ = paused;
@ -40,15 +41,18 @@ void LvglComponent::set_paused(bool paused, bool show_snow) {
 }
 void LvglComponent::add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event) {
  lv_obj_add_event_cb(obj, callback, event, this);
-  if (event == LV_EVENT_VALUE_CHANGED) {
-    lv_obj_add_event_cb(obj, callback, lv_custom_event, this);
-  }
 }
 void LvglComponent::add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1,
                                 lv_event_code_t event2) {
  this->add_event_cb(obj, callback, event1);
  this->add_event_cb(obj, callback, event2);
 }
+void LvglComponent::add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1,
+                                 lv_event_code_t event2, lv_event_code_t event3) {
+  this->add_event_cb(obj, callback, event1);
+  this->add_event_cb(obj, callback, event2);
+  this->add_event_cb(obj, callback, event3);
+}
 void LvglComponent::add_page(LvPageType *page) {
  this->pages_.push_back(page);
  page->setup(this->pages_.size() - 1);
@ -228,7 +232,8 @@ void LvglComponent::setup() {
  lv_log_register_print_cb(log_cb);
 #endif
  lv_init();
-  lv_custom_event = static_cast<lv_event_code_t>(lv_event_register_id());
+  lv_update_event = static_cast<lv_event_code_t>(lv_event_register_id());
+  lv_api_event = static_cast<lv_event_code_t>(lv_event_register_id());
  auto *display = this->displays_[0];
  size_t buffer_pixels = display->get_width() * display->get_height() / this->buffer_frac_;
  auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
--- a/esphome/components/lvgl/lvgl_esphome.h
+++ b/esphome/components/lvgl/lvgl_esphome.h
@ -38,7 +38,8 @@
 namespace esphome {
 namespace lvgl {

-extern lv_event_code_t lv_custom_event;  // NOLINT
+extern lv_event_code_t lv_api_event;     // NOLINT
+extern lv_event_code_t lv_update_event;  // NOLINT
 #ifdef USE_LVGL_COLOR
 inline lv_color_t lv_color_from(Color color) { return lv_color_make(color.red, color.green, color.blue); }
 #endif  // USE_LVGL_COLOR
@ -133,6 +134,8 @@ class LvglComponent : public PollingComponent {
  void set_paused(bool paused, bool show_snow);
  void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event);
  void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2);
+  void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2,
+                    lv_event_code_t event3);
  bool is_paused() const { return this->paused_; }
  void add_page(LvPageType *page);
  void show_page(size_t index, lv_scr_load_anim_t anim, uint32_t time);
--- a/esphome/components/lvgl/number/init.py
+++ b/esphome/components/lvgl/number/init.py
@ -3,9 +3,17 @@ from esphome.components import number
 import esphome.config_validation as cv
 from esphome.cpp_generator import MockObj

-from ..defines import CONF_ANIMATED, CONF_LVGL_ID, CONF_WIDGET
+from ..defines import CONF_ANIMATED, CONF_LVGL_ID, CONF_UPDATE_ON_RELEASE, CONF_WIDGET
 from ..lv_validation import animated
-from ..lvcode import CUSTOM_EVENT, EVENT_ARG, LambdaContext, LvContext, lv, lv_add
+from ..lvcode import (
+    API_EVENT,
+    EVENT_ARG,
+    UPDATE_EVENT,
+    LambdaContext,
+    LvContext,
+    lv,
+    lv_add,
+)
 from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LvNumber, lvgl_ns
 from ..widgets import get_widgets
@ -19,6 +27,7 @@ CONFIG_SCHEMA = (
        {
            cv.Required(CONF_WIDGET): cv.use_id(LvNumber),
            cv.Optional(CONF_ANIMATED, default=True): animated,
+            cv.Optional(CONF_UPDATE_ON_RELEASE, default=False): cv.boolean,
        }
    )
 )
@ -39,14 +48,19 @@ async def to_code(config):
        await widget.set_property(
            "value", MockObj("v") * MockObj(widget.get_scale()), config[CONF_ANIMATED]
        )
-        lv.event_send(widget.obj, CUSTOM_EVENT, cg.nullptr)
+        lv.event_send(widget.obj, API_EVENT, cg.nullptr)
    async with LambdaContext(EVENT_ARG) as event:
        event.add(var.publish_state(widget.get_value()))
+    event_code = (
+        LV_EVENT.VALUE_CHANGED
+        if not config[CONF_UPDATE_ON_RELEASE]
+        else LV_EVENT.RELEASED
+    )
    async with LvContext(paren):
        lv_add(var.set_control_lambda(await control.get_lambda()))
        lv_add(
            paren.add_event_cb(
-                widget.obj, await event.get_lambda(), LV_EVENT.VALUE_CHANGED
+                widget.obj, await event.get_lambda(), UPDATE_EVENT, event_code
            )
        )
        lv_add(var.publish_state(widget.get_value()))
--- a/esphome/components/lvgl/number/lvgl_number.h
+++ b/esphome/components/lvgl/number/lvgl_number.h
@ -1,5 +1,7 @@
 #pragma once

+#include <utility>
+
 #include "esphome/components/number/number.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
@ -11,7 +13,7 @@ namespace lvgl {
 class LVGLNumber : public number::Number {
 public:
  void set_control_lambda(std::function<void(float)> control_lambda) {
-    this->control_lambda_ = control_lambda;
+    this->control_lambda_ = std::move(control_lambda);
    if (this->initial_state_.has_value()) {
      this->control_lambda_(this->initial_state_.value());
      this->initial_state_.reset();
@ -20,10 +22,11 @@ class LVGLNumber : public number::Number {

 protected:
  void control(float value) override {
-    if (this->control_lambda_ != nullptr)
+    if (this->control_lambda_ != nullptr) {
      this->control_lambda_(value);
-    else
+    } else {
      this->initial_state_ = value;
+    }
  }
  std::function<void(float)> control_lambda_{};
  optional<float> initial_state_{};
--- a/esphome/components/lvgl/schemas.py
+++ b/esphome/components/lvgl/schemas.py
@ -14,11 +14,19 @@ from esphome.const import (
 from esphome.core import TimePeriod
 from esphome.schema_extractors import SCHEMA_EXTRACT

-from . import defines as df, lv_validation as lvalid, types as ty
+from . import defines as df, lv_validation as lvalid
 from .helpers import add_lv_use, requires_component, validate_printf
 from .lv_validation import lv_color, lv_font, lv_image
 from .lvcode import LvglComponent
-from .types import WidgetType, lv_group_t
+from .types import (
+    LVEncoderListener,
+    LvType,
+    WidgetType,
+    lv_group_t,
+    lv_obj_t,
+    lv_pseudo_button_t,
+    lv_style_t,
+)

 # this will be populated later, in __init__.py to avoid circular imports.
 WIDGET_TYPES: dict = {}
@ -46,7 +54,7 @@ TEXT_SCHEMA = cv.Schema(
 LIST_ACTION_SCHEMA = cv.ensure_list(
    cv.maybe_simple_value(
        {
-            cv.Required(CONF_ID): cv.use_id(ty.lv_pseudo_button_t),
+            cv.Required(CONF_ID): cv.use_id(lv_pseudo_button_t),
        },
        key=CONF_ID,
    )
@ -59,9 +67,10 @@ PRESS_TIME = cv.All(
 ENCODER_SCHEMA = cv.Schema(
    {
        cv.GenerateID(): cv.All(
-            cv.declare_id(ty.LVEncoderListener), requires_component("binary_sensor")
+            cv.declare_id(LVEncoderListener), requires_component("binary_sensor")
        ),
        cv.Optional(CONF_GROUP): cv.declare_id(lv_group_t),
+        cv.Optional(df.CONF_INITIAL_FOCUS): cv.use_id(lv_obj_t),
        cv.Optional(df.CONF_LONG_PRESS_TIME, default="400ms"): PRESS_TIME,
        cv.Optional(df.CONF_LONG_PRESS_REPEAT_TIME, default="100ms"): PRESS_TIME,
    }
@ -94,6 +103,7 @@ STYLE_PROPS = {
    ).several_of,
    "border_width": cv.positive_int,
    "clip_corner": lvalid.lv_bool,
+    "color_filter_opa": lvalid.opacity,
    "height": lvalid.size,
    "image_recolor": lvalid.lv_color,
    "image_recolor_opa": lvalid.opacity,
@ -161,7 +171,7 @@ STYLE_REMAP = {
 # Complete object style schema
 STYLE_SCHEMA = cv.Schema({cv.Optional(k): v for k, v in STYLE_PROPS.items()}).extend(
    {
-        cv.Optional(df.CONF_STYLES): cv.ensure_list(cv.use_id(ty.lv_style_t)),
+        cv.Optional(df.CONF_STYLES): cv.ensure_list(cv.use_id(lv_style_t)),
        cv.Optional(df.CONF_SCROLLBAR_MODE): df.LvConstant(
            "LV_SCROLLBAR_MODE_", "OFF", "ON", "ACTIVE", "AUTO"
        ).one_of,
@ -193,12 +203,12 @@ def part_schema(widget_type: WidgetType):
    )


-def automation_schema(typ: ty.LvType):
+def automation_schema(typ: LvType):
    if typ.has_on_value:
        events = df.LV_EVENT_TRIGGERS + (CONF_ON_VALUE,)
    else:
        events = df.LV_EVENT_TRIGGERS
-    if isinstance(typ, ty.LvType):
+    if isinstance(typ, LvType):
        template = Trigger.template(typ.get_arg_type())
    else:
        template = Trigger.template()
@ -261,7 +271,7 @@ LAYOUT_SCHEMAS = {}
 ALIGN_TO_SCHEMA = {
    cv.Optional(df.CONF_ALIGN_TO): cv.Schema(
        {
-            cv.Required(CONF_ID): cv.use_id(ty.lv_obj_t),
+            cv.Required(CONF_ID): cv.use_id(lv_obj_t),
            cv.Required(df.CONF_ALIGN): df.ALIGN_ALIGNMENTS.one_of,
            cv.Optional(df.CONF_X, default=0): lvalid.pixels_or_percent,
            cv.Optional(df.CONF_Y, default=0): lvalid.pixels_or_percent,
--- a/esphome/components/lvgl/select/init.py
+++ b/esphome/components/lvgl/select/init.py
@ -4,7 +4,15 @@ import esphome.config_validation as cv
 from esphome.const import CONF_OPTIONS

 from ..defines import CONF_ANIMATED, CONF_LVGL_ID, CONF_WIDGET
-from ..lvcode import CUSTOM_EVENT, EVENT_ARG, LambdaContext, LvContext, lv, lv_add
+from ..lvcode import (
+    API_EVENT,
+    EVENT_ARG,
+    UPDATE_EVENT,
+    LambdaContext,
+    LvContext,
+    lv,
+    lv_add,
+)
 from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LvSelect, lvgl_ns
 from ..widgets import get_widgets
@ -33,7 +41,7 @@ async def to_code(config):
        pub_ctx.add(selector.publish_index(widget.get_value()))
    async with LambdaContext([(cg.uint16, "v")]) as control:
        await widget.set_property("selected", "v", animated=config[CONF_ANIMATED])
-        lv.event_send(widget.obj, CUSTOM_EVENT, cg.nullptr)
+        lv.event_send(widget.obj, API_EVENT, cg.nullptr)
    async with LvContext(paren) as ctx:
        lv_add(selector.set_control_lambda(await control.get_lambda()))
        ctx.add(
@ -41,6 +49,7 @@ async def to_code(config):
                widget.obj,
                await pub_ctx.get_lambda(),
                LV_EVENT.VALUE_CHANGED,
+                UPDATE_EVENT,
            )
        )
        lv_add(selector.publish_index(widget.get_value()))
--- a/esphome/components/lvgl/select/lvgl_select.h
+++ b/esphome/components/lvgl/select/lvgl_select.h
@ -1,5 +1,7 @@
 #pragma once

+#include <utility>
+
 #include "esphome/components/select/select.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
@ -28,7 +30,7 @@ static std::vector<std::string> split_string(const std::string &str) {
 class LVGLSelect : public select::Select {
 public:
  void set_control_lambda(std::function<void(size_t)> lambda) {
-    this->control_lambda_ = lambda;
+    this->control_lambda_ = std::move(lambda);
    if (this->initial_state_.has_value()) {
      this->control(this->initial_state_.value());
      this->initial_state_.reset();
--- a/esphome/components/lvgl/sensor/init.py
+++ b/esphome/components/lvgl/sensor/init.py
@ -3,7 +3,15 @@ from esphome.components.sensor import Sensor, new_sensor, sensor_schema
 import esphome.config_validation as cv

 from ..defines import CONF_LVGL_ID, CONF_WIDGET
-from ..lvcode import EVENT_ARG, LVGL_COMP_ARG, LambdaContext, LvContext, lv_add
+from ..lvcode import (
+    API_EVENT,
+    EVENT_ARG,
+    LVGL_COMP_ARG,
+    UPDATE_EVENT,
+    LambdaContext,
+    LvContext,
+    lv_add,
+)
 from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LvNumber
 from ..widgets import Widget, get_widgets
@ -30,6 +38,10 @@ async def to_code(config):
    async with LvContext(paren, LVGL_COMP_ARG):
        lv_add(
            paren.add_event_cb(
-                widget.obj, await lamb.get_lambda(), LV_EVENT.VALUE_CHANGED
+                widget.obj,
+                await lamb.get_lambda(),
+                LV_EVENT.VALUE_CHANGED,
+                API_EVENT,
+                UPDATE_EVENT,
            )
        )
--- a/esphome/components/lvgl/switch/init.py
+++ b/esphome/components/lvgl/switch/init.py
@ -5,8 +5,9 @@ from esphome.cpp_generator import MockObj

 from ..defines import CONF_LVGL_ID, CONF_WIDGET
 from ..lvcode import (
-    CUSTOM_EVENT,
+    API_EVENT,
    EVENT_ARG,
+    UPDATE_EVENT,
    LambdaContext,
    LvConditional,
    LvContext,
@ -41,7 +42,7 @@ async def to_code(config):
            widget.add_state(LV_STATE.CHECKED)
            cond.else_()
            widget.clear_state(LV_STATE.CHECKED)
-        lv.event_send(widget.obj, CUSTOM_EVENT, cg.nullptr)
+        lv.event_send(widget.obj, API_EVENT, cg.nullptr)
    async with LvContext(paren) as ctx:
        lv_add(switch.set_control_lambda(await control.get_lambda()))
        ctx.add(
@ -49,6 +50,7 @@ async def to_code(config):
                widget.obj,
                await checked_ctx.get_lambda(),
                LV_EVENT.VALUE_CHANGED,
+                UPDATE_EVENT,
            )
        )
        lv_add(switch.publish_state(widget.get_value()))
--- a/esphome/components/lvgl/switch/lvgl_switch.h
+++ b/esphome/components/lvgl/switch/lvgl_switch.h
@ -1,5 +1,7 @@
 #pragma once

+#include <utility>
+
 #include "esphome/components/switch/switch.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
@ -11,7 +13,7 @@ namespace lvgl {
 class LVGLSwitch : public switch_::Switch {
 public:
  void set_control_lambda(std::function<void(bool)> state_lambda) {
-    this->state_lambda_ = state_lambda;
+    this->state_lambda_ = std::move(state_lambda);
    if (this->initial_state_.has_value()) {
      this->state_lambda_(this->initial_state_.value());
      this->initial_state_.reset();
@ -20,10 +22,11 @@ class LVGLSwitch : public switch_::Switch {

 protected:
  void write_state(bool value) override {
-    if (this->state_lambda_ != nullptr)
+    if (this->state_lambda_ != nullptr) {
      this->state_lambda_(value);
-    else
+    } else {
      this->initial_state_ = value;
+    }
  }
  std::function<void(bool)> state_lambda_{};
  optional<bool> initial_state_{};
--- a/esphome/components/lvgl/text/init.py
+++ b/esphome/components/lvgl/text/init.py
@ -4,7 +4,15 @@ from esphome.components.text import new_text
 import esphome.config_validation as cv

 from ..defines import CONF_LVGL_ID, CONF_WIDGET
-from ..lvcode import CUSTOM_EVENT, EVENT_ARG, LambdaContext, LvContext, lv, lv_add
+from ..lvcode import (
+    API_EVENT,
+    EVENT_ARG,
+    UPDATE_EVENT,
+    LambdaContext,
+    LvContext,
+    lv,
+    lv_add,
+)
 from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LvText, lvgl_ns
 from ..widgets import get_widgets
@ -26,14 +34,17 @@ async def to_code(config):
    widget = widget[0]
    async with LambdaContext([(cg.std_string, "text_value")]) as control:
        await widget.set_property("text", "text_value.c_str())")
-        lv.event_send(widget.obj, CUSTOM_EVENT, None)
+        lv.event_send(widget.obj, API_EVENT, None)
    async with LambdaContext(EVENT_ARG) as lamb:
        lv_add(textvar.publish_state(widget.get_value()))
    async with LvContext(paren):
        widget.var.set_control_lambda(await control.get_lambda())
        lv_add(
            paren.add_event_cb(
-                widget.obj, await lamb.get_lambda(), LV_EVENT.VALUE_CHANGED
+                widget.obj,
+                await lamb.get_lambda(),
+                LV_EVENT.VALUE_CHANGED,
+                UPDATE_EVENT,
            )
        )
        lv_add(textvar.publish_state(widget.get_value()))
--- a/esphome/components/lvgl/text/lvgl_text.h
+++ b/esphome/components/lvgl/text/lvgl_text.h
@ -1,5 +1,7 @@
 #pragma once

+#include <utility>
+
 #include "esphome/components/text/text.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
@ -11,7 +13,7 @@ namespace lvgl {
 class LVGLText : public text::Text {
 public:
  void set_control_lambda(std::function<void(const std::string)> control_lambda) {
-    this->control_lambda_ = control_lambda;
+    this->control_lambda_ = std::move(control_lambda);
    if (this->initial_state_.has_value()) {
      this->control_lambda_(this->initial_state_.value());
      this->initial_state_.reset();
@ -20,10 +22,11 @@ class LVGLText : public text::Text {

 protected:
  void control(const std::string &value) override {
-    if (this->control_lambda_ != nullptr)
+    if (this->control_lambda_ != nullptr) {
      this->control_lambda_(value);
-    else
+    } else {
      this->initial_state_ = value;
+    }
  }
  std::function<void(const std::string)> control_lambda_{};
  optional<std::string> initial_state_{};
--- a/esphome/components/lvgl/text_sensor/init.py
+++ b/esphome/components/lvgl/text_sensor/init.py
@ -7,7 +7,7 @@ from esphome.components.text_sensor import (
 import esphome.config_validation as cv

 from ..defines import CONF_LVGL_ID, CONF_WIDGET
-from ..lvcode import EVENT_ARG, LambdaContext, LvContext
+from ..lvcode import API_EVENT, EVENT_ARG, UPDATE_EVENT, LambdaContext, LvContext
 from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LvText
 from ..widgets import get_widgets
@ -36,5 +36,7 @@ async def to_code(config):
                widget.obj,
                await pressed_ctx.get_lambda(),
                LV_EVENT.VALUE_CHANGED,
+                API_EVENT,
+                UPDATE_EVENT,
            )
        )
--- a/esphome/components/lvgl/trigger.py
+++ b/esphome/components/lvgl/trigger.py
@ -11,7 +11,15 @@ from .defines import (
    LV_EVENT_TRIGGERS,
    literal,
 )
-from .lvcode import EVENT_ARG, LambdaContext, LvConditional, lv, lv_add
+from .lvcode import (
+    API_EVENT,
+    EVENT_ARG,
+    UPDATE_EVENT,
+    LambdaContext,
+    LvConditional,
+    lv,
+    lv_add,
+)
 from .types import LV_EVENT
 from .widgets import widget_map

@ -34,9 +42,16 @@ async def generate_triggers(lv_component):
                conf = conf[0]
                w.add_flag("LV_OBJ_FLAG_CLICKABLE")
                event = literal("LV_EVENT_" + LV_EVENT_MAP[event[3:].upper()])
-                await add_trigger(conf, event, lv_component, w)
+                await add_trigger(conf, lv_component, w, event)
            for conf in w.config.get(CONF_ON_VALUE, ()):
-                await add_trigger(conf, LV_EVENT.VALUE_CHANGED, lv_component, w)
+                await add_trigger(
+                    conf,
+                    lv_component,
+                    w,
+                    LV_EVENT.VALUE_CHANGED,
+                    API_EVENT,
+                    UPDATE_EVENT,
+                )

            # Generate align to directives while we're here
            if align_to := w.config.get(CONF_ALIGN_TO):
@ -47,7 +62,7 @@ async def generate_triggers(lv_component):
                lv.obj_align_to(w.obj, target, align, x, y)


-async def add_trigger(conf, event, lv_component, w):
+async def add_trigger(conf, lv_component, w, *events):
    tid = conf[CONF_TRIGGER_ID]
    trigger = cg.new_Pvariable(tid)
    args = w.get_args()
@ -56,4 +71,4 @@ async def add_trigger(conf, event, lv_component, w):
    async with LambdaContext(EVENT_ARG, where=tid) as context:
        with LvConditional(w.is_selected()):
            lv_add(trigger.trigger(value))
-    lv_add(lv_component.add_event_cb(w.obj, await context.get_lambda(), event))
+    lv_add(lv_component.add_event_cb(w.obj, await context.get_lambda(), *events))
--- a/esphome/components/micro_wake_word/init.py
+++ b/esphome/components/micro_wake_word/init.py
@ -1,39 +1,34 @@
-import logging
-
-import json
 import hashlib
-from urllib.parse import urljoin
+import json
+import logging
 from pathlib import Path
+from urllib.parse import urljoin
+
 import requests

-import esphome.config_validation as cv
-import esphome.codegen as cg
-
-from esphome.core import CORE, HexInt
-
-from esphome.components import esp32, microphone
-from esphome import automation, git, external_files
+from esphome import automation, external_files, git
 from esphome.automation import register_action, register_condition
-
-
+import esphome.codegen as cg
+from esphome.components import esp32, microphone
+import esphome.config_validation as cv
 from esphome.const import (
-    __version__,
+    CONF_FILE,
    CONF_ID,
    CONF_MICROPHONE,
    CONF_MODEL,
-    CONF_URL,
-    CONF_FILE,
+    CONF_PASSWORD,
    CONF_PATH,
+    CONF_RAW_DATA_ID,
    CONF_REF,
    CONF_REFRESH,
    CONF_TYPE,
+    CONF_URL,
    CONF_USERNAME,
-    CONF_PASSWORD,
-    CONF_RAW_DATA_ID,
    TYPE_GIT,
    TYPE_LOCAL,
+    __version__,
 )
-
+from esphome.core import CORE, HexInt

 _LOGGER = logging.getLogger(__name__)

@ -174,12 +169,12 @@ def _convert_manifest_v1_to_v2(v1_manifest):
        CONF_SLIDING_WINDOW_AVERAGE_SIZE
    ]
    del v2_manifest[KEY_MICRO][CONF_SLIDING_WINDOW_AVERAGE_SIZE]
-    v2_manifest[KEY_MICRO][
-        CONF_TENSOR_ARENA_SIZE
-    ] = 45672  # Original Inception-based V1 manifest models require a minimum of 45672 bytes
-    v2_manifest[KEY_MICRO][
-        CONF_FEATURE_STEP_SIZE
-    ] = 20  # Original Inception-based V1 manifest models use a 20 ms feature step size
+
+    # Original Inception-based V1 manifest models require a minimum of 45672 bytes
+    v2_manifest[KEY_MICRO][CONF_TENSOR_ARENA_SIZE] = 45672
+
+    # Original Inception-based V1 manifest models use a 20 ms feature step size
+    v2_manifest[KEY_MICRO][CONF_FEATURE_STEP_SIZE] = 20

    return v2_manifest

@ -502,7 +497,7 @@ async def to_code(config):
            )

    cg.add(var.set_features_step_size(manifest[KEY_MICRO][CONF_FEATURE_STEP_SIZE]))
-    cg.add_library("kahrendt/ESPMicroSpeechFeatures", "1.0.0")
+    cg.add_library("kahrendt/ESPMicroSpeechFeatures", "1.1.0")


 MICRO_WAKE_WORD_ACTION_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(MicroWakeWord)})
--- a/esphome/components/mqtt/mqtt_backend.h
+++ b/esphome/components/mqtt/mqtt_backend.h
@ -1,5 +1,6 @@
 #pragma once
-
+#include "esphome/core/defines.h"
+#ifdef USE_MQTT
 #include <string>
 #include <map>
 #include "esphome/components/network/ip_address.h"
@ -67,3 +68,4 @@ class MQTTBackend {

 }  // namespace mqtt
 }  // namespace esphome
+#endif
--- a/esphome/components/mqtt/mqtt_backend_esp32.cpp
+++ b/esphome/components/mqtt/mqtt_backend_esp32.cpp
@ -1,7 +1,9 @@
+#include "mqtt_backend_esp32.h"
+
+#ifdef USE_MQTT
 #ifdef USE_ESP32

 #include <string>
-#include "mqtt_backend_esp32.h"
 #include "esphome/core/log.h"
 #include "esphome/core/helpers.h"

@ -189,3 +191,4 @@ void MQTTBackendESP32::mqtt_event_handler(void *handler_args, esp_event_base_t b
 }  // namespace mqtt
 }  // namespace esphome
 #endif  // USE_ESP32
+#endif
--- a/esphome/components/mqtt/mqtt_backend_esp32.h
+++ b/esphome/components/mqtt/mqtt_backend_esp32.h
@ -1,5 +1,7 @@
 #pragma once

+#include "mqtt_backend.h"
+#ifdef USE_MQTT
 #ifdef USE_ESP32

 #include <string>
@ -7,7 +9,6 @@
 #include <mqtt_client.h>
 #include "esphome/components/network/ip_address.h"
 #include "esphome/core/helpers.h"
-#include "mqtt_backend.h"

 namespace esphome {
 namespace mqtt {
@ -174,3 +175,4 @@ class MQTTBackendESP32 final : public MQTTBackend {
 }  // namespace esphome

 #endif
+#endif
--- a/esphome/components/mqtt/mqtt_backend_esp8266.h
+++ b/esphome/components/mqtt/mqtt_backend_esp8266.h
@ -1,8 +1,9 @@
 #pragma once
+#include "mqtt_backend.h"

+#ifdef USE_MQTT
 #ifdef USE_ESP8266

-#include "mqtt_backend.h"
 #include <AsyncMqttClient.h>

 namespace esphome {
@ -70,3 +71,4 @@ class MQTTBackendESP8266 final : public MQTTBackend {
 }  // namespace esphome

 #endif  // defined(USE_ESP8266)
+#endif
--- a/esphome/components/mqtt/mqtt_backend_libretiny.h
+++ b/esphome/components/mqtt/mqtt_backend_libretiny.h
@ -1,8 +1,9 @@
 #pragma once
+#include "mqtt_backend.h"

+#ifdef USE_MQTT
 #ifdef USE_LIBRETINY

-#include "mqtt_backend.h"
 #include <AsyncMqttClient.h>

 namespace esphome {
@ -70,3 +71,4 @@ class MQTTBackendLibreTiny final : public MQTTBackend {
 }  // namespace esphome

 #endif  // defined(USE_LIBRETINY)
+#endif
--- a/esphome/components/mqtt/mqtt_client.cpp
+++ b/esphome/components/mqtt/mqtt_client.cpp
@ -632,6 +632,7 @@ void MQTTClientComponent::disable_discovery() {
  this->discovery_info_ = MQTTDiscoveryInfo{
      .prefix = "",
      .retain = false,
+      .discover_ip = false,
      .clean = false,
      .unique_id_generator = MQTT_LEGACY_UNIQUE_ID_GENERATOR,
      .object_id_generator = MQTT_NONE_OBJECT_ID_GENERATOR,
--- a/esphome/components/network/init.py
+++ b/esphome/components/network/init.py
@ -1,8 +1,6 @@
-from esphome.core import CORE
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components.esp32 import add_idf_sdkconfig_option
-
+import esphome.config_validation as cv
 from esphome.const import (
    CONF_ENABLE_IPV6,
    CONF_MIN_IPV6_ADDR_COUNT,
@ -10,6 +8,7 @@ from esphome.const import (
    PLATFORM_ESP8266,
    PLATFORM_RP2040,
 )
+from esphome.core import CORE

 CODEOWNERS = ["@esphome/core"]
 AUTO_LOAD = ["mdns"]
@ -25,7 +24,11 @@ CONFIG_SCHEMA = cv.Schema(
            esp32=False,
            rp2040=False,
        ): cv.All(
-            cv.boolean, cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_RP2040])
+            cv.boolean,
+            cv.Any(
+                cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_RP2040]),
+                cv.boolean_false,
+            ),
        ),
        cv.Optional(CONF_MIN_IPV6_ADDR_COUNT, default=0): cv.positive_int,
    }
@ -33,6 +36,7 @@ CONFIG_SCHEMA = cv.Schema(


 async def to_code(config):
+    cg.add_define("USE_NETWORK")
    if (enable_ipv6 := config.get(CONF_ENABLE_IPV6, None)) is not None:
        cg.add_define("USE_NETWORK_IPV6", enable_ipv6)
        if enable_ipv6:
@ -42,11 +46,10 @@ async def to_code(config):
        if CORE.using_esp_idf:
            add_idf_sdkconfig_option("CONFIG_LWIP_IPV6", enable_ipv6)
            add_idf_sdkconfig_option("CONFIG_LWIP_IPV6_AUTOCONFIG", enable_ipv6)
-        else:
-            if enable_ipv6:
-                cg.add_build_flag("-DCONFIG_LWIP_IPV6")
-                cg.add_build_flag("-DCONFIG_LWIP_IPV6_AUTOCONFIG")
-                if CORE.is_rp2040:
-                    cg.add_build_flag("-DPIO_FRAMEWORK_ARDUINO_ENABLE_IPV6")
-                if CORE.is_esp8266:
-                    cg.add_build_flag("-DPIO_FRAMEWORK_ARDUINO_LWIP2_IPV6_LOW_MEMORY")
+        elif enable_ipv6:
+            cg.add_build_flag("-DCONFIG_LWIP_IPV6")
+            cg.add_build_flag("-DCONFIG_LWIP_IPV6_AUTOCONFIG")
+            if CORE.is_rp2040:
+                cg.add_build_flag("-DPIO_FRAMEWORK_ARDUINO_ENABLE_IPV6")
+            if CORE.is_esp8266:
+                cg.add_build_flag("-DPIO_FRAMEWORK_ARDUINO_LWIP2_IPV6_LOW_MEMORY")
--- a/esphome/components/network/ip_address.h
+++ b/esphome/components/network/ip_address.h
@ -1,4 +1,6 @@
 #pragma once
+#include "esphome/core/defines.h"
+#ifdef USE_NETWORK
 #include <cstdint>
 #include <string>
 #include <cstdio>
@ -140,3 +142,4 @@ using IPAddresses = std::array<IPAddress, 5>;

 }  // namespace network
 }  // namespace esphome
+#endif
--- a/esphome/components/network/util.cpp
+++ b/esphome/components/network/util.cpp
@ -1,6 +1,6 @@
 #include "util.h"
 #include "esphome/core/defines.h"
-
+#ifdef USE_NETWORK
 #ifdef USE_WIFI
 #include "esphome/components/wifi/wifi_component.h"
 #endif
@ -63,3 +63,4 @@ std::string get_use_address() {

 }  // namespace network
 }  // namespace esphome
+#endif
--- a/esphome/components/network/util.h
+++ b/esphome/components/network/util.h
@ -1,5 +1,6 @@
 #pragma once
-
+#include "esphome/core/defines.h"
+#ifdef USE_NETWORK
 #include <string>
 #include "ip_address.h"

@ -16,3 +17,4 @@ IPAddresses get_ip_addresses();

 }  // namespace network
 }  // namespace esphome
+#endif
--- a/esphome/components/online_image/init.py
+++ b/esphome/components/online_image/init.py
@ -27,6 +27,7 @@ CODEOWNERS = ["@guillempages"]
 MULTI_CONF = True

 CONF_ON_DOWNLOAD_FINISHED = "on_download_finished"
+CONF_PLACEHOLDER = "placeholder"

 _LOGGER = logging.getLogger(__name__)

@ -73,6 +74,7 @@ ONLINE_IMAGE_SCHEMA = cv.Schema(
        #
        cv.Required(CONF_URL): cv.url,
        cv.Required(CONF_FORMAT): cv.enum(IMAGE_FORMAT, upper=True),
+        cv.Optional(CONF_PLACEHOLDER): cv.use_id(Image_),
        cv.Optional(CONF_BUFFER_SIZE, default=2048): cv.int_range(256, 65536),
        cv.Optional(CONF_ON_DOWNLOAD_FINISHED): automation.validate_automation(
            {
@ -152,6 +154,10 @@ async def to_code(config):

    cg.add(var.set_transparency(transparent))

+    if placeholder_id := config.get(CONF_PLACEHOLDER):
+        placeholder = await cg.get_variable(placeholder_id)
+        cg.add(var.set_placeholder(placeholder))
+
    for conf in config.get(CONF_ON_DOWNLOAD_FINISHED, []):
        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
        await automation.build_automation(trigger, [], conf)
--- a/esphome/components/online_image/online_image.cpp
+++ b/esphome/components/online_image/online_image.cpp
@ -35,6 +35,14 @@ OnlineImage::OnlineImage(const std::string &url, int width, int height, ImageFor
  this->set_url(url);
 }

+void OnlineImage::draw(int x, int y, display::Display *display, Color color_on, Color color_off) {
+  if (this->data_start_) {
+    Image::draw(x, y, display, color_on, color_off);
+  } else if (this->placeholder_) {
+    this->placeholder_->draw(x, y, display, color_on, color_off);
+  }
+}
+
 void OnlineImage::release() {
  if (this->buffer_) {
    ESP_LOGD(TAG, "Deallocating old buffer...");
--- a/esphome/components/online_image/online_image.h
+++ b/esphome/components/online_image/online_image.h
@ -50,6 +50,8 @@ class OnlineImage : public PollingComponent,
  OnlineImage(const std::string &url, int width, int height, ImageFormat format, image::ImageType type,
              uint32_t buffer_size);

+  void draw(int x, int y, display::Display *display, Color color_on, Color color_off) override;
+
  void update() override;
  void loop() override;

@ -60,6 +62,14 @@ class OnlineImage : public PollingComponent,
    }
  }

+  /**
+   * @brief Set the image that needs to be shown as long as the downloaded image
+   *  is not available.
+   *
+   * @param placeholder Pointer to the (@link Image) to show as placeholder.
+   */
+  void set_placeholder(image::Image *placeholder) { this->placeholder_ = placeholder; }
+
  /**
   * Release the buffer storing the image. The image will need to be downloaded again
   * to be able to be displayed.
@ -113,6 +123,7 @@ class OnlineImage : public PollingComponent,
  DownloadBuffer download_buffer_;

  const ImageFormat format_;
+  image::Image *placeholder_{nullptr};

  std::string url_{""};

--- a/esphome/components/prometheus/prometheus_handler.cpp
+++ b/esphome/components/prometheus/prometheus_handler.cpp
@ -1,4 +1,5 @@
 #include "prometheus_handler.h"
+#ifdef USE_NETWORK
 #include "esphome/core/application.h"

 namespace esphome {
@ -350,3 +351,4 @@ void PrometheusHandler::lock_row_(AsyncResponseStream *stream, lock::Lock *obj)

 }  // namespace prometheus
 }  // namespace esphome
+#endif
--- a/esphome/components/prometheus/prometheus_handler.h
+++ b/esphome/components/prometheus/prometheus_handler.h
@ -1,5 +1,6 @@
 #pragma once
-
+#include "esphome/core/defines.h"
+#ifdef USE_NETWORK
 #include <map>
 #include <utility>

@ -117,3 +118,4 @@ class PrometheusHandler : public AsyncWebHandler, public Component {

 }  // namespace prometheus
 }  // namespace esphome
+#endif
--- a/esphome/components/remote_base/pronto_protocol.cpp
+++ b/esphome/components/remote_base/pronto_protocol.cpp
@ -201,9 +201,6 @@ std::string ProntoProtocol::compensate_and_dump_sequence_(const RawTimings &data
    out += dump_duration_(t_duration, timebase);
  }

-  // append minimum gap
-  out += dump_duration_(PRONTO_DEFAULT_GAP, timebase, true);
-
  return out;
 }

--- a/esphome/components/rgbct/rgbct_light_output.h
+++ b/esphome/components/rgbct/rgbct_light_output.h
@ -23,10 +23,11 @@ class RGBCTLightOutput : public light::LightOutput {

  light::LightTraits get_traits() override {
    auto traits = light::LightTraits();
-    if (this->color_interlock_)
+    if (this->color_interlock_) {
      traits.set_supported_color_modes({light::ColorMode::RGB, light::ColorMode::COLOR_TEMPERATURE});
-    else
+    } else {
      traits.set_supported_color_modes({light::ColorMode::RGB_COLOR_TEMPERATURE, light::ColorMode::COLOR_TEMPERATURE});
+    }
    traits.set_min_mireds(this->cold_white_temperature_);
    traits.set_max_mireds(this->warm_white_temperature_);
    return traits;
--- a/esphome/components/rgbw/rgbw_light_output.h
+++ b/esphome/components/rgbw/rgbw_light_output.h
@ -16,10 +16,11 @@ class RGBWLightOutput : public light::LightOutput {
  void set_color_interlock(bool color_interlock) { color_interlock_ = color_interlock; }
  light::LightTraits get_traits() override {
    auto traits = light::LightTraits();
-    if (this->color_interlock_)
+    if (this->color_interlock_) {
      traits.set_supported_color_modes({light::ColorMode::RGB, light::ColorMode::WHITE});
-    else
+    } else {
      traits.set_supported_color_modes({light::ColorMode::RGB_WHITE});
+    }
    return traits;
  }
  void write_state(light::LightState *state) override {
--- a/esphome/components/rgbww/rgbww_light_output.h
+++ b/esphome/components/rgbww/rgbww_light_output.h
@ -20,10 +20,11 @@ class RGBWWLightOutput : public light::LightOutput {
  void set_color_interlock(bool color_interlock) { color_interlock_ = color_interlock; }
  light::LightTraits get_traits() override {
    auto traits = light::LightTraits();
-    if (this->color_interlock_)
+    if (this->color_interlock_) {
      traits.set_supported_color_modes({light::ColorMode::RGB, light::ColorMode::COLD_WARM_WHITE});
-    else
+    } else {
      traits.set_supported_color_modes({light::ColorMode::RGB_COLD_WARM_WHITE});
+    }
    traits.set_min_mireds(this->cold_white_temperature_);
    traits.set_max_mireds(this->warm_white_temperature_);
    return traits;
--- a/esphome/components/rtttl/rtttl.cpp
+++ b/esphome/components/rtttl/rtttl.cpp
@ -29,6 +29,13 @@ inline double deg2rad(double degrees) {
 void Rtttl::dump_config() { ESP_LOGCONFIG(TAG, "Rtttl"); }

 void Rtttl::play(std::string rtttl) {
+  if (this->state_ != State::STATE_STOPPED && this->state_ != State::STATE_STOPPING) {
+    int pos = this->rtttl_.find(':');
+    auto name = this->rtttl_.substr(0, pos);
+    ESP_LOGW(TAG, "RTTL Component is already playing: %s", name.c_str());
+    return;
+  }
+
  this->rtttl_ = std::move(rtttl);

  this->default_duration_ = 4;
@ -98,13 +105,20 @@ void Rtttl::play(std::string rtttl) {
  this->note_duration_ = 1;

 #ifdef USE_SPEAKER
-  this->samples_sent_ = 0;
-  this->samples_count_ = 0;
+  if (this->speaker_ != nullptr) {
+    this->set_state_(State::STATE_INIT);
+    this->samples_sent_ = 0;
+    this->samples_count_ = 0;
+  }
+#endif
+#ifdef USE_OUTPUT
+  if (this->output_ != nullptr) {
+    this->set_state_(State::STATE_RUNNING);
+  }
 #endif
 }

 void Rtttl::stop() {
-  this->note_duration_ = 0;
 #ifdef USE_OUTPUT
  if (this->output_ != nullptr) {
    this->output_->set_level(0.0);
@ -117,16 +131,35 @@ void Rtttl::stop() {
    }
  }
 #endif
+  this->note_duration_ = 0;
+  this->set_state_(STATE_STOPPING);
 }

 void Rtttl::loop() {
-  if (this->note_duration_ == 0)
+  if (this->note_duration_ == 0 || this->state_ == State::STATE_STOPPED)
    return;

 #ifdef USE_SPEAKER
  if (this->speaker_ != nullptr) {
+    if (this->state_ == State::STATE_STOPPING) {
+      if (this->speaker_->is_stopped()) {
+        this->set_state_(State::STATE_STOPPED);
+      }
+    } else if (this->state_ == State::STATE_INIT) {
+      if (this->speaker_->is_stopped()) {
+        this->speaker_->start();
+        this->set_state_(State::STATE_STARTING);
+      }
+    } else if (this->state_ == State::STATE_STARTING) {
+      if (this->speaker_->is_running()) {
+        this->set_state_(State::STATE_RUNNING);
+      }
+    }
+    if (!this->speaker_->is_running()) {
+      return;
+    }
    if (this->samples_sent_ != this->samples_count_) {
-      SpeakerSample sample[SAMPLE_BUFFER_SIZE + 1];
+      SpeakerSample sample[SAMPLE_BUFFER_SIZE + 2];
      int x = 0;
      double rem = 0.0;

@ -136,7 +169,7 @@ void Rtttl::loop() {
        if (this->samples_per_wave_ != 0 && this->samples_sent_ >= this->samples_gap_) {  // Play note//
          rem = ((this->samples_sent_ << 10) % this->samples_per_wave_) * (360.0 / this->samples_per_wave_);

-          int16_t val = (49152 * this->gain_) * sin(deg2rad(rem));
+          int16_t val = (127 * this->gain_) * sin(deg2rad(rem));  // 16bit = 49152

          sample[x].left = val;
          sample[x].right = val;
@ -153,9 +186,9 @@ void Rtttl::loop() {
        x++;
      }
      if (x > 0) {
-        int send = this->speaker_->play((uint8_t *) (&sample), x * 4);
+        int send = this->speaker_->play((uint8_t *) (&sample), x * 2);
        if (send != x * 4) {
-          this->samples_sent_ -= (x - (send / 4));
+          this->samples_sent_ -= (x - (send / 2));
        }
        return;
      }
@ -167,14 +200,7 @@ void Rtttl::loop() {
    return;
 #endif
  if (!this->rtttl_[position_]) {
-    this->note_duration_ = 0;
-#ifdef USE_OUTPUT
-    if (this->output_ != nullptr) {
-      this->output_->set_level(0.0);
-    }
-#endif
-    ESP_LOGD(TAG, "Playback finished");
-    this->on_finished_playback_callback_.call();
+    this->finish_();
    return;
  }

@ -213,6 +239,7 @@ void Rtttl::loop() {
    case 'a':
      note = 10;
      break;
+    case 'h':
    case 'b':
      note = 12;
      break;
@ -238,14 +265,21 @@ void Rtttl::loop() {
  uint8_t scale = get_integer_();
  if (scale == 0)
    scale = this->default_octave_;
+
+  if (scale < 4 || scale > 7) {
+    ESP_LOGE(TAG, "Octave out of valid range. Should be between 4 and 7. (Octave: %d)", scale);
+    this->finish_();
+    return;
+  }
  bool need_note_gap = false;

  // Now play the note
  if (note) {
    auto note_index = (scale - 4) * 12 + note;
    if (note_index < 0 || note_index >= (int) sizeof(NOTES)) {
-      ESP_LOGE(TAG, "Note out of valid range");
-      this->note_duration_ = 0;
+      ESP_LOGE(TAG, "Note out of valid range (note: %d, scale: %d, index: %d, max: %d)", note, scale, note_index,
+               (int) sizeof(NOTES));
+      this->finish_();
      return;
    }
    auto freq = NOTES[note_index];
@ -285,14 +319,17 @@ void Rtttl::loop() {
      this->samples_gap_ = (this->sample_rate_ * DOUBLE_NOTE_GAP_MS) / 1600;  //(ms);
    }
    if (this->output_freq_ != 0) {
+      // make sure there is enough samples to add a full last sinus.
+
+      uint16_t samples_wish = this->samples_count_;
      this->samples_per_wave_ = (this->sample_rate_ << 10) / this->output_freq_;

-      // make sure there is enough samples to add a full last sinus.
      uint16_t division = ((this->samples_count_ << 10) / this->samples_per_wave_) + 1;
-      uint16_t x = this->samples_count_;
+
      this->samples_count_ = (division * this->samples_per_wave_);
-      ESP_LOGD(TAG, "play time old: %d div: %d new: %d %d", x, division, this->samples_count_, this->samples_per_wave_);
      this->samples_count_ = this->samples_count_ >> 10;
+      ESP_LOGVV(TAG, "- Calc play time: wish: %d gets: %d (div: %d spw: %d)", samples_wish, this->samples_count_,
+                division, this->samples_per_wave_);
    }
    // Convert from frequency in Hz to high and low samples in fixed point
  }
@ -301,5 +338,53 @@ void Rtttl::loop() {
  this->last_note_ = millis();
 }

+void Rtttl::finish_() {
+#ifdef USE_OUTPUT
+  if (this->output_ != nullptr) {
+    this->output_->set_level(0.0);
+  }
+#endif
+#ifdef USE_SPEAKER
+  if (this->speaker_ != nullptr) {
+    SpeakerSample sample[2];
+    sample[0].left = 0;
+    sample[0].right = 0;
+    sample[1].left = 0;
+    sample[1].right = 0;
+    this->speaker_->play((uint8_t *) (&sample), 8);
+
+    this->speaker_->finish();
+  }
+#endif
+  this->set_state_(State::STATE_STOPPING);
+  this->note_duration_ = 0;
+  this->on_finished_playback_callback_.call();
+  ESP_LOGD(TAG, "Playback finished");
+}
+
+static const LogString *state_to_string(State state) {
+  switch (state) {
+    case STATE_STOPPED:
+      return LOG_STR("STATE_STOPPED");
+    case STATE_STARTING:
+      return LOG_STR("STATE_STARTING");
+    case STATE_RUNNING:
+      return LOG_STR("STATE_RUNNING");
+    case STATE_STOPPING:
+      return LOG_STR("STATE_STOPPING");
+    case STATE_INIT:
+      return LOG_STR("STATE_INIT");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+};
+
+void Rtttl::set_state_(State state) {
+  State old_state = this->state_;
+  this->state_ = state;
+  ESP_LOGD(TAG, "State changed from %s to %s", LOG_STR_ARG(state_to_string(old_state)),
+           LOG_STR_ARG(state_to_string(state)));
+}
+
 }  // namespace rtttl
 }  // namespace esphome
--- a/esphome/components/rtttl/rtttl.h
+++ b/esphome/components/rtttl/rtttl.h
@ -14,12 +14,20 @@
 namespace esphome {
 namespace rtttl {

+enum State : uint8_t {
+  STATE_STOPPED = 0,
+  STATE_INIT,
+  STATE_STARTING,
+  STATE_RUNNING,
+  STATE_STOPPING,
+};
+
 #ifdef USE_SPEAKER
-static const size_t SAMPLE_BUFFER_SIZE = 512;
+static const size_t SAMPLE_BUFFER_SIZE = 2048;

 struct SpeakerSample {
-  int16_t left{0};
-  int16_t right{0};
+  int8_t left{0};
+  int8_t right{0};
 };
 #endif

@ -42,7 +50,7 @@ class Rtttl : public Component {
  void stop();
  void dump_config() override;

-  bool is_playing() { return this->note_duration_ != 0; }
+  bool is_playing() { return this->state_ != State::STATE_STOPPED; }
  void loop() override;

  void add_on_finished_playback_callback(std::function<void()> callback) {
@ -57,6 +65,8 @@ class Rtttl : public Component {
    }
    return ret;
  }
+  void finish_();
+  void set_state_(State state);

  std::string rtttl_{""};
  size_t position_{0};
@ -68,13 +78,12 @@ class Rtttl : public Component {

  uint32_t output_freq_;
  float gain_{0.6f};
+  State state_{State::STATE_STOPPED};

 #ifdef USE_OUTPUT
  output::FloatOutput *output_;
 #endif

-  void play_output_();
-
 #ifdef USE_SPEAKER
  speaker::Speaker *speaker_{nullptr};
  int sample_rate_{16000};
--- a/esphome/components/speaker/init.py
+++ b/esphome/components/speaker/init.py
@ -1,13 +1,11 @@
 from esphome import automation
-import esphome.config_validation as cv
-import esphome.codegen as cg
-
 from esphome.automation import maybe_simple_id
-from esphome.const import CONF_ID, CONF_DATA
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA, CONF_ID
 from esphome.core import CORE
 from esphome.coroutine import coroutine_with_priority

-
 CODEOWNERS = ["@jesserockz"]

 IS_PLATFORM_COMPONENT = True
@ -22,8 +20,12 @@ PlayAction = speaker_ns.class_(
 StopAction = speaker_ns.class_(
    "StopAction", automation.Action, cg.Parented.template(Speaker)
 )
+FinishAction = speaker_ns.class_(
+    "FinishAction", automation.Action, cg.Parented.template(Speaker)
+)

 IsPlayingCondition = speaker_ns.class_("IsPlayingCondition", automation.Condition)
+IsStoppedCondition = speaker_ns.class_("IsStoppedCondition", automation.Condition)


 async def setup_speaker_core_(var, config):
@ -75,11 +77,18 @@ async def speaker_play_action(config, action_id, template_arg, args):
 automation.register_action("speaker.stop", StopAction, SPEAKER_AUTOMATION_SCHEMA)(
    speaker_action
 )
+automation.register_action("speaker.finish", FinishAction, SPEAKER_AUTOMATION_SCHEMA)(
+    speaker_action
+)

 automation.register_condition(
    "speaker.is_playing", IsPlayingCondition, SPEAKER_AUTOMATION_SCHEMA
 )(speaker_action)

+automation.register_condition(
+    "speaker.is_stopped", IsStoppedCondition, SPEAKER_AUTOMATION_SCHEMA
+)(speaker_action)
+

@coroutine_with_priority(100.0)
 async def to_code(config):
--- a/Show more
+++ b/Show more