esphome 2025.5.1__py3-none-any.whl → 2025.6.0__py3-none-any.whl

esphome/components/openthread/openthread.cpp

@@ -0,0 +1,206 @@
+#include "esphome/core/defines.h"
+#ifdef USE_OPENTHREAD
+#include "openthread.h"
+
+#include <freertos/portmacro.h>
+
+#include <openthread/cli.h>
+#include <openthread/instance.h>
+#include <openthread/logging.h>
+#include <openthread/netdata.h>
+#include <openthread/srp_client.h>
+#include <openthread/srp_client_buffers.h>
+#include <openthread/tasklet.h>
+
+#include <cstring>
+
+#include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+static const char *const TAG = "openthread";
+
+namespace esphome {
+namespace openthread {
+
+OpenThreadComponent *global_openthread_component =  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+    nullptr;                                        // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+OpenThreadComponent::OpenThreadComponent() { global_openthread_component = this; }
+
+OpenThreadComponent::~OpenThreadComponent() {
+  auto lock = InstanceLock::try_acquire(100);
+  if (!lock) {
+    ESP_LOGW(TAG, "Failed to acquire OpenThread lock in destructor, leaking memory");
+    return;
+  }
+  otInstance *instance = lock->get_instance();
+  otSrpClientClearHostAndServices(instance);
+  otSrpClientBuffersFreeAllServices(instance);
+  global_openthread_component = nullptr;
+}
+
+bool OpenThreadComponent::is_connected() {
+  auto lock = InstanceLock::try_acquire(100);
+  if (!lock) {
+    ESP_LOGW(TAG, "Failed to acquire OpenThread lock in is_connected");
+    return false;
+  }
+
+  otInstance *instance = lock->get_instance();
+  if (instance == nullptr) {
+    return false;
+  }
+
+  otDeviceRole role = otThreadGetDeviceRole(instance);
+
+  // TODO: If we're a leader, check that there is at least 1 known peer
+  return role >= OT_DEVICE_ROLE_CHILD;
+}
+
+// Gets the off-mesh routable address
+std::optional<otIp6Address> OpenThreadComponent::get_omr_address() {
+  InstanceLock lock = InstanceLock::acquire();
+  return this->get_omr_address_(lock);
+}
+
+std::optional<otIp6Address> OpenThreadComponent::get_omr_address_(InstanceLock &lock) {
+  otNetworkDataIterator iterator = OT_NETWORK_DATA_ITERATOR_INIT;
+  otInstance *instance = nullptr;
+
+  instance = lock.get_instance();
+
+  otBorderRouterConfig config;
+  if (otNetDataGetNextOnMeshPrefix(instance, &iterator, &config) != OT_ERROR_NONE) {
+    return std::nullopt;
+  }
+
+  const otIp6Prefix *omr_prefix = &config.mPrefix;
+  const otNetifAddress *unicast_addresses = otIp6GetUnicastAddresses(instance);
+  for (const otNetifAddress *addr = unicast_addresses; addr; addr = addr->mNext) {
+    const otIp6Address *local_ip = &addr->mAddress;
+    if (otIp6PrefixMatch(&omr_prefix->mPrefix, local_ip)) {
+      return *local_ip;
+    }
+  }
+  return {};
+}
+
+void srp_callback(otError err, const otSrpClientHostInfo *host_info, const otSrpClientService *services,
+                  const otSrpClientService *removed_services, void *context) {
+  if (err != 0) {
+    ESP_LOGW(TAG, "SRP client reported an error: %s", otThreadErrorToString(err));
+    for (const otSrpClientHostInfo *host = host_info; host; host = nullptr) {
+      ESP_LOGW(TAG, "  Host: %s", host->mName);
+    }
+    for (const otSrpClientService *service = services; service; service = service->mNext) {
+      ESP_LOGW(TAG, "  Service: %s", service->mName);
+    }
+  }
+}
+
+void srp_start_callback(const otSockAddr *server_socket_address, void *context) {
+  ESP_LOGI(TAG, "SRP client has started");
+}
+
+void OpenThreadSrpComponent::setup() {
+  otError error;
+  InstanceLock lock = InstanceLock::acquire();
+  otInstance *instance = lock.get_instance();
+
+  otSrpClientSetCallback(instance, srp_callback, nullptr);
+
+  // set the host name
+  uint16_t size;
+  char *existing_host_name = otSrpClientBuffersGetHostNameString(instance, &size);
+  const std::string &host_name = App.get_name();
+  uint16_t host_name_len = host_name.size();
+  if (host_name_len > size) {
+    ESP_LOGW(TAG, "Hostname is too long, choose a shorter project name");
+    return;
+  }
+  memset(existing_host_name, 0, size);
+  memcpy(existing_host_name, host_name.c_str(), host_name_len);
+
+  error = otSrpClientSetHostName(instance, existing_host_name);
+  if (error != 0) {
+    ESP_LOGW(TAG, "Could not set host name");
+    return;
+  }
+
+  error = otSrpClientEnableAutoHostAddress(instance);
+  if (error != 0) {
+    ESP_LOGW(TAG, "Could not enable auto host address");
+    return;
+  }
+
+  // Copy the mdns services to our local instance so that the c_str pointers remain valid for the lifetime of this
+  // component
+  this->mdns_services_ = this->mdns_->get_services();
+  ESP_LOGW(TAG, "Setting up SRP services. count = %d\n", this->mdns_services_.size());
+  for (const auto &service : this->mdns_services_) {
+    otSrpClientBuffersServiceEntry *entry = otSrpClientBuffersAllocateService(instance);
+    if (!entry) {
+      ESP_LOGW(TAG, "Failed to allocate service entry");
+      continue;
+    }
+
+    // Set service name
+    char *string = otSrpClientBuffersGetServiceEntryServiceNameString(entry, &size);
+    std::string full_service = service.service_type + "." + service.proto;
+    if (full_service.size() > size) {
+      ESP_LOGW(TAG, "Service name too long: %s", full_service.c_str());
+      continue;
+    }
+    memcpy(string, full_service.c_str(), full_service.size() + 1);
+
+    // Set instance name (using host_name)
+    string = otSrpClientBuffersGetServiceEntryInstanceNameString(entry, &size);
+    if (host_name_len > size) {
+      ESP_LOGW(TAG, "Instance name too long: %s", host_name.c_str());
+      continue;
+    }
+    memset(string, 0, size);
+    memcpy(string, host_name.c_str(), host_name_len);
+
+    // Set port
+    entry->mService.mPort = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
+
+    otDnsTxtEntry *txt_entries =
+        reinterpret_cast<otDnsTxtEntry *>(this->pool_alloc_(sizeof(otDnsTxtEntry) * service.txt_records.size()));
+    // Set TXT records
+    entry->mService.mNumTxtEntries = service.txt_records.size();
+    for (size_t i = 0; i < service.txt_records.size(); i++) {
+      const auto &txt = service.txt_records[i];
+      auto value = const_cast<TemplatableValue<std::string> &>(txt.value).value();
+      txt_entries[i].mKey = strdup(txt.key.c_str());
+      txt_entries[i].mValue = reinterpret_cast<const uint8_t *>(strdup(value.c_str()));
+      txt_entries[i].mValueLength = value.size();
+    }
+    entry->mService.mTxtEntries = txt_entries;
+    entry->mService.mNumTxtEntries = service.txt_records.size();
+
+    // Add service
+    error = otSrpClientAddService(instance, &entry->mService);
+    if (error != OT_ERROR_NONE) {
+      ESP_LOGW(TAG, "Failed to add service: %s", otThreadErrorToString(error));
+    }
+    ESP_LOGW(TAG, "Added service: %s", full_service.c_str());
+  }
+
+  otSrpClientEnableAutoStartMode(instance, srp_start_callback, nullptr);
+  ESP_LOGW(TAG, "Finished SRP setup");
+}
+
+void *OpenThreadSrpComponent::pool_alloc_(size_t size) {
+  uint8_t *ptr = new uint8_t[size];
+  this->memory_pool_.emplace_back(std::unique_ptr<uint8_t[]>(ptr));
+  return ptr;
+}
+
+void OpenThreadSrpComponent::set_mdns(esphome::mdns::MDNSComponent *mdns) { this->mdns_ = mdns; }
+
+}  // namespace openthread
+}  // namespace esphome
+
+#endif

