esphome 2025.8.4__py3-none-any.whl → 2025.9.0b2__py3-none-any.whl

esphome/components/http_request/ota/__init__.py

@@ -3,7 +3,7 @@ import esphome.codegen as cg
 from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_PASSWORD, CONF_URL, CONF_USERNAME
-from esphome.core import coroutine_with_priority
+from esphome.core import CoroPriority, coroutine_with_priority
 
 from .. import CONF_HTTP_REQUEST_ID, HttpRequestComponent, http_request_ns
 
@@ -40,7 +40,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(52.0)
+@coroutine_with_priority(CoroPriority.COMMUNICATION)
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await ota_to_code(var, config)

esphome/components/i2c/__init__.py

@@ -18,7 +18,7 @@ from esphome.const import (
     PLATFORM_RP2040,
     PlatformFramework,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 import esphome.final_validate as fv
 
 LOGGER = logging.getLogger(__name__)
@@ -74,7 +74,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(1.0)
+@coroutine_with_priority(CoroPriority.BUS)
 async def to_code(config):
     cg.add_global(i2c_ns.using)
     cg.add_define("USE_I2C")

esphome/components/i2c/i2c.cpp

@@ -39,18 +39,22 @@ ErrorCode I2CDevice::read_register16(uint16_t a_register, uint8_t *data, size_t
 }
 
 ErrorCode I2CDevice::write_register(uint8_t a_register, const uint8_t *data, size_t len) const {
-  std::vector<uint8_t> v{};
-  v.push_back(a_register);
-  v.insert(v.end(), data, data + len);
-  return bus_->write_readv(this->address_, v.data(), v.size(), nullptr, 0);
+  SmallBufferWithHeapFallback<17> buffer_alloc;  // Most I2C writes are <= 16 bytes
+  uint8_t *buffer = buffer_alloc.get(len + 1);
+
+  buffer[0] = a_register;
+  std::copy(data, data + len, buffer + 1);
+  return this->bus_->write_readv(this->address_, buffer, len + 1, nullptr, 0);
 }
 
 ErrorCode I2CDevice::write_register16(uint16_t a_register, const uint8_t *data, size_t len) const {
-  std::vector<uint8_t> v(len + 2);
-  v[0] = a_register >> 8;
-  v[1] = a_register;
-  std::copy(data, data + len, v.begin() + 2);
-  return bus_->write_readv(this->address_, v.data(), v.size(), nullptr, 0);
+  SmallBufferWithHeapFallback<18> buffer_alloc;  // Most I2C writes are <= 16 bytes + 2 for register
+  uint8_t *buffer = buffer_alloc.get(len + 2);
+
+  buffer[0] = a_register >> 8;
+  buffer[1] = a_register;
+  std::copy(data, data + len, buffer + 2);
+  return this->bus_->write_readv(this->address_, buffer, len + 2, nullptr, 0);
 }
 
 bool I2CDevice::read_bytes_16(uint8_t a_register, uint16_t *data, uint8_t len) {

esphome/components/i2c/i2c_bus.h

@@ -2,6 +2,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <memory>
 #include <utility>
 #include <vector>
 
@@ -10,6 +11,22 @@
 namespace esphome {
 namespace i2c {
 
+/// @brief Helper class for efficient buffer allocation - uses stack for small sizes, heap for large
+template<size_t STACK_SIZE> class SmallBufferWithHeapFallback {
+ public:
+  uint8_t *get(size_t size) {
+    if (size <= STACK_SIZE) {
+      return this->stack_buffer_;
+    }
+    this->heap_buffer_ = std::unique_ptr<uint8_t[]>(new uint8_t[size]);
+    return this->heap_buffer_.get();
+  }
+
+ private:
+  uint8_t stack_buffer_[STACK_SIZE];
+  std::unique_ptr<uint8_t[]> heap_buffer_;
+};
+
 /// @brief Error codes returned by I2CBus and I2CDevice methods
 enum ErrorCode {
   NO_ERROR = 0,                ///< No error found during execution of method
@@ -74,14 +91,17 @@ class I2CBus {
     for (size_t i = 0; i != count; i++) {
       total_len += read_buffers[i].len;
     }
-    std::vector<uint8_t> buffer(total_len);
-    auto err = this->write_readv(address, nullptr, 0, buffer.data(), total_len);
+
+    SmallBufferWithHeapFallback<128> buffer_alloc;  // Most I2C reads are small
+    uint8_t *buffer = buffer_alloc.get(total_len);
+
+    auto err = this->write_readv(address, nullptr, 0, buffer, total_len);
     if (err != ERROR_OK)
       return err;
     size_t pos = 0;
     for (size_t i = 0; i != count; i++) {
       if (read_buffers[i].len != 0) {
-        std::memcpy(read_buffers[i].data, buffer.data() + pos, read_buffers[i].len);
+        std::memcpy(read_buffers[i].data, buffer + pos, read_buffers[i].len);
         pos += read_buffers[i].len;
       }
     }
@@ -91,11 +111,21 @@ class I2CBus {
   ESPDEPRECATED("This method is deprecated and will be removed in ESPHome 2026.3.0. Use write_readv() instead.",
                 "2025.9.0")
   ErrorCode writev(uint8_t address, const WriteBuffer *write_buffers, size_t count, bool stop = true) {
-    std::vector<uint8_t> buffer{};
+    size_t total_len = 0;
     for (size_t i = 0; i != count; i++) {
-      buffer.insert(buffer.end(), write_buffers[i].data, write_buffers[i].data + write_buffers[i].len);
+      total_len += write_buffers[i].len;
     }
-    return this->write_readv(address, buffer.data(), buffer.size(), nullptr, 0);
+
+    SmallBufferWithHeapFallback<128> buffer_alloc;  // Most I2C writes are small
+    uint8_t *buffer = buffer_alloc.get(total_len);
+
+    size_t pos = 0;
+    for (size_t i = 0; i != count; i++) {
+      std::memcpy(buffer + pos, write_buffers[i].data, write_buffers[i].len);
+      pos += write_buffers[i].len;
+    }
+
+    return this->write_readv(address, buffer, total_len, nullptr, 0);
   }
 
  protected:

esphome/components/i2s_audio/__init__.py

@@ -4,6 +4,9 @@ from esphome.components.esp32 import add_idf_sdkconfig_option, get_esp32_variant
 from esphome.components.esp32.const import (
     VARIANT_ESP32,
     VARIANT_ESP32C3,
+    VARIANT_ESP32C5,
+    VARIANT_ESP32C6,
+    VARIANT_ESP32H2,
     VARIANT_ESP32P4,
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
@@ -62,12 +65,15 @@ I2S_ROLE_OPTIONS = {
     CONF_SECONDARY: i2s_role_t.I2S_ROLE_SLAVE,  # NOLINT
 }
 
-# https://github.com/espressif/esp-idf/blob/master/components/soc/{variant}/include/soc/soc_caps.h
+# https://github.com/espressif/esp-idf/blob/master/components/soc/{variant}/include/soc/soc_caps.h (SOC_I2S_NUM)
 I2S_PORTS = {
     VARIANT_ESP32: 2,
     VARIANT_ESP32S2: 1,
     VARIANT_ESP32S3: 2,
     VARIANT_ESP32C3: 1,
+    VARIANT_ESP32C5: 1,
+    VARIANT_ESP32C6: 1,
+    VARIANT_ESP32H2: 1,
     VARIANT_ESP32P4: 3,
 }
 
@@ -212,7 +218,7 @@ def validate_use_legacy(value):
                 f"All i2s_audio components must set {CONF_USE_LEGACY} to the same value."
             )
         if (not value[CONF_USE_LEGACY]) and (CORE.using_arduino):
-            raise cv.Invalid("Arduino supports only the legacy i2s driver.")
+            raise cv.Invalid("Arduino supports only the legacy i2s driver")
         _use_legacy_driver = value[CONF_USE_LEGACY]
     return value
 

esphome/components/i2s_audio/media_player/__init__.py

@@ -92,7 +92,7 @@ CONFIG_SCHEMA = cv.All(
 
 def _final_validate(_):
     if not use_legacy():
-        raise cv.Invalid("I2S media player is only compatible with legacy i2s driver.")
+        raise cv.Invalid("I2S media player is only compatible with legacy i2s driver")
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate

esphome/components/i2s_audio/microphone/__init__.py

@@ -122,7 +122,7 @@ CONFIG_SCHEMA = cv.All(
 
 def _final_validate(config):
     if not use_legacy() and config[CONF_ADC_TYPE] == "internal":
-        raise cv.Invalid("Internal ADC is only compatible with legacy i2s driver.")
+        raise cv.Invalid("Internal ADC is only compatible with legacy i2s driver")
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate

esphome/components/i2s_audio/speaker/__init__.py

@@ -163,7 +163,7 @@ CONFIG_SCHEMA = cv.All(
 def _final_validate(config):
     if not use_legacy():
         if config[CONF_DAC_TYPE] == "internal":
-            raise cv.Invalid("Internal DAC is only compatible with legacy i2s driver.")
+            raise cv.Invalid("Internal DAC is only compatible with legacy i2s driver")
         if config[CONF_I2S_COMM_FMT] == "stand_max":
             raise cv.Invalid(
                 "I2S standard max format only implemented with legacy i2s driver."

esphome/components/ina2xx_base/__init__.py

@@ -18,6 +18,7 @@ from esphome.const import (
     DEVICE_CLASS_TEMPERATURE,
     DEVICE_CLASS_VOLTAGE,
     STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_TOTAL_INCREASING,
     UNIT_AMPERE,
     UNIT_CELSIUS,
     UNIT_VOLT,
@@ -162,7 +163,7 @@ INA2XX_SCHEMA = cv.Schema(
                 unit_of_measurement=UNIT_WATT_HOURS,
                 accuracy_decimals=8,
                 device_class=DEVICE_CLASS_ENERGY,
-                state_class=STATE_CLASS_MEASUREMENT,
+                state_class=STATE_CLASS_TOTAL_INCREASING,
             ),
             key=CONF_NAME,
         ),
@@ -170,7 +171,8 @@ INA2XX_SCHEMA = cv.Schema(
             sensor.sensor_schema(
                 unit_of_measurement=UNIT_JOULE,
                 accuracy_decimals=8,
-                state_class=STATE_CLASS_MEASUREMENT,
+                device_class=DEVICE_CLASS_ENERGY,
+                state_class=STATE_CLASS_TOTAL_INCREASING,
             ),
             key=CONF_NAME,
         ),

esphome/components/inkplate/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@jesserockz", "@JosipKuci"]

esphome/components/inkplate/const.py

@@ -0,0 +1,105 @@
+WAVEFORMS = {
+    "inkplate_6": (
+        (0, 1, 1, 0, 0, 1, 1, 0, 0),
+        (0, 1, 2, 1, 1, 2, 1, 0, 0),
+        (1, 1, 1, 2, 2, 1, 0, 0, 0),
+        (0, 0, 0, 1, 1, 1, 2, 0, 0),
+        (2, 1, 1, 1, 2, 1, 2, 0, 0),
+        (2, 2, 1, 1, 2, 1, 2, 0, 0),
+        (1, 1, 1, 2, 1, 2, 2, 0, 0),
+        (0, 0, 0, 0, 0, 0, 2, 0, 0),
+    ),
+    "inkplate_10": (
+        (0, 0, 0, 0, 0, 0, 0, 1, 0),
+        (0, 0, 0, 2, 2, 2, 1, 1, 0),
+        (0, 0, 2, 1, 1, 2, 2, 1, 0),
+        (0, 1, 2, 2, 1, 2, 2, 1, 0),
+        (0, 0, 2, 1, 2, 2, 2, 1, 0),
+        (0, 2, 2, 2, 2, 2, 2, 1, 0),
+        (0, 0, 0, 0, 0, 2, 1, 2, 0),
+        (0, 0, 0, 2, 2, 2, 2, 2, 0),
+    ),
+    "inkplate_6_plus": (
+        (0, 0, 0, 0, 0, 2, 1, 1, 0),
+        (0, 0, 2, 1, 1, 1, 2, 1, 0),
+        (0, 2, 2, 2, 1, 1, 2, 1, 0),
+        (0, 0, 2, 2, 2, 1, 2, 1, 0),
+        (0, 0, 0, 0, 2, 2, 2, 1, 0),
+        (0, 0, 2, 1, 2, 1, 1, 2, 0),
+        (0, 0, 2, 2, 2, 1, 1, 2, 0),
+        (0, 0, 0, 0, 2, 2, 2, 2, 0),
+    ),
+    "inkplate_6_v2": (
+        (1, 0, 1, 0, 1, 1, 1, 0, 0),
+        (0, 0, 0, 1, 1, 1, 1, 0, 0),
+        (1, 1, 1, 1, 0, 2, 1, 0, 0),
+        (1, 1, 1, 2, 2, 1, 1, 0, 0),
+        (1, 1, 1, 1, 2, 2, 1, 0, 0),
+        (0, 1, 1, 1, 2, 2, 1, 0, 0),
+        (0, 0, 0, 0, 1, 1, 2, 0, 0),
+        (0, 0, 0, 0, 0, 1, 2, 0, 0),
+    ),
+    "inkplate_5": (
+        (0, 0, 1, 1, 0, 1, 1, 1, 0),
+        (0, 1, 1, 1, 1, 2, 0, 1, 0),
+        (1, 2, 2, 0, 2, 1, 1, 1, 0),
+        (1, 1, 1, 2, 0, 1, 1, 2, 0),
+        (0, 1, 1, 1, 2, 0, 1, 2, 0),
+        (0, 0, 0, 1, 1, 2, 1, 2, 0),
+        (1, 1, 1, 2, 0, 2, 1, 2, 0),
+        (0, 0, 0, 0, 0, 0, 0, 0, 0),
+    ),
+    "inkplate_5_v2": (
+        (0, 0, 1, 1, 2, 1, 1, 1, 0),
+        (1, 1, 2, 2, 1, 2, 1, 1, 0),
+        (0, 1, 2, 2, 1, 1, 2, 1, 0),
+        (0, 0, 1, 1, 1, 1, 1, 2, 0),
+        (1, 2, 1, 2, 1, 1, 1, 2, 0),
+        (0, 1, 1, 1, 2, 0, 1, 2, 0),
+        (1, 1, 1, 2, 2, 2, 1, 2, 0),
+        (0, 0, 0, 0, 0, 0, 0, 0, 0),
+    ),
+}
+
+INKPLATE_10_CUSTOM_WAVEFORMS = (
+    (
+        (0, 0, 0, 0, 0, 0, 0, 0, 0),
+        (0, 0, 0, 2, 1, 2, 1, 1, 0),
+        (0, 0, 0, 2, 2, 1, 2, 1, 0),
+        (0, 0, 2, 2, 1, 2, 2, 1, 0),
+        (0, 0, 0, 2, 1, 1, 1, 2, 0),
+        (0, 0, 2, 2, 2, 1, 1, 2, 0),
+        (0, 0, 0, 0, 0, 1, 2, 2, 0),
+        (0, 0, 0, 0, 2, 2, 2, 2, 0),
+    ),
+    (
+        (0, 3, 3, 3, 3, 3, 3, 3, 0),
+        (0, 1, 2, 1, 1, 2, 2, 1, 0),
+        (0, 2, 2, 2, 1, 2, 2, 1, 0),
+        (0, 0, 2, 2, 2, 2, 2, 1, 0),
+        (0, 3, 3, 2, 1, 1, 1, 2, 0),
+        (0, 3, 3, 2, 2, 1, 1, 2, 0),
+        (0, 2, 1, 2, 1, 2, 1, 2, 0),
+        (0, 3, 3, 3, 2, 2, 2, 2, 0),
+    ),
+    (
+        (0, 0, 0, 0, 0, 0, 0, 1, 0),
+        (0, 0, 0, 2, 2, 2, 1, 1, 0),
+        (0, 0, 2, 1, 1, 2, 2, 1, 0),
+        (1, 1, 2, 2, 1, 2, 2, 1, 0),
+        (0, 0, 2, 1, 2, 2, 2, 1, 0),
+        (0, 1, 2, 2, 2, 2, 2, 1, 0),
+        (0, 0, 0, 2, 2, 2, 1, 2, 0),
+        (0, 0, 0, 2, 2, 2, 2, 2, 0),
+    ),
+    (
+        (0, 0, 0, 0, 0, 0, 0, 1, 0),
+        (0, 0, 0, 2, 2, 2, 1, 1, 0),
+        (2, 2, 2, 1, 0, 2, 1, 0, 0),
+        (2, 1, 1, 2, 1, 1, 1, 2, 0),
+        (2, 2, 2, 1, 1, 1, 0, 2, 0),
+        (2, 2, 2, 1, 1, 2, 1, 2, 0),
+        (0, 0, 0, 0, 2, 1, 2, 2, 0),
+        (0, 0, 0, 0, 2, 2, 2, 2, 0),
+    ),
+)

esphome/components/inkplate/display.py

@@ -0,0 +1,238 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import display, i2c
+from esphome.components.esp32 import CONF_CPU_FREQUENCY
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_FULL_UPDATE_EVERY,
+    CONF_ID,
+    CONF_LAMBDA,
+    CONF_MIRROR_X,
+    CONF_MIRROR_Y,
+    CONF_MODEL,
+    CONF_OE_PIN,
+    CONF_PAGES,
+    CONF_TRANSFORM,
+    CONF_WAKEUP_PIN,
+    PLATFORM_ESP32,
+)
+import esphome.final_validate as fv
+
+from .const import INKPLATE_10_CUSTOM_WAVEFORMS, WAVEFORMS
+
+DEPENDENCIES = ["i2c", "esp32"]
+AUTO_LOAD = ["psram"]
+
+CONF_DISPLAY_DATA_0_PIN = "display_data_0_pin"
+CONF_DISPLAY_DATA_1_PIN = "display_data_1_pin"
+CONF_DISPLAY_DATA_2_PIN = "display_data_2_pin"
+CONF_DISPLAY_DATA_3_PIN = "display_data_3_pin"
+CONF_DISPLAY_DATA_4_PIN = "display_data_4_pin"
+CONF_DISPLAY_DATA_5_PIN = "display_data_5_pin"
+CONF_DISPLAY_DATA_6_PIN = "display_data_6_pin"
+CONF_DISPLAY_DATA_7_PIN = "display_data_7_pin"
+
+CONF_CL_PIN = "cl_pin"
+CONF_CKV_PIN = "ckv_pin"
+CONF_GREYSCALE = "greyscale"
+CONF_GMOD_PIN = "gmod_pin"
+CONF_GPIO0_ENABLE_PIN = "gpio0_enable_pin"
+CONF_LE_PIN = "le_pin"
+CONF_PARTIAL_UPDATING = "partial_updating"
+CONF_POWERUP_PIN = "powerup_pin"
+CONF_SPH_PIN = "sph_pin"
+CONF_SPV_PIN = "spv_pin"
+CONF_VCOM_PIN = "vcom_pin"
+
+inkplate_ns = cg.esphome_ns.namespace("inkplate")
+Inkplate = inkplate_ns.class_(
+    "Inkplate",
+    cg.PollingComponent,
+    i2c.I2CDevice,
+    display.Display,
+    display.DisplayBuffer,
+)
+
+InkplateModel = inkplate_ns.enum("InkplateModel")
+
+MODELS = {
+    "inkplate_6": InkplateModel.INKPLATE_6,
+    "inkplate_10": InkplateModel.INKPLATE_10,
+    "inkplate_6_plus": InkplateModel.INKPLATE_6_PLUS,
+    "inkplate_6_v2": InkplateModel.INKPLATE_6_V2,
+    "inkplate_5": InkplateModel.INKPLATE_5,
+    "inkplate_5_v2": InkplateModel.INKPLATE_5_V2,
+}
+
+CONF_CUSTOM_WAVEFORM = "custom_waveform"
+
+
+def _validate_custom_waveform(config):
+    if CONF_CUSTOM_WAVEFORM in config and config[CONF_MODEL] != "inkplate_10":
+        raise cv.Invalid("Custom waveforms are only supported on the Inkplate 10")
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    display.FULL_DISPLAY_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(Inkplate),
+            cv.Optional(CONF_GREYSCALE, default=False): cv.boolean,
+            cv.Optional(CONF_CUSTOM_WAVEFORM): cv.All(
+                cv.uint8_t, cv.Range(min=1, max=len(INKPLATE_10_CUSTOM_WAVEFORMS))
+            ),
+            cv.Optional(CONF_TRANSFORM): cv.Schema(
+                {
+                    cv.Optional(CONF_MIRROR_X, default=False): cv.boolean,
+                    cv.Optional(CONF_MIRROR_Y, default=False): cv.boolean,
+                }
+            ),
+            cv.Optional(CONF_PARTIAL_UPDATING, default=True): cv.boolean,
+            cv.Optional(CONF_FULL_UPDATE_EVERY, default=10): cv.uint32_t,
+            cv.Optional(CONF_MODEL, default="inkplate_6"): cv.enum(
+                MODELS, lower=True, space="_"
+            ),
+            # Control pins
+            cv.Required(CONF_CKV_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_GMOD_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_GPIO0_ENABLE_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_OE_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_POWERUP_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_SPH_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_SPV_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_VCOM_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_WAKEUP_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(CONF_CL_PIN, default=0): pins.internal_gpio_output_pin_schema,
+            cv.Optional(CONF_LE_PIN, default=2): pins.internal_gpio_output_pin_schema,
+            # Data pins
+            cv.Optional(
+                CONF_DISPLAY_DATA_0_PIN, default=4
+            ): pins.internal_gpio_output_pin_schema,
+            cv.Optional(
+                CONF_DISPLAY_DATA_1_PIN, default=5
+            ): pins.internal_gpio_output_pin_schema,
+            cv.Optional(
+                CONF_DISPLAY_DATA_2_PIN, default=18
+            ): pins.internal_gpio_output_pin_schema,
+            cv.Optional(
+                CONF_DISPLAY_DATA_3_PIN, default=19
+            ): pins.internal_gpio_output_pin_schema,
+            cv.Optional(
+                CONF_DISPLAY_DATA_4_PIN, default=23
+            ): pins.internal_gpio_output_pin_schema,
+            cv.Optional(
+                CONF_DISPLAY_DATA_5_PIN, default=25
+            ): pins.internal_gpio_output_pin_schema,
+            cv.Optional(
+                CONF_DISPLAY_DATA_6_PIN, default=26
+            ): pins.internal_gpio_output_pin_schema,
+            cv.Optional(
+                CONF_DISPLAY_DATA_7_PIN, default=27
+            ): pins.internal_gpio_output_pin_schema,
+        }
+    )
+    .extend(cv.polling_component_schema("5s"))
+    .extend(i2c.i2c_device_schema(0x48)),
+    cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
+    _validate_custom_waveform,
+)
+
+
+def _validate_cpu_frequency(config):
+    esp32_config = fv.full_config.get()[PLATFORM_ESP32]
+    if esp32_config[CONF_CPU_FREQUENCY] != "240MHZ":
+        raise cv.Invalid(
+            "Inkplate requires 240MHz CPU frequency (set in esp32 component)"
+        )
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _validate_cpu_frequency
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+
+    await display.register_display(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if CONF_LAMBDA in config:
+        lambda_ = await cg.process_lambda(
+            config[CONF_LAMBDA], [(display.DisplayRef, "it")], return_type=cg.void
+        )
+        cg.add(var.set_writer(lambda_))
+
+    cg.add(var.set_greyscale(config[CONF_GREYSCALE]))
+    if transform := config.get(CONF_TRANSFORM):
+        cg.add(var.set_mirror_x(transform[CONF_MIRROR_X]))
+        cg.add(var.set_mirror_y(transform[CONF_MIRROR_Y]))
+    cg.add(var.set_partial_updating(config[CONF_PARTIAL_UPDATING]))
+    cg.add(var.set_full_update_every(config[CONF_FULL_UPDATE_EVERY]))
+
+    cg.add(var.set_model(config[CONF_MODEL]))
+
+    if custom_waveform := config.get(CONF_CUSTOM_WAVEFORM):
+        waveform = INKPLATE_10_CUSTOM_WAVEFORMS[custom_waveform - 1]
+        waveform = [element for tupl in waveform for element in tupl]
+        cg.add(var.set_waveform(waveform, True))
+    else:
+        waveform = WAVEFORMS[config[CONF_MODEL]]
+        waveform = [element for tupl in waveform for element in tupl]
+        cg.add(var.set_waveform(waveform, False))
+
+    ckv = await cg.gpio_pin_expression(config[CONF_CKV_PIN])
+    cg.add(var.set_ckv_pin(ckv))
+
+    gmod = await cg.gpio_pin_expression(config[CONF_GMOD_PIN])
+    cg.add(var.set_gmod_pin(gmod))
+
+    gpio0_enable = await cg.gpio_pin_expression(config[CONF_GPIO0_ENABLE_PIN])
+    cg.add(var.set_gpio0_enable_pin(gpio0_enable))
+
+    oe = await cg.gpio_pin_expression(config[CONF_OE_PIN])
+    cg.add(var.set_oe_pin(oe))
+
+    powerup = await cg.gpio_pin_expression(config[CONF_POWERUP_PIN])
+    cg.add(var.set_powerup_pin(powerup))
+
+    sph = await cg.gpio_pin_expression(config[CONF_SPH_PIN])
+    cg.add(var.set_sph_pin(sph))
+
+    spv = await cg.gpio_pin_expression(config[CONF_SPV_PIN])
+    cg.add(var.set_spv_pin(spv))
+
+    vcom = await cg.gpio_pin_expression(config[CONF_VCOM_PIN])
+    cg.add(var.set_vcom_pin(vcom))
+
+    wakeup = await cg.gpio_pin_expression(config[CONF_WAKEUP_PIN])
+    cg.add(var.set_wakeup_pin(wakeup))
+
+    cl = await cg.gpio_pin_expression(config[CONF_CL_PIN])
+    cg.add(var.set_cl_pin(cl))
+
+    le = await cg.gpio_pin_expression(config[CONF_LE_PIN])
+    cg.add(var.set_le_pin(le))
+
+    display_data_0 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_0_PIN])
+    cg.add(var.set_display_data_0_pin(display_data_0))
+
+    display_data_1 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_1_PIN])
+    cg.add(var.set_display_data_1_pin(display_data_1))
+
+    display_data_2 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_2_PIN])
+    cg.add(var.set_display_data_2_pin(display_data_2))
+
+    display_data_3 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_3_PIN])
+    cg.add(var.set_display_data_3_pin(display_data_3))
+
+    display_data_4 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_4_PIN])
+    cg.add(var.set_display_data_4_pin(display_data_4))
+
+    display_data_5 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_5_PIN])
+    cg.add(var.set_display_data_5_pin(display_data_5))
+
+    display_data_6 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_6_PIN])
+    cg.add(var.set_display_data_6_pin(display_data_6))
+
+    display_data_7 = await cg.gpio_pin_expression(config[CONF_DISPLAY_DATA_7_PIN])
+    cg.add(var.set_display_data_7_pin(display_data_7))