esphome 2025.7.4__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -473,6 +473,12 @@ bool WiFiComponent::wifi_sta_ip_config_(optional<ManualIP> manual_ip) {
   if (!this->wifi_mode_(true, {}))
     return false;
 
+  // Check if the STA interface is initialized before using it
+  if (s_sta_netif == nullptr) {
+    ESP_LOGW(TAG, "STA interface not initialized");
+    return false;
+  }
+
   esp_netif_dhcp_status_t dhcp_status;
   esp_err_t err = esp_netif_dhcpc_get_status(s_sta_netif, &dhcp_status);
   if (err != ESP_OK) {
@@ -640,8 +646,20 @@ const char *get_disconnect_reason_str(uint8_t reason) {
       return "Handshake Failed";
     case WIFI_REASON_CONNECTION_FAIL:
       return "Connection Failed";
+    case WIFI_REASON_AP_TSF_RESET:
+      return "AP TSF reset";
     case WIFI_REASON_ROAMING:
       return "Station Roaming";
+    case WIFI_REASON_ASSOC_COMEBACK_TIME_TOO_LONG:
+      return "Association comeback time too long";
+    case WIFI_REASON_SA_QUERY_TIMEOUT:
+      return "SA query timeout";
+    case WIFI_REASON_NO_AP_FOUND_W_COMPATIBLE_SECURITY:
+      return "No AP found with compatible security";
+    case WIFI_REASON_NO_AP_FOUND_IN_AUTHMODE_THRESHOLD:
+      return "No AP found in auth mode threshold";
+    case WIFI_REASON_NO_AP_FOUND_IN_RSSI_THRESHOLD:
+      return "No AP found in RSSI threshold";
     case WIFI_REASON_UNSPECIFIED:
     default:
       return "Unspecified";
@@ -679,6 +697,8 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
   } else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_STOP) {
     ESP_LOGV(TAG, "STA stop");
     s_sta_started = false;
+    // Clear the STA interface handle to prevent use-after-free
+    s_sta_netif = nullptr;
 
   } else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_AUTHMODE_CHANGE) {
     const auto &it = data->data.sta_authmode_change;
@@ -777,6 +797,10 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
   } else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_AP_STOP) {
     ESP_LOGV(TAG, "AP stop");
     s_ap_started = false;
+#ifdef USE_WIFI_AP
+    // Clear the AP interface handle to prevent use-after-free
+    s_ap_netif = nullptr;
+#endif
 
   } else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_AP_PROBEREQRECVED) {
     const auto &it = data->data.ap_probe_req_rx;
@@ -853,6 +877,12 @@ bool WiFiComponent::wifi_ap_ip_config_(optional<ManualIP> manual_ip) {
   if (!this->wifi_mode_({}, true))
     return false;
 
+  // Check if the AP interface is initialized before using it
+  if (s_ap_netif == nullptr) {
+    ESP_LOGW(TAG, "AP interface not initialized");
+    return false;
+  }
+
   esp_netif_ip_info_t info;
   if (manual_ip.has_value()) {
     info.ip = manual_ip->static_ip;

esphome/components/wifi_info/wifi_info_text_sensor.h

@@ -28,7 +28,6 @@ class IPAddressWiFiInfo : public PollingComponent, public text_sensor::TextSenso
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-ip"; }
   void dump_config() override;
   void add_ip_sensors(uint8_t index, text_sensor::TextSensor *s) { this->ip_sensors_[index] = s; }
 
@@ -51,7 +50,6 @@ class DNSAddressWifiInfo : public PollingComponent, public text_sensor::TextSens
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-dns"; }
   void dump_config() override;
 
  protected:
@@ -80,7 +78,6 @@ class ScanResultsWiFiInfo : public PollingComponent, public text_sensor::TextSen
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-scanresults"; }
   void dump_config() override;
 
  protected:
@@ -97,7 +94,6 @@ class SSIDWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-ssid"; }
   void dump_config() override;
 
  protected:
@@ -116,7 +112,6 @@ class BSSIDWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-bssid"; }
   void dump_config() override;
 
  protected:
@@ -126,7 +121,6 @@ class BSSIDWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
 class MacAddressWifiInfo : public Component, public text_sensor::TextSensor {
  public:
   void setup() override { this->publish_state(get_mac_address_pretty()); }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-macadr"; }
   void dump_config() override;
 };
 

esphome/components/wifi_signal/wifi_signal_sensor.h

@@ -13,7 +13,6 @@ class WiFiSignalSensor : public sensor::Sensor, public PollingComponent {
   void update() override { this->publish_state(wifi::global_wifi_component->wifi_rssi()); }
   void dump_config() override;
 
-  std::string unique_id() override { return get_mac_address() + "-wifisignal"; }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
 };
 

esphome/components/wireguard/wireguard.cpp

@@ -28,8 +28,6 @@ static const char *const LOGMSG_ONLINE = "online";
 static const char *const LOGMSG_OFFLINE = "offline";
 
 void Wireguard::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   this->wg_config_.address = this->address_.c_str();
   this->wg_config_.private_key = this->private_key_.c_str();
   this->wg_config_.endpoint = this->peer_endpoint_.c_str();

esphome/components/x9c/x9c.cpp

@@ -34,8 +34,6 @@ void X9cOutput::trim_value(int change_amount) {
 }
 
 void X9cOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   this->inc_pin_->get_pin();
   this->inc_pin_->setup();
   this->inc_pin_->digital_write(false);

esphome/components/xgzp68xx/xgzp68xx.cpp

@@ -69,7 +69,6 @@ void XGZP68XXComponent::update() {
 }
 
 void XGZP68XXComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t config;
 
   // Display some sample bits to confirm we are talking to the sensor

esphome/components/xl9535/xl9535.cpp

@@ -7,8 +7,6 @@ namespace xl9535 {
 static const char *const TAG = "xl9535";
 
 void XL9535Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Check to see if the device can read from the register
   uint8_t port = 0;
   if (this->read_register(XL9535_INPUT_PORT_0_REGISTER, &port, 1) != i2c::ERROR_OK) {

esphome/components/zephyr/__init__.py

@@ -0,0 +1,252 @@
+import os
+from typing import TypedDict
+
+import esphome.codegen as cg
+from esphome.const import CONF_BOARD
+from esphome.core import CORE
+from esphome.helpers import copy_file_if_changed, write_file_if_changed
+
+from .const import (
+    BOOTLOADER_MCUBOOT,
+    KEY_BOARD,
+    KEY_BOOTLOADER,
+    KEY_EXTRA_BUILD_FILES,
+    KEY_OVERLAY,
+    KEY_PM_STATIC,
+    KEY_PRJ_CONF,
+    KEY_USER,
+    KEY_ZEPHYR,
+    zephyr_ns,
+)
+
+CODEOWNERS = ["@tomaszduda23"]
+AUTO_LOAD = ["preferences"]
+
+PrjConfValueType = bool | str | int
+
+
+class Section:
+    def __init__(self, name, address, size, region):
+        self.name = name
+        self.address = address
+        self.size = size
+        self.region = region
+        self.end_address = self.address + self.size
+
+    def __str__(self):
+        return (
+            f"{self.name}:\n"
+            f"  address: 0x{self.address:X}\n"
+            f"  end_address: 0x{self.end_address:X}\n"
+            f"  region: {self.region}\n"
+            f"  size: 0x{self.size:X}"
+        )
+
+
+class ZephyrData(TypedDict):
+    board: str
+    bootloader: str
+    prj_conf: dict[str, tuple[PrjConfValueType, bool]]
+    overlay: str
+    extra_build_files: dict[str, str]
+    pm_static: list[Section]
+    user: dict[str, list[str]]
+
+
+def zephyr_set_core_data(config):
+    CORE.data[KEY_ZEPHYR] = ZephyrData(
+        board=config[CONF_BOARD],
+        bootloader=config[KEY_BOOTLOADER],
+        prj_conf={},
+        overlay="",
+        extra_build_files={},
+        pm_static=[],
+        user={},
+    )
+    return config
+
+
+def zephyr_data() -> ZephyrData:
+    return CORE.data[KEY_ZEPHYR]
+
+
+def zephyr_add_prj_conf(
+    name: str, value: PrjConfValueType, required: bool = True
+) -> None:
+    """Set an zephyr prj conf value."""
+    if not name.startswith("CONFIG_"):
+        name = "CONFIG_" + name
+    prj_conf = zephyr_data()[KEY_PRJ_CONF]
+    if name not in prj_conf:
+        prj_conf[name] = (value, required)
+        return
+    old_value, old_required = prj_conf[name]
+    if old_value != value and old_required:
+        raise ValueError(
+            f"{name} already set with value '{old_value}', cannot set again to '{value}'"
+        )
+    if required:
+        prj_conf[name] = (value, required)
+
+
+def zephyr_add_overlay(content):
+    zephyr_data()[KEY_OVERLAY] += content
+
+
+def add_extra_build_file(filename: str, path: str) -> bool:
+    """Add an extra build file to the project."""
+    extra_build_files = zephyr_data()[KEY_EXTRA_BUILD_FILES]
+    if filename not in extra_build_files:
+        extra_build_files[filename] = path
+        return True
+    return False
+
+
+def add_extra_script(stage: str, filename: str, path: str):
+    """Add an extra script to the project."""
+    key = f"{stage}:{filename}"
+    if add_extra_build_file(filename, path):
+        cg.add_platformio_option("extra_scripts", [key])
+
+
+def zephyr_to_code(config):
+    cg.add(zephyr_ns.setup_preferences())
+    cg.add_build_flag("-DUSE_ZEPHYR")
+    cg.set_cpp_standard("gnu++20")
+    # build is done by west so bypass board checking in platformio
+    cg.add_platformio_option("boards_dir", CORE.relative_build_path("boards"))
+
+    # c++ support
+    zephyr_add_prj_conf("NEWLIB_LIBC", True)
+    zephyr_add_prj_conf("CONFIG_FPU", True)
+    zephyr_add_prj_conf("NEWLIB_LIBC_FLOAT_PRINTF", True)
+    zephyr_add_prj_conf("CPLUSPLUS", True)
+    zephyr_add_prj_conf("CONFIG_STD_CPP20", True)
+    zephyr_add_prj_conf("LIB_CPLUSPLUS", True)
+    # preferences
+    zephyr_add_prj_conf("SETTINGS", True)
+    zephyr_add_prj_conf("NVS", True)
+    zephyr_add_prj_conf("FLASH_MAP", True)
+    zephyr_add_prj_conf("CONFIG_FLASH", True)
+    # watchdog
+    zephyr_add_prj_conf("WATCHDOG", True)
+    zephyr_add_prj_conf("WDT_DISABLE_AT_BOOT", False)
+    # disable console
+    zephyr_add_prj_conf("UART_CONSOLE", False)
+    zephyr_add_prj_conf("CONSOLE", False, False)
+    # use NFC pins as GPIO
+    zephyr_add_prj_conf("NFCT_PINS_AS_GPIOS", True)
+
+    # <err> os: ***** USAGE FAULT *****
+    # <err> os:   Illegal load of EXC_RETURN into PC
+    zephyr_add_prj_conf("MAIN_STACK_SIZE", 2048)
+
+    add_extra_script(
+        "pre",
+        "pre_build.py",
+        os.path.join(os.path.dirname(__file__), "pre_build.py.script"),
+    )
+
+
+def _format_prj_conf_val(value: PrjConfValueType) -> str:
+    if isinstance(value, bool):
+        return "y" if value else "n"
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, str):
+        return f'"{value}"'
+    raise ValueError
+
+
+def zephyr_add_cdc_acm(config, id):
+    zephyr_add_prj_conf("USB_DEVICE_STACK", True)
+    zephyr_add_prj_conf("USB_CDC_ACM", True)
+    # prevent device to go to susspend, without this communication stop working in python
+    # there should be a way to solve it
+    zephyr_add_prj_conf("USB_DEVICE_REMOTE_WAKEUP", False)
+    # prevent logging when buffer is full
+    zephyr_add_prj_conf("USB_CDC_ACM_LOG_LEVEL_WRN", True)
+    zephyr_add_overlay(
+        f"""
+&zephyr_udc0 {{
+    cdc_acm_uart{id}: cdc_acm_uart{id} {{
+        compatible = "zephyr,cdc-acm-uart";
+    }};
+}};
+"""
+    )
+
+
+def zephyr_add_pm_static(section: Section):
+    CORE.data[KEY_ZEPHYR][KEY_PM_STATIC].extend(section)
+
+
+def zephyr_add_user(key, value):
+    user = zephyr_data()[KEY_USER]
+    if key not in user:
+        user[key] = []
+    user[key] += [value]
+
+
+def copy_files():
+    user = zephyr_data()[KEY_USER]
+    if user:
+        zephyr_add_overlay(
+            f"""
+/ {{
+    zephyr,user {{
+        {[f"{key} = {', '.join(value)};" for key, value in user.items()][0]}
+}};
+}};"""
+        )
+
+    want_opts = zephyr_data()[KEY_PRJ_CONF]
+
+    prj_conf = (
+        "\n".join(
+            f"{name}={_format_prj_conf_val(value[0])}"
+            for name, value in sorted(want_opts.items())
+        )
+        + "\n"
+    )
+
+    write_file_if_changed(CORE.relative_build_path("zephyr/prj.conf"), prj_conf)
+
+    write_file_if_changed(
+        CORE.relative_build_path("zephyr/app.overlay"),
+        zephyr_data()[KEY_OVERLAY],
+    )
+
+    if zephyr_data()[KEY_BOOTLOADER] == BOOTLOADER_MCUBOOT or zephyr_data()[
+        KEY_BOARD
+    ] in ["xiao_ble"]:
+        fake_board_manifest = """
+{
+"frameworks": [
+    "zephyr"
+],
+"name": "esphome nrf52",
+"upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104
+},
+"url": "https://esphome.io/",
+"vendor": "esphome"
+}
+"""
+        write_file_if_changed(
+            CORE.relative_build_path(f"boards/{zephyr_data()[KEY_BOARD]}.json"),
+            fake_board_manifest,
+        )
+
+    for filename, path in zephyr_data()[KEY_EXTRA_BUILD_FILES].items():
+        copy_file_if_changed(
+            path,
+            CORE.relative_build_path(filename),
+        )
+
+    pm_static = "\n".join(str(item) for item in zephyr_data()[KEY_PM_STATIC])
+    if pm_static:
+        write_file_if_changed(
+            CORE.relative_build_path("zephyr/pm_static.yml"), pm_static
+        )

esphome/components/zephyr/const.py

@@ -0,0 +1,16 @@
+from typing import Final
+
+import esphome.codegen as cg
+
+BOOTLOADER_MCUBOOT = "mcuboot"
+
+KEY_BOOTLOADER: Final = "bootloader"
+KEY_EXTRA_BUILD_FILES: Final = "extra_build_files"
+KEY_OVERLAY: Final = "overlay"
+KEY_PM_STATIC: Final = "pm_static"
+KEY_PRJ_CONF: Final = "prj_conf"
+KEY_ZEPHYR = "zephyr"
+KEY_BOARD: Final = "board"
+KEY_USER: Final = "user"
+
+zephyr_ns = cg.esphome_ns.namespace("zephyr")

esphome/components/zephyr/core.cpp

@@ -0,0 +1,90 @@
+#ifdef USE_ZEPHYR
+
+#include <zephyr/kernel.h>
+#include <zephyr/drivers/watchdog.h>
+#include <zephyr/sys/reboot.h>
+#include <zephyr/random/rand32.h>
+#include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+
+static int wdt_channel_id = -1;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static const device *const WDT = DEVICE_DT_GET(DT_ALIAS(watchdog0));
+
+void yield() { ::k_yield(); }
+uint32_t millis() { return k_ticks_to_ms_floor32(k_uptime_ticks()); }
+uint32_t micros() { return k_ticks_to_us_floor32(k_uptime_ticks()); }
+void delayMicroseconds(uint32_t us) { ::k_usleep(us); }
+void delay(uint32_t ms) { ::k_msleep(ms); }
+
+void arch_init() {
+  if (device_is_ready(WDT)) {
+    static wdt_timeout_cfg wdt_config{};
+    wdt_config.flags = WDT_FLAG_RESET_SOC;
+    wdt_config.window.max = 2000;
+    wdt_channel_id = wdt_install_timeout(WDT, &wdt_config);
+    if (wdt_channel_id >= 0) {
+      wdt_setup(WDT, WDT_OPT_PAUSE_HALTED_BY_DBG | WDT_OPT_PAUSE_IN_SLEEP);
+    }
+  }
+}
+
+void arch_feed_wdt() {
+  if (wdt_channel_id >= 0) {
+    wdt_feed(WDT, wdt_channel_id);
+  }
+}
+
+void arch_restart() { sys_reboot(SYS_REBOOT_COLD); }
+uint32_t arch_get_cpu_cycle_count() { return k_cycle_get_32(); }
+uint32_t arch_get_cpu_freq_hz() { return sys_clock_hw_cycles_per_sec(); }
+uint8_t progmem_read_byte(const uint8_t *addr) { return *addr; }
+
+Mutex::Mutex() {
+  auto *mutex = new k_mutex();
+  this->handle_ = mutex;
+  k_mutex_init(mutex);
+}
+Mutex::~Mutex() { delete static_cast<k_mutex *>(this->handle_); }
+void Mutex::lock() { k_mutex_lock(static_cast<k_mutex *>(this->handle_), K_FOREVER); }
+bool Mutex::try_lock() { return k_mutex_lock(static_cast<k_mutex *>(this->handle_), K_NO_WAIT) == 0; }
+void Mutex::unlock() { k_mutex_unlock(static_cast<k_mutex *>(this->handle_)); }
+
+IRAM_ATTR InterruptLock::InterruptLock() { state_ = irq_lock(); }
+IRAM_ATTR InterruptLock::~InterruptLock() { irq_unlock(state_); }
+
+// Zephyr doesn't support lwIP core locking, so this is a no-op
+LwIPLock::LwIPLock() {}
+LwIPLock::~LwIPLock() {}
+
+uint32_t random_uint32() { return rand(); }  // NOLINT(cert-msc30-c, cert-msc50-cpp)
+bool random_bytes(uint8_t *data, size_t len) {
+  sys_rand_get(data, len);
+  return true;
+}
+
+void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
+  mac[0] = ((NRF_FICR->DEVICEADDR[1] & 0xFFFF) >> 8) | 0xC0;
+  mac[1] = NRF_FICR->DEVICEADDR[1] & 0xFFFF;
+  mac[2] = NRF_FICR->DEVICEADDR[0] >> 24;
+  mac[3] = NRF_FICR->DEVICEADDR[0] >> 16;
+  mac[4] = NRF_FICR->DEVICEADDR[0] >> 8;
+  mac[5] = NRF_FICR->DEVICEADDR[0];
+}
+
+}  // namespace esphome
+
+void setup();
+void loop();
+
+int main() {
+  setup();
+  while (true) {
+    loop();
+    esphome::yield();
+  }
+  return 0;
+}
+
+#endif

esphome/components/zephyr/gpio.cpp

@@ -0,0 +1,120 @@
+#ifdef USE_ZEPHYR
+#include "gpio.h"
+#include <zephyr/drivers/gpio.h>
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace zephyr {
+
+static const char *const TAG = "zephyr";
+
+static int flags_to_mode(gpio::Flags flags, bool inverted, bool value) {
+  int ret = 0;
+  if (flags & gpio::FLAG_INPUT) {
+    ret |= GPIO_INPUT;
+  }
+  if (flags & gpio::FLAG_OUTPUT) {
+    ret |= GPIO_OUTPUT;
+    if (value != inverted) {
+      ret |= GPIO_OUTPUT_INIT_HIGH;
+    } else {
+      ret |= GPIO_OUTPUT_INIT_LOW;
+    }
+  }
+  if (flags & gpio::FLAG_PULLUP) {
+    ret |= GPIO_PULL_UP;
+  }
+  if (flags & gpio::FLAG_PULLDOWN) {
+    ret |= GPIO_PULL_DOWN;
+  }
+  if (flags & gpio::FLAG_OPEN_DRAIN) {
+    ret |= GPIO_OPEN_DRAIN;
+  }
+  return ret;
+}
+
+struct ISRPinArg {
+  uint8_t pin;
+  bool inverted;
+};
+
+ISRInternalGPIOPin ZephyrGPIOPin::to_isr() const {
+  auto *arg = new ISRPinArg{};  // NOLINT(cppcoreguidelines-owning-memory)
+  arg->pin = this->pin_;
+  arg->inverted = this->inverted_;
+  return ISRInternalGPIOPin((void *) arg);
+}
+
+void ZephyrGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const {
+  // TODO
+}
+
+void ZephyrGPIOPin::setup() {
+  const struct device *gpio = nullptr;
+  if (this->pin_ < 32) {
+#define GPIO0 DT_NODELABEL(gpio0)
+#if DT_NODE_HAS_STATUS(GPIO0, okay)
+    gpio = DEVICE_DT_GET(GPIO0);
+#else
+#error "gpio0 is disabled"
+#endif
+  } else {
+#define GPIO1 DT_NODELABEL(gpio1)
+#if DT_NODE_HAS_STATUS(GPIO1, okay)
+    gpio = DEVICE_DT_GET(GPIO1);
+#else
+#error "gpio1 is disabled"
+#endif
+  }
+  if (device_is_ready(gpio)) {
+    this->gpio_ = gpio;
+  } else {
+    ESP_LOGE(TAG, "gpio %u is not ready.", this->pin_);
+    return;
+  }
+  this->pin_mode(this->flags_);
+}
+
+void ZephyrGPIOPin::pin_mode(gpio::Flags flags) {
+  if (nullptr == this->gpio_) {
+    return;
+  }
+  gpio_pin_configure(this->gpio_, this->pin_ % 32, flags_to_mode(flags, this->inverted_, this->value_));
+}
+
+std::string ZephyrGPIOPin::dump_summary() const {
+  char buffer[32];
+  snprintf(buffer, sizeof(buffer), "GPIO%u, P%u.%u", this->pin_, this->pin_ / 32, this->pin_ % 32);
+  return buffer;
+}
+
+bool ZephyrGPIOPin::digital_read() {
+  if (nullptr == this->gpio_) {
+    return false;
+  }
+  return bool(gpio_pin_get(this->gpio_, this->pin_ % 32) != this->inverted_);
+}
+
+void ZephyrGPIOPin::digital_write(bool value) {
+  // make sure that value is not ignored since it can be inverted e.g. on switch side
+  // that way init state should be correct
+  this->value_ = value;
+  if (nullptr == this->gpio_) {
+    return;
+  }
+  gpio_pin_set(this->gpio_, this->pin_ % 32, value != this->inverted_ ? 1 : 0);
+}
+void ZephyrGPIOPin::detach_interrupt() const {
+  // TODO
+}
+
+}  // namespace zephyr
+
+bool IRAM_ATTR ISRInternalGPIOPin::digital_read() {
+  // TODO
+  return false;
+}
+
+}  // namespace esphome
+
+#endif

esphome/components/zephyr/gpio.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#ifdef USE_ZEPHYR
+#include "esphome/core/hal.h"
+struct device;
+namespace esphome {
+namespace zephyr {
+
+class ZephyrGPIOPin : public InternalGPIOPin {
+ public:
+  void set_pin(uint8_t pin) { this->pin_ = pin; }
+  void set_inverted(bool inverted) { this->inverted_ = inverted; }
+  void set_flags(gpio::Flags flags) { this->flags_ = flags; }
+
+  void setup() override;
+  void pin_mode(gpio::Flags flags) override;
+  bool digital_read() override;
+  void digital_write(bool value) override;
+  std::string dump_summary() const override;
+  void detach_interrupt() const override;
+  ISRInternalGPIOPin to_isr() const override;
+  uint8_t get_pin() const override { return this->pin_; }
+  bool is_inverted() const override { return this->inverted_; }
+  gpio::Flags get_flags() const override { return flags_; }
+
+ protected:
+  void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
+  uint8_t pin_;
+  bool inverted_;
+  gpio::Flags flags_;
+  const device *gpio_ = nullptr;
+  bool value_ = false;
+};
+
+}  // namespace zephyr
+}  // namespace esphome
+
+#endif  // USE_ZEPHYR

esphome/components/zephyr/pre_build.py.script

@@ -0,0 +1,4 @@
+Import("env")
+
+board_config = env.BoardConfig()
+board_config.update("frameworks", ["arduino", "zephyr"])