Merge pull request #18957 from esphome/bump-2026.9.0b1

2026.9.0b1

.github/workflows/ci.yml

@@ -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

@@ -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

@@ -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

@@ -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.9.0b1
 
 # 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

esphome/components/cm1106/cm1106.cpp

@@ -100,7 +100,6 @@ bool CM1106Component::cm1106_write_command_(const uint8_t *command, size_t comma
 void CM1106Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CM1106:");
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
-  this->check_uart_settings(9600);
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }

esphome/components/cm1106/sensor.py

@@ -46,6 +46,14 @@ CONFIG_SCHEMA = (
     .extend(uart.UART_DEVICE_SCHEMA)
 )
 
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "cm1106",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+
 
 async def to_code(config: ConfigType) -> None:
     """Code generation entry point."""

esphome/components/cse7761/cse7761.cpp

@@ -58,7 +58,6 @@ void CSE7761Component::dump_config() {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
-  this->check_uart_settings(38400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
 }
 
 void CSE7761Component::update() {

esphome/components/cse7761/sensor.py

@@ -68,7 +68,13 @@ CONFIG_SCHEMA = (
 )
 
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "cse7761", baud_rate=38400, require_rx=True, require_tx=True
+    "cse7761",
+    baud_rate=38400,
+    require_rx=True,
+    require_tx=True,
+    data_bits=8,
+    parity="EVEN",
+    stop_bits=1,
 )
 
 

esphome/components/cse7766/cse7766.cpp

@@ -255,7 +255,6 @@ void CSE7766Component::dump_config() {
   LOG_SENSOR("  ", "Apparent Power", this->apparent_power_sensor_);
   LOG_SENSOR("  ", "Reactive Power", this->reactive_power_sensor_);
   LOG_SENSOR("  ", "Power Factor", this->power_factor_sensor_);
-  this->check_uart_settings(4800, 1, uart::UART_CONFIG_PARITY_EVEN);
 }
 
 }  // namespace esphome::cse7766

esphome/components/cse7766/sensor.py

@@ -84,7 +84,12 @@ CONFIG_SCHEMA = (
     .extend(cv.COMPONENT_SCHEMA)
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "cse7766", baud_rate=4800, parity="EVEN", require_rx=True
+    "cse7766",
+    baud_rate=4800,
+    require_rx=True,
+    data_bits=8,
+    parity="EVEN",
+    stop_bits=1,
 )
 
 

esphome/components/daly_bms/__init__.py

@@ -26,6 +26,14 @@ CONFIG_SCHEMA = (
     .extend(cv.polling_component_schema("30s"))
 )
 
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "daly_bms",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/daly_bms/daly_bms.cpp

@@ -22,10 +22,7 @@ static const uint8_t DALY_REQUEST_TEMPERATURE = 0x96;
 
 void DalyBmsComponent::setup() { this->next_request_ = 1; }
 
-void DalyBmsComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Daly BMS:");
-  this->check_uart_settings(9600);
-}
+void DalyBmsComponent::dump_config() { ESP_LOGCONFIG(TAG, "Daly BMS:"); }
 
 void DalyBmsComponent::update() {
   this->trigger_next_ = true;

esphome/components/dfplayer/__init__.py

@@ -60,7 +60,12 @@ CONFIG_SCHEMA = cv.All(
     ).extend(uart.UART_DEVICE_SCHEMA)
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "dfplayer", baud_rate=9600, require_tx=True
+    "dfplayer",
+    baud_rate=9600,
+    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
 )
 
 

esphome/components/dfplayer/dfplayer.cpp

@@ -277,9 +277,6 @@ void DFPlayer::loop() {
     }
   }
 }
-void DFPlayer::dump_config() {
-  ESP_LOGCONFIG(TAG, "DFPlayer:");
-  this->check_uart_settings(9600);
-}
+void DFPlayer::dump_config() { ESP_LOGCONFIG(TAG, "DFPlayer:"); }
 
 }  // namespace esphome::dfplayer

esphome/components/hc8/hc8.cpp

@@ -96,7 +96,6 @@ void HC8Component::dump_config() {
                 "  Warmup time: %" PRIu32 " s",
                 this->warmup_seconds_);
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
-  this->check_uart_settings(9600);
 }
 
 }  // namespace esphome::hc8

