Add raw bus voltage log

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>

docker/Dockerfile

@@ -38,7 +38,6 @@ RUN \
         openssh-client=1:9.2p1-2+deb12u1 \
         python3-cffi=1.15.1-5 \
         libcairo2=1.16.0-7 \
-        libmagic1=1:5.44-3 \
         patch=2.7.6-7; \
     if [ "$TARGETARCH$TARGETVARIANT" = "armv7" ]; then \
         apt-get install -y --no-install-recommends \
@@ -49,8 +48,6 @@ RUN \
           libfreetype-dev=2.12.1+dfsg-5 \
           libssl-dev=3.0.11-1~deb12u2 \
           libffi-dev=3.4.4-1 \
-          libopenjp2-7=2.5.0-2 \
-          libtiff6=4.5.0-6 \
           cargo=0.66.0+ds1-1 \
           pkg-config=1.8.1-1 \
           gcc-arm-linux-gnueabihf=4:12.2.0-3; \
@@ -71,7 +68,7 @@ ENV \
 # See: https://unix.stackexchange.com/questions/553743/correct-way-to-add-lib-ld-linux-so-3-in-debian
 RUN \
     if [ "$TARGETARCH$TARGETVARIANT" = "armv7" ]; then \
-        ln -s /lib/arm-linux-gnueabihf/ld-linux-armhf.so.3 /lib/ld-linux.so.3; \
+        ln -s /lib/arm-linux-gnueabihf/ld-linux.so.3 /lib/ld-linux.so.3; \
     fi
 
 RUN \

esphome/components/api/client.py

@@ -1,65 +1,71 @@
-from __future__ import annotations
-
 import asyncio
 import logging
 from datetime import datetime
-from typing import Any
+from typing import Optional
 
-from aioesphomeapi import APIClient
-from aioesphomeapi.api_pb2 import SubscribeLogsResponse
-from aioesphomeapi.log_runner import async_run
-from zeroconf.asyncio import AsyncZeroconf
-
-from esphome.const import CONF_KEY, CONF_PASSWORD, CONF_PORT, __version__
-from esphome.core import CORE
+from aioesphomeapi import APIClient, ReconnectLogic, APIConnectionError, LogLevel
+import zeroconf
 
+from esphome.const import CONF_KEY, CONF_PORT, CONF_PASSWORD, __version__
+from esphome.util import safe_print
 from . import CONF_ENCRYPTION
 
 _LOGGER = logging.getLogger(__name__)
 
 
 async def async_run_logs(config, address):
-    """Run the logs command in the event loop."""
     conf = config["api"]
     port: int = int(conf[CONF_PORT])
     password: str = conf[CONF_PASSWORD]
-    noise_psk: str | None = None
+    noise_psk: Optional[str] = None
     if CONF_ENCRYPTION in conf:
         noise_psk = conf[CONF_ENCRYPTION][CONF_KEY]
     _LOGGER.info("Starting log output from %s using esphome API", address)
-    aiozc = AsyncZeroconf()
-
     cli = APIClient(
         address,
         port,
         password,
         client_info=f"ESPHome Logs {__version__}",
         noise_psk=noise_psk,
-        zeroconf_instance=aiozc.zeroconf,
     )
-    dashboard = CORE.dashboard
+    first_connect = True
 
-    def on_log(msg: SubscribeLogsResponse) -> None:
-        """Handle a new log message."""
-        time_ = datetime.now()
-        message: bytes = msg.message
-        text = message.decode("utf8", "backslashreplace")
-        if dashboard:
-            text = text.replace("\033", "\\033")
-        print(f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}]{text}")
+    def on_log(msg):
+        time_ = datetime.now().time().strftime("[%H:%M:%S]")
+        text = msg.message.decode("utf8", "backslashreplace")
+        safe_print(time_ + text)
+
+    async def on_connect():
+        nonlocal first_connect
+        try:
+            await cli.subscribe_logs(
+                on_log,
+                log_level=LogLevel.LOG_LEVEL_VERY_VERBOSE,
+                dump_config=first_connect,
+            )
+            first_connect = False
+        except APIConnectionError:
+            cli.disconnect()
+
+    async def on_disconnect(expected_disconnect: bool) -> None:
+        _LOGGER.warning("Disconnected from API")
+
+    zc = zeroconf.Zeroconf()
+    reconnect = ReconnectLogic(
+        client=cli,
+        on_connect=on_connect,
+        on_disconnect=on_disconnect,
+        zeroconf_instance=zc,
+    )
+    await reconnect.start()
 
-    stop = await async_run(cli, on_log, aio_zeroconf_instance=aiozc)
     try:
         while True:
             await asyncio.sleep(60)
-    finally:
-        await aiozc.async_close()
-        await stop()
-
-
-def run_logs(config: dict[str, Any], address: str) -> None:
-    """Run the logs command."""
-    try:
-        asyncio.run(async_run_logs(config, address))
     except KeyboardInterrupt:
-        pass
+        await reconnect.stop()
+        zc.close()
+
+
+def run_logs(config, address):
+    asyncio.run(async_run_logs(config, address))

esphome/components/esp32/__init__.py

@@ -3,26 +3,23 @@ from typing import Union, Optional
 from pathlib import Path
 import logging
 import os
-import esphome.final_validate as fv
 
 from esphome.helpers import copy_file_if_changed, write_file_if_changed, mkdir_p
 from esphome.const import (
-    CONF_ADVANCED,
     CONF_BOARD,
     CONF_COMPONENTS,
-    CONF_ESPHOME,
     CONF_FRAMEWORK,
-    CONF_IGNORE_EFUSE_MAC_CRC,
     CONF_NAME,
-    CONF_PATH,
-    CONF_PLATFORMIO_OPTIONS,
-    CONF_REF,
-    CONF_REFRESH,
     CONF_SOURCE,
     CONF_TYPE,
-    CONF_URL,
     CONF_VARIANT,
     CONF_VERSION,
+    CONF_ADVANCED,
+    CONF_REFRESH,
+    CONF_PATH,
+    CONF_URL,
+    CONF_REF,
+    CONF_IGNORE_EFUSE_MAC_CRC,
     KEY_CORE,
     KEY_FRAMEWORK_VERSION,
     KEY_NAME,
@@ -330,32 +327,6 @@ def _detect_variant(value):
     return value
 
 
-def final_validate(config):
-    if CONF_PLATFORMIO_OPTIONS not in fv.full_config.get()[CONF_ESPHOME]:
-        return config
-
-    pio_flash_size_key = "board_upload.flash_size"
-    pio_partitions_key = "board_build.partitions"
-    if (
-        CONF_PARTITIONS in config
-        and pio_partitions_key
-        in fv.full_config.get()[CONF_ESPHOME][CONF_PLATFORMIO_OPTIONS]
-    ):
-        raise cv.Invalid(
-            f"Do not specify '{pio_partitions_key}' in '{CONF_PLATFORMIO_OPTIONS}' with '{CONF_PARTITIONS}' in esp32"
-        )
-
-    if (
-        pio_flash_size_key
-        in fv.full_config.get()[CONF_ESPHOME][CONF_PLATFORMIO_OPTIONS]
-    ):
-        raise cv.Invalid(
-            f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
-        )
-
-    return config
-
-
 CONF_PLATFORM_VERSION = "platform_version"
 
 ARDUINO_FRAMEWORK_SCHEMA = cv.All(
@@ -415,24 +386,10 @@ FRAMEWORK_SCHEMA = cv.typed_schema(
 )
 
 
-FLASH_SIZES = [
-    "2MB",
-    "4MB",
-    "8MB",
-    "16MB",
-    "32MB",
-]
-
-CONF_FLASH_SIZE = "flash_size"
-CONF_PARTITIONS = "partitions"
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.Required(CONF_BOARD): cv.string_strict,
-            cv.Optional(CONF_FLASH_SIZE, default="4MB"): cv.one_of(
-                *FLASH_SIZES, upper=True
-            ),
-            cv.Optional(CONF_PARTITIONS): cv.file_,
             cv.Optional(CONF_VARIANT): cv.one_of(*VARIANTS, upper=True),
             cv.Optional(CONF_FRAMEWORK, default={}): FRAMEWORK_SCHEMA,
         }
@@ -442,12 +399,8 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-FINAL_VALIDATE_SCHEMA = cv.Schema(final_validate)
-
-
 async def to_code(config):
     cg.add_platformio_option("board", config[CONF_BOARD])
-    cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
     cg.add_build_flag("-DUSE_ESP32")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_build_flag(f"-DUSE_ESP32_VARIANT_{config[CONF_VARIANT]}")
@@ -497,10 +450,7 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0", False)
         add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)
 
-        if CONF_PARTITIONS in config:
-            cg.add_platformio_option("board_build.partitions", config[CONF_PARTITIONS])
-        else:
-            cg.add_platformio_option("board_build.partitions", "partitions.csv")
+        cg.add_platformio_option("board_build.partitions", "partitions.csv")
 
         for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
             add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
@@ -545,10 +495,7 @@ async def to_code(config):
             [f"platformio/framework-arduinoespressif32@{conf[CONF_SOURCE]}"],
         )
 
-        if CONF_PARTITIONS in config:
-            cg.add_platformio_option("board_build.partitions", config[CONF_PARTITIONS])
-        else:
-            cg.add_platformio_option("board_build.partitions", "partitions.csv")
+        cg.add_platformio_option("board_build.partitions", "partitions.csv")
 
         cg.add_define(
             "USE_ARDUINO_VERSION_CODE",
@@ -558,47 +505,24 @@ async def to_code(config):
         )
 
 