esphome/components/openthread/openthread.h

@@ -0,0 +1,68 @@
+#pragma once
+#include "esphome/core/defines.h"
+#ifdef USE_OPENTHREAD
+
+#include "esphome/components/mdns/mdns_component.h"
+#include "esphome/components/network/ip_address.h"
+#include "esphome/core/component.h"
+
+#include <openthread/thread.h>
+
+#include <optional>
+#include <vector>
+
+namespace esphome {
+namespace openthread {
+
+class InstanceLock;
+
+class OpenThreadComponent : public Component {
+ public:
+  OpenThreadComponent();
+  ~OpenThreadComponent();
+  void setup() override;
+  float get_setup_priority() const override { return setup_priority::WIFI; }
+
+  bool is_connected();
+  network::IPAddresses get_ip_addresses();
+  std::optional<otIp6Address> get_omr_address();
+  void ot_main();
+
+ protected:
+  std::optional<otIp6Address> get_omr_address_(InstanceLock &lock);
+};
+
+extern OpenThreadComponent *global_openthread_component;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+class OpenThreadSrpComponent : public Component {
+ public:
+  void set_mdns(esphome::mdns::MDNSComponent *mdns);
+  // This has to run after the mdns component or else no services are available to advertise
+  float get_setup_priority() const override { return this->mdns_->get_setup_priority() - 1.0; }
+  void setup() override;
+
+ protected:
+  esphome::mdns::MDNSComponent *mdns_{nullptr};
+  std::vector<esphome::mdns::MDNSService> mdns_services_;
+  std::vector<std::unique_ptr<uint8_t[]>> memory_pool_;
+  void *pool_alloc_(size_t size);
+};
+
+class InstanceLock {
+ public:
+  static std::optional<InstanceLock> try_acquire(int delay);
+  static InstanceLock acquire();
+  ~InstanceLock();
+
+  // Returns the global openthread instance guarded by this lock
+  otInstance *get_instance();
+
+ private:
+  // Use a private constructor in order to force thehandling
+  // of acquisition failure
+  InstanceLock() {}
+};
+
+}  // namespace openthread
+}  // namespace esphome
+#endif