esphome/components/hc8/sensor.py

@@ -47,6 +47,9 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     baud_rate=9600,
     require_rx=True,
     require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
 )
 
 

esphome/components/he60r/he60r.cpp

@@ -38,7 +38,6 @@ CoverTraits HE60rCover::get_traits() {
 
 void HE60rCover::dump_config() {
   LOG_COVER("", "HE60R Cover", this);
-  this->check_uart_settings(1200, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
   ESP_LOGCONFIG(TAG,
                 "  Open Duration: %.1fs\n"
                 "  Close Duration: %.1fs",

esphome/components/hrxl_maxsonar_wr/hrxl_maxsonar_wr.cpp

@@ -68,8 +68,6 @@ void HrxlMaxsonarWrComponent::check_buffer_() {
 void HrxlMaxsonarWrComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "HRXL MaxSonar WR Sensor:");
   LOG_SENSOR("  ", "Distance", this);
-  // As specified in the sensor's data sheet
-  this->check_uart_settings(9600, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
 }
 
 }  // namespace esphome::hrxl_maxsonar_wr

esphome/components/hrxl_maxsonar_wr/sensor.py

@@ -23,6 +23,14 @@ CONFIG_SCHEMA = sensor.sensor_schema(
     state_class=STATE_CLASS_MEASUREMENT,
 ).extend(uart.UART_DEVICE_SCHEMA)
 
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "hrxl_maxsonar_wr",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+
 
 async def to_code(config: ConfigType) -> None:
     var = await sensor.new_sensor(config)

esphome/components/hydreon_rgxx/hydreon_rgxx.cpp

@@ -11,7 +11,6 @@ static const char *const PROTOCOL_NAMES[] = {HYDREON_RGXX_PROTOCOL_LIST(, HYDREO
 static const char *const IGNORE_STRINGS[] = {HYDREON_RGXX_IGNORE_LIST(, HYDREON_RGXX_COMMA)};
 
 void HydreonRGxxComponent::dump_config() {
-  this->check_uart_settings(9600, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
   ESP_LOGCONFIG(TAG, "hydreon_rgxx:");
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Connection with hydreon_rgxx failed!");

esphome/components/hydreon_rgxx/sensor.py

@@ -130,6 +130,14 @@ CONFIG_SCHEMA = cv.All(
     _validate,
 )
 
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "hydreon_rgxx",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/kamstrup_kmp/kamstrup_kmp.cpp

@@ -26,8 +26,6 @@ void KamstrupKMPComponent::dump_config() {
     LOG_SENSOR("  ", "Custom Sensor", this->custom_sensors_[i]);
     ESP_LOGCONFIG(TAG, "    Command: 0x%04X", this->custom_commands_[i]);
   }
-
-  this->check_uart_settings(1200, 2, uart::UART_CONFIG_PARITY_NONE, 8);
 }
 
 void KamstrupKMPComponent::update() {

esphome/components/kamstrup_kmp/sensor.py

@@ -102,7 +102,13 @@ CONFIG_SCHEMA = (
 )
 
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "kamstrup_kmp", baud_rate=1200, require_rx=True, require_tx=True
+    "kamstrup_kmp",
+    baud_rate=1200,
+    require_rx=True,
+    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=2,
 )
 
 

esphome/components/mhz19/mhz19.cpp

@@ -143,8 +143,6 @@ void MHZ19Component::dump_config() {
   ESP_LOGCONFIG(TAG, "MH-Z19:");
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
-  this->check_uart_settings(9600);
-
   if (this->abc_boot_logic_ == MHZ19_ABC_ENABLED) {
     ESP_LOGCONFIG(TAG, "  Automatic baseline calibration enabled on boot");
   } else if (this->abc_boot_logic_ == MHZ19_ABC_DISABLED) {

esphome/components/mhz19/sensor.py

@@ -80,6 +80,14 @@ CONFIG_SCHEMA = (
     .extend(uart.UART_DEVICE_SCHEMA)
 )
 
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "mhz19",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/mk2pvrouter/mk2pvrouter.cpp

@@ -163,10 +163,7 @@ void Mk2PVRouter::publish_value_(const char *tag, const char *val) {
 #endif
 }
 
-void Mk2PVRouter::dump_config() {
-  ESP_LOGCONFIG(TAG, "Mk2PVRouter:");
-  this->check_uart_settings(BAUD_RATE, 1, uart::UART_CONFIG_PARITY_EVEN, 7);
-}
+void Mk2PVRouter::dump_config() { ESP_LOGCONFIG(TAG, "Mk2PVRouter:"); }
 
 #ifdef MK2PVROUTER_LISTENER_COUNT
 void Mk2PVRouter::register_mk2pvrouter_listener(Mk2PVRouterListener *listener) {

esphome/components/mk2pvrouter/mk2pvrouter.h

@@ -43,7 +43,6 @@ class Mk2PVRouter final : public Component, public uart::UARTDevice {
 
  protected:
   static constexpr size_t CRC_SUFFIX_LEN = 1;
-  static constexpr uint32_t BAUD_RATE = 9600;
 
   enum class State : uint8_t {
     WAITING_FOR_START,

esphome/components/pm1006/pm1006.cpp

@@ -16,7 +16,6 @@ void PM1006Component::dump_config() {
   ESP_LOGCONFIG(TAG, "PM1006:");
   LOG_SENSOR("  ", "PM2.5", this->pm_2_5_sensor_);
   LOG_UPDATE_INTERVAL(this);
-  this->check_uart_settings(9600);
 }
 
 void PM1006Component::update() {

esphome/components/pm1006/sensor.py

@@ -48,6 +48,9 @@ def validate_interval_uart(config: ConfigType) -> None:
         baud_rate=9600,
         require_rx=True,
         require_tx=interval.total_milliseconds != SCHEDULER_DONT_RUN,
+        data_bits=8,
+        parity="NONE",
+        stop_bits=1,
     )(config)
 
 

esphome/components/pmsx003/pmsx003.cpp

@@ -46,8 +46,6 @@ void PMSX003Component::dump_config() {
   } else {
     ESP_LOGCONFIG(TAG, "  Mode: passive with sleep/wake cycles");
   }
-
-  this->check_uart_settings(9600);
 }
 
 void PMSX003Component::loop() {

esphome/components/pmsx003/sensor.py

@@ -302,7 +302,13 @@ CONFIG_SCHEMA = cv.All(
 def final_validate(config: ConfigType) -> None:
     require_tx = config[CONF_UPDATE_INTERVAL] > cv.time_period("0s")
     schema = uart.final_validate_device_schema(
-        "pmsx003", baud_rate=9600, require_rx=True, require_tx=require_tx
+        "pmsx003",
+        baud_rate=9600,
+        require_rx=True,
+        require_tx=require_tx,
+        data_bits=8,
+        parity="NONE",
+        stop_bits=1,
     )
     schema(config)
 

esphome/components/pylontech/__init__.py

@@ -41,6 +41,14 @@ CONFIG_SCHEMA = cv.All(
     .extend(uart.UART_DEVICE_SCHEMA)
 )
 
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "pylontech",
+    baud_rate=115200,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/pylontech/pylontech.cpp

@@ -33,7 +33,6 @@ static const uint8_t ASCII_LF = 0x0A;
 PylontechComponent::PylontechComponent() {}
 
 void PylontechComponent::dump_config() {
-  this->check_uart_settings(115200, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
   ESP_LOGCONFIG(TAG, "pylontech:");
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Connection with pylontech failed!");

esphome/components/sdl/__init__.py

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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/seeed_mr60fda2/__init__.py

@@ -31,6 +31,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     require_tx=True,
     require_rx=True,
     baud_rate=115200,
+    data_bits=8,
     parity="NONE",
     stop_bits=1,
 )

esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp

@@ -33,8 +33,6 @@ void MR60FDA2Component::dump_config() {
 
 // Initialisation functions
 void MR60FDA2Component::setup() {
-  this->check_uart_settings(115200);
-
   this->current_frame_locate_ = LOCATE_FRAME_HEADER;
   this->current_frame_id_ = 0;
   this->current_frame_len_ = 0;

esphome/components/serial_proxy/serial_proxy.cpp

@@ -130,17 +130,26 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
     return SerialProxyResult::SERIAL_PROXY_RESULT_NOT_SUPPORTED;
   }
 
-  // Apply validated parameters
-  uart_comp->set_baud_rate(baudrate);
-  uart_comp->set_stop_bits(stop_bits);
-  uart_comp->set_data_bits(data_size);
-
-  // Map parity value to UARTParityOptions
+  // Skip a no-op reconfigure. Clients routinely re-send identical settings on every
+  // port open, and on a USB UART each apply is a CDC SET_LINE_CODING control transfer.
+  // Some bridges watch line-coding changes as a signalling channel (a magic baud
+  // sequence to enter a bootloader, say), so redundant applies are not harmless.
   static const uart::UARTParityOptions PARITY_MAP[] = {
       uart::UART_CONFIG_PARITY_NONE,
       uart::UART_CONFIG_PARITY_EVEN,
       uart::UART_CONFIG_PARITY_ODD,
   };
+  if (uart_comp->get_baud_rate() == baudrate && uart_comp->get_stop_bits() == stop_bits &&
+      uart_comp->get_data_bits() == data_size && uart_comp->get_parity() == PARITY_MAP[parity]) {
+    ESP_LOGV(TAG, "Settings unchanged, skipping reconfigure [%" PRIu32 "]", this->instance_index_);
+    return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
+  }
+
+  // Apply validated parameters
+  uart_comp->set_baud_rate(baudrate);
+  uart_comp->set_stop_bits(stop_bits);
+  uart_comp->set_data_bits(data_size);
+
   uart_comp->set_parity(PARITY_MAP[parity]);
 
   // load_settings() is available on ESP8266 and ESP32 platforms

esphome/components/smt100/sensor.py

@@ -68,7 +68,13 @@ CONFIG_SCHEMA = (
 )
 
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "smt100", baud_rate=9600, require_rx=True, require_tx=True
+    "smt100",
+    baud_rate=9600,
+    require_rx=True,
+    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
 )
 
 

esphome/components/smt100/smt100.cpp

@@ -65,7 +65,6 @@ void SMT100Component::dump_config() {
   LOG_SENSOR(TAG, "Temperature", this->temperature_sensor_);
   LOG_SENSOR(TAG, "Moisture", this->moisture_sensor_);
   LOG_UPDATE_INTERVAL(this);
-  this->check_uart_settings(9600);
 }
 
 int SMT100Component::readline_(int readch, char *buffer, int len) {

esphome/components/snapshot/__init__.py

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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/t6615/sensor.py

@@ -33,7 +33,13 @@ CONFIG_SCHEMA = (
 )
 
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "t6615", baud_rate=19200, require_rx=True, require_tx=True
+    "t6615",
+    baud_rate=19200,
+    require_rx=True,
+    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
 )
 
 

esphome/components/t6615/t6615.cpp

@@ -88,7 +88,6 @@ void T6615Component::query_ppm_() {
 void T6615Component::dump_config() {
   ESP_LOGCONFIG(TAG, "T6615:");
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
-  this->check_uart_settings(19200);
 }
 
 }  // namespace esphome::t6615

esphome/components/teleinfo/__init__.py

@@ -35,6 +35,22 @@ CONFIG_SCHEMA = (
 )
 
 
+def _final_validate(config: ConfigType) -> ConfigType:
+    # Historical mode runs at 1200 baud, standard mode at 9600 baud.
+    baud_rate = 1200 if config[CONF_HISTORICAL_MODE] else 9600
+    uart.final_validate_device_schema(
+        "teleinfo",
+        baud_rate=baud_rate,
+        data_bits=7,
+        parity="EVEN",
+        stop_bits=1,
+    )(config)
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID], config[CONF_HISTORICAL_MODE])
     await cg.register_component(var, config)

esphome/components/teleinfo/teleinfo.cpp

@@ -184,10 +184,7 @@ void TeleInfo::publish_value_(const std::string &tag, const std::string &val) {
     element->publish_val(val);
   }
 }
-void TeleInfo::dump_config() {
-  ESP_LOGCONFIG(TAG, "TeleInfo:");
-  this->check_uart_settings(baud_rate_, 1, uart::UART_CONFIG_PARITY_EVEN, 7);
-}
+void TeleInfo::dump_config() { ESP_LOGCONFIG(TAG, "TeleInfo:"); }
 TeleInfo::TeleInfo(bool historical_mode) {
   if (historical_mode) {
     /*
@@ -195,11 +192,9 @@ TeleInfo::TeleInfo(bool historical_mode) {
      */
     checksum_area_end_ = 2;
     separator_ = 0x20;
-    baud_rate_ = 1200;
   } else {
     checksum_area_end_ = 1;
     separator_ = 0x9;
-    baud_rate_ = 9600;
   }
 }
 void TeleInfo::register_teleinfo_listener(TeleInfoListener *listener) { teleinfo_listeners_.push_back(listener); }

esphome/components/teleinfo/teleinfo.h

@@ -31,7 +31,6 @@ class TeleInfo final : public PollingComponent, public uart::UARTDevice {
   std::vector<TeleInfoListener *> teleinfo_listeners_{};
 
  protected:
-  uint32_t baud_rate_;
   int checksum_area_end_;
   int separator_;
   char buf_[MAX_BUF_SIZE];

esphome/components/tormatic/tormatic_cover.cpp

@@ -36,8 +36,6 @@ cover::CoverTraits Tormatic::get_traits() {
 
 void Tormatic::dump_config() {
   LOG_COVER("", "Tormatic Cover", this);
-  this->check_uart_settings(9600, 1, uart::UART_CONFIG_PARITY_NONE, 8);
-
   ESP_LOGCONFIG(TAG,
                 "  Open Duration: %.1fs\n"
                 "  Close Duration: %.1fs",

esphome/components/uart/uart.h

@@ -3,6 +3,7 @@
 #include <vector>
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "uart_component.h"
 
@@ -66,6 +67,7 @@ class UARTDevice {
   }
 
   /// Check that the configuration of the UART bus matches the provided values and otherwise print a warning
+  ESPDEPRECATED("Use uart.final_validate_device_schema() in Python instead. Removed in 2027.3.0", "2026.9.0")
   void check_uart_settings(uint32_t baud_rate, uint8_t stop_bits = 1,
                            UARTParityOptions parity = UART_CONFIG_PARITY_NONE, uint8_t data_bits = 8);
 

esphome/components/ufm01/__init__.py

@@ -30,6 +30,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     require_tx=True,
     require_rx=True,
     baud_rate=2400,
+    data_bits=8,
     parity="EVEN",
     stop_bits=1,
 )

esphome/components/ufm01/ufm01.cpp

@@ -213,7 +213,6 @@ void UFM01Component::dump_config() {
   LOG_BINARY_SENSOR("  ", "Empty Tube", this->empty_tube_binary_sensor_);
   LOG_BINARY_SENSOR("  ", "Flow Rate Out Of Range", this->flow_rate_out_of_range_binary_sensor_);
 #endif
-  this->check_uart_settings(2400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
 }
 
 void UFM01Component::on_active_frame_(uint8_t data[FRAME_SIZE]) {

esphome/components/uponor_smatrix/__init__.py

@@ -50,7 +50,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     require_tx=True,
     require_rx=True,
     data_bits=8,
-    parity=None,
+    parity="NONE",
     stop_bits=1,
 )
 

esphome/components/uponor_smatrix/uponor_smatrix.cpp

@@ -29,8 +29,6 @@ void UponorSmatrixComponent::dump_config() {
   }
 #endif
 
-  this->check_uart_settings(19200);
-
   if (!this->unknown_devices_.empty()) {
     ESP_LOGCONFIG(TAG, "  Detected unknown device addresses:");
     for (auto device_address : this->unknown_devices_) {

esphome/components/vbus/__init__.py

@@ -29,6 +29,14 @@ CONFIG_SCHEMA = uart.UART_DEVICE_SCHEMA.extend(
     }
 )
 
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "vbus",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/vbus/vbus.cpp

@@ -11,10 +11,7 @@ static const char *const TAG = "vbus";
 // Maximum bytes to log in verbose hex output (16 frames * 4 bytes = 64 bytes typical)
 static constexpr size_t VBUS_MAX_LOG_BYTES = 64;
 
-void VBus::dump_config() {
-  ESP_LOGCONFIG(TAG, "VBus:");
-  check_uart_settings(9600);
-}
+void VBus::dump_config() { ESP_LOGCONFIG(TAG, "VBus:"); }
 
 static void septet_spread(uint8_t *data, int start, int count, uint8_t septet) {
   for (int i = 0; i < count; i++, septet >>= 1) {

esphome/components/wl_134/text_sensor.py

@@ -21,6 +21,14 @@ CONFIG_SCHEMA = (
     .extend(uart.UART_DEVICE_SCHEMA)
 )
 
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "wl_134",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+
 
 async def to_code(config: ConfigType) -> None:
     var = await text_sensor.new_text_sensor(config)

esphome/components/wl_134/wl_134.cpp

@@ -110,7 +110,5 @@ uint64_t Wl134Component::hex_lsb_ascii_to_uint64_(const uint8_t *text, uint8_t t
 void Wl134Component::dump_config() {
   ESP_LOGCONFIG(TAG, "WL-134 Sensor:");
   LOG_TEXT_SENSOR("", "Tag", this);
-  // As specified in the sensor's data sheet
-  this->check_uart_settings(9600, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
 }
 }  // namespace esphome::wl_134

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2026.9.0-dev"
+__version__ = "2026.9.0b1"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/core/defines.h

@@ -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

tests/component_tests/sdl/test_sdl.py

@@ -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/cse7761/test.esp32-idf.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO14
 
 packages:
-  uart_38400: !include ../../test_build_components/common/uart_38400/esp32-idf.yaml
+  uart_38400_even: !include ../../test_build_components/common/uart_38400_even/esp32-idf.yaml
 
 <<: !include common.yaml

tests/components/cse7761/test.esp8266-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO3
 
 packages:
-  uart_38400: !include ../../test_build_components/common/uart_38400/esp8266-ard.yaml
+  uart_38400_even: !include ../../test_build_components/common/uart_38400_even/esp8266-ard.yaml
 
 <<: !include common.yaml

tests/components/cse7761/test.rp2040-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO5
 
 packages:
-  uart_38400: !include ../../test_build_components/common/uart_38400/rp2040-ard.yaml
+  uart_38400_even: !include ../../test_build_components/common/uart_38400_even/rp2040-ard.yaml
 
 <<: !include common.yaml

tests/components/kamstrup_kmp/test.esp32-idf.yaml

@@ -1,4 +1,4 @@
 packages:
-  uart_1200: !include ../../test_build_components/common/uart_1200/esp32-idf.yaml
+  uart_1200_none_2stopbits: !include ../../test_build_components/common/uart_1200_none_2stopbits/esp32-idf.yaml
 
 <<: !include common.yaml

tests/components/kamstrup_kmp/test.esp8266-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   uart_rx_pin: GPIO3
 
 packages:
-  uart_1200: !include ../../test_build_components/common/uart_1200/esp8266-ard.yaml
+  uart_1200_none_2stopbits: !include ../../test_build_components/common/uart_1200_none_2stopbits/esp8266-ard.yaml
 
 <<: !include common.yaml

tests/components/pylontech/test.esp32-idf.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO5
 
 packages:
-  uart: !include ../../test_build_components/common/uart/esp32-idf.yaml
+  uart_115200: !include ../../test_build_components/common/uart_115200/esp32-idf.yaml
 
 <<: !include common.yaml

tests/components/pylontech/test.esp8266-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO2
 
 packages:
-  uart: !include ../../test_build_components/common/uart/esp8266-ard.yaml
+  uart_115200: !include ../../test_build_components/common/uart_115200/esp8266-ard.yaml
 
 <<: !include common.yaml

tests/components/pylontech/test.rp2040-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO5
 
 packages:
-  uart: !include ../../test_build_components/common/uart/rp2040-ard.yaml
+  uart_115200: !include ../../test_build_components/common/uart_115200/rp2040-ard.yaml
 
 <<: !include common.yaml

tests/components/sdl/common.yaml

@@ -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

@@ -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

@@ -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

@@ -0,0 +1,5 @@
+host:
+  mac_address: "62:23:45:AF:B3:DE"
+
+packages:
+  snapshot: !include common.yaml

tests/components/teleinfo/test.esp32-idf.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO5
 
 packages:
-  uart: !include ../../test_build_components/common/uart/esp32-idf.yaml
+  uart_1200_even_7bits: !include ../../test_build_components/common/uart_1200_even_7bits/esp32-idf.yaml
 
 <<: !include common.yaml

tests/components/teleinfo/test.esp8266-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO2
 
 packages:
-  uart: !include ../../test_build_components/common/uart/esp8266-ard.yaml
+  uart_1200_even_7bits: !include ../../test_build_components/common/uart_1200_even_7bits/esp8266-ard.yaml
 
 <<: !include common.yaml

tests/components/teleinfo/test.rp2040-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO5
 
 packages:
-  uart: !include ../../test_build_components/common/uart/rp2040-ard.yaml
+  uart_1200_even_7bits: !include ../../test_build_components/common/uart_1200_even_7bits/rp2040-ard.yaml
 
 <<: !include common.yaml

tests/components/teleinfo/validate-standard.esp32-idf.yaml

@@ -0,0 +1,14 @@
+packages:
+  uart_9600_even_7bits: !include ../../test_build_components/common/uart_9600_even_7bits/esp32-idf.yaml
+
+teleinfo:
+  id: test_teleinfo_standard
+  historical_mode: false
+  update_interval: 60s
+
+sensor:
+  - platform: teleinfo
+    name: sinsts
+    tag_name: SINSTS
+    teleinfo_id: test_teleinfo_standard
+    unit_of_measurement: VA

tests/integration/artifact_utils.py

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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/test_build_components/common/uart_1200_even_7bits/esp32-ard.yaml

@@ -0,0 +1,14 @@
+# Common UART configuration for ESP32 Arduino tests - 1200 baud, EVEN parity, 7 data bits
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 1200
+    parity: EVEN
+    data_bits: 7
+    stop_bits: 1

tests/test_build_components/common/uart_1200_even_7bits/esp32-c3-ard.yaml

@@ -0,0 +1,14 @@
+# Common UART configuration for ESP32-C3 Arduino tests - 1200 baud, EVEN parity, 7 data bits
+
+substitutions:
+  tx_pin: GPIO20
+  rx_pin: GPIO21
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 1200
+    parity: EVEN
+    data_bits: 7
+    stop_bits: 1

tests/test_build_components/common/uart_1200_even_7bits/esp32-c3-idf.yaml

@@ -0,0 +1,14 @@
+# Common UART configuration for ESP32-C3 IDF tests - 1200 baud, EVEN parity, 7 data bits
+
+substitutions:
+  tx_pin: GPIO20
+  rx_pin: GPIO21
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 1200
+    parity: EVEN
+    data_bits: 7
+    stop_bits: 1

tests/test_build_components/common/uart_1200_even_7bits/esp32-idf.yaml

@@ -0,0 +1,14 @@
+# Common UART configuration for ESP32 IDF tests - 1200 baud, EVEN parity, 7 data bits
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 1200
+    parity: EVEN
+    data_bits: 7
+    stop_bits: 1

tests/test_build_components/common/uart_1200_even_7bits/esp8266-ard.yaml

@@ -0,0 +1,14 @@
+# Common UART configuration for ESP8266 Arduino tests - 1200 baud, EVEN parity, 7 data bits
+
+substitutions:
+  tx_pin: GPIO4
+  rx_pin: GPIO5
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 1200
+    parity: EVEN
+    data_bits: 7
+    stop_bits: 1

tests/test_build_components/common/uart_1200_even_7bits/rp2040-ard.yaml

@@ -0,0 +1,14 @@
+# Common UART configuration for RP2040 Arduino tests - 1200 baud, EVEN parity, 7 data bits
+
+substitutions:
+  tx_pin: GPIO0
+  rx_pin: GPIO1
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 1200
+    parity: EVEN
+    data_bits: 7
+    stop_bits: 1

tests/test_build_components/common/uart_38400_even/esp32-ard.yaml

@@ -0,0 +1,12 @@
+# Common UART configuration for ESP32 Arduino tests - 38400 baud, EVEN parity
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 38400
+    parity: EVEN

tests/test_build_components/common/uart_38400_even/esp32-c3-ard.yaml

@@ -0,0 +1,12 @@
+# Common UART configuration for ESP32-C3 Arduino tests - 38400 baud, EVEN parity
+
+substitutions:
+  tx_pin: GPIO20
+  rx_pin: GPIO21
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 38400
+    parity: EVEN