-APP_PARTITION_SIZES = {
-    "2MB": 0x0C0000,  # 768 KB
-    "4MB": 0x1C0000,  # 1792 KB
-    "8MB": 0x3C0000,  # 3840 KB
-    "16MB": 0x7C0000,  # 7936 KB
-    "32MB": 0xFC0000,  # 16128 KB
-}
-
-
-def get_arduino_partition_csv(flash_size):
-    app_partition_size = APP_PARTITION_SIZES[flash_size]
-    eeprom_partition_size = 0x1000  # 4 KB
-    spiffs_partition_size = 0xF000  # 60 KB
-
-    app0_partition_start = 0x010000  # 64 KB
-    app1_partition_start = app0_partition_start + app_partition_size
-    eeprom_partition_start = app1_partition_start + app_partition_size
-    spiffs_partition_start = eeprom_partition_start + eeprom_partition_size
-
-    partition_csv = f"""\
-nvs,      data, nvs,     0x9000, 0x5000,
-otadata,  data, ota,     0xE000, 0x2000,
-app0,     app,  ota_0,   0x{app0_partition_start:X}, 0x{app_partition_size:X},
-app1,     app,  ota_1,   0x{app1_partition_start:X}, 0x{app_partition_size:X},
-eeprom,   data, 0x99,    0x{eeprom_partition_start:X}, 0x{eeprom_partition_size:X},
-spiffs,   data, spiffs,  0x{spiffs_partition_start:X}, 0x{spiffs_partition_size:X}
+ARDUINO_PARTITIONS_CSV = """\
+nvs,      data, nvs,     0x009000, 0x005000,
+otadata,  data, ota,     0x00e000, 0x002000,
+app0,     app,  ota_0,   0x010000, 0x1C0000,
+app1,     app,  ota_1,   0x1D0000, 0x1C0000,
+eeprom,   data, 0x99,    0x390000, 0x001000,
+spiffs,   data, spiffs,  0x391000, 0x00F000
 """
-    return partition_csv
 
 
-def get_idf_partition_csv(flash_size):
-    app_partition_size = APP_PARTITION_SIZES[flash_size]
-
-    partition_csv = f"""\
+IDF_PARTITIONS_CSV = """\
+# Name,   Type, SubType, Offset,   Size, Flags
 otadata,  data, ota,     ,        0x2000,
 phy_init, data, phy,     ,        0x1000,
-app0,     app,  ota_0,   ,        0x{app_partition_size:X},
-app1,     app,  ota_1,   ,        0x{app_partition_size:X},
-nvs,      data, nvs,     ,        0x6D000,
+app0,     app,  ota_0,   ,      0x1C0000,
+app1,     app,  ota_1,   ,      0x1C0000,
+nvs,      data, nvs,     ,       0x6d000,
 """
-    return partition_csv
 
 
 def _format_sdkconfig_val(value: SdkconfigValueType) -> str:
@@ -641,17 +565,13 @@ def copy_files():
     if CORE.using_arduino:
         write_file_if_changed(
             CORE.relative_build_path("partitions.csv"),
-            get_arduino_partition_csv(
-                CORE.platformio_options.get("board_upload.flash_size")
-            ),
+            ARDUINO_PARTITIONS_CSV,
         )
     if CORE.using_esp_idf:
         _write_sdkconfig()
         write_file_if_changed(
             CORE.relative_build_path("partitions.csv"),
-            get_idf_partition_csv(
-                CORE.platformio_options.get("board_upload.flash_size")
-            ),
+            IDF_PARTITIONS_CSV,
         )
         # IDF build scripts look for version string to put in the build.
         # However, if the build path does not have an initialized git repo,

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -220,8 +220,6 @@ size_t I2SAudioSpeaker::play(const uint8_t *data, size_t length) {
   return index;
 }
 
-bool I2SAudioSpeaker::has_buffered_data() const { return uxQueueMessagesWaiting(this->buffer_queue_) > 0; }
-
 }  // namespace i2s_audio
 }  // namespace esphome
 

esphome/components/i2s_audio/speaker/i2s_audio_speaker.h

@@ -56,8 +56,6 @@ class I2SAudioSpeaker : public Component, public speaker::Speaker, public I2SAud
 
   size_t play(const uint8_t *data, size_t length) override;
 
-  bool has_buffered_data() const override;
-
  protected:
   void start_();
   // void stop_();

esphome/components/image/__init__.py

@@ -1,23 +1,15 @@
-from __future__ import annotations
-
 import logging
 
-import hashlib
 import io
 from pathlib import Path
 import re
 import requests
-from magic import Magic
-
-from PIL import Image
 
 from esphome import core
 from esphome.components import font
-from esphome import external_files
 import esphome.config_validation as cv
 import esphome.codegen as cg
 from esphome.const import (
-    __version__,
     CONF_DITHER,
     CONF_FILE,
     CONF_ICON,
@@ -27,7 +19,6 @@ from esphome.const import (
     CONF_RESIZE,
     CONF_SOURCE,
     CONF_TYPE,
-    CONF_URL,
 )
 from esphome.core import CORE, HexInt
 
@@ -52,74 +43,34 @@ IMAGE_TYPE = {
 CONF_USE_TRANSPARENCY = "use_transparency"
 
 # If the MDI file cannot be downloaded within this time, abort.
-IMAGE_DOWNLOAD_TIMEOUT = 30  # seconds
+MDI_DOWNLOAD_TIMEOUT = 30  # seconds
 
 SOURCE_LOCAL = "local"
 SOURCE_MDI = "mdi"
-SOURCE_WEB = "web"
-
 
 Image_ = image_ns.class_("Image")
 
 
-def _compute_local_icon_path(value: dict) -> Path:
-    base_dir = external_files.compute_local_file_dir(DOMAIN) / "mdi"
+def _compute_local_icon_path(value) -> Path:
+    base_dir = Path(CORE.data_dir) / DOMAIN / "mdi"
     return base_dir / f"{value[CONF_ICON]}.svg"
 
 
-def _compute_local_image_path(value: dict) -> Path:
-    url = value[CONF_URL]
-    h = hashlib.new("sha256")
-    h.update(url.encode())
-    key = h.hexdigest()[:8]
-    base_dir = external_files.compute_local_file_dir(DOMAIN)
-    return base_dir / key
-
-
-def download_content(url: str, path: Path) -> None:
-    if not external_files.has_remote_file_changed(url, path):
-        _LOGGER.debug("Remote file has not changed %s", url)
-        return
-
-    _LOGGER.debug(
-        "Remote file has changed, downloading from %s to %s",
-        url,
-        path,
-    )
-
+def download_mdi(value):
+    mdi_id = value[CONF_ICON]
+    path = _compute_local_icon_path(value)
+    if path.is_file():
+        return value
+    url = f"https://raw.githubusercontent.com/Templarian/MaterialDesign/master/svg/{mdi_id}.svg"
+    _LOGGER.debug("Downloading %s MDI image from %s", mdi_id, url)
     try:
-        req = requests.get(
-            url,
-            timeout=IMAGE_DOWNLOAD_TIMEOUT,
-            headers={"User-agent": f"ESPHome/{__version__} (https://esphome.io)"},
-        )
+        req = requests.get(url, timeout=MDI_DOWNLOAD_TIMEOUT)
         req.raise_for_status()
     except requests.exceptions.RequestException as e:
-        raise cv.Invalid(f"Could not download from {url}: {e}")
+        raise cv.Invalid(f"Could not download MDI image {mdi_id} from {url}: {e}")
 
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_bytes(req.content)
-
-
-def download_mdi(value):
-    validate_cairosvg_installed(value)
-
-    mdi_id = value[CONF_ICON]
-    path = _compute_local_icon_path(value)
-
-    url = f"https://raw.githubusercontent.com/Templarian/MaterialDesign/master/svg/{mdi_id}.svg"
-
-    download_content(url, path)
-
-    return value
-
-
-def download_image(value):
-    url = value[CONF_URL]
-    path = _compute_local_image_path(value)
-
-    download_content(url, path)
-
     return value
 
 
@@ -188,13 +139,6 @@ def validate_file_shorthand(value):
                 CONF_ICON: icon,
             }
         )
-    if value.startswith("http://") or value.startswith("https://"):
-        return FILE_SCHEMA(
-            {
-                CONF_SOURCE: SOURCE_WEB,
-                CONF_URL: value,
-            }
-        )
     return FILE_SCHEMA(
         {
             CONF_SOURCE: SOURCE_LOCAL,
@@ -216,18 +160,10 @@ MDI_SCHEMA = cv.All(
     download_mdi,
 )
 
-WEB_SCHEMA = cv.All(
-    {
-        cv.Required(CONF_URL): cv.string,
-    },
-    download_image,
-)
-
 TYPED_FILE_SCHEMA = cv.typed_schema(
     {
         SOURCE_LOCAL: LOCAL_SCHEMA,
         SOURCE_MDI: MDI_SCHEMA,
-        SOURCE_WEB: WEB_SCHEMA,
     },
     key=CONF_SOURCE,
 )
@@ -265,7 +201,9 @@ IMAGE_SCHEMA = cv.Schema(
 CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, IMAGE_SCHEMA)
 
 
-def load_svg_image(file: bytes, resize: tuple[int, int]):
+def load_svg_image(file: str, resize: tuple[int, int]):
+    from PIL import Image
+
     # This import is only needed in case of SVG images; adding it
     # to the top would force configurations not using SVG to also have it
     # installed for no reason.
@@ -274,17 +212,19 @@ def load_svg_image(file: bytes, resize: tuple[int, int]):
     if resize:
         req_width, req_height = resize
         svg_image = svg2png(
-            file,
+            url=file,
             output_width=req_width,
             output_height=req_height,
         )
     else:
-        svg_image = svg2png(file)
+        svg_image = svg2png(url=file)
 
     return Image.open(io.BytesIO(svg_image))
 
 
 async def to_code(config):
+    from PIL import Image
+
     conf_file = config[CONF_FILE]
 
     if conf_file[CONF_SOURCE] == SOURCE_LOCAL:
@@ -293,26 +233,17 @@ async def to_code(config):
     elif conf_file[CONF_SOURCE] == SOURCE_MDI:
         path = _compute_local_icon_path(conf_file).as_posix()
 
-    elif conf_file[CONF_SOURCE] == SOURCE_WEB:
-        path = _compute_local_image_path(conf_file).as_posix()
-
     try:
-        with open(path, "rb") as f:
-            file_contents = f.read()
+        resize = config.get(CONF_RESIZE)
+        if path.lower().endswith(".svg"):
+            image = load_svg_image(path, resize)
+        else:
+            image = Image.open(path)
+            if resize:
+                image.thumbnail(resize)
     except Exception as e:
         raise core.EsphomeError(f"Could not load image file {path}: {e}")
 
-    mime = Magic(mime=True)
-    file_type = mime.from_buffer(file_contents)
-
-    resize = config.get(CONF_RESIZE)
-    if "svg" in file_type:
-        image = load_svg_image(file_contents, resize)
-    else:
-        image = Image.open(io.BytesIO(file_contents))
-        if resize:
-            image.thumbnail(resize)
-
     width, height = image.size
 
     if CONF_RESIZE not in config and (width > 500 or height > 500):

esphome/components/ina226/ina226.cpp

@@ -1,7 +1,7 @@
 #include "ina226.h"
-#include "esphome/core/log.h"
-#include "esphome/core/hal.h"
 #include <cinttypes>
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ina226 {
@@ -102,6 +102,7 @@ void INA226Component::update() {
       this->status_set_warning();
       return;
     }
+    ESP_LOGD(TAG, "Got raw bus voltage: %d", raw_bus_voltage);
     float bus_voltage_v = int16_t(raw_bus_voltage) * 0.00125f;
     this->bus_voltage_sensor_->publish_state(bus_voltage_v);
   }

esphome/components/ld2420/ld2420.cpp

@@ -68,7 +68,6 @@ void LD2420Component::dump_config() {
   ESP_LOGCONFIG(TAG, "LD2420:");
   ESP_LOGCONFIG(TAG, "  Firmware Version : %7s", this->ld2420_firmware_ver_);
   ESP_LOGCONFIG(TAG, "LD2420 Number:");
-#ifdef USE_NUMBER
   LOG_NUMBER(TAG, "  Gate Timeout:", this->gate_timeout_number_);
   LOG_NUMBER(TAG, "  Gate Max Distance:", this->max_gate_distance_number_);
   LOG_NUMBER(TAG, "  Gate Min Distance:", this->min_gate_distance_number_);
@@ -77,13 +76,10 @@ void LD2420Component::dump_config() {
     LOG_NUMBER(TAG, "  Gate Move Threshold:", this->gate_move_threshold_numbers_[gate]);
     LOG_NUMBER(TAG, "  Gate Still Threshold::", this->gate_still_threshold_numbers_[gate]);
   }
-#endif
-#ifdef USE_BUTTON
   LOG_BUTTON(TAG, "  Apply Config:", this->apply_config_button_);
   LOG_BUTTON(TAG, "  Revert Edits:", this->revert_config_button_);
   LOG_BUTTON(TAG, "  Factory Reset:", this->factory_reset_button_);
   LOG_BUTTON(TAG, "  Restart Module:", this->restart_module_button_);
-#endif
   ESP_LOGCONFIG(TAG, "LD2420 Select:");
   LOG_SELECT(TAG, "  Operating Mode", this->operating_selector_);
   if (this->get_firmware_int_(ld2420_firmware_ver_) < CALIBRATE_VERSION_MIN) {
@@ -187,11 +183,9 @@ void LD2420Component::factory_reset_action() {
     return;
   }
   this->set_min_max_distances_timeout(FACTORY_MAX_GATE, FACTORY_MIN_GATE, FACTORY_TIMEOUT);
-#ifdef USE_NUMBER
   this->gate_timeout_number_->state = FACTORY_TIMEOUT;
   this->min_gate_distance_number_->state = FACTORY_MIN_GATE;
   this->max_gate_distance_number_->state = FACTORY_MAX_GATE;
-#endif
   for (uint8_t gate = 0; gate < LD2420_TOTAL_GATES; gate++) {
     this->new_config.move_thresh[gate] = FACTORY_MOVE_THRESH[gate];
     this->new_config.still_thresh[gate] = FACTORY_STILL_THRESH[gate];

esphome/components/mqtt/mqtt_client.cpp

@@ -147,7 +147,7 @@ void MQTTClientComponent::dump_config() {
     ESP_LOGCONFIG(TAG, "  Availability: '%s'", this->availability_.topic.c_str());
   }
 }
-bool MQTTClientComponent::can_proceed() { return network::is_disabled() || this->is_connected(); }
+bool MQTTClientComponent::can_proceed() { return this->is_connected(); }
 
 void MQTTClientComponent::start_dnslookup_() {
   for (auto &subscription : this->subscriptions_) {

esphome/components/mqtt/mqtt_lock.cpp

@@ -40,8 +40,6 @@ const EntityBase *MQTTLockComponent::get_entity() const { return this->lock_; }
 void MQTTLockComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
   if (this->lock_->traits.get_assumed_state())
     root[MQTT_OPTIMISTIC] = true;
-  if (this->lock_->traits.get_supports_open())
-    root[MQTT_PAYLOAD_OPEN] = "OPEN";
 }
 bool MQTTLockComponent::send_initial_state() { return this->publish_state(); }
 

esphome/components/my9231/my9231.cpp

@@ -1,6 +1,5 @@
 #include "my9231.h"
 #include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace my9231 {
@@ -52,11 +51,7 @@ void MY9231OutputComponent::setup() {
       MY9231_CMD_SCATTER_APDM | MY9231_CMD_FREQUENCY_DIVIDE_1 | MY9231_CMD_REACTION_FAST | MY9231_CMD_ONE_SHOT_DISABLE;
   ESP_LOGV(TAG, "  Command: 0x%02X", command);
 
-  {
-    InterruptLock lock;
-    this->send_dcki_pulses_(32 * this->num_chips_);
-    this->init_chips_(command);
-  }
+  this->init_chips_(command);
   ESP_LOGV(TAG, "  Chips initialized.");
 }
 void MY9231OutputComponent::dump_config() {
@@ -71,14 +66,11 @@ void MY9231OutputComponent::loop() {
   if (!this->update_)
     return;
 
-  {
-    InterruptLock lock;
-    for (auto pwm_amount : this->pwm_amounts_) {
-      this->write_word_(pwm_amount, this->bit_depth_);
-    }
-    // Send 8 DI pulses. After 8 falling edges, the duty data are store.
-    this->send_di_pulses_(8);
+  for (auto pwm_amount : this->pwm_amounts_) {
+    this->write_word_(pwm_amount, this->bit_depth_);
   }
+  // Send 8 DI pulses. After 8 falling edges, the duty data are store.
+  this->send_di_pulses_(8);
   this->update_ = false;
 }
 void MY9231OutputComponent::set_channel_value_(uint8_t channel, uint16_t value) {
@@ -100,7 +92,6 @@ void MY9231OutputComponent::init_chips_(uint8_t command) {
   // Send 16 DI pulse. After 14 falling edges, the command data are
   // stored and after 16 falling edges the duty mode is activated.
   this->send_di_pulses_(16);
-  delayMicroseconds(12);
 }
 void MY9231OutputComponent::write_word_(uint16_t value, uint8_t bits) {
   for (uint8_t i = bits; i > 0; i--) {
@@ -115,13 +106,6 @@ void MY9231OutputComponent::send_di_pulses_(uint8_t count) {
     this->pin_di_->digital_write(false);
   }
 }
-void MY9231OutputComponent::send_dcki_pulses_(uint8_t count) {
-  delayMicroseconds(12);
-  for (uint8_t i = 0; i < count; i++) {
-    this->pin_dcki_->digital_write(true);
-    this->pin_dcki_->digital_write(false);
-  }
-}
 
 }  // namespace my9231
 }  // namespace esphome

esphome/components/my9231/my9231.h

@@ -49,7 +49,6 @@ class MY9231OutputComponent : public Component {
   void init_chips_(uint8_t command);
   void write_word_(uint16_t value, uint8_t bits);
   void send_di_pulses_(uint8_t count);
-  void send_dcki_pulses_(uint8_t count);
 
   GPIOPin *pin_di_;
   GPIOPin *pin_dcki_;

esphome/components/network/util.cpp

@@ -29,14 +29,6 @@ bool is_connected() {
   return false;
 }
 
-bool is_disabled() {
-#ifdef USE_WIFI
-  if (wifi::global_wifi_component != nullptr)
-    return wifi::global_wifi_component->is_disabled();
-#endif
-  return false;
-}
-
 network::IPAddress get_ip_address() {
 #ifdef USE_ETHERNET
   if (ethernet::global_eth_component != nullptr)

esphome/components/network/util.h

@@ -8,8 +8,6 @@ namespace network {
 
 /// Return whether the node is connected to the network (through wifi, eth, ...)
 bool is_connected();
-/// Return whether the network is disabled (only wifi for now)
-bool is_disabled();
 /// Get the active network hostname
 std::string get_use_address();
 IPAddress get_ip_address();

esphome/components/nextion/display.py

@@ -36,7 +36,7 @@ CONFIG_SCHEMA = (
     display.BASIC_DISPLAY_SCHEMA.extend(
         {
             cv.GenerateID(): cv.declare_id(Nextion),
-            cv.Optional(CONF_TFT_URL): cv.All(cv.string, cv.only_with_arduino),
+            cv.Optional(CONF_TFT_URL): cv.url,
             cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
             cv.Optional(CONF_ON_SETUP): automation.validate_automation(
                 {
@@ -85,10 +85,10 @@ async def to_code(config):
     if CONF_TFT_URL in config:
         cg.add_define("USE_NEXTION_TFT_UPLOAD")
         cg.add(var.set_tft_url(config[CONF_TFT_URL]))
-        if CORE.is_esp32:
+        if CORE.is_esp32 and CORE.using_arduino:
             cg.add_library("WiFiClientSecure", None)
             cg.add_library("HTTPClient", None)
-        if CORE.is_esp8266:
+        elif CORE.is_esp8266 and CORE.using_arduino:
             cg.add_library("ESP8266HTTPClient", None)
 
     if CONF_TOUCH_SLEEP_TIMEOUT in config:

esphome/components/nextion/nextion.cpp

@@ -128,7 +128,7 @@ void Nextion::dump_config() {
   ESP_LOGCONFIG(TAG, "  Wake On Touch:    %s", this->auto_wake_on_touch_ ? "True" : "False");
 
   if (this->touch_sleep_timeout_ != 0) {
-    ESP_LOGCONFIG(TAG, "  Touch Timeout:       %d", this->touch_sleep_timeout_);
+    ESP_LOGCONFIG(TAG, "  Touch Timeout:       %" PRIu32, this->touch_sleep_timeout_);
   }
 
   if (this->wake_up_page_ != -1) {
@@ -868,6 +868,12 @@ uint16_t Nextion::recv_ret_string_(std::string &response, uint32_t timeout, bool
   start = millis();
 
   while ((timeout == 0 && this->available()) || millis() - start <= timeout) {
+    if (!this->available()) {
+      App.feed_wdt();
+      delay(1);
+      continue;
+    }
+
     this->read_byte(&c);
     if (c == 0xFF) {
       nr_of_ff_bytes++;
@@ -886,7 +892,7 @@ uint16_t Nextion::recv_ret_string_(std::string &response, uint32_t timeout, bool
       }
     }
     App.feed_wdt();
-    delay(1);
+    delay(2);
 
     if (exit_flag || ff_flag) {
       break;

esphome/components/nextion/nextion.h

@@ -12,14 +12,18 @@
 #include "esphome/components/display/display_color_utils.h"
 
 #ifdef USE_NEXTION_TFT_UPLOAD
+#ifdef ARDUINO
 #ifdef USE_ESP32
 #include <HTTPClient.h>
-#endif
+#endif  // USE_ESP32
 #ifdef USE_ESP8266
 #include <ESP8266HTTPClient.h>
 #include <WiFiClientSecure.h>
-#endif
-#endif
+#endif  // USE_ESP8266
+#elif defined(USE_ESP_IDF)
+#include <esp_http_client.h>
+#endif  // ARDUINO vs ESP-IDF
+#endif  // USE_NEXTION_TFT_UPLOAD
 
 namespace esphome {
 namespace nextion {
@@ -685,16 +689,18 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
 
 #ifdef USE_NEXTION_TFT_UPLOAD
   /**
-   * Set the tft file URL. https seems problamtic with arduino..
+   * Set the tft file URL. https seems problematic with arduino..
    */
   void set_tft_url(const std::string &tft_url) { this->tft_url_ = tft_url; }
 
 #endif
 
   /**
-   * Upload the tft file and softreset the Nextion
+   * Upload the tft file and soft reset Nextion
+   * @return bool True: Transfer completed successfuly, False: Transfer failed.
    */
-  void upload_tft();
+  bool upload_tft();
+
   void dump_config() override;
 
   /**
@@ -817,16 +823,16 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   BearSSL::WiFiClientSecure *wifi_client_secure_{nullptr};
   WiFiClient *get_wifi_client_();
 #endif
-
+  int content_length_ = 0;
+  int tft_size_ = 0;
+#ifdef ARDUINO
   /**
    * will request chunk_size chunks from the web server
    * and send each to the nextion
-   * @param int contentLength Total size of the file
-   * @param uint32_t chunk_size
-   * @return true if success, false for failure.
+   * @param HTTPClient http HTTP client handler.
+   * @param int range_start Position of next byte to transfer.
+   * @return position of last byte transferred, -1 for failure.
    */
-  int content_length_ = 0;
-  int tft_size_ = 0;
   int upload_by_chunks_(HTTPClient *http, int range_start);
 
   bool upload_with_range_(uint32_t range_start, uint32_t range_end);
@@ -839,7 +845,30 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * @return true if success, false for failure.
    */
   bool upload_from_buffer_(const uint8_t *file_buf, size_t buf_size);
-  void upload_end_();
+  /**
+   * Ends the upload process, restart Nextion and, if successful,
+   * restarts ESP
+   * @param bool url successful True: Transfer completed successfuly, False: Transfer failed.
+   * @return bool True: Transfer completed successfuly, False: Transfer failed.
+   */
+  bool upload_end_(bool successful);
+#elif defined(USE_ESP_IDF)
+  /**
+   * will request 4096 bytes chunks from the web server
+   * and send each to Nextion
+   * @param std::string url Full url for download.
+   * @param int range_start Position of next byte to transfer.
+   * @return position of last byte transferred, -1 for failure.
+   */
+  int upload_range(const std::string &url, int range_start);
+  /**
+   * Ends the upload process, restart Nextion and, if successful,
+   * restarts ESP
+   * @param bool url successful True: Transfer completed successfuly, False: Transfer failed.
+   * @return bool True: Transfer completed successfuly, False: Transfer failed.
+   */
+  bool upload_end(bool successful);
+#endif  // ARDUINO vs ESP-IDF
 
 #endif  // USE_NEXTION_TFT_UPLOAD
 

esphome/components/nextion/nextion_commands.cpp

@@ -55,7 +55,7 @@ void Nextion::set_protocol_reparse_mode(bool active_mode) {
 
 // Set Colors
 void Nextion::set_component_background_color(const char *component, uint32_t color) {
-  this->add_no_result_to_queue_with_printf_("set_component_background_color", "%s.bco=%d", component, color);
+  this->add_no_result_to_queue_with_printf_("set_component_background_color", "%s.bco=%" PRIu32, component, color);
 }
 
 void Nextion::set_component_background_color(const char *component, const char *color) {
@@ -68,7 +68,8 @@ void Nextion::set_component_background_color(const char *component, Color color)
 }
 
 void Nextion::set_component_pressed_background_color(const char *component, uint32_t color) {
-  this->add_no_result_to_queue_with_printf_("set_component_pressed_background_color", "%s.bco2=%d", component, color);
+  this->add_no_result_to_queue_with_printf_("set_component_pressed_background_color", "%s.bco2=%" PRIu32, component,
+                                            color);
 }
 
 void Nextion::set_component_pressed_background_color(const char *component, const char *color) {
@@ -89,7 +90,7 @@ void Nextion::set_component_picc(const char *component, uint8_t pic_id) {
 }
 
 void Nextion::set_component_font_color(const char *component, uint32_t color) {
-  this->add_no_result_to_queue_with_printf_("set_component_font_color", "%s.pco=%d", component, color);
+  this->add_no_result_to_queue_with_printf_("set_component_font_color", "%s.pco=%" PRIu32, component, color);
 }
 
 void Nextion::set_component_font_color(const char *component, const char *color) {
@@ -102,7 +103,7 @@ void Nextion::set_component_font_color(const char *component, Color color) {
 }
 
 void Nextion::set_component_pressed_font_color(const char *component, uint32_t color) {
-  this->add_no_result_to_queue_with_printf_("set_component_pressed_font_color", "%s.pco2=%d", component, color);
+  this->add_no_result_to_queue_with_printf_("set_component_pressed_font_color", "%s.pco2=%" PRIu32, component, color);
 }
 
 void Nextion::set_component_pressed_font_color(const char *component, const char *color) {

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -1,5 +1,6 @@
 #include "nextion.h"
 
+#ifdef ARDUINO
 #ifdef USE_NEXTION_TFT_UPLOAD
 
 #include "esphome/core/application.h"
@@ -128,15 +129,15 @@ int Nextion::upload_by_chunks_(HTTPClient *http, int range_start) {
   return range_end + 1;
 }
 
-void Nextion::upload_tft() {
+bool Nextion::upload_tft() {
   if (this->is_updating_) {
     ESP_LOGD(TAG, "Currently updating");
-    return;
+    return false;
   }
 
   if (!network::is_connected()) {
     ESP_LOGD(TAG, "network is not connected");
-    return;
+    return false;
   }
 
   this->is_updating_ = true;
@@ -164,7 +165,7 @@ void Nextion::upload_tft() {
     ESP_LOGD(TAG, "connection failed");
     ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
     allocator.deallocate(this->transfer_buffer_, this->transfer_buffer_size_);
-    return;
+    return false;
   } else {
     ESP_LOGD(TAG, "Connected");
   }
@@ -192,7 +193,7 @@ void Nextion::upload_tft() {
   }
 
   if ((code != 200 && code != 206) || tries > 5) {
-    this->upload_end_();
+    return this->upload_end_(false);
   }
 
   String content_range_string = http.header("Content-Range");
@@ -203,7 +204,7 @@ void Nextion::upload_tft() {
 
   if (this->content_length_ < 4096) {
     ESP_LOGE(TAG, "Failed to get file size");
-    this->upload_end_();
+    return this->upload_end_(false);
   }
 
   ESP_LOGD(TAG, "Updating Nextion %s...", this->device_model_.c_str());
@@ -246,7 +247,7 @@ void Nextion::upload_tft() {
     ESP_LOGD(TAG, "preparation for tft update done");
   } else {
     ESP_LOGD(TAG, "preparation for tft update failed %d \"%s\"", response[0], response.c_str());
-    this->upload_end_();
+    return this->upload_end_(false);
   }
 
   // Nextion wants 4096 bytes at a time. Make chunk_size a multiple of 4096
@@ -280,7 +281,7 @@ void Nextion::upload_tft() {
       this->transfer_buffer_ = allocator.allocate(chunk_size);
 
       if (!this->transfer_buffer_)
-        this->upload_end_();
+        return this->upload_end_(false);
     }
 
     this->transfer_buffer_size_ = chunk_size;
@@ -295,7 +296,7 @@ void Nextion::upload_tft() {
     result = this->upload_by_chunks_(&http, result);
     if (result < 0) {
       ESP_LOGD(TAG, "Error updating Nextion!");
-      this->upload_end_();
+      return this->upload_end_(false);
     }
     App.feed_wdt();
     // NOLINTNEXTLINE(readability-static-accessed-through-instance)
@@ -303,15 +304,19 @@ void Nextion::upload_tft() {
   }
   ESP_LOGD(TAG, "Successfully updated Nextion!");
 
-  this->upload_end_();
+  return this->upload_end_(true);
 }
 
-void Nextion::upload_end_() {
+bool Nextion::upload_end_(bool successful) {
+  this->is_updating_ = false;
   ESP_LOGD(TAG, "Restarting Nextion");
   this->soft_reset();
-  delay(1500);  // NOLINT
-  ESP_LOGD(TAG, "Restarting esphome");
-  ESP.restart();  // NOLINT(readability-static-accessed-through-instance)
+  if (successful) {
+    delay(1500);  // NOLINT
+    ESP_LOGD(TAG, "Restarting esphome");
+    ESP.restart();  // NOLINT(readability-static-accessed-through-instance)
+  }
+  return successful;
 }
 
 #ifdef USE_ESP8266
@@ -337,3 +342,4 @@ WiFiClient *Nextion::get_wifi_client_() {
 }  // namespace esphome
 
 #endif  // USE_NEXTION_TFT_UPLOAD
+#endif  // ARDUINO

esphome/components/nextion/nextion_upload_idf.cpp

@@ -0,0 +1,268 @@
+#include "nextion.h"
+
+#ifdef USE_ESP_IDF
+#ifdef USE_NEXTION_TFT_UPLOAD
+
+#include "esphome/core/application.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/util.h"
+#include "esphome/core/log.h"
+#include "esphome/components/network/util.h"
+
+#include <esp_heap_caps.h>
+#include <esp_http_client.h>
+
+namespace esphome {
+namespace nextion {
+static const char *const TAG = "nextion_upload";
+
+// Followed guide
+// https://unofficialnextion.com/t/nextion-upload-protocol-v1-2-the-fast-one/1044/2
+
+int Nextion::upload_range(const std::string &url, int range_start) {
+  ESP_LOGVV(TAG, "url: %s", url.c_str());
+  uint range_size = this->tft_size_ - range_start;
+  ESP_LOGVV(TAG, "tft_size_: %i", this->tft_size_);
+  ESP_LOGV(TAG, "Available heap: %u", esp_get_free_heap_size());
+  int range_end = (range_start == 0) ? std::min(this->tft_size_, 16383) : this->tft_size_;
+  if (range_size <= 0 or range_end <= range_start) {
+    ESP_LOGE(TAG, "Invalid range");
+    ESP_LOGD(TAG, "Range start: %i", range_start);
+    ESP_LOGD(TAG, "Range end: %i", range_end);
+    ESP_LOGD(TAG, "Range size: %i", range_size);
+    return -1;
+  }
+
+  esp_http_client_config_t config = {
+      .url = url.c_str(),
+      .cert_pem = nullptr,
+  };
+  esp_http_client_handle_t client = esp_http_client_init(&config);
+
+  char range_header[64];
+  sprintf(range_header, "bytes=%d-%d", range_start, range_end);
+  ESP_LOGV(TAG, "Requesting range: %s", range_header);
+  esp_http_client_set_header(client, "Range", range_header);
+  ESP_LOGVV(TAG, "Available heap: %u", esp_get_free_heap_size());
+
+  ESP_LOGV(TAG, "Opening http connetion");
+  esp_err_t err;
+  if ((err = esp_http_client_open(client, 0)) != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to open HTTP connection: %s", esp_err_to_name(err));
+    esp_http_client_cleanup(client);
+    return -1;
+  }
+
+  ESP_LOGV(TAG, "Fetch content length");
+  int content_length = esp_http_client_fetch_headers(client);
+  ESP_LOGV(TAG, "content_length = %d", content_length);
+  if (content_length <= 0) {
+    ESP_LOGE(TAG, "Failed to get content length: %d", content_length);
+    esp_http_client_cleanup(client);
+    return -1;
+  }
+
+  int total_read_len = 0, read_len;
+
+  ESP_LOGV(TAG, "Allocate buffer");
+  uint8_t *buffer = new uint8_t[4096];
+  std::string recv_string;
+  if (buffer == nullptr) {
+    ESP_LOGE(TAG, "Failed to allocate memory for buffer");
+    ESP_LOGV(TAG, "Available heap: %u", esp_get_free_heap_size());
+  } else {
+    ESP_LOGV(TAG, "Memory for buffer allocated successfully");
+
+    while (true) {
+      App.feed_wdt();
+      ESP_LOGVV(TAG, "Available heap: %u", esp_get_free_heap_size());
+      int read_len = esp_http_client_read(client, reinterpret_cast<char *>(buffer), 4096);
+      ESP_LOGVV(TAG, "Read %d bytes from HTTP client, writing to UART", read_len);
+      if (read_len > 0) {
+        this->write_array(buffer, read_len);
+        ESP_LOGVV(TAG, "Write to UART successful");
+        this->recv_ret_string_(recv_string, 5000, true);
+        this->content_length_ -= read_len;
+        ESP_LOGD(TAG, "Uploaded %0.2f %%, remaining %d bytes",
+                 100.0 * (this->tft_size_ - this->content_length_) / this->tft_size_, this->content_length_);
+        if (recv_string[0] != 0x05) {  // 0x05 == "ok"
+          ESP_LOGD(
+              TAG, "recv_string [%s]",
+              format_hex_pretty(reinterpret_cast<const uint8_t *>(recv_string.data()), recv_string.size()).c_str());
+        }
+        // handle partial upload request
+        if (recv_string[0] == 0x08 && recv_string.size() == 5) {
+          uint32_t result = 0;
+          for (int j = 0; j < 4; ++j) {
+            result += static_cast<uint8_t>(recv_string[j + 1]) << (8 * j);
+          }
+          if (result > 0) {
+            ESP_LOGI(TAG, "Nextion reported new range %" PRIu32, result);
+            this->content_length_ = this->tft_size_ - result;
+            // Deallocate the buffer when done
+            delete[] buffer;
+            ESP_LOGVV(TAG, "Memory for buffer deallocated");
+            esp_http_client_cleanup(client);
+            esp_http_client_close(client);
+            return result;
+          }
+        }
+        recv_string.clear();
+      } else if (read_len == 0) {
+        ESP_LOGV(TAG, "End of HTTP response reached");
+        break;  // Exit the loop if there is no more data to read
+      } else {
+        ESP_LOGE(TAG, "Failed to read from HTTP client, error code: %d", read_len);
+        break;  // Exit the loop on error
+      }
+    }
+
+    // Deallocate the buffer when done
+    delete[] buffer;
+    ESP_LOGVV(TAG, "Memory for buffer deallocated");
+  }
+  esp_http_client_cleanup(client);
+  esp_http_client_close(client);
+  return range_end + 1;
+}
+
+bool Nextion::upload_tft() {
+  ESP_LOGD(TAG, "Nextion TFT upload requested");
+  ESP_LOGD(TAG, "url: %s", this->tft_url_.c_str());
+
+  if (this->is_updating_) {
+    ESP_LOGW(TAG, "Currently updating");
+    return false;
+  }
+
+  if (!network::is_connected()) {
+    ESP_LOGE(TAG, "Network is not connected");
+    return false;
+  }
+
+  this->is_updating_ = true;
+
+  // Define the configuration for the HTTP client
+  ESP_LOGV(TAG, "Establishing connection to HTTP server");
+  ESP_LOGVV(TAG, "Available heap: %u", esp_get_free_heap_size());
+  esp_http_client_config_t config = {
+      .url = this->tft_url_.c_str(),
+      .cert_pem = nullptr,
+      .method = HTTP_METHOD_HEAD,
+      .timeout_ms = 15000,
+  };
+
+  // Initialize the HTTP client with the configuration
+  ESP_LOGV(TAG, "Initializing HTTP client");
+  ESP_LOGV(TAG, "Available heap: %u", esp_get_free_heap_size());
+  esp_http_client_handle_t http = esp_http_client_init(&config);
+  if (!http) {
+    ESP_LOGE(TAG, "Failed to initialize HTTP client.");
+    return this->upload_end(false);
+  }
+
+  // Perform the HTTP request
+  ESP_LOGV(TAG, "Check if the client could connect");
+  ESP_LOGV(TAG, "Available heap: %u", esp_get_free_heap_size());
+  esp_err_t err = esp_http_client_perform(http);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "HTTP request failed: %s", esp_err_to_name(err));
+    esp_http_client_cleanup(http);
+    return this->upload_end(false);
+  }
+
+  // Check the HTTP Status Code
+  int status_code = esp_http_client_get_status_code(http);
+  ESP_LOGV(TAG, "HTTP Status Code: %d", status_code);
+  size_t tft_file_size = esp_http_client_get_content_length(http);
+  ESP_LOGD(TAG, "TFT file size: %zu", tft_file_size);
+
+  if (tft_file_size < 4096) {
+    ESP_LOGE(TAG, "File size check failed. Size: %zu", tft_file_size);
+    esp_http_client_cleanup(http);
+    return this->upload_end(false);
+  } else {
+    ESP_LOGV(TAG, "File size check passed. Proceeding...");
+  }
+  this->content_length_ = tft_file_size;
+  this->tft_size_ = tft_file_size;
+
+  ESP_LOGD(TAG, "Updating Nextion");
+  // The Nextion will ignore the update command if it is sleeping
+
+  this->send_command_("sleep=0");
+  this->set_backlight_brightness(1.0);
+  vTaskDelay(pdMS_TO_TICKS(250));  // NOLINT
+
+  App.feed_wdt();
+  char command[128];
+  // Tells the Nextion the content length of the tft file and baud rate it will be sent at
+  // Once the Nextion accepts the command it will wait until the file is successfully uploaded
+  // If it fails for any reason a power cycle of the display will be needed
+  sprintf(command, "whmi-wris %d,%" PRIu32 ",1", this->content_length_, this->parent_->get_baud_rate());
+
+  // Clear serial receive buffer
+  uint8_t d;
+  while (this->available()) {
+    this->read_byte(&d);
+  };
+
+  this->send_command_(command);
+
+  std::string response;
+  ESP_LOGV(TAG, "Waiting for upgrade response");
+  this->recv_ret_string_(response, 2048, true);  // This can take some time to return
+
+  // The Nextion display will, if it's ready to accept data, send a 0x05 byte.
+  ESP_LOGD(TAG, "Upgrade response is [%s]",
+           format_hex_pretty(reinterpret_cast<const uint8_t *>(response.data()), response.size()).c_str());
+
+  if (response.find(0x05) != std::string::npos) {
+    ESP_LOGV(TAG, "Preparation for tft update done");
+  } else {
+    ESP_LOGE(TAG, "Preparation for tft update failed %d \"%s\"", response[0], response.c_str());
+    esp_http_client_cleanup(http);
+    return this->upload_end(false);
+  }
+
+  ESP_LOGD(TAG, "Updating tft from \"%s\" with a file size of %d, Heap Size %" PRIu32, this->tft_url_.c_str(),
+           content_length_, esp_get_free_heap_size());
+
+  ESP_LOGV(TAG, "Starting transfer by chunks loop");
+  int result = 0;
+  while (content_length_ > 0) {
+    result = upload_range(this->tft_url_.c_str(), result);
+    if (result < 0) {
+      ESP_LOGE(TAG, "Error updating Nextion!");
+      esp_http_client_cleanup(http);
+      return this->upload_end(false);
+    }
+    App.feed_wdt();
+    ESP_LOGV(TAG, "Heap Size %" PRIu32 ", Bytes left %d", esp_get_free_heap_size(), content_length_);
+  }
+
+  ESP_LOGD(TAG, "Successfully updated Nextion!");
+
+  ESP_LOGD(TAG, "Close HTTP connection");
+  esp_http_client_close(http);
+  esp_http_client_cleanup(http);
+  return upload_end(true);
+}
+
+bool Nextion::upload_end(bool successful) {
+  this->is_updating_ = false;
+  ESP_LOGD(TAG, "Restarting Nextion");
+  this->soft_reset();
+  vTaskDelay(pdMS_TO_TICKS(1500));  // NOLINT
+  if (successful) {
+    ESP_LOGD(TAG, "Restarting esphome");
+    esp_restart();  // NOLINT(readability-static-accessed-through-instance)
+  }
+  return successful;
+}
+
+}  // namespace nextion
+}  // namespace esphome
+
+#endif  // USE_NEXTION_TFT_UPLOAD
+#endif  // USE_ESP_IDF

esphome/components/remote_base/remote_base.cpp

@@ -1,8 +1,6 @@
 #include "remote_base.h"
 #include "esphome/core/log.h"
 
-#include <cinttypes>
-
 namespace esphome {
 namespace remote_base {
 

esphome/components/speaker/speaker.h

@@ -18,8 +18,6 @@ class Speaker {
   virtual void start() = 0;
   virtual void stop() = 0;
 
-  virtual bool has_buffered_data() const = 0;
-
   bool is_running() const { return this->state_ == STATE_RUNNING; }
 
  protected:

esphome/components/voice_assistant/__init__.py

@@ -18,27 +18,20 @@ DEPENDENCIES = ["api", "microphone"]
 
 CODEOWNERS = ["@jesserockz"]
 
-CONF_ON_END = "on_end"
-CONF_ON_ERROR = "on_error"
-CONF_ON_INTENT_END = "on_intent_end"
-CONF_ON_INTENT_START = "on_intent_start"
+CONF_SILENCE_DETECTION = "silence_detection"
 CONF_ON_LISTENING = "on_listening"
 CONF_ON_START = "on_start"
-CONF_ON_STT_END = "on_stt_end"
-CONF_ON_STT_VAD_END = "on_stt_vad_end"
-CONF_ON_STT_VAD_START = "on_stt_vad_start"
-CONF_ON_TTS_END = "on_tts_end"
-CONF_ON_TTS_START = "on_tts_start"
-CONF_ON_TTS_STREAM_START = "on_tts_stream_start"
-CONF_ON_TTS_STREAM_END = "on_tts_stream_end"
 CONF_ON_WAKE_WORD_DETECTED = "on_wake_word_detected"
-
-CONF_SILENCE_DETECTION = "silence_detection"
+CONF_ON_STT_END = "on_stt_end"
+CONF_ON_TTS_START = "on_tts_start"
+CONF_ON_TTS_END = "on_tts_end"
+CONF_ON_END = "on_end"
+CONF_ON_ERROR = "on_error"
 CONF_USE_WAKE_WORD = "use_wake_word"
 CONF_VAD_THRESHOLD = "vad_threshold"
 
-CONF_AUTO_GAIN = "auto_gain"
 CONF_NOISE_SUPPRESSION_LEVEL = "noise_suppression_level"
+CONF_AUTO_GAIN = "auto_gain"
 CONF_VOLUME_MULTIPLIER = "volume_multiplier"
 
 
@@ -57,20 +50,6 @@ StopAction = voice_assistant_ns.class_(
 IsRunningCondition = voice_assistant_ns.class_(
     "IsRunningCondition", automation.Condition, cg.Parented.template(VoiceAssistant)
 )
-ConnectedCondition = voice_assistant_ns.class_(
-    "ConnectedCondition", automation.Condition, cg.Parented.template(VoiceAssistant)
-)
-
-
-def tts_stream_validate(config):
-    if CONF_SPEAKER not in config and (
-        CONF_ON_TTS_STREAM_START in config or CONF_ON_TTS_STREAM_END in config
-    ):
-        raise cv.Invalid(
-            f"{CONF_SPEAKER} is required when using {CONF_ON_TTS_STREAM_START} and/or {CONF_ON_TTS_STREAM_END}"
-        )
-    return config
-
 
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
@@ -109,27 +88,8 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_ON_CLIENT_DISCONNECTED): automation.validate_automation(
                 single=True
             ),
-            cv.Optional(CONF_ON_INTENT_START): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(CONF_ON_INTENT_END): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(CONF_ON_STT_VAD_START): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(CONF_ON_STT_VAD_END): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(CONF_ON_TTS_STREAM_START): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(CONF_ON_TTS_STREAM_END): automation.validate_automation(
-                single=True
-            ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
-    tts_stream_validate,
 )
 
 
@@ -217,48 +177,6 @@ async def to_code(config):
             config[CONF_ON_CLIENT_DISCONNECTED],
         )
 
-    if CONF_ON_INTENT_START in config:
-        await automation.build_automation(
-            var.get_intent_start_trigger(),
-            [],
-            config[CONF_ON_INTENT_START],
-        )
-
-    if CONF_ON_INTENT_END in config:
-        await automation.build_automation(
-            var.get_intent_end_trigger(),
-            [],
-            config[CONF_ON_INTENT_END],
-        )
-
-    if CONF_ON_STT_VAD_START in config:
-        await automation.build_automation(
-            var.get_stt_vad_start_trigger(),
-            [],
-            config[CONF_ON_STT_VAD_START],
-        )
-
-    if CONF_ON_STT_VAD_END in config:
-        await automation.build_automation(
-            var.get_stt_vad_end_trigger(),
-            [],
-            config[CONF_ON_STT_VAD_END],
-        )
-
-    if CONF_ON_TTS_STREAM_START in config:
-        await automation.build_automation(
-            var.get_tts_stream_start_trigger(),
-            [],
-            config[CONF_ON_TTS_STREAM_START],
-        )
-
-    if CONF_ON_TTS_STREAM_END in config:
-        await automation.build_automation(
-            var.get_tts_stream_end_trigger(),
-            [],
-            config[CONF_ON_TTS_STREAM_END],
-        )
-
     cg.add_define("USE_VOICE_ASSISTANT")
 
 
@@ -301,12 +219,3 @@ async def voice_assistant_is_running_to_code(config, condition_id, template_arg,
     var = cg.new_Pvariable(condition_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
     return var
-
-
-@register_condition(
-    "voice_assistant.connected", ConnectedCondition, VOICE_ASSISTANT_ACTION_SCHEMA
-)
-async def voice_assistant_connected_to_code(config, condition_id, template_arg, args):
-    var = cg.new_Pvariable(condition_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var

esphome/components/voice_assistant/voice_assistant.cpp

@@ -31,7 +31,7 @@ void VoiceAssistant::setup() {
 
   this->socket_ = socket::socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
   if (socket_ == nullptr) {
-    ESP_LOGW(TAG, "Could not create socket");
+    ESP_LOGW(TAG, "Could not create socket.");
     this->mark_failed();
     return;
   }
@@ -69,7 +69,7 @@ void VoiceAssistant::setup() {
     ExternalRAMAllocator<uint8_t> speaker_allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
     this->speaker_buffer_ = speaker_allocator.allocate(SPEAKER_BUFFER_SIZE);
     if (this->speaker_buffer_ == nullptr) {
-      ESP_LOGW(TAG, "Could not allocate speaker buffer");
+      ESP_LOGW(TAG, "Could not allocate speaker buffer.");
       this->mark_failed();
       return;
     }
@@ -79,7 +79,7 @@ void VoiceAssistant::setup() {
   ExternalRAMAllocator<int16_t> allocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
   this->input_buffer_ = allocator.allocate(INPUT_BUFFER_SIZE);
   if (this->input_buffer_ == nullptr) {
-    ESP_LOGW(TAG, "Could not allocate input buffer");
+    ESP_LOGW(TAG, "Could not allocate input buffer.");
     this->mark_failed();
     return;
   }
@@ -89,7 +89,7 @@ void VoiceAssistant::setup() {
 
   this->ring_buffer_ = rb_create(BUFFER_SIZE, sizeof(int16_t));
   if (this->ring_buffer_ == nullptr) {
-    ESP_LOGW(TAG, "Could not allocate ring buffer");
+    ESP_LOGW(TAG, "Could not allocate ring buffer.");
     this->mark_failed();
     return;
   }
@@ -98,7 +98,7 @@ void VoiceAssistant::setup() {
   ExternalRAMAllocator<uint8_t> send_allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
   this->send_buffer_ = send_allocator.allocate(SEND_BUFFER_SIZE);
   if (send_buffer_ == nullptr) {
-    ESP_LOGW(TAG, "Could not allocate send buffer");
+    ESP_LOGW(TAG, "Could not allocate send buffer.");
     this->mark_failed();
     return;
   }
@@ -221,8 +221,8 @@ void VoiceAssistant::loop() {
       msg.audio_settings = audio_settings;
 
       if (this->api_client_ == nullptr || !this->api_client_->send_voice_assistant_request(msg)) {
-        ESP_LOGW(TAG, "Could not request start");
-        this->error_trigger_->trigger("not-connected", "Could not request start");
+        ESP_LOGW(TAG, "Could not request start.");
+        this->error_trigger_->trigger("not-connected", "Could not request start.");
         this->continuous_ = false;
         this->set_state_(State::IDLE, State::IDLE);
         break;
@@ -273,27 +273,28 @@ void VoiceAssistant::loop() {
       bool playing = false;
 #ifdef USE_SPEAKER
       if (this->speaker_ != nullptr) {
-        ssize_t received_len = 0;
         if (this->speaker_buffer_index_ + RECEIVE_SIZE < SPEAKER_BUFFER_SIZE) {
-          received_len = this->socket_->read(this->speaker_buffer_ + this->speaker_buffer_index_, RECEIVE_SIZE);
-          if (received_len > 0) {
-            this->speaker_buffer_index_ += received_len;
-            this->speaker_buffer_size_ += received_len;
-            this->speaker_bytes_received_ += received_len;
+          auto len = this->socket_->read(this->speaker_buffer_ + this->speaker_buffer_index_, RECEIVE_SIZE);
+          if (len > 0) {
+            this->speaker_buffer_index_ += len;
+            this->speaker_buffer_size_ += len;
           }
         } else {
-          ESP_LOGD(TAG, "Receive buffer full");
+          ESP_LOGW(TAG, "Receive buffer full.");
+        }
+        if (this->speaker_buffer_size_ > 0) {
+          size_t written = this->speaker_->play(this->speaker_buffer_, this->speaker_buffer_size_);
+          if (written > 0) {
+            memmove(this->speaker_buffer_, this->speaker_buffer_ + written, this->speaker_buffer_size_ - written);
+            this->speaker_buffer_size_ -= written;
+            this->speaker_buffer_index_ -= written;
+            this->set_timeout("speaker-timeout", 2000, [this]() { this->speaker_->stop(); });
+          } else {
+            ESP_LOGW(TAG, "Speaker buffer full.");
+          }
         }
-        // Build a small buffer of audio before sending to the speaker
-        if (this->speaker_bytes_received_ > RECEIVE_SIZE * 4)
-          this->write_speaker_();
         if (this->wait_for_stream_end_) {
           this->cancel_timeout("playing");
-          if (this->stream_ended_ && received_len < 0) {
-            ESP_LOGD(TAG, "End of audio stream received");
-            this->cancel_timeout("speaker-timeout");
-            this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
-          }
           break;  // We dont want to timeout here as the STREAM_END event will take care of that.
         }
         playing = this->speaker_->is_running();
@@ -315,26 +316,14 @@ void VoiceAssistant::loop() {
     case State::RESPONSE_FINISHED: {
 #ifdef USE_SPEAKER
       if (this->speaker_ != nullptr) {
-        if (this->speaker_buffer_size_ > 0) {
-          this->write_speaker_();
-          break;
-        }
-        if (this->speaker_->has_buffered_data() || this->speaker_->is_running()) {
-          break;
-        }
-        ESP_LOGD(TAG, "Speaker has finished outputting all audio");
         this->speaker_->stop();
         this->cancel_timeout("speaker-timeout");
         this->cancel_timeout("playing");
         this->speaker_buffer_size_ = 0;
         this->speaker_buffer_index_ = 0;
-        this->speaker_bytes_received_ = 0;
         memset(this->speaker_buffer_, 0, SPEAKER_BUFFER_SIZE);
-        this->wait_for_stream_end_ = false;
-        this->stream_ended_ = false;
-
-        this->tts_stream_end_trigger_->trigger();
       }
+      this->wait_for_stream_end_ = false;
 #endif
       this->set_state_(State::IDLE, State::IDLE);
       break;
@@ -344,22 +333,6 @@ void VoiceAssistant::loop() {
   }
 }
 
-#ifdef USE_SPEAKER
-void VoiceAssistant::write_speaker_() {
-  if (this->speaker_buffer_size_ > 0) {
-    size_t written = this->speaker_->play(this->speaker_buffer_, this->speaker_buffer_size_);
-    if (written > 0) {
-      memmove(this->speaker_buffer_, this->speaker_buffer_ + written, this->speaker_buffer_size_ - written);
-      this->speaker_buffer_size_ -= written;
-      this->speaker_buffer_index_ -= written;
-      this->set_timeout("speaker-timeout", 5000, [this]() { this->speaker_->stop(); });
-    } else {
-      ESP_LOGD(TAG, "Speaker buffer full, trying again next loop");
-    }
-  }
-}
-#endif
-
 void VoiceAssistant::client_subscription(api::APIConnection *client, bool subscribe) {
   if (!subscribe) {
     if (this->api_client_ == nullptr || client != this->api_client_) {
@@ -530,20 +503,21 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
   switch (msg.event_type) {
     case api::enums::VOICE_ASSISTANT_RUN_START:
       ESP_LOGD(TAG, "Assist Pipeline running");
-      this->defer([this]() { this->start_trigger_->trigger(); });
+      this->start_trigger_->trigger();
       break;
     case api::enums::VOICE_ASSISTANT_WAKE_WORD_START:
       break;
     case api::enums::VOICE_ASSISTANT_WAKE_WORD_END: {
       ESP_LOGD(TAG, "Wake word detected");
-      this->defer([this]() { this->wake_word_detected_trigger_->trigger(); });
+      this->wake_word_detected_trigger_->trigger();
       break;
     }
     case api::enums::VOICE_ASSISTANT_STT_START:
-      ESP_LOGD(TAG, "STT started");
-      this->defer([this]() { this->listening_trigger_->trigger(); });
+      ESP_LOGD(TAG, "STT Started");
+      this->listening_trigger_->trigger();
       break;
     case api::enums::VOICE_ASSISTANT_STT_END: {
+      this->set_state_(State::STOP_MICROPHONE, State::AWAITING_RESPONSE);
       std::string text;
       for (auto arg : msg.data) {
         if (arg.name == "text") {
@@ -551,24 +525,19 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
       }
       if (text.empty()) {
-        ESP_LOGW(TAG, "No text in STT_END event");
+        ESP_LOGW(TAG, "No text in STT_END event.");
         return;
       }
       ESP_LOGD(TAG, "Speech recognised as: \"%s\"", text.c_str());
-      this->defer([this, text]() { this->stt_end_trigger_->trigger(text); });
+      this->stt_end_trigger_->trigger(text);
       break;
     }
-    case api::enums::VOICE_ASSISTANT_INTENT_START:
-      ESP_LOGD(TAG, "Intent started");
-      this->defer([this]() { this->intent_start_trigger_->trigger(); });
-      break;
     case api::enums::VOICE_ASSISTANT_INTENT_END: {
       for (auto arg : msg.data) {
         if (arg.name == "conversation_id") {
           this->conversation_id_ = std::move(arg.value);
         }
       }
-      this->defer([this]() { this->intent_end_trigger_->trigger(); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_TTS_START: {
@@ -579,16 +548,14 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
       }
       if (text.empty()) {
-        ESP_LOGW(TAG, "No text in TTS_START event");
+        ESP_LOGW(TAG, "No text in TTS_START event.");
         return;
       }
       ESP_LOGD(TAG, "Response: \"%s\"", text.c_str());
-      this->defer([this, text]() {
-        this->tts_start_trigger_->trigger(text);
+      this->tts_start_trigger_->trigger(text);
 #ifdef USE_SPEAKER
-        this->speaker_->start();
+      this->speaker_->start();
 #endif
-      });
       break;
     }
     case api::enums::VOICE_ASSISTANT_TTS_END: {
@@ -599,20 +566,18 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
       }
       if (url.empty()) {
-        ESP_LOGW(TAG, "No url in TTS_END event");
+        ESP_LOGW(TAG, "No url in TTS_END event.");
         return;
       }
       ESP_LOGD(TAG, "Response URL: \"%s\"", url.c_str());
-      this->defer([this, url]() {
 #ifdef USE_MEDIA_PLAYER
-        if (this->media_player_ != nullptr) {
-          this->media_player_->make_call().set_media_url(url).perform();
-        }
+      if (this->media_player_ != nullptr) {
+        this->media_player_->make_call().set_media_url(url).perform();
+      }
 #endif
-        this->tts_end_trigger_->trigger(url);
-      });
       State new_state = this->local_output_ ? State::STREAMING_RESPONSE : State::IDLE;
       this->set_state_(new_state, new_state);
+      this->tts_end_trigger_->trigger(url);
       break;
     }
     case api::enums::VOICE_ASSISTANT_RUN_END: {
@@ -629,7 +594,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
           this->set_state_(State::IDLE, State::IDLE);
         }
       }
-      this->defer([this]() { this->end_trigger_->trigger(); });
+      this->end_trigger_->trigger();
       break;
     }
     case api::enums::VOICE_ASSISTANT_ERROR: {
@@ -645,46 +610,25 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       if (code == "wake-word-timeout" || code == "wake_word_detection_aborted") {
         // Don't change state here since either the "tts-end" or "run-end" events will do it.
         return;
-      } else if (code == "wake-provider-missing" || code == "wake-engine-missing") {
-        // Wake word is not set up or not ready on Home Assistant so stop and do not retry until user starts again.
-        this->defer([this, code, message]() {
-          this->request_stop();
-          this->error_trigger_->trigger(code, message);
-        });
-        return;
       }
       ESP_LOGE(TAG, "Error: %s - %s", code.c_str(), message.c_str());
       if (this->state_ != State::IDLE) {
         this->signal_stop_();
         this->set_state_(State::STOP_MICROPHONE, State::IDLE);
       }
-      this->defer([this, code, message]() { this->error_trigger_->trigger(code, message); });
+      this->error_trigger_->trigger(code, message);
       break;
     }
     case api::enums::VOICE_ASSISTANT_TTS_STREAM_START: {
 #ifdef USE_SPEAKER
       this->wait_for_stream_end_ = true;
-      ESP_LOGD(TAG, "TTS stream start");
-      this->defer([this] { this->tts_stream_start_trigger_->trigger(); });
 #endif
       break;
     }
     case api::enums::VOICE_ASSISTANT_TTS_STREAM_END: {
-#ifdef USE_SPEAKER
-      this->stream_ended_ = true;
-      ESP_LOGD(TAG, "TTS stream end");
-#endif
+      this->set_state_(State::RESPONSE_FINISHED, State::IDLE);
       break;
     }
-    case api::enums::VOICE_ASSISTANT_STT_VAD_START:
-      ESP_LOGD(TAG, "Starting STT by VAD");
-      this->defer([this]() { this->stt_vad_start_trigger_->trigger(); });
-      break;
-    case api::enums::VOICE_ASSISTANT_STT_VAD_END:
-      ESP_LOGD(TAG, "STT by VAD end");
-      this->set_state_(State::STOP_MICROPHONE, State::AWAITING_RESPONSE);
-      this->defer([this]() { this->stt_vad_end_trigger_->trigger(); });
-      break;
     default:
       ESP_LOGD(TAG, "Unhandled event type: %d", msg.event_type);
       break;

esphome/components/voice_assistant/voice_assistant.h

@@ -100,21 +100,13 @@ class VoiceAssistant : public Component {
   void set_auto_gain(uint8_t auto_gain) { this->auto_gain_ = auto_gain; }
   void set_volume_multiplier(float volume_multiplier) { this->volume_multiplier_ = volume_multiplier; }
 
-  Trigger<> *get_intent_end_trigger() const { return this->intent_end_trigger_; }
-  Trigger<> *get_intent_start_trigger() const { return this->intent_start_trigger_; }
   Trigger<> *get_listening_trigger() const { return this->listening_trigger_; }
-  Trigger<> *get_end_trigger() const { return this->end_trigger_; }
   Trigger<> *get_start_trigger() const { return this->start_trigger_; }
-  Trigger<> *get_stt_vad_end_trigger() const { return this->stt_vad_end_trigger_; }
-  Trigger<> *get_stt_vad_start_trigger() const { return this->stt_vad_start_trigger_; }
-#ifdef USE_SPEAKER
-  Trigger<> *get_tts_stream_start_trigger() const { return this->tts_stream_start_trigger_; }
-  Trigger<> *get_tts_stream_end_trigger() const { return this->tts_stream_end_trigger_; }
-#endif
   Trigger<> *get_wake_word_detected_trigger() const { return this->wake_word_detected_trigger_; }
   Trigger<std::string> *get_stt_end_trigger() const { return this->stt_end_trigger_; }
-  Trigger<std::string> *get_tts_end_trigger() const { return this->tts_end_trigger_; }
   Trigger<std::string> *get_tts_start_trigger() const { return this->tts_start_trigger_; }
+  Trigger<std::string> *get_tts_end_trigger() const { return this->tts_end_trigger_; }
+  Trigger<> *get_end_trigger() const { return this->end_trigger_; }
   Trigger<std::string, std::string> *get_error_trigger() const { return this->error_trigger_; }
 
   Trigger<> *get_client_connected_trigger() const { return this->client_connected_trigger_; }
@@ -132,21 +124,13 @@ class VoiceAssistant : public Component {
   std::unique_ptr<socket::Socket> socket_ = nullptr;
   struct sockaddr_storage dest_addr_;
 
-  Trigger<> *intent_end_trigger_ = new Trigger<>();
-  Trigger<> *intent_start_trigger_ = new Trigger<>();
   Trigger<> *listening_trigger_ = new Trigger<>();
-  Trigger<> *end_trigger_ = new Trigger<>();
   Trigger<> *start_trigger_ = new Trigger<>();
-  Trigger<> *stt_vad_start_trigger_ = new Trigger<>();
-  Trigger<> *stt_vad_end_trigger_ = new Trigger<>();
-#ifdef USE_SPEAKER
-  Trigger<> *tts_stream_start_trigger_ = new Trigger<>();
-  Trigger<> *tts_stream_end_trigger_ = new Trigger<>();
-#endif
   Trigger<> *wake_word_detected_trigger_ = new Trigger<>();
   Trigger<std::string> *stt_end_trigger_ = new Trigger<std::string>();
-  Trigger<std::string> *tts_end_trigger_ = new Trigger<std::string>();
   Trigger<std::string> *tts_start_trigger_ = new Trigger<std::string>();
+  Trigger<std::string> *tts_end_trigger_ = new Trigger<std::string>();
+  Trigger<> *end_trigger_ = new Trigger<>();
   Trigger<std::string, std::string> *error_trigger_ = new Trigger<std::string, std::string>();
 
   Trigger<> *client_connected_trigger_ = new Trigger<>();
@@ -156,14 +140,11 @@ class VoiceAssistant : public Component {
 
   microphone::Microphone *mic_{nullptr};
 #ifdef USE_SPEAKER
-  void write_speaker_();
   speaker::Speaker *speaker_{nullptr};
   uint8_t *speaker_buffer_;
   size_t speaker_buffer_index_{0};
   size_t speaker_buffer_size_{0};
-  size_t speaker_bytes_received_{0};
   bool wait_for_stream_end_{false};
-  bool stream_ended_{false};
 #endif
 #ifdef USE_MEDIA_PLAYER
   media_player::MediaPlayer *media_player_{nullptr};
@@ -222,11 +203,6 @@ template<typename... Ts> class IsRunningCondition : public Condition<Ts...>, pub
   bool check(Ts... x) override { return this->parent_->is_running() || this->parent_->is_continuous(); }
 };
 
-template<typename... Ts> class ConnectedCondition : public Condition<Ts...>, public Parented<VoiceAssistant> {
- public:
-  bool check(Ts... x) override { return this->parent_->get_api_connection() != nullptr; }
-};
-
 extern VoiceAssistant *global_voice_assistant;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace voice_assistant

esphome/components/wifi/wifi_component.cpp

@@ -389,10 +389,6 @@ void WiFiComponent::print_connect_params_() {
   bssid_t bssid = wifi_bssid();
 
   ESP_LOGCONFIG(TAG, "  Local MAC: %s", get_mac_address_pretty().c_str());
-  if (this->is_disabled()) {
-    ESP_LOGCONFIG(TAG, "  WiFi is disabled!");
-    return;
-  }
   ESP_LOGCONFIG(TAG, "  SSID: " LOG_SECRET("'%s'"), wifi_ssid().c_str());
   ESP_LOGCONFIG(TAG, "  IP Address: %s", wifi_sta_ip().str().c_str());
   ESP_LOGCONFIG(TAG, "  BSSID: " LOG_SECRET("%02X:%02X:%02X:%02X:%02X:%02X"), bssid[0], bssid[1], bssid[2], bssid[3],

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -674,11 +674,6 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
       return;
     }
 
-    if (it.number == 0) {
-      // no results
-      return;
-    }
-
     uint16_t number = it.number;
     std::vector<wifi_ap_record_t> records(number);
     err = esp_wifi_scan_get_ap_records(&number, records.data());

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2023.11.6"
+__version__ = "2023.12.0-dev"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/dashboard/dashboard.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-import asyncio
 import base64
 import binascii
+import codecs
 import collections
 import datetime
 import functools
@@ -339,8 +339,8 @@ class EsphomeCommandWebSocket(tornado.websocket.WebSocketHandler):
     def handle_stdin(self, json_message):
         if not self.is_process_active:
             return
-        text: str = json_message["data"]
-        data = text.encode("utf-8", "replace")
+        data = json_message["data"]
+        data = codecs.encode(data, "utf8", "replace")
         _LOGGER.debug("< stdin: %s", data)
         self._proc.stdin.write(data)
 
@@ -351,18 +351,18 @@ class EsphomeCommandWebSocket(tornado.websocket.WebSocketHandler):
         while True:
             try:
                 if self._use_popen:
-                    data: bytes = yield self._queue.get()
+                    data = yield self._queue.get()
                     if data is None:
                         self._proc_on_exit(self._proc.poll())
                         break
                 else:
-                    data: bytes = yield self._proc.stdout.read_until_regex(reg)
+                    data = yield self._proc.stdout.read_until_regex(reg)
             except tornado.iostream.StreamClosedError:
                 break
+            data = codecs.decode(data, "utf8", "replace")
 
-            text = data.decode("utf-8", "replace")
-            _LOGGER.debug("> stdout: %s", text)
-            self.write_message({"event": "line", "data": text})
+            _LOGGER.debug("> stdout: %s", data)
+            self.write_message({"event": "line", "data": data})
 
     def _stdout_thread(self):
         if not self._use_popen:
@@ -509,8 +509,8 @@ class EsphomeUpdateAllHandler(EsphomeCommandWebSocket):
 
 class SerialPortRequestHandler(BaseHandler):
     @authenticated
-    async def get(self):
-        ports = await asyncio.get_running_loop().run_in_executor(None, get_serial_ports)
+    def get(self):
+        ports = get_serial_ports()
         data = []
         for port in ports:
             desc = port.description
@@ -973,7 +973,6 @@ class MDNSStatusThread(threading.Thread):
         self.host_name_to_filename: dict[str, str] = {}
         # This is a set of host names to track (i.e no_mdns = false)
         self.host_name_with_mdns_enabled: set[set] = set()
-        self.zc: EsphomeZeroconf | None = None
         self._refresh_hosts()
 
     def _refresh_hosts(self):
@@ -997,14 +996,7 @@ class MDNSStatusThread(threading.Thread):
             # If we just adopted/imported this host, we likely
             # already have a state for it, so we should make sure
             # to set it so the dashboard shows it as online
-            if self.zc and (
-                entry.loaded_integrations and "api" not in entry.loaded_integrations
-            ):
-                # No api available so we have to poll since
-                # the device won't respond to a request to ._esphomelib._tcp.local.
-                PING_RESULT[filename] = bool(self.zc.resolve_host(entry.name))
-            elif name in host_mdns_state:
-                # We already have a state for this host
+            if name in host_mdns_state:
                 PING_RESULT[filename] = host_mdns_state[name]
 
             # Make sure the mapping is up to date
@@ -1015,8 +1007,7 @@ class MDNSStatusThread(threading.Thread):
     def run(self):
         global IMPORT_RESULT
 
-        self.zc = EsphomeZeroconf()
-        zc = self.zc
+        zc = EsphomeZeroconf()
         host_mdns_state = self.host_mdns_state
         host_name_to_filename = self.host_name_to_filename
         host_name_with_mdns_enabled = self.host_name_with_mdns_enabled

esphome/external_files.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-import os
-from datetime import datetime
-import requests
-import esphome.config_validation as cv
-from esphome.core import CORE, TimePeriodSeconds
-
-_LOGGER = logging.getLogger(__name__)
-CODEOWNERS = ["@landonr"]
-
-NETWORK_TIMEOUT = 30
-
-IF_MODIFIED_SINCE = "If-Modified-Since"
-CACHE_CONTROL = "Cache-Control"
-CACHE_CONTROL_MAX_AGE = "max-age="
-CONTENT_DISPOSITION = "content-disposition"
-TEMP_DIR = "temp"
-
-
-def has_remote_file_changed(url, local_file_path):
-    if os.path.exists(local_file_path):
-        _LOGGER.debug("has_remote_file_changed: File exists at %s", local_file_path)
-        try:
-            local_modification_time = os.path.getmtime(local_file_path)
-            local_modification_time_str = datetime.utcfromtimestamp(
-                local_modification_time
-            ).strftime("%a, %d %b %Y %H:%M:%S GMT")
-
-            headers = {
-                IF_MODIFIED_SINCE: local_modification_time_str,
-                CACHE_CONTROL: CACHE_CONTROL_MAX_AGE + "3600",
-            }
-            response = requests.head(url, headers=headers, timeout=NETWORK_TIMEOUT)
-
-            _LOGGER.debug(
-                "has_remote_file_changed: File %s, Local modified %s, response code %d",
-                local_file_path,
-                local_modification_time_str,
-                response.status_code,
-            )
-
-            if response.status_code == 304:
-                _LOGGER.debug(
-                    "has_remote_file_changed: File not modified since %s",
-                    local_modification_time_str,
-                )
-                return False
-            _LOGGER.debug("has_remote_file_changed: File modified")
-            return True
-        except requests.exceptions.RequestException as e:
-            raise cv.Invalid(
-                f"Could not check if {url} has changed, please check if file exists "
-                f"({e})"
-            )
-
-    _LOGGER.debug("has_remote_file_changed: File doesn't exists at %s", local_file_path)
-    return True
-
-
-def is_file_recent(file_path: str, refresh: TimePeriodSeconds) -> bool:
-    if os.path.exists(file_path):
-        creation_time = os.path.getctime(file_path)
-        current_time = datetime.now().timestamp()
-        return current_time - creation_time <= refresh.total_seconds
-    return False
-
-
-def compute_local_file_dir(domain: str) -> Path:
-    base_directory = Path(CORE.data_dir) / domain
-    base_directory.mkdir(parents=True, exist_ok=True)
-
-    return base_directory

esphome/zeroconf.py

@@ -147,17 +147,12 @@ class DashboardImportDiscovery:
 
 
 class EsphomeZeroconf(Zeroconf):
-    def resolve_host(self, host: str, timeout: float = 3.0) -> str | None:
+    def resolve_host(self, host: str, timeout=3.0):
         """Resolve a host name to an IP address."""
         name = host.partition(".")[0]
-        info = HostResolver(
-            ESPHOME_SERVICE_TYPE,
-            f"{name}.{ESPHOME_SERVICE_TYPE}",
-            server=f"{name}.local.",
-        )
-        if (
-            info.load_from_cache(self)
-            or (timeout and info.request(self, timeout * 1000))
-        ) and (addresses := info.ip_addresses_by_version(IPVersion.V4Only)):
+        info = HostResolver(f"{name}.{ESPHOME_SERVICE_TYPE}", ESPHOME_SERVICE_TYPE)
+        if (info.load_from_cache(self) or info.request(self, timeout * 1000)) and (
+            addresses := info.ip_addresses_by_version(IPVersion.V4Only)
+        ):
             return str(addresses[0])
         return None

requirements.txt

@@ -10,9 +10,8 @@ platformio==6.1.11  # When updating platformio, also update Dockerfile
 esptool==4.6.2
 click==8.1.7
 esphome-dashboard==20231107.0
-aioesphomeapi==18.5.2
-zeroconf==0.123.0
-python-magic==0.4.27
+aioesphomeapi==18.2.7
+zeroconf==0.122.3
 
 # esp-idf requires this, but doesn't bundle it by default
 # https://github.com/espressif/esp-idf/blob/220590d599e134d7a5e7f1e683cc4550349ffbf8/requirements.txt#L24

tests/test2.yaml

@@ -752,18 +752,6 @@ image:
     file: pnglogo.png
     type: RGB565
     use_transparency: no
-  - id: web_svg_image
-    file: https://raw.githubusercontent.com/esphome/esphome-docs/a62d7ab193c1a464ed791670170c7d518189109b/images/logo.svg
-    resize: 256x48
-    type: TRANSPARENT_BINARY
-  - id: web_tiff_image
-    file: https://upload.wikimedia.org/wikipedia/commons/b/b6/SIPI_Jelly_Beans_4.1.07.tiff
-    type: RGB24
-    resize: 48x48
-  - id: web_redirect_image
-    file: https://avatars.githubusercontent.com/u/3060199?s=48&v=4
-    type: RGB24
-    resize: 48x48
 
   - id: mdi_alert
     file: mdi:alert-circle-outline