esphome/components/openthread/openthread_esp.cpp

@@ -0,0 +1,164 @@
+#include "esphome/core/defines.h"
+#if defined(USE_OPENTHREAD) && defined(USE_ESP_IDF)
+#include <openthread/logging.h>
+#include "openthread.h"
+
+#include "esp_log.h"
+#include "esp_openthread.h"
+#include "esp_openthread_lock.h"
+
+#include "esp_task_wdt.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+#include "esp_err.h"
+#include "esp_event.h"
+#include "esp_netif.h"
+#include "esp_netif_types.h"
+#include "esp_openthread_cli.h"
+#include "esp_openthread_netif_glue.h"
+#include "esp_vfs_eventfd.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "nvs_flash.h"
+
+static const char *const TAG = "openthread";
+
+namespace esphome {
+namespace openthread {
+
+void OpenThreadComponent::setup() {
+  ESP_LOGCONFIG(TAG, "Running setup");
+  // Used eventfds:
+  // * netif
+  // * ot task queue
+  // * radio driver
+  esp_vfs_eventfd_config_t eventfd_config = {
+      .max_fds = 3,
+  };
+  ESP_ERROR_CHECK(nvs_flash_init());
+  ESP_ERROR_CHECK(esp_event_loop_create_default());
+  ESP_ERROR_CHECK(esp_netif_init());
+  ESP_ERROR_CHECK(esp_vfs_eventfd_register(&eventfd_config));
+
+  xTaskCreate(
+      [](void *arg) {
+        static_cast<OpenThreadComponent *>(arg)->ot_main();
+        vTaskDelete(nullptr);
+      },
+      "ot_main", 10240, this, 5, nullptr);
+}
+
+static esp_netif_t *init_openthread_netif(const esp_openthread_platform_config_t *config) {
+  esp_netif_config_t cfg = ESP_NETIF_DEFAULT_OPENTHREAD();
+  esp_netif_t *netif = esp_netif_new(&cfg);
+  assert(netif != nullptr);
+  ESP_ERROR_CHECK(esp_netif_attach(netif, esp_openthread_netif_glue_init(config)));
+
+  return netif;
+}
+
+void OpenThreadComponent::ot_main() {
+  esp_openthread_platform_config_t config = {
+      .radio_config =
+          {
+              .radio_mode = RADIO_MODE_NATIVE,
+              .radio_uart_config = {},
+          },
+      .host_config =
+          {
+              // There is a conflict between esphome's logger which also
+              // claims the usb serial jtag device.
+              // .host_connection_mode = HOST_CONNECTION_MODE_CLI_USB,
+              // .host_usb_config = USB_SERIAL_JTAG_DRIVER_CONFIG_DEFAULT(),
+          },
+      .port_config =
+          {
+              .storage_partition_name = "nvs",
+              .netif_queue_size = 10,
+              .task_queue_size = 10,
+          },
+  };
+
+  // Initialize the OpenThread stack
+  // otLoggingSetLevel(OT_LOG_LEVEL_DEBG);
+  ESP_ERROR_CHECK(esp_openthread_init(&config));
+
+#if CONFIG_OPENTHREAD_STATE_INDICATOR_ENABLE
+  ESP_ERROR_CHECK(esp_openthread_state_indicator_init(esp_openthread_get_instance()));
+#endif
+
+#if CONFIG_OPENTHREAD_LOG_LEVEL_DYNAMIC
+  // The OpenThread log level directly matches ESP log level
+  (void) otLoggingSetLevel(CONFIG_LOG_DEFAULT_LEVEL);
+#endif
+  // Initialize the OpenThread cli
+#if CONFIG_OPENTHREAD_CLI
+  esp_openthread_cli_init();
+#endif
+
+  esp_netif_t *openthread_netif;
+  // Initialize the esp_netif bindings
+  openthread_netif = init_openthread_netif(&config);
+  esp_netif_set_default_netif(openthread_netif);
+
+#if CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
+  esp_cli_custom_command_init();
+#endif  // CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
+
+  // Run the main loop
+#if CONFIG_OPENTHREAD_CLI
+  esp_openthread_cli_create_task();
+#endif
+  ESP_LOGI(TAG, "Activating dataset...");
+  otOperationalDatasetTlvs dataset;
+
+#ifdef CONFIG_OPENTHREAD_FORCE_DATASET
+  ESP_ERROR_CHECK(esp_openthread_auto_start(NULL));
+#else
+  otError error = otDatasetGetActiveTlvs(esp_openthread_get_instance(), &dataset);
+  ESP_ERROR_CHECK(esp_openthread_auto_start((error == OT_ERROR_NONE) ? &dataset : NULL));
+#endif
+  esp_openthread_launch_mainloop();
+
+  // Clean up
+  esp_openthread_netif_glue_deinit();
+  esp_netif_destroy(openthread_netif);
+
+  esp_vfs_eventfd_unregister();
+}
+
+network::IPAddresses OpenThreadComponent::get_ip_addresses() {
+  network::IPAddresses addresses;
+  struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
+  uint8_t count = 0;
+  esp_netif_t *netif = esp_netif_get_default_netif();
+  count = esp_netif_get_all_ip6(netif, if_ip6s);
+  assert(count <= CONFIG_LWIP_IPV6_NUM_ADDRESSES);
+  for (int i = 0; i < count; i++) {
+    addresses[i + 1] = network::IPAddress(&if_ip6s[i]);
+  }
+  return addresses;
+}
+
+std::optional<InstanceLock> InstanceLock::try_acquire(int delay) {
+  if (esp_openthread_lock_acquire(delay)) {
+    return InstanceLock();
+  }
+  return {};
+}
+
+InstanceLock InstanceLock::acquire() {
+  while (!esp_openthread_lock_acquire(100)) {
+    esp_task_wdt_reset();
+  }
+  return InstanceLock();
+}
+
+otInstance *InstanceLock::get_instance() { return esp_openthread_get_instance(); }
+
+InstanceLock::~InstanceLock() { esp_openthread_lock_release(); }
+
+}  // namespace openthread
+}  // namespace esphome
+#endif

esphome/components/openthread/tlv.py

@@ -0,0 +1,58 @@
+# Sourced from https://gist.github.com/agners/0338576e0003318b63ec1ea75adc90f9
+import binascii
+
+from esphome.const import CONF_CHANNEL
+
+from . import (
+    CONF_EXT_PAN_ID,
+    CONF_MESH_LOCAL_PREFIX,
+    CONF_NETWORK_KEY,
+    CONF_NETWORK_NAME,
+    CONF_PAN_ID,
+    CONF_PSKC,
+)
+
+TLV_TYPES = {
+    0: CONF_CHANNEL,
+    1: CONF_PAN_ID,
+    2: CONF_EXT_PAN_ID,
+    3: CONF_NETWORK_NAME,
+    4: CONF_PSKC,
+    5: CONF_NETWORK_KEY,
+    7: CONF_MESH_LOCAL_PREFIX,
+}
+
+
+def parse_tlv(tlv) -> dict:
+    data = binascii.a2b_hex(tlv)
+    output = {}
+    pos = 0
+    while pos < len(data):
+        tag = data[pos]
+        pos += 1
+        _len = data[pos]
+        pos += 1
+        val = data[pos : pos + _len]
+        pos += _len
+        if tag in TLV_TYPES:
+            if tag == 3:
+                output[TLV_TYPES[tag]] = val.decode("utf-8")
+            else:
+                output[TLV_TYPES[tag]] = int.from_bytes(val)
+    return output
+
+
+def main():
+    import sys
+
+    args = sys.argv[1:]
+    parsed = parse_tlv(args[0])
+    # print the parsed TLV data
+    for key, value in parsed.items():
+        if isinstance(value, bytes):
+            value = value.hex()
+        print(f"{key}: {value}")
+
+
+if __name__ == "__main__":
+    main()

esphome/components/openthread_info/openthread_info_text_sensor.cpp

@@ -0,0 +1,24 @@
+
+#include "openthread_info_text_sensor.h"
+#ifdef USE_OPENTHREAD
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace openthread_info {
+
+static const char *const TAG = "openthread_info";
+
+void IPAddressOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "IPAddress", this); }
+void RoleOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "Role", this); }
+void ChannelOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "Channel", this); }
+void Rloc16OpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "Rloc16", this); }
+void ExtAddrOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "ExtAddr", this); }
+void Eui64OpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "Eui64", this); }
+void NetworkNameOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "Network Name", this); }
+void NetworkKeyOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "Network Key", this); }
+void PanIdOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "PAN ID", this); }
+void ExtPanIdOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "Extended PAN ID", this); }
+
+}  // namespace openthread_info
+}  // namespace esphome
+#endif