From c3c3a27af2535a3bbdb66c2b57bd8765000211bd Mon Sep 17 00:00:00 2001 From: Jesse Hills <3060199+jesserockz@users.noreply.github.com> Date: Wed, 11 Jun 2025 22:41:38 +1200 Subject: [PATCH] Openthread code updates (#9047) --- esphome/components/openthread/__init__.py | 2 - esphome/components/openthread/openthread.cpp | 81 ++++++++++--------- esphome/components/openthread/openthread.h | 16 ++-- .../components/openthread/openthread_esp.cpp | 24 +++--- .../openthread_info_text_sensor.cpp | 20 ++--- .../openthread_info_text_sensor.h | 50 +++++------- 6 files changed, 90 insertions(+), 103 deletions(-) diff --git a/esphome/components/openthread/__init__.py b/esphome/components/openthread/__init__.py index 9643239cb0..5b1ea491e3 100644 --- a/esphome/components/openthread/__init__.py +++ b/esphome/components/openthread/__init__.py @@ -8,7 +8,6 @@ from esphome.components.esp32 import ( from esphome.components.mdns import MDNSComponent import esphome.config_validation as cv from esphome.const import CONF_CHANNEL, CONF_ENABLE_IPV6, CONF_ID -from esphome.core import CORE import esphome.final_validate as fv from .const import ( @@ -140,7 +139,6 @@ async def to_code(config): await cg.register_component(ot, config) srp = cg.new_Pvariable(config[CONF_SRP_ID]) - cg.add(srp.set_host_name(cg.RawExpression(f'"{CORE.name}"'))) mdns_component = await cg.get_variable(config[CONF_MDNS_ID]) cg.add(srp.set_mdns(mdns_component)) await cg.register_component(srp, config) diff --git a/esphome/components/openthread/openthread.cpp b/esphome/components/openthread/openthread.cpp index c42d1fb4e1..f40a56952a 100644 --- a/esphome/components/openthread/openthread.cpp +++ b/esphome/components/openthread/openthread.cpp @@ -14,15 +14,17 @@ #include +#include "esphome/core/application.h" #include "esphome/core/helpers.h" #include "esphome/core/log.h" -#define TAG "openthread" +static const char *const TAG = "openthread"; namespace esphome { namespace openthread { -OpenThreadComponent *global_openthread_component = nullptr; +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; } @@ -58,63 +60,67 @@ bool OpenThreadComponent::is_connected() { // Gets the off-mesh routable address std::optional OpenThreadComponent::get_omr_address() { - auto lock = InstanceLock::acquire(); + InstanceLock lock = InstanceLock::acquire(); return this->get_omr_address_(lock); } -std::optional OpenThreadComponent::get_omr_address_(std::optional &lock) { +std::optional OpenThreadComponent::get_omr_address_(InstanceLock &lock) { otNetworkDataIterator iterator = OT_NETWORK_DATA_ITERATOR_INIT; otInstance *instance = nullptr; - instance = lock->get_instance(); + instance = lock.get_instance(); - otBorderRouterConfig aConfig; - if (otNetDataGetNextOnMeshPrefix(instance, &iterator, &aConfig) != OT_ERROR_NONE) { + otBorderRouterConfig config; + if (otNetDataGetNextOnMeshPrefix(instance, &iterator, &config) != OT_ERROR_NONE) { return std::nullopt; } - const otIp6Prefix *omrPrefix = &aConfig.mPrefix; - const otNetifAddress *unicastAddrs = otIp6GetUnicastAddresses(instance); - for (const otNetifAddress *addr = unicastAddrs; addr; addr = addr->mNext) { - const otIp6Address *localIp = &addr->mAddress; - if (otIp6PrefixMatch(&omrPrefix->mPrefix, localIp)) { - return *localIp; + 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 srpCallback(otError aError, const otSrpClientHostInfo *aHostInfo, const otSrpClientService *aServices, - const otSrpClientService *aRemovedServices, void *aContext) { - if (aError != 0) { - ESP_LOGW(TAG, "SRP client reported an error: %s", otThreadErrorToString(aError)); - for (const otSrpClientHostInfo *host = aHostInfo; host; host = nullptr) { +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 = aServices; service; service = service->mNext) { + for (const otSrpClientService *service = services; service; service = service->mNext) { ESP_LOGW(TAG, " Service: %s", service->mName); } } } -void srpStartCallback(const otSockAddr *aServerSockAddr, void *aContext) { ESP_LOGI(TAG, "SRP client has started"); } +void srp_start_callback(const otSockAddr *server_socket_address, void *context) { + ESP_LOGI(TAG, "SRP client has started"); +} void OpenThreadSrpComponent::setup() { otError error; - auto lock = InstanceLock::acquire(); - otInstance *instance = lock->get_instance(); + InstanceLock lock = InstanceLock::acquire(); + otInstance *instance = lock.get_instance(); - otSrpClientSetCallback(instance, srpCallback, nullptr); + otSrpClientSetCallback(instance, srp_callback, nullptr); // set the host name uint16_t size; char *existing_host_name = otSrpClientBuffersGetHostNameString(instance, &size); - uint16_t len = this->host_name_.size(); - if (len > 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; } - memcpy(existing_host_name, this->host_name_.c_str(), len + 1); + 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) { @@ -150,27 +156,28 @@ void OpenThreadSrpComponent::setup() { // Set instance name (using host_name) string = otSrpClientBuffersGetServiceEntryInstanceNameString(entry, &size); - if (this->host_name_.size() > size) { - ESP_LOGW(TAG, "Instance name too long: %s", this->host_name_.c_str()); + if (host_name_len > size) { + ESP_LOGW(TAG, "Instance name too long: %s", host_name.c_str()); continue; } - memcpy(string, this->host_name_.c_str(), this->host_name_.size() + 1); + memset(string, 0, size); + memcpy(string, host_name.c_str(), host_name_len); // Set port entry->mService.mPort = const_cast &>(service.port).value(); - otDnsTxtEntry *mTxtEntries = + otDnsTxtEntry *txt_entries = reinterpret_cast(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 &>(txt.value).value(); - mTxtEntries[i].mKey = txt.key.c_str(); - mTxtEntries[i].mValue = reinterpret_cast(value.c_str()); - mTxtEntries[i].mValueLength = value.size(); + txt_entries[i].mKey = strdup(txt.key.c_str()); + txt_entries[i].mValue = reinterpret_cast(strdup(value.c_str())); + txt_entries[i].mValueLength = value.size(); } - entry->mService.mTxtEntries = mTxtEntries; + entry->mService.mTxtEntries = txt_entries; entry->mService.mNumTxtEntries = service.txt_records.size(); // Add service @@ -181,8 +188,8 @@ void OpenThreadSrpComponent::setup() { ESP_LOGW(TAG, "Added service: %s", full_service.c_str()); } - otSrpClientEnableAutoStartMode(instance, srpStartCallback, nullptr); - ESP_LOGW(TAG, "Finished SRP setup **** "); + otSrpClientEnableAutoStartMode(instance, srp_start_callback, nullptr); + ESP_LOGW(TAG, "Finished SRP setup"); } void *OpenThreadSrpComponent::pool_alloc_(size_t size) { @@ -191,8 +198,6 @@ void *OpenThreadSrpComponent::pool_alloc_(size_t size) { return ptr; } -void OpenThreadSrpComponent::set_host_name(std::string host_name) { this->host_name_ = host_name; } - void OpenThreadSrpComponent::set_mdns(esphome::mdns::MDNSComponent *mdns) { this->mdns_ = mdns; } } // namespace openthread diff --git a/esphome/components/openthread/openthread.h b/esphome/components/openthread/openthread.h index 32728521ae..77fd58851a 100644 --- a/esphome/components/openthread/openthread.h +++ b/esphome/components/openthread/openthread.h @@ -2,14 +2,14 @@ #include "esphome/core/defines.h" #ifdef USE_OPENTHREAD -#include "esphome/core/component.h" #include "esphome/components/mdns/mdns_component.h" #include "esphome/components/network/ip_address.h" +#include "esphome/core/component.h" #include -#include #include +#include namespace esphome { namespace openthread { @@ -29,23 +29,19 @@ class OpenThreadComponent : public Component { void ot_main(); protected: - std::optional get_omr_address_(std::optional &lock); + std::optional get_omr_address_(InstanceLock &lock); }; -extern OpenThreadComponent *global_openthread_component; +extern OpenThreadComponent *global_openthread_component; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) class OpenThreadSrpComponent : public Component { public: void set_mdns(esphome::mdns::MDNSComponent *mdns); - void set_host_name(std::string host_name); // 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; } - - protected: void setup() override; - private: - std::string host_name_; + protected: esphome::mdns::MDNSComponent *mdns_{nullptr}; std::vector mdns_services_; std::vector> memory_pool_; @@ -55,7 +51,7 @@ class OpenThreadSrpComponent : public Component { class InstanceLock { public: static std::optional try_acquire(int delay); - static std::optional acquire(); + static InstanceLock acquire(); ~InstanceLock(); // Returns the global openthread instance guarded by this lock diff --git a/esphome/components/openthread/openthread_esp.cpp b/esphome/components/openthread/openthread_esp.cpp index f7601c69f5..c5c817382f 100644 --- a/esphome/components/openthread/openthread_esp.cpp +++ b/esphome/components/openthread/openthread_esp.cpp @@ -1,34 +1,34 @@ #include "esphome/core/defines.h" #if defined(USE_OPENTHREAD) && defined(USE_ESP_IDF) -#include "openthread.h" #include +#include "openthread.h" +#include "esp_log.h" #include "esp_openthread.h" #include "esp_openthread_lock.h" -#include "esp_log.h" +#include "esp_task_wdt.h" #include "esphome/core/helpers.h" #include "esphome/core/log.h" -#include "esp_task_wdt.h" -#include "esp_openthread_cli.h" -#include "esp_openthread_netif_glue.h" +#include "esp_err.h" #include "esp_event.h" -#include "nvs_flash.h" -#include "esp_vfs_eventfd.h" #include "esp_netif.h" #include "esp_netif_types.h" -#include "esp_err.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" -#define TAG "openthread" +static const char *const TAG = "openthread"; namespace esphome { namespace openthread { void OpenThreadComponent::setup() { - ESP_LOGI(TAG, "Setting up OpenThread..."); + ESP_LOGCONFIG(TAG, "Running setup"); // Used eventfds: // * netif // * ot task queue @@ -47,8 +47,6 @@ void OpenThreadComponent::setup() { vTaskDelete(nullptr); }, "ot_main", 10240, this, 5, nullptr); - - ESP_LOGI(TAG, "OpenThread started"); } static esp_netif_t *init_openthread_netif(const esp_openthread_platform_config_t *config) { @@ -150,7 +148,7 @@ std::optional InstanceLock::try_acquire(int delay) { return {}; } -std::optional InstanceLock::acquire() { +InstanceLock InstanceLock::acquire() { while (!esp_openthread_lock_acquire(100)) { esp_task_wdt_reset(); } diff --git a/esphome/components/openthread_info/openthread_info_text_sensor.cpp b/esphome/components/openthread_info/openthread_info_text_sensor.cpp index 6570ed9d59..10724f3e2f 100644 --- a/esphome/components/openthread_info/openthread_info_text_sensor.cpp +++ b/esphome/components/openthread_info/openthread_info_text_sensor.cpp @@ -8,16 +8,16 @@ namespace openthread_info { static const char *const TAG = "openthread_info"; -void IPAddressOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo IPAddress", this); } -void RoleOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo Role", this); } -void ChannelOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo Channel", this); } -void Rloc16OpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo Rloc16", this); } -void ExtAddrOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo ExtAddr", this); } -void Eui64OpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo Eui64", this); } -void NetworkNameOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo Network Name", this); } -void NetworkKeyOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo Network Key", this); } -void PanIdOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo PAN ID", this); } -void ExtPanIdOpenThreadInfo::dump_config() { LOG_TEXT_SENSOR("", "OpenThreadInfo Extended PAN ID", this); } +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 diff --git a/esphome/components/openthread_info/openthread_info_text_sensor.h b/esphome/components/openthread_info/openthread_info_text_sensor.h index d6a32181d8..bbcd2d4655 100644 --- a/esphome/components/openthread_info/openthread_info_text_sensor.h +++ b/esphome/components/openthread_info/openthread_info_text_sensor.h @@ -1,8 +1,8 @@ #pragma once -#include "esphome/core/component.h" -#include "esphome/components/text_sensor/text_sensor.h" #include "esphome/components/openthread/openthread.h" +#include "esphome/components/text_sensor/text_sensor.h" +#include "esphome/core/component.h" #ifdef USE_OPENTHREAD namespace esphome { @@ -18,12 +18,12 @@ class OpenThreadInstancePollingComponent : public PollingComponent { return; } - this->update_instance_(lock->get_instance()); + this->update_instance(lock->get_instance()); } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } protected: - virtual void update_instance_(otInstance *instance) = 0; + virtual void update_instance(otInstance *instance) = 0; }; class IPAddressOpenThreadInfo : public PollingComponent, public text_sensor::TextSensor { @@ -34,9 +34,9 @@ class IPAddressOpenThreadInfo : public PollingComponent, public text_sensor::Tex return; } - char addressAsString[40]; - otIp6AddressToString(&*address, addressAsString, 40); - std::string ip = addressAsString; + char address_as_string[40]; + otIp6AddressToString(&*address, address_as_string, 40); + std::string ip = address_as_string; if (this->last_ip_ != ip) { this->last_ip_ = ip; @@ -44,7 +44,6 @@ class IPAddressOpenThreadInfo : public PollingComponent, public text_sensor::Tex } } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-ip"; } void dump_config() override; protected: @@ -53,7 +52,7 @@ class IPAddressOpenThreadInfo : public PollingComponent, public text_sensor::Tex class RoleOpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor { public: - void update_instance_(otInstance *instance) override { + void update_instance(otInstance *instance) override { otDeviceRole role = otThreadGetDeviceRole(instance); if (this->last_role_ != role) { @@ -61,7 +60,6 @@ class RoleOpenThreadInfo : public OpenThreadInstancePollingComponent, public tex this->publish_state(otThreadDeviceRoleToString(this->last_role_)); } } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-role"; } void dump_config() override; protected: @@ -70,7 +68,7 @@ class RoleOpenThreadInfo : public OpenThreadInstancePollingComponent, public tex class Rloc16OpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor { public: - void update_instance_(otInstance *instance) override { + void update_instance(otInstance *instance) override { uint16_t rloc16 = otThreadGetRloc16(instance); if (this->last_rloc16_ != rloc16) { this->last_rloc16_ = rloc16; @@ -80,7 +78,6 @@ class Rloc16OpenThreadInfo : public OpenThreadInstancePollingComponent, public t } } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-rloc16"; } void dump_config() override; protected: @@ -89,15 +86,14 @@ class Rloc16OpenThreadInfo : public OpenThreadInstancePollingComponent, public t class ExtAddrOpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor { public: - void update_instance_(otInstance *instance) override { - auto extaddr = otLinkGetExtendedAddress(instance); + void update_instance(otInstance *instance) override { + const auto *extaddr = otLinkGetExtendedAddress(instance); if (!std::equal(this->last_extaddr_.begin(), this->last_extaddr_.end(), extaddr->m8)) { std::copy(extaddr->m8, extaddr->m8 + 8, this->last_extaddr_.begin()); this->publish_state(format_hex(extaddr->m8, 8)); } } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-extaddr"; } void dump_config() override; protected: @@ -106,7 +102,7 @@ class ExtAddrOpenThreadInfo : public OpenThreadInstancePollingComponent, public class Eui64OpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor { public: - void update_instance_(otInstance *instance) override { + void update_instance(otInstance *instance) override { otExtAddress addr; otLinkGetFactoryAssignedIeeeEui64(instance, &addr); @@ -116,7 +112,6 @@ class Eui64OpenThreadInfo : public OpenThreadInstancePollingComponent, public te } } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-extaddr"; } void dump_config() override; protected: @@ -125,7 +120,7 @@ class Eui64OpenThreadInfo : public OpenThreadInstancePollingComponent, public te class ChannelOpenThreadInfo : public OpenThreadInstancePollingComponent, public text_sensor::TextSensor { public: - void update_instance_(otInstance *instance) override { + void update_instance(otInstance *instance) override { uint8_t channel = otLinkGetChannel(instance); if (this->last_channel_ != channel) { this->last_channel_ = channel; @@ -133,7 +128,6 @@ class ChannelOpenThreadInfo : public OpenThreadInstancePollingComponent, public } } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-extaddr"; } void dump_config() override; protected: @@ -142,29 +136,28 @@ class ChannelOpenThreadInfo : public OpenThreadInstancePollingComponent, public class DatasetOpenThreadInfo : public OpenThreadInstancePollingComponent { public: - void update_instance_(otInstance *instance) override { + void update_instance(otInstance *instance) override { otOperationalDataset dataset; if (otDatasetGetActive(instance, &dataset) != OT_ERROR_NONE) { return; } - this->update_dataset_(&dataset); + this->update_dataset(&dataset); } protected: - virtual void update_dataset_(otOperationalDataset *dataset) = 0; + virtual void update_dataset(otOperationalDataset *dataset) = 0; }; class NetworkNameOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::TextSensor { public: - void update_dataset_(otOperationalDataset *dataset) override { + void update_dataset(otOperationalDataset *dataset) override { if (this->last_network_name_ != dataset->mNetworkName.m8) { this->last_network_name_ = dataset->mNetworkName.m8; this->publish_state(this->last_network_name_); } } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-networkname"; } void dump_config() override; protected: @@ -173,14 +166,13 @@ class NetworkNameOpenThreadInfo : public DatasetOpenThreadInfo, public text_sens class NetworkKeyOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::TextSensor { public: - void update_dataset_(otOperationalDataset *dataset) override { + void update_dataset(otOperationalDataset *dataset) override { if (!std::equal(this->last_key_.begin(), this->last_key_.end(), dataset->mNetworkKey.m8)) { std::copy(dataset->mNetworkKey.m8, dataset->mNetworkKey.m8 + 16, this->last_key_.begin()); this->publish_state(format_hex(dataset->mNetworkKey.m8, 16)); } } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-networkkey"; } void dump_config() override; protected: @@ -189,7 +181,7 @@ class NetworkKeyOpenThreadInfo : public DatasetOpenThreadInfo, public text_senso class PanIdOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::TextSensor { public: - void update_dataset_(otOperationalDataset *dataset) override { + void update_dataset(otOperationalDataset *dataset) override { uint16_t panid = dataset->mPanId; if (this->last_panid_ != panid) { this->last_panid_ = panid; @@ -199,7 +191,6 @@ class PanIdOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::Te } } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-panid"; } void dump_config() override; protected: @@ -208,7 +199,7 @@ class PanIdOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::Te class ExtPanIdOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor::TextSensor { public: - void update_dataset_(otOperationalDataset *dataset) override { + void update_dataset(otOperationalDataset *dataset) override { if (!std::equal(this->last_extpanid_.begin(), this->last_extpanid_.end(), dataset->mExtendedPanId.m8)) { std::copy(dataset->mExtendedPanId.m8, dataset->mExtendedPanId.m8 + 8, this->last_extpanid_.begin()); this->publish_state(format_hex(this->last_extpanid_.begin(), 8)); @@ -216,7 +207,6 @@ class ExtPanIdOpenThreadInfo : public DatasetOpenThreadInfo, public text_sensor: } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } - std::string unique_id() override { return get_mac_address() + "-openthreadinfo-extpanid"; } void dump_config() override; protected: