github/esphome
2
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2026-09-11 15:27:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy

Browse Source
This commit is contained in:
kbx81
2026-09-03 19:49:55 -05:00
parent feeacda4ba ab800dc09d
commit bd94a6858f
53 changed files with 1966 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/ci.yml
+13 -2
View File
@@ -374,8 +374,9 @@ jobs:
- name: Install apt packages (cached)
# ccache speeds up the host compiles. A cache hit never touches apt
# (mirror outages cannot hang the job); the timeout bounds the cold
# path. Packages and version must match seed-apt-cache exactly;
# libsdl2-dev is unused here and carried only for cache-key parity.
# path. Packages and version must match seed-apt-cache exactly.
# libsdl2-dev is needed by the headless display tests, which capture
# screenshots.
timeout-minutes: 10
uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
with:
@@ -438,6 +439,16 @@ jobs:
echo "Bucket ${{ matrix.bucket.name }}: running ${#test_files[@]} integration tests"
pytest -vv --no-cov --tb=native --durations=30 -n auto --dist worksteal \
--junitxml=junit-integration.xml "${test_files[@]}"
- name: Upload test artifacts
# Tests that compare rendered output write the image they actually got here, so a
# failure can be looked at without reproducing the whole build locally.
if: failure()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
with:
name: integration-test-artifacts-${{ matrix.bucket.name }}
path: test_artifacts/
if-no-files-found: ignore
retention-days: 7
- name: Upload junit timings
# Consumed by sync-integration-durations.yml through
# script/update_integration_test_durations.py; only full matrix dev
.gitignore
+2
View File
@@ -137,6 +137,8 @@ config/
!tests/component_tests/**/config/
tests/build/
tests/.esphome/
# Output kept by failing tests for inspection; uploaded by CI
test_artifacts/
/.temp-clang-tidy.cpp
/.temp/
.pio/
CODEOWNERS
+1
View File
@@ -496,6 +496,7 @@ esphome/components/sm2335/* @Cossid
esphome/components/sml/* @alengwenus
esphome/components/smt100/* @piechade
esphome/components/sn74hc165/* @jesserockz
esphome/components/snapshot/* @clydebarrow
esphome/components/socket/* @esphome/core
esphome/components/sonoff_d1/* @anatoly-savchenkov
esphome/components/sound_level/* @kahrendt
Doxyfile
+1 -1
View File
@@ -48,7 +48,7 @@ PROJECT_NAME = ESPHome
# could be handy for archiving the generated documentation or if some version
# control system is used.
PROJECT_NUMBER = 2026.9.0-dev
PROJECT_NUMBER = 2026.10.0-dev
# Using the PROJECT_BRIEF tag one can provide an optional one line description
# for a project that appears at the top of each page and should give viewer a
docker/Dockerfile
+1 -1
View File
@@ -22,7 +22,7 @@ RUN \
-r /requirements.txt
# Install the ESPHome Device Builder dashboard.
RUN uv pip install --no-cache-dir esphome-device-builder==1.13.1
RUN uv pip install --no-cache-dir esphome-device-builder==1.14.0
RUN \
platformio settings set enable_telemetry No \
esphome/arduino8266/framework.py
+4 -9
View File
@@ -44,8 +44,7 @@ def get_arduino8266_tools_path() -> Path:
return tools_cache_path(*ARDUINO8266_TOOLS_CACHE)
# 3.1.1 rather than 3.1.0: the registry has no package for 3.1.0, and the
# encoder below cannot name 3.0.0/3.0.1 either (see its docstring)
# 3.1.1 rather than 3.1.0: the registry has no packages for 3.0.0, 3.0.1 or 3.1.0
MIN_FRAMEWORK_VERSION = Version(3, 1, 1)
@@ -53,20 +52,16 @@ def framework_package_version(ver: Version) -> str:
"""Map an Arduino core version to its registry package version (3.1.2 ->
3.30102.0; the leading 3 is the package major).
Exact registry names only for cores > 2.6.2 and >= 3.0.2; callers floor
at MIN_FRAMEWORK_VERSION.
Exact registry names for 3.x cores; callers floor at MIN_FRAMEWORK_VERSION.
"""
if ver.major > 3:
raise EsphomeError(
f"Arduino core {ver} is not supported yet; "
"the newest known core series is 3.x"
)
if ver <= Version(2, 6, 2):
# Cores <= 2.6.2 use the older 1.x/2.x package-major encodings (same
# boundary as _format_framework_arduino_version's era guard)
if ver.major < 3:
raise EsphomeError(
f"Arduino core {ver} uses an older package encoding than this "
"helper implements (newer than 2.6.2)"
f"Arduino core {ver} is not supported; ESPHome requires core 3.x"
)
return f"3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
esphome/components/climate/climate.cpp
+2 -2
View File
@@ -368,8 +368,8 @@ optional<ClimateDeviceRestoreState> Climate::restore_state_() {
}
void Climate::save_state_(const ClimateTraits &traits) {
#if (defined(USE_ESP32) || (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0))) && \
!defined(CLANG_TIDY)
#if (defined(USE_ESP32) || defined(USE_ESP8266)) && !defined(CLANG_TIDY)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#define TEMP_IGNORE_MEMACCESS
#endif
esphome/components/debug/debug_component.cpp
+2 -2
View File
@@ -22,9 +22,9 @@ void DebugComponent::dump_config() {
LOG_SENSOR(" ", "Free space on heap", this->free_sensor_);
LOG_SENSOR(" ", "Largest free heap block", this->block_sensor_);
LOG_SENSOR(" ", "CPU frequency", this->cpu_frequency_sensor_);
#if defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
#ifdef USE_ESP8266
LOG_SENSOR(" ", "Heap fragmentation", this->fragmentation_sensor_);
#endif // defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
#endif // USE_ESP8266
#endif // USE_SENSOR
char device_info_buffer[DEVICE_INFO_BUFFER_SIZE];
esphome/components/debug/debug_component.h
+2 -2
View File
@@ -35,7 +35,7 @@ class DebugComponent final : public PollingComponent {
#ifdef USE_SENSOR
void set_free_sensor(sensor::Sensor *free_sensor) { free_sensor_ = free_sensor; }
void set_block_sensor(sensor::Sensor *block_sensor) { block_sensor_ = block_sensor; }
#if (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)) || defined(USE_ESP32)
#if defined(USE_ESP8266) || defined(USE_ESP32)
void set_fragmentation_sensor(sensor::Sensor *fragmentation_sensor) { fragmentation_sensor_ = fragmentation_sensor; }
#endif
#if defined(USE_ESP32) || defined(USE_LIBRETINY)
@@ -61,7 +61,7 @@ class DebugComponent final : public PollingComponent {
sensor::Sensor *free_sensor_{nullptr};
sensor::Sensor *block_sensor_{nullptr};
#if (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)) || defined(USE_ESP32)
#if defined(USE_ESP8266) || defined(USE_ESP32)
sensor::Sensor *fragmentation_sensor_{nullptr};
#endif
#if defined(USE_ESP32) || defined(USE_LIBRETINY)
esphome/components/debug/debug_esp8266.cpp
-2
View File
@@ -159,12 +159,10 @@ void DebugComponent::update_platform_() {
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
this->block_sensor_->publish_state(ESP.getMaxFreeBlockSize());
}
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
if (this->fragmentation_sensor_ != nullptr) {
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
this->fragmentation_sensor_->publish_state(ESP.getHeapFragmentation());
}
#endif
#endif
}
esphome/components/debug/sensor.py
+2 -5
View File
@@ -52,12 +52,9 @@ CONFIG_SCHEMA = {
),
cv.Optional(CONF_FRAGMENTATION): cv.All(
cv.Any(
cv.All(
cv.only_on_esp8266,
cv.require_framework_version(esp8266_arduino=cv.Version(2, 5, 2)),
),
cv.only_on_esp8266,
cv.only_on_esp32,
msg="This feature is only available on ESP8266 (Arduino 2.5.2+) and ESP32",
msg="This feature is only available on ESP8266 and ESP32",
),
sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
esphome/components/esp8266/__init__.py
+17 -40
View File
@@ -35,7 +35,7 @@ from esphome.platformio.toolchain import copy_ccache_script
from esphome.storage_json import StorageJSON
from esphome.types import ConfigType
from .boards import BOARDS, ESP8266_LD_SCRIPTS, board_ld_script
from .boards import BOARDS, board_ld_script
from .const import (
CONF_EARLY_PIN_INIT,
CONF_ENABLE_SERIAL,
@@ -43,8 +43,6 @@ from .const import (
CONF_RESTORE_FROM_FLASH,
KEY_BOARD,
KEY_ESP8266,
KEY_FLASH_SIZE,
KEY_LDSCRIPT,
KEY_PIN_INITIAL_STATES,
KEY_SERIAL1_REQUIRED,
KEY_SERIAL_REQUIRED,
@@ -133,10 +131,6 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
# format the given arduino (https://github.com/esp8266/Arduino/releases) version to
# a PIO platformio/framework-arduinoespressif8266 value
# List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif8266
if ver <= cv.Version(2, 4, 1):
return f"~1.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
if ver <= cv.Version(2, 6, 2):
return f"~2.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
# Same encoding the native toolchain uses for its package download, so a
# version bump cannot drift between the two paths.
from esphome.arduino8266.framework import framework_package_version
@@ -159,11 +153,9 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
# - https://github.com/esp8266/Arduino/releases
# - https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif8266
RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(3, 1, 2)
# The platformio/espressif8266 version to use for arduino 2 framework versions
# The platformio/espressif8266 version to use for arduino 3 framework versions
# - https://github.com/platformio/platform-espressif8266/releases
# - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif8266
ARDUINO_2_PLATFORM_VERSION = cv.Version(2, 6, 3)
# for arduino 3 framework versions
ARDUINO_3_PLATFORM_VERSION = cv.Version(3, 2, 0)
# for arduino 4 framework versions
ARDUINO_4_PLATFORM_VERSION = cv.Version(4, 2, 1)
@@ -188,6 +180,14 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
source = value.get(CONF_SOURCE, None)
if version < cv.Version(3, 0, 0):
raise cv.Invalid(
f"Arduino framework {version} is no longer supported; ESPHome requires "
f"C++20, which needs Arduino core 3.x. Use the recommended version "
f"({RECOMMENDED_ARDUINO_FRAMEWORK_VERSION}).",
path=[CONF_VERSION],
)
value[CONF_VERSION] = str(version)
value[CONF_SOURCE] = source or _format_framework_arduino_version(version)
@@ -195,12 +195,8 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
if platform_version is None:
if version >= cv.Version(3, 1, 0):
platform_version = _parse_platform_version(str(ARDUINO_4_PLATFORM_VERSION))
elif version >= cv.Version(3, 0, 0):
platform_version = _parse_platform_version(str(ARDUINO_3_PLATFORM_VERSION))
elif version >= cv.Version(2, 5, 0):
platform_version = _parse_platform_version(str(ARDUINO_2_PLATFORM_VERSION))
else:
platform_version = _parse_platform_version(str(cv.Version(1, 8, 0)))
platform_version = _parse_platform_version(str(ARDUINO_3_PLATFORM_VERSION))
value[CONF_PLATFORM_VERSION] = platform_version
if version != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
@@ -289,29 +285,11 @@ def check_rosetta() -> None:
)
def _choose_ld_script(board: str, ver: cv.Version) -> str | None:
"""The flash ld to pin for this board and core, or None for cores
without ld-script support."""
board_data = BOARDS[board]
ld_scripts = ESP8266_LD_SCRIPTS[board_data[KEY_FLASH_SIZE]]
if ver <= cv.Version(2, 3, 0):
# No ld script support
return None
if ver <= cv.Version(2, 4, 2):
# Old ld script path; the modern per-board override names do not
# exist in this core's SDK, so the override cannot be honored.
# Substituting the size default would move _FS_end and the
# preferences sector, wiping flash-backed state on flash.
if KEY_LDSCRIPT in board_data:
raise EsphomeError(
f"Board {board} requires its {board_data[KEY_LDSCRIPT]} "
f"flash layout, which Arduino core {ver} cannot honor; "
"use a core newer than 2.4.2"
)
return ld_scripts[0]
def _choose_ld_script(board: str) -> str:
"""The flash ld to pin for this board."""
# A per-board override preserves a layout the board shipped with
# (see d1_wroom_02 in boards.py)
return board_ld_script(board_data)
return board_ld_script(BOARDS[board])
@coroutine_with_priority(CoroPriority.PLATFORM)
@@ -435,10 +413,9 @@ async def to_code(config: ConfigType) -> None:
)
if config[CONF_BOARD] in BOARDS:
ld_script = _choose_ld_script(config[CONF_BOARD], ver)
if ld_script is not None:
cg.add_platformio_option("board_build.ldscript", ld_script)
cg.add_platformio_option(
"board_build.ldscript", _choose_ld_script(config[CONF_BOARD])
)
CORE.add_job(add_pin_initial_states_array)
CORE.add_job(finalize_waveform_config)
esphome/components/nextion/nextion_upload_arduino.cpp
-6
View File
@@ -209,14 +209,8 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
http_client.setTimeout(this->tft_upload_http_timeout_);
bool begin_status = false;
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 7, 0)
http_client.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
#elif USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
http_client.setFollowRedirects(true);
#endif
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
http_client.setRedirectLimit(3);
#endif
begin_status = http_client.begin(*this->get_wifi_client_(), this->tft_url_.c_str());
if (!begin_status) {
this->connection_state_.is_updating_ = false;
esphome/components/remote_transmitter/__init__.py
+5 -9
View File
@@ -4,11 +4,7 @@ from esphome import automation, pins
import esphome.codegen as cg
from esphome.components import esp32, esp32_rmt, remote_base
from esphome.components.libretiny import get_libretiny_family
from esphome.components.libretiny.const import (
FAMILY_BK7231N,
FAMILY_BK7238,
FAMILY_RTL8720C,
)
from esphome.components.libretiny.const import FAMILY_BK7238, FAMILY_RTL8720C
from esphome.config_helpers import filter_source_files_from_platform
import esphome.config_validation as cv
from esphome.const import (
@@ -49,7 +45,9 @@ DigitalWriteAction = remote_transmitter_ns.class_(
)
_NON_BLOCKING_LIBRETINY_FAMILIES = (FAMILY_RTL8720C, FAMILY_BK7231N, FAMILY_BK7238)
# Keep in sync with the USE_LIBRETINY_VARIANT_RTL8720C / REMOTE_TRANSMITTER_BK_PWM gates in
# remote_transmitter.h, which decide where set_non_blocking() is declared
_NON_BLOCKING_LIBRETINY_FAMILIES = (FAMILY_RTL8720C, FAMILY_BK7238)
def _validate_non_blocking_platform(value: bool) -> bool:
@@ -59,9 +57,7 @@ def _validate_non_blocking_platform(value: bool) -> bool:
return cv.boolean(value)
if CORE.is_libretiny and get_libretiny_family() in _NON_BLOCKING_LIBRETINY_FAMILIES:
return cv.boolean(value)
raise cv.Invalid(
"non_blocking is only supported on ESP32, RTL8720C, BK7231N and BK7238"
)
raise cv.Invalid("non_blocking is only supported on ESP32, RTL8720C and BK7238")
MULTI_CONF = True
esphome/components/remote_transmitter/remote_transmitter.h
+5 -4
View File
@@ -12,10 +12,11 @@
#endif // SOC_RMT_SUPPORTED
#endif // USE_ESP32
// The BK7231N-style PWM block (hardware shadow-load duty updates) enables the ISR-driven
// transmitter on these families; family-level proxy for the SDK's CFG_SOC_NAME gate.
// See remote_transmitter_bk72xx.cpp.
#if defined(USE_LIBRETINY_VARIANT_BK7231N) || defined(USE_LIBRETINY_VARIANT_BK7238)
// Enables the ISR-driven transmitter on Beken. Gated on BK7238 alone: the shadow-load PWM
// block is shared with BK7231N, but LibreTiny builds that family against an older BDK whose
// PWM driver has no pwm_init_param()/pwm_start(). See remote_transmitter_bk72xx.cpp.
// Keep in sync with _NON_BLOCKING_LIBRETINY_FAMILIES in __init__.py.
#ifdef USE_LIBRETINY_VARIANT_BK7238
#define REMOTE_TRANSMITTER_BK_PWM
#endif
esphome/components/remote_transmitter/remote_transmitter_bk72xx.cpp
+7 -4
View File
@@ -9,10 +9,13 @@
// with the core's fixes for type-name collisions between the two
#include <ArduinoPrivate.h>
// Only the BK7231N-style PWM block (shadow registers with a hardware CFG_UPDATA load bit)
// supports glitch-free per-edge duty updates; older SoCs compile the generic bit-bang
// implementation (remote_transmitter.cpp) instead, and this file compiles to nothing.
// REMOTE_TRANSMITTER_BK_PWM is set per-family in remote_transmitter.h.
// Needs the BK7231N-style PWM block (shadow registers with a hardware CFG_UPDATA load bit)
// for glitch-free per-edge duty updates, and an SDK exposing pwm_init_param()/pwm_start().
// BK7231N has the block but LibreTiny builds it against an older BDK offering only the
// sddev_control API (CMD_PWM_INIT_PARAM), so it stays on the generic bit-bang path until
// someone can add and validate that path on real hardware. Every other Beken SoC lacks the
// block. REMOTE_TRANSMITTER_BK_PWM is set per-family in remote_transmitter.h; when it is
// unset this file compiles to nothing and remote_transmitter.cpp is used instead.
namespace esphome::remote_transmitter {
esphome/components/remote_transmitter/remote_transmitter_libretiny_isr.cpp
+5 -5
View File
@@ -3,11 +3,11 @@
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
// Envelope chain shared by the LibreTiny families that pace transmission from a hardware
// timer interrupt: RTL8720C (gtimer) and the BK7231N-style PWM block (BKTIMER1). Everything
// platform-specific sits behind five hooks implemented in the per-family files -- carrier
// setup, duty writes, one-shot arming and timer stop. Families without a usable timer keep
// the generic bit-bang implementation and compile none of this.
// Envelope chain shared by the LibreTiny families that pace transmission from a hardware timer
// interrupt: RTL8720C (gtimer) and BK7238 (BKTIMER1). Everything platform-specific sits behind
// five hooks implemented in the per-family files -- carrier setup, duty writes, one-shot arming
// and timer stop. Families without a usable timer keep the generic bit-bang implementation and
// compile none of this.
#if defined(USE_LIBRETINY_VARIANT_RTL8720C) || defined(REMOTE_TRANSMITTER_BK_PWM)
namespace esphome::remote_transmitter {
esphome/components/sdl/__init__.py
+253
View File
@@ -1 +1,254 @@
import esphome.codegen as cg
CODEOWNERS = ["@clydebarrow"]
SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
SDL_KEYS = (
"SDLK_UNKNOWN",
"SDLK_RETURN",
"SDLK_ESCAPE",
"SDLK_BACKSPACE",
"SDLK_TAB",
"SDLK_SPACE",
"SDLK_EXCLAIM",
"SDLK_QUOTEDBL",
"SDLK_HASH",
"SDLK_PERCENT",
"SDLK_DOLLAR",
"SDLK_AMPERSAND",
"SDLK_QUOTE",
"SDLK_LEFTPAREN",
"SDLK_RIGHTPAREN",
"SDLK_ASTERISK",
"SDLK_PLUS",
"SDLK_COMMA",
"SDLK_MINUS",
"SDLK_PERIOD",
"SDLK_SLASH",
"SDLK_0",
"SDLK_1",
"SDLK_2",
"SDLK_3",
"SDLK_4",
"SDLK_5",
"SDLK_6",
"SDLK_7",
"SDLK_8",
"SDLK_9",
"SDLK_COLON",
"SDLK_SEMICOLON",
"SDLK_LESS",
"SDLK_EQUALS",
"SDLK_GREATER",
"SDLK_QUESTION",
"SDLK_AT",
"SDLK_LEFTBRACKET",
"SDLK_BACKSLASH",
"SDLK_RIGHTBRACKET",
"SDLK_CARET",
"SDLK_UNDERSCORE",
"SDLK_BACKQUOTE",
"SDLK_a",
"SDLK_b",
"SDLK_c",
"SDLK_d",
"SDLK_e",
"SDLK_f",
"SDLK_g",
"SDLK_h",
"SDLK_i",
"SDLK_j",
"SDLK_k",
"SDLK_l",
"SDLK_m",
"SDLK_n",
"SDLK_o",
"SDLK_p",
"SDLK_q",
"SDLK_r",
"SDLK_s",
"SDLK_t",
"SDLK_u",
"SDLK_v",
"SDLK_w",
"SDLK_x",
"SDLK_y",
"SDLK_z",
"SDLK_CAPSLOCK",
"SDLK_F1",
"SDLK_F2",
"SDLK_F3",
"SDLK_F4",
"SDLK_F5",
"SDLK_F6",
"SDLK_F7",
"SDLK_F8",
"SDLK_F9",
"SDLK_F10",
"SDLK_F11",
"SDLK_F12",
"SDLK_PRINTSCREEN",
"SDLK_SCROLLLOCK",
"SDLK_PAUSE",
"SDLK_INSERT",
"SDLK_HOME",
"SDLK_PAGEUP",
"SDLK_DELETE",
"SDLK_END",
"SDLK_PAGEDOWN",
"SDLK_RIGHT",
"SDLK_LEFT",
"SDLK_DOWN",
"SDLK_UP",
"SDLK_NUMLOCKCLEAR",
"SDLK_KP_DIVIDE",
"SDLK_KP_MULTIPLY",
"SDLK_KP_MINUS",
"SDLK_KP_PLUS",
"SDLK_KP_ENTER",
"SDLK_KP_1",
"SDLK_KP_2",
"SDLK_KP_3",
"SDLK_KP_4",
"SDLK_KP_5",
"SDLK_KP_6",
"SDLK_KP_7",
"SDLK_KP_8",
"SDLK_KP_9",
"SDLK_KP_0",
"SDLK_KP_PERIOD",
"SDLK_APPLICATION",
"SDLK_POWER",
"SDLK_KP_EQUALS",
"SDLK_F13",
"SDLK_F14",
"SDLK_F15",
"SDLK_F16",
"SDLK_F17",
"SDLK_F18",
"SDLK_F19",
"SDLK_F20",
"SDLK_F21",
"SDLK_F22",
"SDLK_F23",
"SDLK_F24",
"SDLK_EXECUTE",
"SDLK_HELP",
"SDLK_MENU",
"SDLK_SELECT",
"SDLK_STOP",
"SDLK_AGAIN",
"SDLK_UNDO",
"SDLK_CUT",
"SDLK_COPY",
"SDLK_PASTE",
"SDLK_FIND",
"SDLK_MUTE",
"SDLK_VOLUMEUP",
"SDLK_VOLUMEDOWN",
"SDLK_KP_COMMA",
"SDLK_KP_EQUALSAS400",
"SDLK_ALTERASE",
"SDLK_SYSREQ",
"SDLK_CANCEL",
"SDLK_CLEAR",
"SDLK_PRIOR",
"SDLK_RETURN2",
"SDLK_SEPARATOR",
"SDLK_OUT",
"SDLK_OPER",
"SDLK_CLEARAGAIN",
"SDLK_CRSEL",
"SDLK_EXSEL",
"SDLK_KP_00",
"SDLK_KP_000",
"SDLK_THOUSANDSSEPARATOR",
"SDLK_DECIMALSEPARATOR",
"SDLK_CURRENCYUNIT",
"SDLK_CURRENCYSUBUNIT",
"SDLK_KP_LEFTPAREN",
"SDLK_KP_RIGHTPAREN",
"SDLK_KP_LEFTBRACE",
"SDLK_KP_RIGHTBRACE",
"SDLK_KP_TAB",
"SDLK_KP_BACKSPACE",
"SDLK_KP_A",
"SDLK_KP_B",
"SDLK_KP_C",
"SDLK_KP_D",
"SDLK_KP_E",
"SDLK_KP_F",
"SDLK_KP_XOR",
"SDLK_KP_POWER",
"SDLK_KP_PERCENT",
"SDLK_KP_LESS",
"SDLK_KP_GREATER",
"SDLK_KP_AMPERSAND",
"SDLK_KP_DBLAMPERSAND",
"SDLK_KP_VERTICALBAR",
"SDLK_KP_DBLVERTICALBAR",
"SDLK_KP_COLON",
"SDLK_KP_HASH",
"SDLK_KP_SPACE",
"SDLK_KP_AT",
"SDLK_KP_EXCLAM",
"SDLK_KP_MEMSTORE",
"SDLK_KP_MEMRECALL",
"SDLK_KP_MEMCLEAR",
"SDLK_KP_MEMADD",
"SDLK_KP_MEMSUBTRACT",
"SDLK_KP_MEMMULTIPLY",
"SDLK_KP_MEMDIVIDE",
"SDLK_KP_PLUSMINUS",
"SDLK_KP_CLEAR",
"SDLK_KP_CLEARENTRY",
"SDLK_KP_BINARY",
"SDLK_KP_OCTAL",
"SDLK_KP_DECIMAL",
"SDLK_KP_HEXADECIMAL",
"SDLK_LCTRL",
"SDLK_LSHIFT",
"SDLK_LALT",
"SDLK_LGUI",
"SDLK_RCTRL",
"SDLK_RSHIFT",
"SDLK_RALT",
"SDLK_RGUI",
"SDLK_MODE",
"SDLK_AUDIONEXT",
"SDLK_AUDIOPREV",
"SDLK_AUDIOSTOP",
"SDLK_AUDIOPLAY",
"SDLK_AUDIOMUTE",
"SDLK_MEDIASELECT",
"SDLK_WWW",
"SDLK_MAIL",
"SDLK_CALCULATOR",
"SDLK_COMPUTER",
"SDLK_AC_SEARCH",
"SDLK_AC_HOME",
"SDLK_AC_BACK",
"SDLK_AC_FORWARD",
"SDLK_AC_STOP",
"SDLK_AC_REFRESH",
"SDLK_AC_BOOKMARKS",
"SDLK_BRIGHTNESSDOWN",
"SDLK_BRIGHTNESSUP",
"SDLK_DISPLAYSWITCH",
"SDLK_KBDILLUMTOGGLE",
"SDLK_KBDILLUMDOWN",
"SDLK_KBDILLUMUP",
"SDLK_EJECT",
"SDLK_SLEEP",
"SDLK_APP1",
"SDLK_APP2",
"SDLK_AUDIOREWIND",
"SDLK_AUDIOFASTFORWARD",
"SDLK_SOFTLEFT",
"SDLK_SOFTRIGHT",
"SDLK_CALL",
"SDLK_ENDCALL",
)
SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}
esphome/components/sdl/binary_sensor.py
+3 -250
View File
@@ -7,262 +7,15 @@ from esphome.core import Lambda
from esphome.cpp_generator import ExpressionStatement, RawExpression
from esphome.types import ConfigType
from .display import CONF_SDL_ID, Sdl
from . import SDL_KEYMAP
from .display import CONF_SDL_ID, Sdl, headless_final_validate
CODEOWNERS = ["@bdm310"]
STATE_ARG = "state"
SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
FINAL_VALIDATE_SCHEMA = headless_final_validate("binary_sensor")
SDL_KEYS = (
"SDLK_UNKNOWN",
"SDLK_RETURN",
"SDLK_ESCAPE",
"SDLK_BACKSPACE",
"SDLK_TAB",
"SDLK_SPACE",
"SDLK_EXCLAIM",
"SDLK_QUOTEDBL",
"SDLK_HASH",
"SDLK_PERCENT",
"SDLK_DOLLAR",
"SDLK_AMPERSAND",
"SDLK_QUOTE",
"SDLK_LEFTPAREN",
"SDLK_RIGHTPAREN",
"SDLK_ASTERISK",
"SDLK_PLUS",
"SDLK_COMMA",
"SDLK_MINUS",
"SDLK_PERIOD",
"SDLK_SLASH",
"SDLK_0",
"SDLK_1",
"SDLK_2",
"SDLK_3",
"SDLK_4",
"SDLK_5",
"SDLK_6",
"SDLK_7",
"SDLK_8",
"SDLK_9",
"SDLK_COLON",
"SDLK_SEMICOLON",
"SDLK_LESS",
"SDLK_EQUALS",
"SDLK_GREATER",
"SDLK_QUESTION",
"SDLK_AT",
"SDLK_LEFTBRACKET",
"SDLK_BACKSLASH",
"SDLK_RIGHTBRACKET",
"SDLK_CARET",
"SDLK_UNDERSCORE",
"SDLK_BACKQUOTE",
"SDLK_a",
"SDLK_b",
"SDLK_c",
"SDLK_d",
"SDLK_e",
"SDLK_f",
"SDLK_g",
"SDLK_h",
"SDLK_i",
"SDLK_j",
"SDLK_k",
"SDLK_l",
"SDLK_m",
"SDLK_n",
"SDLK_o",
"SDLK_p",
"SDLK_q",
"SDLK_r",
"SDLK_s",
"SDLK_t",
"SDLK_u",
"SDLK_v",
"SDLK_w",
"SDLK_x",
"SDLK_y",
"SDLK_z",
"SDLK_CAPSLOCK",
"SDLK_F1",
"SDLK_F2",
"SDLK_F3",
"SDLK_F4",
"SDLK_F5",
"SDLK_F6",
"SDLK_F7",
"SDLK_F8",
"SDLK_F9",
"SDLK_F10",
"SDLK_F11",
"SDLK_F12",
"SDLK_PRINTSCREEN",
"SDLK_SCROLLLOCK",
"SDLK_PAUSE",
"SDLK_INSERT",
"SDLK_HOME",
"SDLK_PAGEUP",
"SDLK_DELETE",
"SDLK_END",
"SDLK_PAGEDOWN",
"SDLK_RIGHT",
"SDLK_LEFT",
"SDLK_DOWN",
"SDLK_UP",
"SDLK_NUMLOCKCLEAR",
"SDLK_KP_DIVIDE",
"SDLK_KP_MULTIPLY",
"SDLK_KP_MINUS",
"SDLK_KP_PLUS",
"SDLK_KP_ENTER",
"SDLK_KP_1",
"SDLK_KP_2",
"SDLK_KP_3",
"SDLK_KP_4",
"SDLK_KP_5",
"SDLK_KP_6",
"SDLK_KP_7",
"SDLK_KP_8",
"SDLK_KP_9",
"SDLK_KP_0",
"SDLK_KP_PERIOD",
"SDLK_APPLICATION",
"SDLK_POWER",
"SDLK_KP_EQUALS",
"SDLK_F13",
"SDLK_F14",
"SDLK_F15",
"SDLK_F16",
"SDLK_F17",
"SDLK_F18",
"SDLK_F19",
"SDLK_F20",
"SDLK_F21",
"SDLK_F22",
"SDLK_F23",
"SDLK_F24",
"SDLK_EXECUTE",
"SDLK_HELP",
"SDLK_MENU",
"SDLK_SELECT",
"SDLK_STOP",
"SDLK_AGAIN",
"SDLK_UNDO",
"SDLK_CUT",
"SDLK_COPY",
"SDLK_PASTE",
"SDLK_FIND",
"SDLK_MUTE",
"SDLK_VOLUMEUP",
"SDLK_VOLUMEDOWN",
"SDLK_KP_COMMA",
"SDLK_KP_EQUALSAS400",
"SDLK_ALTERASE",
"SDLK_SYSREQ",
"SDLK_CANCEL",
"SDLK_CLEAR",
"SDLK_PRIOR",
"SDLK_RETURN2",
"SDLK_SEPARATOR",
"SDLK_OUT",
"SDLK_OPER",
"SDLK_CLEARAGAIN",
"SDLK_CRSEL",
"SDLK_EXSEL",
"SDLK_KP_00",
"SDLK_KP_000",
"SDLK_THOUSANDSSEPARATOR",
"SDLK_DECIMALSEPARATOR",
"SDLK_CURRENCYUNIT",
"SDLK_CURRENCYSUBUNIT",
"SDLK_KP_LEFTPAREN",
"SDLK_KP_RIGHTPAREN",
"SDLK_KP_LEFTBRACE",
"SDLK_KP_RIGHTBRACE",
"SDLK_KP_TAB",
"SDLK_KP_BACKSPACE",
"SDLK_KP_A",
"SDLK_KP_B",
"SDLK_KP_C",
"SDLK_KP_D",
"SDLK_KP_E",
"SDLK_KP_F",
"SDLK_KP_XOR",
"SDLK_KP_POWER",
"SDLK_KP_PERCENT",
"SDLK_KP_LESS",
"SDLK_KP_GREATER",
"SDLK_KP_AMPERSAND",
"SDLK_KP_DBLAMPERSAND",
"SDLK_KP_VERTICALBAR",
"SDLK_KP_DBLVERTICALBAR",
"SDLK_KP_COLON",
"SDLK_KP_HASH",
"SDLK_KP_SPACE",
"SDLK_KP_AT",
"SDLK_KP_EXCLAM",
"SDLK_KP_MEMSTORE",
"SDLK_KP_MEMRECALL",
"SDLK_KP_MEMCLEAR",
"SDLK_KP_MEMADD",
"SDLK_KP_MEMSUBTRACT",
"SDLK_KP_MEMMULTIPLY",
"SDLK_KP_MEMDIVIDE",
"SDLK_KP_PLUSMINUS",
"SDLK_KP_CLEAR",
"SDLK_KP_CLEARENTRY",
"SDLK_KP_BINARY",
"SDLK_KP_OCTAL",
"SDLK_KP_DECIMAL",
"SDLK_KP_HEXADECIMAL",
"SDLK_LCTRL",
"SDLK_LSHIFT",
"SDLK_LALT",
"SDLK_LGUI",
"SDLK_RCTRL",
"SDLK_RSHIFT",
"SDLK_RALT",
"SDLK_RGUI",
"SDLK_MODE",
"SDLK_AUDIONEXT",
"SDLK_AUDIOPREV",
"SDLK_AUDIOSTOP",
"SDLK_AUDIOPLAY",
"SDLK_AUDIOMUTE",
"SDLK_MEDIASELECT",
"SDLK_WWW",
"SDLK_MAIL",
"SDLK_CALCULATOR",
"SDLK_COMPUTER",
"SDLK_AC_SEARCH",
"SDLK_AC_HOME",
"SDLK_AC_BACK",
"SDLK_AC_FORWARD",
"SDLK_AC_STOP",
"SDLK_AC_REFRESH",
"SDLK_AC_BOOKMARKS",
"SDLK_BRIGHTNESSDOWN",
"SDLK_BRIGHTNESSUP",
"SDLK_DISPLAYSWITCH",
"SDLK_KBDILLUMTOGGLE",
"SDLK_KBDILLUMDOWN",
"SDLK_KBDILLUMUP",
"SDLK_EJECT",
"SDLK_SLEEP",
"SDLK_APP1",
"SDLK_APP2",
"SDLK_AUDIOREWIND",
"SDLK_AUDIOFASTFORWARD",
"SDLK_SOFTLEFT",
"SDLK_SOFTRIGHT",
"SDLK_CALL",
"SDLK_ENDCALL",
)
SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}
CONFIG_SCHEMA = (
binary_sensor.binary_sensor_schema(BinarySensor)
esphome/components/sdl/display.py
+52 -1
View File
@@ -4,6 +4,7 @@ from typing import Any
import esphome.codegen as cg
from esphome.components import display
from esphome.components.snapshot import Snapshot, register_snapshot
import esphome.config_validation as cv
from esphome.const import (
CONF_DIMENSIONS,
@@ -16,14 +17,21 @@ from esphome.const import (
CONF_Y,
PLATFORM_HOST,
)
import esphome.final_validate as fv
from esphome.types import ConfigType
from . import SDL_KEYMAP
AUTO_LOAD = ["snapshot"]
sdl_ns = cg.esphome_ns.namespace("sdl")
Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component)
Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component, Snapshot)
sdl_window_flags = cg.global_ns.enum("SDL_WindowFlags")
CONF_CENTERED_ON_DISPLAY = "centered_on_display"
CONF_HEADLESS = "headless"
CONF_SNAPSHOT_KEY = "snapshot_key"
CONF_SDL_OPTIONS = "sdl_options"
CONF_SDL_ID = "sdl_id"
CONF_WINDOW_OPTIONS = "window_options"
@@ -67,12 +75,29 @@ def _validate_position(config: dict) -> dict:
raise cv.Invalid("Must specify either 'x' and 'y' or 'centered_on_display'")
def _validate_headless(config: ConfigType) -> ConfigType:
if not config[CONF_HEADLESS]:
return config
if CONF_WINDOW_OPTIONS in config:
raise cv.Invalid(
f"'{CONF_WINDOW_OPTIONS}' has no effect when '{CONF_HEADLESS}' is set - there is no window"
)
if CONF_SNAPSHOT_KEY in config:
raise cv.Invalid(
f"'{CONF_SNAPSHOT_KEY}' cannot be used when '{CONF_HEADLESS}' is set - "
f"there is no keyboard. Use the 'snapshot.take' action instead"
)
return config
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(Sdl),
cv.Optional(CONF_SDL_OPTIONS, default=""): get_sdl_options,
cv.Optional(CONF_HEADLESS, default=False): cv.boolean,
cv.Optional(CONF_SNAPSHOT_KEY): cv.enum(SDL_KEYMAP),
cv.Required(CONF_DIMENSIONS): cv.Any(
cv.dimensions,
cv.Schema(
@@ -99,16 +124,42 @@ CONFIG_SCHEMA = cv.All(
}
)
),
_validate_headless,
cv.only_on(PLATFORM_HOST),
)
def headless_final_validate(platform: str) -> cv.Schema:
"""Build a FINAL_VALIDATE_SCHEMA rejecting a platform whose sdl display is headless.
Mouse and keyboard platforms are driven by window events, so under a headless display they
would never report anything.
"""
def validate_display(display_config: ConfigType) -> ConfigType:
if display_config.get(CONF_HEADLESS):
raise cv.Invalid(
f"The sdl {platform} platform needs a window, but its display has "
f"'{CONF_HEADLESS}' set"
)
return display_config
return cv.Schema(
{cv.Required(CONF_SDL_ID): fv.id_declaration_match_schema(validate_display)},
extra=cv.ALLOW_EXTRA,
)
async def to_code(config: ConfigType) -> None:
for option in config[CONF_SDL_OPTIONS].split():
cg.add_build_flag(option)
cg.add_build_flag("-DSDL_BYTEORDER=4321")
var = cg.new_Pvariable(config[CONF_ID])
await display.register_display(var, config)
await register_snapshot(var, config)
cg.add(var.set_headless(config[CONF_HEADLESS]))
if (key := config.get(CONF_SNAPSHOT_KEY)) is not None:
cg.add(var.set_snapshot_key(key))
dimensions = config[CONF_DIMENSIONS]
if isinstance(dimensions, dict):
esphome/components/sdl/sdl_esphome.cpp
+228 -46
View File
@@ -2,8 +2,17 @@
#include "sdl_esphome.h"
#include "esphome/components/display/display_color_utils.h"
#include <cstdlib>
namespace esphome::sdl {
namespace {
// Key under which each window keeps a pointer back to its Sdl instance.
constexpr const char *const WINDOW_DATA_KEY = "esphome_sdl";
} // namespace
int Sdl::get_width() {
switch (this->rotation_) {
case display::DISPLAY_ROTATION_90_DEGREES:
@@ -28,17 +37,96 @@ int Sdl::get_height() {
}
}
void Sdl::setup() {
SDL_Init(SDL_INIT_VIDEO);
this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
this->window_options_);
this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_);
void Sdl::destroy_renderer_() {
// Reverse order of creation: the renderer refers to the window or surface it was made from.
if (this->shot_target_ != nullptr) {
SDL_DestroyTexture(this->shot_target_);
this->shot_target_ = nullptr;
}
if (this->texture_ != nullptr) {
SDL_DestroyTexture(this->texture_);
this->texture_ = nullptr;
}
if (this->renderer_ != nullptr) {
SDL_DestroyRenderer(this->renderer_);
this->renderer_ = nullptr;
}
if (this->window_ != nullptr) {
SDL_DestroyWindow(this->window_);
this->window_ = nullptr;
}
if (this->surface_ != nullptr) {
SDL_FreeSurface(this->surface_);
this->surface_ = nullptr;
}
}
bool Sdl::setup_failed_(const char *what) {
ESP_LOGE(TAG, "%s: %s", what, SDL_GetError());
// Give back whatever was created before the failure. Without this a half set up display leaves an
// empty window on screen for the life of the process, still registered as an event target.
this->destroy_renderer_();
return false;
}
bool Sdl::setup_renderer_() {
SDL_SetMainReady();
if (this->headless_) {
// SDL_INIT_VIDEO is deliberately not requested: a software renderer bound to a surface needs no
// video device, so this works on a machine with no display server at all.
if (SDL_Init(0) != 0)
return this->setup_failed_("SDL_Init failed");
this->surface_ = SDL_CreateRGBSurfaceWithFormat(0, this->width_, this->height_, 16, SDL_PIXELFORMAT_RGB565);
if (this->surface_ == nullptr)
return this->setup_failed_("Could not create offscreen surface");
this->renderer_ = SDL_CreateSoftwareRenderer(this->surface_);
} else {
if (SDL_Init(SDL_INIT_VIDEO) != 0)
return this->setup_failed_("SDL_Init failed");
this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
this->window_options_);
if (this->window_ == nullptr)
return this->setup_failed_("Could not create window");
// Lets loop() find the display an event belongs to, so one display does not act on another's
// input when several windows are open.
SDL_SetWindowData(this->window_, WINDOW_DATA_KEY, this);
this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
}
if (this->renderer_ == nullptr)
return this->setup_failed_("Could not create renderer");
if (SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_) != 0)
return this->setup_failed_("Could not set renderer logical size");
this->texture_ =
SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, this->width_, this->height_);
SDL_SetTextureBlendMode(this->texture_, SDL_BLENDMODE_BLEND);
if (this->texture_ == nullptr)
return this->setup_failed_("Could not create texture");
// The texture has no alpha channel, so blending is pointless. Headless it would also force a
// different software blit path onto the 16 bit target surface.
if (SDL_SetTextureBlendMode(this->texture_, this->headless_ ? SDL_BLENDMODE_NONE : SDL_BLENDMODE_BLEND) != 0)
return this->setup_failed_("Could not set texture blend mode");
return true;
}
void Sdl::setup() {
if (!this->setup_renderer_()) {
this->mark_failed();
return;
}
if (this->headless_) {
// Nothing generates events, so there is nothing for loop() to do.
this->disable_loop();
} else if (this->snapshot_key_ != 0) {
this->add_key_listener(this->snapshot_key_, [this](bool down) {
if (down && !this->take_snapshot(nullptr)) {
ESP_LOGW(TAG, "snapshot key did not write a file");
}
});
}
}
void Sdl::update() {
if (this->texture_ == nullptr)
return;
this->do_update_();
if ((this->x_high_ < this->x_low_) || (this->y_high_ < this->y_low_))
return;
@@ -51,12 +139,19 @@ void Sdl::update() {
}
void Sdl::redraw_(SDL_Rect &rect) {
// Nothing to present when headless - a snapshot blits the whole texture when it needs it, so
// doing it here as well would just burn CPU. draw_pixels_at() calls this on every partial
// update, so it is worth skipping.
if (this->headless_)
return;
SDL_RenderCopy(this->renderer_, this->texture_, &rect, &rect);
SDL_RenderPresent(this->renderer_);
}
void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
if (this->texture_ == nullptr)
return;
SDL_Rect rect{x_start, y_start, w, h};
if (this->rotation_ != display::DISPLAY_ROTATION_0_DEGREES || bitness != display::COLOR_BITNESS_565 || big_endian) {
Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
@@ -69,7 +164,7 @@ void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *
}
void Sdl::draw_pixel_at(int x, int y, Color color) {
if (!this->get_clipping().inside(x, y))
if (this->texture_ == nullptr || !this->get_clipping().inside(x, y))
return;
if (this->rotation_ == display::DISPLAY_ROTATION_180_DEGREES) {
@@ -104,61 +199,148 @@ void Sdl::process_key(uint32_t keycode, bool down) {
callback->second(down);
}
Sdl *Sdl::instance_for_window_(uint32_t window_id) {
SDL_Window *window = SDL_GetWindowFromID(window_id);
if (window == nullptr)
return nullptr;
return static_cast<Sdl *>(SDL_GetWindowData(window, WINDOW_DATA_KEY));
}
void Sdl::handle_event_(const SDL_Event &event) {
switch (event.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if (event.button.button == 1) {
this->mouse_x = event.button.x;
this->mouse_y = event.button.y;
this->mouse_down = event.button.state != 0;
}
break;
case SDL_MOUSEMOTION:
if (event.motion.state & 1) {
this->mouse_x = event.motion.x;
this->mouse_y = event.motion.y;
this->mouse_down = true;
} else {
this->mouse_down = false;
}
break;
case SDL_KEYDOWN:
// Ignore auto-repeat, otherwise holding a key floods the listeners.
if (event.key.repeat != 0)
break;
ESP_LOGD(TAG, "keydown %d", event.key.keysym.sym);
this->process_key(event.key.keysym.sym, true);
break;
case SDL_KEYUP:
ESP_LOGD(TAG, "keyup %d", event.key.keysym.sym);
this->process_key(event.key.keysym.sym, false);
break;
case SDL_WINDOWEVENT:
switch (event.window.event) {
case SDL_WINDOWEVENT_SIZE_CHANGED:
case SDL_WINDOWEVENT_EXPOSED:
case SDL_WINDOWEVENT_RESIZED: {
SDL_Rect rect{0, 0, this->width_, this->height_};
this->redraw_(rect);
break;
}
default:
break;
}
break;
default:
break;
}
}
void Sdl::loop() {
SDL_Event e;
if (SDL_PollEvent(&e)) {
switch (e.type) {
case SDL_QUIT:
exit(0);
// Take everything that is waiting, not one event per loop. A touch drag produces a burst of
// motion events, and consuming them one at a time lets the queue grow without bound, so the
// pointer ends up acting on input from further and further in the past. Draining collapses a
// burst to the position it ended at, which is the one the user is asking for anyway.
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT)
exit(0);
// Events carry the window they happened in, so send each one to the display that owns it.
uint32_t window_id;
switch (e.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if (e.button.button == 1) {
this->mouse_x = e.button.x;
this->mouse_y = e.button.y;
this->mouse_down = e.button.state != 0;
}
window_id = e.button.windowID;
break;
case SDL_MOUSEMOTION:
if (e.motion.state & 1) {
this->mouse_x = e.button.x;
this->mouse_y = e.button.y;
this->mouse_down = true;
} else {
this->mouse_down = false;
}
window_id = e.motion.windowID;
break;
case SDL_KEYDOWN:
ESP_LOGD(TAG, "keydown %d", e.key.keysym.sym);
this->process_key(e.key.keysym.sym, true);
break;
case SDL_KEYUP:
ESP_LOGD(TAG, "keyup %d", e.key.keysym.sym);
this->process_key(e.key.keysym.sym, false);
window_id = e.key.windowID;
break;
case SDL_WINDOWEVENT:
switch (e.window.event) {
case SDL_WINDOWEVENT_SIZE_CHANGED:
case SDL_WINDOWEVENT_EXPOSED:
case SDL_WINDOWEVENT_RESIZED: {
SDL_Rect rect{0, 0, this->width_, this->height_};
this->redraw_(rect);
break;
}
default:
break;
}
window_id = e.window.windowID;
break;
default:
// Anything else, including the touch events SDL reports alongside the mouse events it
// synthesises from them, is not used here.
ESP_LOGV(TAG, "Event %d", e.type);
break;
continue;
}
Sdl *target = instance_for_window_(window_id);
if (target == nullptr) {
// Nothing to route this to: the window has gone, or it is not one of ours. Say so, otherwise
// input that stops working leaves no trace at all.
ESP_LOGV(TAG, "Event %d for unknown window %u", e.type, window_id);
continue;
}
target->handle_event_(e);
}
}
bool Sdl::capture_bgr(uint8_t *dest, size_t row_stride) {
if (this->texture_ == nullptr || this->renderer_ == nullptr) {
ESP_LOGE(TAG, "Snapshot requested but SDL is not set up");
return false;
}
if (this->shot_target_ == nullptr) {
this->shot_target_ = SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_TARGET,
this->width_, this->height_);
if (this->shot_target_ == nullptr) {
ESP_LOGE(TAG, "Could not create capture texture: %s", SDL_GetError());
return false;
}
SDL_SetTextureBlendMode(this->shot_target_, SDL_BLENDMODE_NONE);
}
// Render into an offscreen target first. SDL_RenderReadPixels works in physical output pixels and
// ignores the logical size, so reading straight off a resizable window would read more pixels than
// there is room for.
// Every step is checked: a failed clear or copy would otherwise be read back as a blank or stale
// picture, written out, and reported as a snapshot that worked.
bool ok = false;
if (SDL_SetRenderTarget(this->renderer_, this->shot_target_) == 0) {
ok = SDL_SetRenderDrawColor(this->renderer_, 0, 0, 0, SDL_ALPHA_OPAQUE) == 0 &&
SDL_RenderClear(this->renderer_) == 0 &&
SDL_RenderCopy(this->renderer_, this->texture_, nullptr, nullptr) == 0 &&
SDL_RenderReadPixels(this->renderer_, nullptr, SDL_PIXELFORMAT_BGR24, dest, static_cast<int>(row_stride)) == 0;
if (SDL_SetRenderTarget(this->renderer_, nullptr) != 0) {
// Stuck rendering into shot_target_ from here on, so there's no point continuing.
ESP_LOGE(TAG, "Could not restore the render target: %s", SDL_GetError());
this->mark_failed();
return false;
}
}
if (!ok) {
ESP_LOGE(TAG, "Could not capture the screen: %s", SDL_GetError());
}
return ok;
}
} // namespace esphome::sdl
esphome/components/sdl/sdl_esphome.h
+30 -5
View File
@@ -1,10 +1,12 @@
#pragma once
#ifdef USE_HOST
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/log.h"
#include "esphome/core/application.h"
#include "esphome/components/display/display.h"
#include "esphome/components/snapshot/snapshot.h"
#define SDL_MAIN_HANDLED
#include "SDL.h"
#include <map>
@@ -13,7 +15,7 @@ namespace esphome::sdl {
constexpr static const char *const TAG = "sdl";
class Sdl final : public display::Display {
class Sdl final : public display::Display, public snapshot::Snapshot {
public:
display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
void update() override;
@@ -32,6 +34,9 @@ class Sdl final : public display::Display {
this->pos_x_ = pos_x;
this->pos_y_ = pos_y;
}
void set_headless(bool headless) { this->headless_ = headless; }
void set_snapshot_key(int32_t keycode) { this->snapshot_key_ = keycode; }
int get_width() override;
int get_height() override;
float get_setup_priority() const override { return setup_priority::HARDWARE; }
@@ -51,20 +56,40 @@ class Sdl final : public display::Display {
int get_width_internal() override { return this->width_; }
int get_height_internal() override { return this->height_; }
void redraw_(SDL_Rect &rect);
bool setup_renderer_();
/// Release the window, surface, renderer and textures, and forget them.
void destroy_renderer_();
/// Log an SDL failure during setup, release anything already created, and return false.
bool setup_failed_(const char *what);
int snapshot_width() override { return this->width_; }
int snapshot_height() override { return this->height_; }
bool capture_bgr(uint8_t *dest, size_t row_stride) override;
void handle_event_(const SDL_Event &event);
/// The display owning the given window, or nullptr if it is not one of ours.
static Sdl *instance_for_window_(uint32_t window_id);
SDL_Renderer *renderer_{};
SDL_Window *window_{};
SDL_Texture *texture_{};
// Offscreen render target used when headless. SDL_CreateSoftwareRenderer only borrows the
// surface, and the renderer goes back to using it as its output whenever the capture target is
// released, so it has to stay alive as long as the renderer does.
SDL_Surface *surface_{};
// Capture target, created on first snapshot.
SDL_Texture *shot_target_{};
std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
int width_{};
int height_{};
uint32_t window_options_{0};
int32_t pos_x_{SDL_WINDOWPOS_UNDEFINED};
int32_t pos_y_{SDL_WINDOWPOS_UNDEFINED};
SDL_Renderer *renderer_{};
SDL_Window *window_{};
SDL_Texture *texture_{};
int32_t snapshot_key_{0};
uint16_t x_low_{0};
uint16_t y_low_{0};
uint16_t x_high_{0};
uint16_t y_high_{0};
std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
bool headless_{false};
};
} // namespace esphome::sdl
#endif
esphome/components/sdl/touchscreen/__init__.py
+3 -1
View File
@@ -4,10 +4,12 @@ import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.types import ConfigType
from ..display import CONF_SDL_ID, Sdl, sdl_ns
from ..display import CONF_SDL_ID, Sdl, headless_final_validate, sdl_ns
SdlTouchscreen = sdl_ns.class_("SdlTouchscreen", touchscreen.Touchscreen)
FINAL_VALIDATE_SCHEMA = headless_final_validate("touchscreen")
CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
{
esphome/components/snapshot/__init__.py
+76
View File
@@ -0,0 +1,76 @@
"""Shared support for writing what a display is showing out to an image file.
The component itself has no configuration. It provides the ``snapshot.take`` action and the C++
base class behind it, so any display that can hand over its pixels - the in memory display in this
component, or an SDL window - saves files the same way, under the same directory, with the same
rules about names.
"""
from dataclasses import dataclass
from esphome import automation
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.core import CORE, ID
from esphome.cpp_generator import MockObj
from esphome.types import ConfigType, TemplateArgsType
CODEOWNERS = ["@clydebarrow"]
DOMAIN = "snapshot"
CONF_FILENAME = "filename"
snapshot_ns = cg.esphome_ns.namespace("snapshot")
Snapshot = snapshot_ns.class_("Snapshot")
SnapshotAction = snapshot_ns.class_("SnapshotAction", automation.Action)
@automation.register_action(
"snapshot.take",
SnapshotAction,
automation.maybe_simple_id(
{
cv.GenerateID(): cv.use_id(Snapshot),
cv.Optional(CONF_FILENAME): cv.templatable(cv.string),
}
),
synchronous=True,
)
async def snapshot_take_to_code(
config: ConfigType,
action_id: ID,
template_arg: cg.TemplateArguments,
args: TemplateArgsType,
) -> MockObj:
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
if (filename := config.get(CONF_FILENAME)) is not None:
cg.add(var.set_filename(await cg.templatable(filename, args, cg.std_string)))
return var
@dataclass
class SnapshotData:
directory_defined: bool = False
def _get_data() -> SnapshotData:
if DOMAIN not in CORE.data:
CORE.data[DOMAIN] = SnapshotData()
return CORE.data[DOMAIN]
async def register_snapshot(var: MockObj, config: ConfigType) -> None:
"""Set up a component so that the snapshot action can write its picture to a file."""
data = _get_data()
# Only once, however many displays there are: two defines that say the same thing do not
# compare equal, so asking for this per display repeats the line in defines.h.
if not data.directory_defined:
data.directory_defined = True
cg.add_define(
"ESPHOME_SNAPSHOT_DIR",
(CORE.data_dir / "snapshots" / CORE.name).as_posix(),
)
cg.add(var.set_snapshot_prefix(str(config[CONF_ID])))
esphome/components/snapshot/display/__init__.py
+61
View File
@@ -0,0 +1,61 @@
import esphome.codegen as cg
from esphome.components import display
import esphome.config_validation as cv
from esphome.const import (
CONF_DIMENSIONS,
CONF_HEIGHT,
CONF_ID,
CONF_LAMBDA,
CONF_WIDTH,
PLATFORM_HOST,
)
from esphome.types import ConfigType
from .. import Snapshot, register_snapshot, snapshot_ns
# The base class and the file writing live in the parent component, which nothing else in a
# configuration using only this platform would pull in.
AUTO_LOAD = ["snapshot"]
SnapshotDisplay = snapshot_ns.class_(
"SnapshotDisplay", display.DisplayBuffer, cg.Component, Snapshot
)
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(SnapshotDisplay),
cv.Required(CONF_DIMENSIONS): cv.Any(
cv.dimensions,
cv.Schema(
{
cv.Required(CONF_WIDTH): cv.positive_not_null_int,
cv.Required(CONF_HEIGHT): cv.positive_not_null_int,
}
),
),
}
)
),
cv.only_on(PLATFORM_HOST),
)
async def to_code(config: ConfigType) -> None:
var = cg.new_Pvariable(config[CONF_ID])
await display.register_display(var, config)
await register_snapshot(var, config)
dimensions = config[CONF_DIMENSIONS]
if isinstance(dimensions, dict):
cg.add(var.set_dimensions(dimensions[CONF_WIDTH], dimensions[CONF_HEIGHT]))
else:
(width, height) = dimensions
cg.add(var.set_dimensions(width, height))
if lamb := config.get(CONF_LAMBDA):
lambda_ = await cg.process_lambda(
lamb, [(display.DisplayRef, "it")], return_type=cg.void
)
cg.add(var.set_writer(lambda_))
esphome/components/snapshot/display/snapshot_display.cpp
+80
View File
@@ -0,0 +1,80 @@
#ifdef USE_HOST
#include "snapshot_display.h"
#include "esphome/components/display/display_color_utils.h"
#include "esphome/core/log.h"
#include <cstring>
namespace esphome::snapshot {
static const char *const TAG = "snapshot.display";
namespace {
/// Spread a channel that only goes up to `max` over the whole 0 to 255 range, so that the
/// brightest value stays the brightest. This is the same arithmetic SDL uses, which is what makes
/// a picture taken here come out identical to the same picture taken from an SDL window.
constexpr uint8_t expand_channel(uint16_t value, uint16_t max) { return static_cast<uint8_t>(value * 255 / max); }
constexpr uint16_t RED_MAX = 0x1F;
constexpr uint16_t GREEN_MAX = 0x3F;
constexpr uint16_t BLUE_MAX = 0x1F;
} // namespace
void SnapshotDisplay::setup() {
this->init_internal_(static_cast<uint32_t>(this->width_) * this->height_ * 2);
if (this->buffer_ == nullptr) {
this->mark_failed(LOG_STR("Could not allocate display buffer"));
}
}
void SnapshotDisplay::dump_config() { LOG_DISPLAY("", "Snapshot", this); }
void SnapshotDisplay::draw_absolute_pixel_internal(int x, int y, Color color) {
if (this->buffer_ == nullptr || x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
return;
this->pixels_()[y * this->width_ + x] = display::ColorUtil::color_to_565(color, display::COLOR_ORDER_RGB);
}
void SnapshotDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr,
display::ColorOrder order, display::ColorBitness bitness, bool big_endian,
int x_offset, int y_offset, int x_pad) {
if (this->buffer_ == nullptr)
return;
// Anything that is not already laid out the way the buffer is, or that would reach outside it,
// goes through the base class, which turns it into one call per pixel with the bounds checked.
const bool copyable = this->rotation_ == display::DISPLAY_ROTATION_0_DEGREES &&
bitness == display::COLOR_BITNESS_565 && !big_endian && x_start >= 0 && y_start >= 0 &&
x_start + w <= this->width_ && y_start + h <= this->height_;
if (!copyable) {
DisplayBuffer::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
return;
}
const size_t stride = static_cast<size_t>(x_offset) + w + x_pad;
const uint8_t *src = ptr + (stride * y_offset + x_offset) * 2;
for (int y = 0; y != h; y++) {
memcpy(&this->pixels_()[(y_start + y) * this->width_ + x_start], src + y * stride * 2, w * 2);
}
}
bool SnapshotDisplay::capture_bgr(uint8_t *dest, size_t row_stride) {
if (this->buffer_ == nullptr) {
ESP_LOGE(TAG, "Snapshot requested but there is no buffer to read");
return false;
}
const uint16_t *src = this->pixels_();
for (int y = 0; y != this->height_; y++) {
uint8_t *out = dest + y * row_stride;
for (int x = 0; x != this->width_; x++) {
const uint16_t pixel = *src++;
*out++ = expand_channel(pixel & BLUE_MAX, BLUE_MAX);
*out++ = expand_channel((pixel >> 5) & GREEN_MAX, GREEN_MAX);
*out++ = expand_channel(pixel >> 11, RED_MAX);
}
}
return true;
}
} // namespace esphome::snapshot
#endif
esphome/components/snapshot/display/snapshot_display.h
+48
View File
@@ -0,0 +1,48 @@
#pragma once
#ifdef USE_HOST
#include "esphome/components/display/display_buffer.h"
#include "esphome/components/snapshot/snapshot.h"
#include "esphome/core/component.h"
namespace esphome::snapshot {
/// A display with nowhere to show anything: it keeps the picture in memory, where the snapshot
/// action can pick it up. That makes it a way to see what a configuration draws on a machine with
/// no screen, and to check the result in a test.
class SnapshotDisplay final : public display::DisplayBuffer, public Snapshot {
public:
void setup() override;
void update() override { this->do_update_(); }
void dump_config() override;
float get_setup_priority() const override { return setup_priority::HARDWARE; }
display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
void set_dimensions(uint16_t width, uint16_t height) {
this->width_ = width;
this->height_ = height;
}
void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
protected:
void draw_absolute_pixel_internal(int x, int y, Color color) override;
int get_width_internal() override { return this->width_; }
int get_height_internal() override { return this->height_; }
int snapshot_width() override { return this->width_; }
int snapshot_height() override { return this->height_; }
bool capture_bgr(uint8_t *dest, size_t row_stride) override;
/// The picture, one 16 bit RGB565 value per pixel, topmost row first. Owned by DisplayBuffer as
/// a byte pointer; this is the same memory seen as what is actually stored in it.
uint16_t *pixels_() { return reinterpret_cast<uint16_t *>(this->buffer_); }
int width_{};
int height_{};
};
} // namespace esphome::snapshot
#endif
esphome/components/snapshot/snapshot.cpp
+248
View File
@@ -0,0 +1,248 @@
#ifdef USE_HOST
#include "snapshot.h"
#include "esphome/core/log.h"
#include <fcntl.h>
#include <strings.h>
#include <unistd.h>
#include <cctype>
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <filesystem>
#include <memory>
namespace esphome::snapshot {
namespace {
constexpr const char *const TAG = "snapshot";
// Longest name we will build a path from. NAME_MAX is 255 and we may append a collision suffix.
constexpr size_t MAX_NAME_LENGTH = 200;
// Give up rather than spin forever if every candidate name is taken.
constexpr unsigned MAX_NAME_ATTEMPTS = 1000;
// A BMP file header followed by a BITMAPINFOHEADER, which is where the pixels start.
constexpr size_t BMP_HEADER_SIZE = 54;
constexpr size_t BMP_INFO_HEADER_SIZE = 40;
constexpr int BMP_BITS_PER_PIXEL = 24;
/// True if the name already ends in ".bmp". The comparison ignores case, so "shot.BMP" is left
/// alone rather than turned into "shot.BMP.bmp".
bool has_bmp_suffix(const std::string &name) {
return name.size() >= 4 && strcasecmp(name.c_str() + name.size() - 4, ".bmp") == 0;
}
/// Reduce a user supplied name to a single safe path component. Everything outside the allowed set
/// is replaced, so "..", "/" and absolute paths cannot escape the snapshot directory.
/// Returns an empty string if nothing usable is left.
std::string sanitise_filename(const char *const name, bool *name_changed) {
std::string result;
bool all_dots = true;
bool changed = false;
for (const char *p = name; *p != '\0'; p++) {
if (result.size() >= MAX_NAME_LENGTH) {
changed = true;
break;
}
char c = *p;
if (!(std::isalnum(static_cast<unsigned char>(c)) || c == '.' || c == '_' || c == '-')) {
c = '_';
changed = true;
}
if (c != '.')
all_dots = false;
result.push_back(c);
}
if (all_dots) {
*name_changed = true;
return "";
}
if (!has_bmp_suffix(result))
result += ".bmp";
*name_changed = changed;
return result;
}
/// Insert "-<attempt>" before the file extension, e.g. "shot.bmp" -> "shot-1.bmp".
std::string add_suffix(const std::string &name, unsigned attempt) {
char suffix[12];
snprintf(suffix, sizeof(suffix), "-%u", attempt);
auto dot = name.rfind('.');
if (dot == std::string::npos)
return name + suffix;
return name.substr(0, dot) + suffix + name.substr(dot);
}
/// Directory snapshots are written to. The environment variable lets a test redirect output
/// without rebuilding, matching how the host platform handles ESPHOME_PREFDIR.
const char *snapshot_dir() {
const char *dir = getenv("ESPHOME_SNAPSHOT_DIR"); // NOLINT(concurrency-mt-unsafe)
return dir != nullptr && dir[0] != '\0' ? dir : ESPHOME_SNAPSHOT_DIR;
}
/// Store a value in as many bytes, least significant first, and step the pointer past it.
/// BMP is a little endian format whatever the machine writing it uses.
void put_le(uint8_t *&dest, uint32_t value, size_t bytes) {
for (size_t i = 0; i != bytes; i++)
*dest++ = static_cast<uint8_t>(value >> (8 * i));
}
/// The number of bytes one row of `width` pixels takes up in the file. Rows are padded out to a
/// multiple of four bytes.
size_t bmp_row_size(int width) { return (static_cast<size_t>(width) * 3 + 3) & ~size_t{3}; }
/// Write pixels out as a 24 bit BMP. The rows given start with the topmost and are `row_stride`
/// bytes apart, which must leave room for a whole padded row; a BMP holds its rows the other way
/// up, so they go out last first.
bool write_bmp(FILE *file, const uint8_t *pixels, int width, int height, size_t row_stride) {
const size_t row_size = bmp_row_size(width);
const size_t pixel_bytes = row_size * height;
uint8_t header[BMP_HEADER_SIZE];
uint8_t *pos = header;
*pos++ = 'B';
*pos++ = 'M';
put_le(pos, static_cast<uint32_t>(BMP_HEADER_SIZE + pixel_bytes), 4);
put_le(pos, 0, 4); // reserved
put_le(pos, BMP_HEADER_SIZE, 4);
put_le(pos, BMP_INFO_HEADER_SIZE, 4);
put_le(pos, static_cast<uint32_t>(width), 4);
put_le(pos, static_cast<uint32_t>(height), 4);
put_le(pos, 1, 2); // one plane
put_le(pos, BMP_BITS_PER_PIXEL, 2);
put_le(pos, 0, 4); // not compressed
put_le(pos, static_cast<uint32_t>(pixel_bytes), 4);
put_le(pos, 0, 4); // pixels per metre across, unspecified
put_le(pos, 0, 4); // pixels per metre down, unspecified
put_le(pos, 0, 4); // no palette
put_le(pos, 0, 4); // so no palette entry matters more than another
if (fwrite(header, 1, sizeof(header), file) != sizeof(header))
return false;
for (int y = height - 1; y >= 0; y--) {
if (fwrite(pixels + static_cast<size_t>(y) * row_stride, 1, row_size, file) != row_size)
return false;
}
return true;
}
/// Reserve a name in the snapshot directory and write the picture to it.
/// With `exact` set the given name is the only one tried; otherwise a number is added on
/// collision. Returns true if a file was written.
bool write_snapshot_file(const uint8_t *pixels, int width, int height, size_t row_stride, const std::string &name,
bool exact) {
const std::string dir = snapshot_dir();
std::error_code ec;
std::filesystem::create_directories(dir, ec);
if (ec) {
ESP_LOGE(TAG, "Could not create snapshot directory %s: %s", dir.c_str(), ec.message().c_str());
return false;
}
// O_EXCL guarantees we never write over a file that is already there.
std::string path;
int fd = -1;
for (unsigned attempt = 0; attempt < MAX_NAME_ATTEMPTS; attempt++) {
path = dir + "/" + (attempt == 0 ? name : add_suffix(name, attempt));
fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, 0644);
if (fd >= 0)
break;
if (errno != EEXIST) {
ESP_LOGE(TAG, "Could not create %s: %s", path.c_str(), strerror(errno));
return false;
}
if (exact) {
// The caller asked for this exact name, so silently writing somewhere else would be worse
// than failing - a test asserting on the path would pick up a stale file.
ESP_LOGE(TAG, "Snapshot %s already exists, not overwriting", path.c_str());
return false;
}
}
if (fd < 0) {
ESP_LOGE(TAG, "Could not find an unused name for %s in %s", name.c_str(), dir.c_str());
return false;
}
FILE *file = fdopen(fd, "wb");
if (file == nullptr) {
ESP_LOGE(TAG, "Could not open %s: %s", path.c_str(), strerror(errno));
::close(fd);
::unlink(path.c_str());
return false;
}
bool ok = write_bmp(file, pixels, width, height, row_stride);
int saved_errno = ok ? 0 : errno;
// Closing can fail in its own right - the last of the data is still on its way out.
if (fclose(file) != 0) {
if (ok)
saved_errno = errno;
ok = false;
}
if (!ok) {
ESP_LOGE(TAG, "Could not write %s: %s", path.c_str(), strerror(saved_errno));
// Leave no truncated file behind - it would block a retry under the same name.
::unlink(path.c_str());
return false;
}
ESP_LOGI(TAG, "Snapshot written to %s", path.c_str());
return true;
}
} // namespace
// helper function since ESP_LOGW is disallowed in a header file
void Snapshot::log_action_failed() { ESP_LOGW(TAG, "snapshot.take did not write a file"); }
bool Snapshot::take_snapshot(const char *filename) {
const int width = this->snapshot_width();
const int height = this->snapshot_height();
if (width <= 0 || height <= 0) {
ESP_LOGE(TAG, "Snapshot requested but the display is %dx%d", width, height);
return false;
}
std::string name;
bool exact = false;
if (filename != nullptr) {
bool name_changed = false;
name = sanitise_filename(filename, &name_changed);
exact = !name.empty();
if (name_changed) {
ESP_LOGW(TAG, "Requested snapshot name '%s' is not an acceptable file name, using '%s' instead", filename,
name.empty() ? "a name made from the time" : name.c_str());
}
}
if (name.empty()) {
struct timespec now {};
if (clock_gettime(CLOCK_REALTIME, &now) != 0)
now = {};
struct tm tm_buf {};
if (localtime_r(&now.tv_sec, &tm_buf) == nullptr)
tm_buf = {};
char stamp[32]{};
// ::strftime to be sure of the one from <ctime>; display has an unrelated member of that name
if (::strftime(stamp, sizeof(stamp), "%Y%m%d-%H%M%S", &tm_buf) == 0)
snprintf(stamp, sizeof(stamp), "unknown-time");
char buffer[MAX_NAME_LENGTH];
int written =
snprintf(buffer, sizeof(buffer), "%s-%s-%03ld.bmp", this->snapshot_prefix_, stamp, now.tv_nsec / 1000000);
if (written < 0 || static_cast<size_t>(written) >= sizeof(buffer)) {
ESP_LOGW(TAG, "Could not build a timestamped snapshot name, using a fallback");
snprintf(buffer, sizeof(buffer), "snapshot.bmp");
}
name = buffer;
}
// Rows are padded out to a multiple of four bytes, as the file wants them, so each one can be
// written straight from the buffer. Zeroed on allocation, which is what the padding must be.
const size_t row_stride = bmp_row_size(width);
auto pixels = std::make_unique<uint8_t[]>(row_stride * height);
if (!this->capture_bgr(pixels.get(), row_stride))
return false;
return write_snapshot_file(pixels.get(), width, height, row_stride, name, exact);
}
} // namespace esphome::snapshot
#endif
esphome/components/snapshot/snapshot.h
+72
View File
@@ -0,0 +1,72 @@
#pragma once
#ifdef USE_HOST
#include "esphome/core/automation.h"
#include <cstddef>
#include <cstdint>
#include <string>
// Directory snapshots are written to. Normally set by codegen to a folder under .esphome; the
// fallback keeps the component compiling for static analysis, where no defines.h is generated.
#ifndef ESPHOME_SNAPSHOT_DIR
#define ESPHOME_SNAPSHOT_DIR "."
#endif
namespace esphome::snapshot {
/// Base for anything that can hand over the picture it is showing so it can be written to a file.
///
/// A subclass says how big the picture is and fills in the pixels. Everything else - picking a
/// name, staying inside the snapshot directory, not writing over anything, and encoding the file -
/// is done here, so every component that can take a snapshot behaves the same way.
class Snapshot {
public:
virtual ~Snapshot() = default;
/// Set the word generated names start with. Codegen passes the component id, so with more than
/// one display in a device it is clear which one a file came from.
void set_snapshot_prefix(const char *prefix) { this->snapshot_prefix_ = prefix; }
/// Write the current picture to a BMP file in the snapshot directory.
///
/// Pass nullptr to have a name made up from the prefix and the current time. A file that is
/// already there is never written over. Returns true if a file was written.
bool take_snapshot(const char *filename);
/// Log that an action-triggered snapshot did not write a file.
static void log_action_failed();
protected:
/// Width of the picture in pixels.
virtual int snapshot_width() = 0;
/// Height of the picture in pixels.
virtual int snapshot_height() = 0;
/// Fill in the picture: three bytes per pixel in blue, green, red order, topmost row first, with
/// `row_stride` bytes from the start of one row to the start of the next. Returns false, having
/// logged why, if the picture could not be read.
virtual bool capture_bgr(uint8_t *dest, size_t row_stride) = 0;
const char *snapshot_prefix_{"snapshot"};
};
template<typename... Ts> class SnapshotAction final : public Action<Ts...>, public Parented<Snapshot> {
public:
TEMPLATABLE_VALUE(std::string, filename)
protected:
void play(const Ts &...x) override {
bool ok;
if (this->filename_.has_value()) {
ok = this->parent_->take_snapshot(this->filename_.value(x...).c_str());
} else {
ok = this->parent_->take_snapshot(nullptr);
}
if (!ok)
this->parent_->log_action_failed();
}
};
} // namespace esphome::snapshot
#endif
esphome/components/wifi/wifi_component.h
-5
View File
@@ -40,11 +40,6 @@
#include <ESP8266WiFi.h>
#include <ESP8266WiFiType.h>
#if defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE < VERSION_CODE(2, 4, 0)
extern "C" {
#include <user_interface.h>
};
#endif
#endif
#ifdef USE_RP2
esphome/components/wifi/wifi_component_esp8266.cpp
+1 -9
View File
@@ -21,7 +21,6 @@ extern "C" {
#include "lwip/apps/sntp.h"
#include "lwip/netif.h" // struct netif
#include <AddrList.h>
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0)
#include "LwipDhcpServer.h"
#if USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
#include <ESP8266WiFi.h>
@@ -30,7 +29,6 @@ extern "C" {
#define wifi_softap_set_dhcps_lease_time(time) dhcpSoftAP.set_dhcps_lease_time(time)
#define wifi_softap_set_dhcps_offer_option(offer, mode) dhcpSoftAP.set_dhcps_offer_option(offer, mode)
#endif
#endif
}
#include "esphome/core/application.h"
@@ -293,7 +291,6 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
conf.bssid_set = 0;
}
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
if (ap.password_.empty()) {
conf.threshold.authmode = AUTH_OPEN;
} else {
@@ -310,7 +307,6 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
}
}
conf.threshold.rssi = -127;
#endif
ETS_UART_INTR_DISABLE();
bool ret = wifi_station_set_config_current(&conf);
@@ -602,7 +598,6 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
#endif
break;
}
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
case EVENT_OPMODE_CHANGED: {
auto it = event->event_info.opmode_changed;
ESP_LOGV(TAG, "Changed Mode old=%s new=%s", LOG_STR_ARG(get_op_mode_str(it.old_opmode)),
@@ -620,7 +615,6 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
#endif
break;
}
#endif
default:
break;
}
@@ -705,7 +699,6 @@ bool WiFiComponent::wifi_scan_start_(bool passive) {
config.bssid = nullptr;
config.channel = 0;
config.show_hidden = 1;
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
config.scan_type = passive ? WIFI_SCAN_TYPE_PASSIVE : WIFI_SCAN_TYPE_ACTIVE;
// Use shorter dwell times for roaming scans - we only need to detect strong
// nearby APs, not do a thorough survey. This also reduces off-channel time
@@ -724,7 +717,6 @@ bool WiFiComponent::wifi_scan_start_(bool passive) {
config.scan_time.active.min = roaming ? SCAN_ACTIVE_MIN_ROAMING_MS : SCAN_ACTIVE_MIN_DEFAULT_MS;
config.scan_time.active.max = roaming ? SCAN_ACTIVE_MAX_ROAMING_MS : SCAN_ACTIVE_MAX_DEFAULT_MS;
}
#endif
bool ret = wifi_station_scan(&config, &WiFiComponent::s_wifi_scan_done_callback);
if (!ret) {
ESP_LOGV(TAG, "wifi_station_scan failed");
@@ -830,7 +822,7 @@ bool WiFiComponent::wifi_ap_ip_config_(const optional<ManualIP> &manual_ip) {
return false;
}
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0) && USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
#if USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
dhcpSoftAP.begin(&info);
#endif
esphome/const.py
+1 -1
View File
@@ -4,7 +4,7 @@ from enum import Enum
from esphome.enum import StrEnum
__version__ = "2026.9.0-dev"
__version__ = "2026.10.0-dev"
ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
VALID_SUBSTITUTIONS_CHARACTERS = (
esphome/core/defines.h
+1
View File
@@ -13,6 +13,7 @@
#define ESPHOME_PROJECT_VERSION "v2"
#define ESPHOME_PROJECT_VERSION_30 "v2"
#define ESPHOME_VARIANT "ESP32"
#define ESPHOME_SNAPSHOT_DIR "."
#define ESPHOME_NAME_ADD_MAC_SUFFIX
#define ESPHOME_DEBUG_SCHEDULER
#define ESPHOME_DEBUG_API
esphome/core/log.h
-14
View File
@@ -18,7 +18,6 @@
#ifdef USE_STORE_LOG_STR_IN_FLASH
#include "WString.h"
#include "esphome/core/defines.h" // for USE_ARDUINO_VERSION_CODE
#endif
// Include ESP-IDF/Arduino based logging methods here so they don't undefine ours later
@@ -177,20 +176,7 @@ struct LogString;
#include <pgmspace.h>
#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 0)
#define LOG_STR_ARG(s) ((PGM_P) (s))
#else
// Pre-Arduino 2.5, we can't pass a PSTR() to printf(). Emulate support by copying the message to a
// local buffer first. String length is limited to 63 characters.
// https://github.com/esp8266/Arduino/commit/6280e98b0360f85fdac2b8f10707fffb4f6e6e31
#define LOG_STR_ARG(s) \
({ \
char __buf[64]; \
__buf[63] = '\0'; \
strncpy_P(__buf, (PGM_P) (s), 63); \
__buf; \
})
#endif
#define LOG_STR(s) (reinterpret_cast<const LogString *>(PSTR(s)))
#define LOG_STR_LITERAL(s) LOG_STR_ARG(LOG_STR(s))
requirements.txt
+3 -3
View File
@@ -14,7 +14,7 @@ esptool==5.3.1
click==8.3.3
aioesphomeapi==46.3.0
aiohappyeyeballs==2.7.1 # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
zeroconf==0.151.2
zeroconf==0.151.3
puremagic==2.2.0
ruamel.yaml==0.19.1 # dashboard_import
ruamel.yaml.clib==0.2.15 # dashboard_import
@@ -28,8 +28,8 @@ smpclient==7.2.0
requests==2.34.2
py7zr==1.1.3
platformdirs==4.11.5 # native esp-idf toolchain global cache dir
ninja==1.13.0 # native esp8266 arduino toolchain build driver
filelock==3.32.4 # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
ninja==1.13.2 # native esp8266 arduino toolchain build driver
filelock==3.32.5 # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
# esp-idf >= 5.0 requires this
pyparsing >= 3.3.2
tests/component_tests/remote_transmitter/test_non_blocking_gate.py
+1 -1
View File
@@ -26,7 +26,7 @@ from ..types import SetCoreConfigCallable
(PlatformFramework.ESP32_IDF, None, True),
(PlatformFramework.RTL87XX_ARDUINO, FAMILY_RTL8720C, True),
(PlatformFramework.RTL87XX_ARDUINO, FAMILY_RTL8710B, False),
(PlatformFramework.BK72XX_ARDUINO, FAMILY_BK7231N, True),
(PlatformFramework.BK72XX_ARDUINO, FAMILY_BK7231N, False),
(PlatformFramework.BK72XX_ARDUINO, FAMILY_BK7238, True),
(PlatformFramework.BK72XX_ARDUINO, FAMILY_BK7231T, False),
(PlatformFramework.ESP8266_ARDUINO, None, False),
tests/component_tests/sdl/test_sdl.py
+101
View File
@@ -0,0 +1,101 @@
"""Tests for the sdl display schema, in particular the headless option."""
from __future__ import annotations
import pytest
from esphome import config_validation as cv
from esphome.components.sdl.display import (
CONF_SDL_ID,
CONFIG_SCHEMA,
headless_final_validate,
)
from esphome.config import Config
from esphome.const import PlatformFramework
from esphome.core import ID
from esphome.final_validate import full_config
from esphome.types import ConfigType
from tests.component_tests.types import SetCoreConfigCallable
@pytest.fixture(autouse=True)
def _host_platform(set_core_config: SetCoreConfigCallable) -> None:
set_core_config(PlatformFramework.HOST_NATIVE)
def _config(**extra: object) -> ConfigType:
config: ConfigType = {
"dimensions": {"width": 320, "height": 240},
# sdl2-config is not necessarily installed in the test environment
"sdl_options": "-lSDL2",
}
config.update(extra)
return config
def test_defaults_to_windowed() -> None:
"""A display without the option is not headless."""
assert CONFIG_SCHEMA(_config())["headless"] is False
def test_headless_accepted() -> None:
"""A headless display needs nothing beyond the dimensions."""
assert CONFIG_SCHEMA(_config(headless=True))["headless"] is True
def test_headless_rejects_window_options() -> None:
"""Window options are meaningless without a window."""
with pytest.raises(cv.Invalid, match="has no effect"):
CONFIG_SCHEMA(
_config(headless=True, window_options={"position": {"x": 0, "y": 0}})
)
def test_headless_rejects_snapshot_key() -> None:
"""A headless display has no keyboard, so the action is the only way in."""
with pytest.raises(cv.Invalid, match="snapshot.take"):
CONFIG_SCHEMA(_config(headless=True, snapshot_key="SDLK_F12"))
def test_snapshot_key_accepted_when_windowed() -> None:
"""The key is only valid alongside a window."""
config = CONFIG_SCHEMA(_config(snapshot_key="SDLK_F12"))
assert str(config["snapshot_key"]) == "SDLK_F12"
def _declare_sdl_display(headless: bool) -> ID:
"""Register a full_config with a single sdl display declaration and return a reference to it.
Mirrors what the real config pipeline leaves behind: a "display" domain entry plus a
declare_ids record id_declaration_match_schema uses to find it again.
"""
declared_id = ID("my_sdl", is_declaration=True)
fc = Config()
fc["display"] = [
{
"platform": "sdl",
"id": declared_id,
"headless": headless,
"dimensions": {"width": 320, "height": 240},
}
]
fc.declare_ids.append((declared_id, ["display", 0, "id"]))
full_config.set(fc)
return ID("my_sdl")
@pytest.mark.parametrize("platform", ["binary_sensor", "touchscreen"])
def test_headless_final_validate_rejects_headless_display(platform: str) -> None:
"""binary_sensor and touchscreen both need a window, so a headless display is rejected."""
sdl_ref = _declare_sdl_display(headless=True)
schema = headless_final_validate(platform)
with pytest.raises(cv.Invalid, match="needs a window"):
schema({CONF_SDL_ID: sdl_ref})
@pytest.mark.parametrize("platform", ["binary_sensor", "touchscreen"])
def test_headless_final_validate_accepts_windowed_display(platform: str) -> None:
"""The same platforms are accepted once the display has a window."""
sdl_ref = _declare_sdl_display(headless=False)
schema = headless_final_validate(platform)
schema({CONF_SDL_ID: sdl_ref}) # Should not raise.
tests/components/remote_transmitter/test.bk72xx-ard.yaml
+1 -1
View File
@@ -2,7 +2,7 @@ remote_transmitter:
id: xmitr
pin: GPIO26
carrier_duty_percent: 50%
# non_blocking is bk7231n/bk7238-only; the CI board is a BK7252
# non_blocking is bk7238-only; the CI board is a BK7252, so this builds the bit-bang path
packages:
buttons: !include common-buttons.yaml
tests/components/sdl/common.yaml
+27
View File
@@ -14,6 +14,15 @@ display:
position:
x: 100
y: 100
snapshot_key: SDLK_F12
- platform: sdl
id: headless_display
headless: true
show_test_card: true
dimensions:
width: 320
height: 240
- platform: sdl
id: second_display
@@ -46,3 +55,21 @@ binary_sensor:
sdl_id: sdl_sdl_display
id: key_enter
key: SDLK_RETURN
esphome:
# A name of your own is only good for one snapshot - a second one under the same name fails
# rather than writing over the first - so these run once rather than on a repeating interval.
on_boot:
- delay: 2s
- snapshot.take:
id: headless_display
filename: test_card.bmp
- snapshot.take:
id: headless_display
filename: !lambda 'return "shot.bmp";'
interval:
# A generated name has the time in it, so this one can repeat.
- interval: 10s
then:
- snapshot.take: sdl_sdl_display
tests/components/sdl/validate.host.yaml
+29
View File
@@ -0,0 +1,29 @@
# Config-only test for the headless and screenshot options. The combinations that must be
# rejected are covered by tests/component_tests/sdl/test_sdl.py; this file checks that the
# accepted forms validate together.
host:
mac_address: "62:23:45:AF:B3:DD"
display:
- platform: sdl
id: headless_display
headless: true
dimensions: 320x240
- platform: sdl
id: windowed_display
dimensions: 320x240
snapshot_key: SDLK_F12
binary_sensor:
- platform: sdl
sdl_id: windowed_display
id: key_up
key: SDLK_UP
interval:
- interval: 10s
then:
- snapshot.take:
id: headless_display
filename: periodic.bmp
tests/components/snapshot/common.yaml
+34
View File
@@ -0,0 +1,34 @@
display:
- platform: snapshot
id: snapshot_display
update_interval: 1s
show_test_card: true
# An odd width exercises the row padding in the BMP writer
dimensions:
width: 101
height: 64
- platform: snapshot
id: snapshot_rotated
rotation: 90
dimensions: 320x240
lambda: |-
it.filled_rectangle(0, 0, 40, 20, Color(0xFF, 0x80, 0x00));
esphome:
# A name of your own is only good for one snapshot - a second one under the same name fails
# rather than writing over the first - so these run once rather than on a repeating interval.
on_boot:
- delay: 2s
- snapshot.take:
id: snapshot_display
filename: test_card.bmp
- snapshot.take:
id: snapshot_rotated
filename: !lambda 'return "rotated.bmp";'
interval:
# A generated name has the time in it, so this one can repeat.
- interval: 10s
then:
- snapshot.take: snapshot_display
tests/components/snapshot/test.host.yaml
+5
View File
@@ -0,0 +1,5 @@
host:
mac_address: "62:23:45:AF:B3:DE"
packages:
snapshot: !include common.yaml
tests/integration/artifact_utils.py
+26
View File
@@ -0,0 +1,26 @@
"""Shared utilities for ESPHome integration tests - keeping output from failing tests."""
from __future__ import annotations
from pathlib import Path
#: Where a failing test leaves output for someone to look at afterwards. pytest's own
#: temporary folder is no use on a CI runner, which throws the whole workspace away when
#: the job ends; the workflow uploads this folder instead when a job fails.
ARTIFACT_DIR = Path(__file__).resolve().parents[2] / "test_artifacts"
def keep_artifact(name: str, data: bytes) -> Path:
"""Write ``data`` where it can still be read after the run, and return the path.
Args:
name: File name to write under the artifact folder.
data: Contents to write.
Returns:
The full path written.
"""
ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
path = ARTIFACT_DIR / name
path.write_bytes(data)
return path
tests/integration/bmp_utils.py
+161
View File
@@ -0,0 +1,161 @@
"""Shared utilities for ESPHome integration tests - reading BMP snapshots."""
from __future__ import annotations
import asyncio
from collections.abc import Awaitable, Callable
from dataclasses import dataclass
from pathlib import Path
import struct
# Size of the smallest BMP header pair (file header plus BITMAPINFOHEADER).
_MIN_HEADER_SIZE = 54
# How long capture_when_drawn() keeps asking for a picture with something on it.
DRAW_TIMEOUT = 15.0
@dataclass(frozen=True)
class Bmp:
"""A decoded BMP image."""
width: int
height: int
bits: int
#: Pixel data with the per row padding stripped, so it depends only on the image itself.
pixels: bytes
class NotABmpError(Exception):
"""The data is not a BMP at all, as opposed to a BMP that is still being written."""
def parse_bmp(data: bytes) -> Bmp | None:
"""Decode a BMP, or return None if the data is not a complete image yet.
Raises:
NotABmpError: If the data cannot become a valid BMP however much more is appended.
"""
# Writes go to the file in order, so a short read is always a prefix of what will be there.
# Anything wrong in a prefix we have already read is wrong for good, and worth saying now
# rather than reporting as a timeout later.
if len(data) >= 2 and data[:2] != b"BM":
raise NotABmpError(f"expected a BMP, got {data[:2]!r}")
if len(data) < _MIN_HEADER_SIZE:
return None
file_size = struct.unpack_from("<I", data, 2)[0]
offset = struct.unpack_from("<I", data, 10)[0]
width, height = struct.unpack_from("<ii", data, 18)
bits = struct.unpack_from("<H", data, 28)[0]
rows = abs(height)
row_size = ((width * bits + 31) // 32) * 4
if width <= 0 or rows == 0 or bits == 0 or offset < _MIN_HEADER_SIZE:
raise NotABmpError(
f"BMP header makes no sense: {width}x{height}, {bits} bits, "
f"pixels at offset {offset}"
)
if file_size < offset + row_size * rows:
raise NotABmpError(
f"BMP header claims {file_size} bytes, too few for {width}x{rows} "
f"at {bits} bits"
)
if len(data) < file_size:
return None
used = width * bits // 8
pixels = b"".join(
data[offset + row * row_size : offset + row * row_size + used]
for row in range(rows)
)
return Bmp(width=width, height=rows, bits=bits, pixels=pixels)
async def wait_for_bmp(path: Path, timeout: float = 5.0) -> Bmp:
"""Wait for a complete BMP file to appear at ``path`` and return it.
The file is created before any of its contents are written, so waiting for it to exist is
not enough - a read that wins the race sees a truncated image. Keep reading until the
headers say the whole image is there.
Args:
path: The file to wait for.
timeout: Maximum time to wait in seconds.
Returns:
The decoded image.
Raises:
AssertionError: If no complete image is readable within ``timeout``.
NotABmpError: If what was written is not a BMP. This is reported as soon as it is
seen, so a device that writes the wrong thing is named for what it did rather
than waiting out the timeout.
"""
loop = asyncio.get_running_loop()
deadline = loop.time() + timeout
while True:
try:
data = path.read_bytes()
except FileNotFoundError:
data = b""
if (image := parse_bmp(data)) is not None:
return image
if loop.time() >= deadline:
break
await asyncio.sleep(0.05)
if not data:
raise AssertionError(f"no snapshot appeared at {path} within {timeout}s")
raise AssertionError(
f"{path} was still incomplete after {timeout}s ({len(data)} bytes)"
)
def is_blank(image: Bmp) -> bool:
"""True if every pixel of the image is the same colour.
Whole pixels are counted rather than byte values: a plain background is usually made of more
than one distinct byte, so counting bytes would find several of them in a blank screen.
"""
return len({image.pixels[i : i + 3] for i in range(0, len(image.pixels), 3)}) <= 1
async def capture_when_drawn(
take: Callable[[str], Awaitable[None]],
directory: Path,
prefix: str = "drawn",
timeout: float = DRAW_TIMEOUT,
) -> tuple[Bmp, Path]:
"""Ask for snapshots until one has something drawn on it, and return it and where it went.
A display holds one flat colour until it first draws, which is one update interval after it
starts - long enough that a test connecting over the API can easily get in first. Capturing
once and hoping would compare a blank screen against whatever the test expects, reporting a
drawing fault where the real trouble was timing.
Args:
take: Asks the device for a snapshot under the name it is given.
directory: Where the device writes them.
prefix: Start of the names asked for. Each attempt needs its own, because a snapshot never
writes over a file that is already there.
timeout: How long to keep asking.
Returns:
The first image that is not one flat colour, and the path it was read from.
Raises:
AssertionError: If nothing had been drawn within ``timeout``.
"""
loop = asyncio.get_running_loop()
deadline = loop.time() + timeout
attempt = 0
while True:
attempt += 1
path = directory / f"{prefix}-{attempt}.bmp"
await take(path.name)
image = await wait_for_bmp(path)
if not is_blank(image):
return image, path
if loop.time() >= deadline:
raise AssertionError(
f"the screen was still a single flat colour after {timeout}s and "
f"{attempt} captures - nothing was drawn"
)
await asyncio.sleep(0.5)
tests/integration/fixtures/lvgl_headless_render.yaml
+53
View File
@@ -0,0 +1,53 @@
esphome:
name: lvgl-headless-render-test
host:
api:
actions:
# The name comes from the test so it can capture more than once: a snapshot never writes over
# a file that is already there, so a fixed name could only ever be captured once.
- action: take_screenshot
variables:
name: string
then:
- snapshot.take:
id: lvgl_display
filename: !lambda return name;
logger:
level: DEBUG
display:
# A display with no screen, so what LVGL draws depends on LVGL alone - nothing about the machine
# running the test, and no graphics library outside this repository, can move the result.
- platform: snapshot
id: lvgl_display
auto_clear_enabled: false
dimensions:
width: 300
height: 300
# The widgets are spelled out here rather than left to the built in "Hello World" screen, which
# LVGL builds when nothing is configured: that screen contains a spinner, and an animation cannot
# produce the same picture twice.
#
# Everything that affects the rendered pixels is set explicitly, so the expected hash in the test
# depends only on the drawing code and the built in font. In particular the background comes from a
# full screen object rather than from the theme, so adjusting a theme default does not break this.
lvgl:
displays: lvgl_display
default_font: montserrat_14
widgets:
- obj:
width: 100%
height: 100%
bg_color: 0x000080
bg_opa: cover
border_width: 0
radius: 0
pad_all: 0
widgets:
- label:
align: center
text: "Hello World!"
text_color: 0xFFFFFF
tests/integration/fixtures/sdl_headless_screenshot.yaml
+29
View File
@@ -0,0 +1,29 @@
esphome:
name: sdl-headless-screenshot-test
host:
api:
actions:
# The name comes from the test so it can capture more than once while it waits for the first
# frame: a snapshot never writes over a file that is already there.
- action: take_screenshot
variables:
name: string
then:
- snapshot.take:
id: sdl_display
filename: !lambda return name;
logger:
level: DEBUG
display:
- platform: sdl
id: sdl_display
headless: true
show_test_card: true
update_interval: 100ms
# An odd width exercises the row padding in the BMP writer
dimensions:
width: 101
height: 64
tests/integration/fixtures/snapshot_display.yaml
+28
View File
@@ -0,0 +1,28 @@
esphome:
name: snapshot-display-test
host:
api:
actions:
# The name comes from the test so it can ask for several in a row and check what each one
# does with it.
- action: take_snapshot
variables:
name: string
then:
- snapshot.take:
id: snapshot_display
filename: !lambda return name;
logger:
level: DEBUG
display:
- platform: snapshot
id: snapshot_display
show_test_card: true
update_interval: 100ms
# An odd width exercises the row padding in the BMP writer
dimensions:
width: 101
height: 64
tests/integration/test_lvgl_headless_render.py
+83
View File
@@ -0,0 +1,83 @@
"""Integration test that checks what LVGL actually draws, using a display with no screen.
The rendered screen is compared against a hash rather than a checked in reference image, so the
repository does not have to carry a binary file. If a change to the drawing code or to the bundled
LVGL alters the output, this test fails and prints the hash it saw; update EXPECTED_SHA256 once the
new image has been looked at and found to be correct.
The picture is drawn and encoded entirely by code in this repository, so nothing installed on the
machine running the test takes part in the result.
"""
from __future__ import annotations
import hashlib
from pathlib import Path
import pytest
from .artifact_utils import keep_artifact
from .bmp_utils import capture_when_drawn
from .types import APIClientConnectedFactory, RunCompiledFunction
WIDTH = 300
HEIGHT = 300
# sha256 of the pixel data of a 300x300 screen showing "Hello World!" centred in white on a dark
# blue background, drawn with the built in montserrat_14 font. To regenerate, run this test and
# take the hash it reports.
EXPECTED_SHA256 = "a995b002dd1d183c47514da15ab9a60a3e7d788c2e24386a02fddd48655092ed"
# Bundled LVGL version (esphome/components/lvgl/__init__.py, LVGL_VERSION) the hash above was
# generated against. A version bump can shift anti-aliasing enough to change the hash even though
# nothing is actually wrong -- if this test fails, check that first before regenerating the hash.
EXPECTED_LVGL_VERSION = "9.5.0"
@pytest.mark.asyncio
async def test_lvgl_headless_render(
yaml_config: str,
run_compiled: RunCompiledFunction,
api_client_connected: APIClientConnectedFactory,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""LVGL draws the expected screen on a 300x300 display with no screen behind it."""
snapshot_dir = tmp_path / "snapshots"
monkeypatch.setenv("ESPHOME_SNAPSHOT_DIR", str(snapshot_dir))
async with run_compiled(yaml_config), api_client_connected() as client:
_, services = await client.list_entities_services()
service = next(s for s in services if s.name == "take_screenshot")
async def take(name: str) -> None:
await client.execute_service(service, {"name": name})
# The background is not the whole picture: LVGL must have drawn on it. Waiting for that
# rather than for a fixed time keeps a slow first frame from being reported as a hash
# mismatch, which would look like a drawing regression.
image, capture = await capture_when_drawn(take, snapshot_dir, prefix="render")
assert (image.width, image.height, image.bits) == (WIDTH, HEIGHT, 24)
digest = hashlib.sha256(image.pixels).hexdigest()
if digest != EXPECTED_SHA256:
# Kept outside the temporary folder so CI can upload it; see artifact_utils.
kept = keep_artifact(
"lvgl_headless_render_actual.bmp", capture.read_bytes()
)
from esphome.components.lvgl import LVGL_VERSION
version_hint = ""
if LVGL_VERSION != EXPECTED_LVGL_VERSION:
version_hint = (
f"the bundled LVGL version changed ({EXPECTED_LVGL_VERSION} -> "
f"{LVGL_VERSION}), which is the likely cause\n"
)
pytest.fail(
f"rendered screen does not match the expected hash\n"
f"{version_hint}"
f" expected: {EXPECTED_SHA256}\n"
f" actual: {digest}\n"
f"the image that was rendered has been kept at {kept}\n"
f"on CI it is in the integration-test-artifacts upload for this job"
)
tests/integration/test_sdl_headless_screenshot.py
+49
View File
@@ -0,0 +1,49 @@
"""Integration test for headless SDL rendering and snapshot capture.
How a file is named and written is the same for every display that can take a snapshot and is
covered by test_snapshot_display; what is tested here is that SDL renders and can be read back
with no display server present.
"""
from __future__ import annotations
from pathlib import Path
import pytest
from .bmp_utils import capture_when_drawn
from .types import APIClientConnectedFactory, RunCompiledFunction
WIDTH = 101
HEIGHT = 64
@pytest.mark.asyncio
async def test_sdl_headless_screenshot(
yaml_config: str,
run_compiled: RunCompiledFunction,
api_client_connected: APIClientConnectedFactory,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""A headless SDL display renders with no display server and can be captured."""
snapshot_dir = tmp_path / "snapshots"
# The device reads this when it writes a file; the subprocess inherits our environment, so it
# must be set before the binary is launched.
monkeypatch.setenv("ESPHOME_SNAPSHOT_DIR", str(snapshot_dir))
# Make sure the run really is headless even when the test machine has a display.
monkeypatch.delenv("DISPLAY", raising=False)
monkeypatch.delenv("WAYLAND_DISPLAY", raising=False)
async with run_compiled(yaml_config), api_client_connected() as client:
_, services = await client.list_entities_services()
service = next(s for s in services if s.name == "take_screenshot")
async def take(name: str) -> None:
await client.execute_service(service, {"name": name})
# The test card is drawn in several colours, so once it is on the screen the picture is
# not one flat shade. Capturing until that is true waits out the first update rather than
# racing it.
image, _ = await capture_when_drawn(take, snapshot_dir)
assert (image.width, image.height, image.bits) == (WIDTH, HEIGHT, 24)
tests/integration/test_snapshot_display.py
+78
View File
@@ -0,0 +1,78 @@
"""Integration test for the snapshot display and the file writing shared with other displays."""
from __future__ import annotations
import asyncio
from pathlib import Path
from aioesphomeapi import LogLevel
import pytest
from .bmp_utils import capture_when_drawn, wait_for_bmp
from .types import APIClientConnectedFactory, RunCompiledFunction
WIDTH = 101
HEIGHT = 64
# Part of the message the writer logs when it will not write over a file that is already there.
REFUSAL_MESSAGE = b"not overwriting"
@pytest.mark.asyncio
async def test_snapshot_display(
yaml_config: str,
run_compiled: RunCompiledFunction,
api_client_connected: APIClientConnectedFactory,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""A display with no screen draws into memory and writes what it drew to a file."""
snapshot_dir = tmp_path / "snapshots"
# The device reads this when it writes a file; the subprocess inherits our environment, so it
# must be set before the binary is launched.
monkeypatch.setenv("ESPHOME_SNAPSHOT_DIR", str(snapshot_dir))
async with run_compiled(yaml_config), api_client_connected() as client:
_, services = await client.list_entities_services()
service = next(s for s in services if s.name == "take_snapshot")
async def take(name: str) -> None:
await client.execute_service(service, {"name": name})
# The test card is drawn in several colours, so once it is on the screen the picture is
# not one flat shade. Capturing until that is true waits out the first update rather than
# racing it.
image, capture = await capture_when_drawn(take, snapshot_dir)
assert (image.width, image.height, image.bits) == (WIDTH, HEIGHT, 24)
# An extension is only added when there is not one already, whatever its case.
await take("UPPER.BMP")
await wait_for_bmp(snapshot_dir / "UPPER.BMP")
# A name that tries to lead somewhere else is cut back to one harmless name in the
# snapshot directory.
await take("../escape")
await wait_for_bmp(snapshot_dir / ".._escape.bmp")
# A second capture under a name already used must fail rather than write over the first.
# Wait for the device to report the refusal: on its own, an unchanged file cannot tell a
# refusal apart from a request the device has not got to yet, so a regression that wrote
# over the file could still pass on a busy machine.
refused = asyncio.Event()
def on_log(msg) -> None:
if REFUSAL_MESSAGE in msg.message:
refused.set()
client.subscribe_logs(on_log, log_level=LogLevel.LOG_LEVEL_DEBUG)
before = capture.read_bytes()
await take(capture.name)
await asyncio.wait_for(refused.wait(), timeout=10.0)
assert capture.read_bytes() == before
# Nothing beyond what was asked for, leaving out however many captures it took to wait
# for the first frame.
written = sorted(
p.name for p in snapshot_dir.iterdir() if not p.name.startswith("drawn-")
)
assert written == [".._escape.bmp", "UPPER.BMP"]
tests/unit_tests/components/esp8266/test_boards.py
+3 -14
View File
@@ -1,11 +1,7 @@
"""Tests for the per-board linker-script rule."""
import pytest
from esphome.components.esp8266 import _choose_ld_script
from esphome.components.esp8266.boards import BOARDS, board_ld_script
import esphome.config_validation as cv
from esphome.core import EsphomeError
def test_d1_wroom_02_keeps_its_shipped_layout() -> None:
@@ -21,13 +17,6 @@ def test_default_boards_use_the_flash_size_layout() -> None:
def test_choose_ld_script_paths() -> None:
"""Old cores get the size default, overriding boards hard-error there
(a substituted layout would wipe flash-backed state), modern cores
honor the override."""
assert _choose_ld_script("nodemcuv2", cv.Version(2, 3, 0)) is None
assert _choose_ld_script("nodemcuv2", cv.Version(2, 4, 2)) == "eagle.flash.4m.ld"
assert _choose_ld_script("d1_wroom_02", cv.Version(2, 7, 4)) == (
"eagle.flash.2m64.ld"
)
with pytest.raises(EsphomeError, match="cannot honor"):
_choose_ld_script("d1_wroom_02", cv.Version(2, 4, 2))
"""Default boards get the size layout, overriding boards keep theirs."""
assert _choose_ld_script("nodemcuv2") == "eagle.flash.4m.ld"
assert _choose_ld_script("d1_wroom_02") == "eagle.flash.2m64.ld"
tests/unit_tests/components/esp8266/test_framework_version.py
+23
View File
@@ -0,0 +1,23 @@
"""Tests for the Arduino framework version floor."""
import pytest
from esphome.components.esp8266 import _arduino_check_versions
import esphome.config_validation as cv
from esphome.const import CONF_PLATFORM_VERSION, CONF_VERSION
def test_versions_before_3_are_rejected() -> None:
with pytest.raises(cv.Invalid, match="no longer supported") as excinfo:
_arduino_check_versions({CONF_VERSION: "2.7.4"})
assert excinfo.value.path == [CONF_VERSION]
def test_supported_versions_pass() -> None:
value = _arduino_check_versions({CONF_VERSION: "3.0.2"})
assert value[CONF_VERSION] == "3.0.2"
assert "espressif8266@3.2.0" in value[CONF_PLATFORM_VERSION]
value = _arduino_check_versions({CONF_VERSION: "recommended"})
assert value[CONF_VERSION] == "3.1.2"
assert "espressif8266@4.2.1" in value[CONF_PLATFORM_VERSION]
tests/unit_tests/test_arduino8266_framework.py
+6 -11
View File
@@ -21,17 +21,12 @@ def _build_path(tmp_path: Path) -> None:
def test_framework_package_version() -> None:
assert framework.framework_package_version(cv.Version(3, 1, 2)) == "3.30102.0"
assert framework.framework_package_version(cv.Version(3, 2, 0)) == "3.30200.0"
# 2.6.3+ cores use the same package-major-3 encoding (PlatformIO path)
assert framework.framework_package_version(cv.Version(2, 7, 4)) == "3.20704.0"
# A future major bump needs its own encoding, not a doomed registry lookup
with pytest.raises(EsphomeError, match="not supported yet"):
framework.framework_package_version(cv.Version(4, 0, 0))
# The boundary matches the PlatformIO era guard; a 2.6.2 pre-release
# keeps this encoding
with pytest.raises(EsphomeError, match="older package encoding"):
framework.framework_package_version(cv.Version(2, 6, 2))
assert framework.framework_package_version(cv.Version(2, 6, 2, "b1")) == "3.20602.0"
assert framework.framework_package_version(cv.Version(2, 6, 3)) == "3.20603.0"
# Cores before 3.x cannot build ESPHome (C++20) and are rejected
with pytest.raises(EsphomeError, match="requires core 3"):
framework.framework_package_version(cv.Version(2, 7, 4))
def test_format_framework_arduino_version_pins_all_series() -> None:
@@ -39,10 +34,10 @@ def test_format_framework_arduino_version_pins_all_series() -> None:
era, including the 4.x rejection it now shares with the installer."""
from esphome.components.esp8266 import _format_framework_arduino_version as fmt
assert fmt(cv.Version(2, 4, 1)) == "~1.20401.0"
assert fmt(cv.Version(2, 6, 2)) == "~2.20602.0"
assert fmt(cv.Version(2, 7, 4)) == "~3.20704.0"
assert fmt(cv.Version(3, 1, 2)) == "~3.30102.0"
# Pre-3 cores are rejected with the version line anchored
with pytest.raises(cv.Invalid, match="requires core 3"):
fmt(cv.Version(2, 7, 4))
# Anchored to the framework version line, not a bare EsphomeError
with pytest.raises(cv.Invalid, match="not supported yet") as excinfo:
fmt(cv.Version(4, 0, 0))