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

esphome/components/opentherm/number/{number.cpp → opentherm_number.cpp}

@@ -1,4 +1,4 @@
-#include "number.h"
+#include "opentherm_number.h"
 
 namespace esphome {
 namespace opentherm {
@@ -17,7 +17,7 @@ void OpenthermNumber::setup() {
   if (!this->restore_value_) {
     value = this->initial_value_;
   } else {
-    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     if (!this->pref_.load(&value)) {
       if (!std::isnan(this->initial_value_)) {
         value = this->initial_value_;

esphome/components/opentherm/output/{output.cpp → opentherm_output.cpp}

@@ -1,5 +1,5 @@
 #include "esphome/core/helpers.h"  // for clamp() and lerp()
-#include "output.h"
+#include "opentherm_output.h"
 
 namespace esphome {
 namespace opentherm {

esphome/components/opentherm/switch/{switch.cpp → opentherm_switch.cpp}

@@ -1,4 +1,4 @@
-#include "switch.h"
+#include "opentherm_switch.h"
 
 namespace esphome {
 namespace opentherm {

esphome/components/openthread/openthread.cpp

@@ -11,8 +11,6 @@
 #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>
@@ -77,8 +75,14 @@ std::optional<otIp6Address> OpenThreadComponent::get_omr_address_(InstanceLock &
   return {};
 }
 
-void srp_callback(otError err, const otSrpClientHostInfo *host_info, const otSrpClientService *services,
-                  const otSrpClientService *removed_services, void *context) {
+void OpenThreadComponent::defer_factory_reset_external_callback() {
+  ESP_LOGD(TAG, "Defer factory_reset_external_callback_");
+  this->defer([this]() { this->factory_reset_external_callback_(); });
+}
+
+void OpenThreadSrpComponent::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) {
@@ -90,16 +94,30 @@ void srp_callback(otError err, const otSrpClientHostInfo *host_info, const otSrp
   }
 }
 
-void srp_start_callback(const otSockAddr *server_socket_address, void *context) {
+void OpenThreadSrpComponent::srp_start_callback(const otSockAddr *server_socket_address, void *context) {
   ESP_LOGI(TAG, "SRP client has started");
 }
 
+void OpenThreadSrpComponent::srp_factory_reset_callback(otError err, const otSrpClientHostInfo *host_info,
+                                                        const otSrpClientService *services,
+                                                        const otSrpClientService *removed_services, void *context) {
+  OpenThreadComponent *obj = (OpenThreadComponent *) context;
+  if (err == OT_ERROR_NONE && removed_services != NULL && host_info != NULL &&
+      host_info->mState == OT_SRP_CLIENT_ITEM_STATE_REMOVED) {
+    ESP_LOGD(TAG, "Successful Removal SRP Host and Services");
+  } else if (err != OT_ERROR_NONE) {
+    // Handle other SRP client events or errors
+    ESP_LOGW(TAG, "SRP client event/error: %s", otThreadErrorToString(err));
+  }
+  obj->defer_factory_reset_external_callback();
+}
+
 void OpenThreadSrpComponent::setup() {
   otError error;
   InstanceLock lock = InstanceLock::acquire();
   otInstance *instance = lock.get_instance();
 
-  otSrpClientSetCallback(instance, srp_callback, nullptr);
+  otSrpClientSetCallback(instance, OpenThreadSrpComponent::srp_callback, nullptr);
 
   // set the host name
   uint16_t size;
@@ -179,7 +197,8 @@ void OpenThreadSrpComponent::setup() {
     ESP_LOGD(TAG, "Added service: %s", full_service.c_str());
   }
 
-  otSrpClientEnableAutoStartMode(instance, srp_start_callback, nullptr);
+  otSrpClientEnableAutoStartMode(instance, OpenThreadSrpComponent::srp_start_callback, nullptr);
+  ESP_LOGD(TAG, "Finished SRP setup");
 }
 
 void *OpenThreadSrpComponent::pool_alloc_(size_t size) {
@@ -217,6 +236,21 @@ bool OpenThreadComponent::teardown() {
   return this->teardown_complete_;
 }
 
+void OpenThreadComponent::on_factory_reset(std::function<void()> callback) {
+  factory_reset_external_callback_ = callback;
+  ESP_LOGD(TAG, "Start Removal SRP Host and Services");
+  otError error;
+  InstanceLock lock = InstanceLock::acquire();
+  otInstance *instance = lock.get_instance();
+  otSrpClientSetCallback(instance, OpenThreadSrpComponent::srp_factory_reset_callback, this);
+  error = otSrpClientRemoveHostAndServices(instance, true, true);
+  if (error != OT_ERROR_NONE) {
+    ESP_LOGW(TAG, "Failed to Remove SRP Host and Services");
+    return;
+  }
+  ESP_LOGD(TAG, "Waiting on Confirmation Removal SRP Host and Services");
+}
+
 }  // namespace openthread
 }  // namespace esphome
 

esphome/components/openthread/openthread.h

@@ -6,6 +6,8 @@
 #include "esphome/components/network/ip_address.h"
 #include "esphome/core/component.h"
 
+#include <openthread/srp_client.h>
+#include <openthread/srp_client_buffers.h>
 #include <openthread/thread.h>
 
 #include <optional>
@@ -28,11 +30,14 @@ class OpenThreadComponent : public Component {
   network::IPAddresses get_ip_addresses();
   std::optional<otIp6Address> get_omr_address();
   void ot_main();
+  void on_factory_reset(std::function<void()> callback);
+  void defer_factory_reset_external_callback();
 
  protected:
   std::optional<otIp6Address> get_omr_address_(InstanceLock &lock);
   bool teardown_started_{false};
   bool teardown_complete_{false};
+  std::function<void()> factory_reset_external_callback_;
 };
 
 extern OpenThreadComponent *global_openthread_component;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -43,6 +48,12 @@ class OpenThreadSrpComponent : public Component {
   // 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;
+  static void srp_callback(otError err, const otSrpClientHostInfo *host_info, const otSrpClientService *services,
+                           const otSrpClientService *removed_services, void *context);
+  static void srp_start_callback(const otSockAddr *server_socket_address, void *context);
+  static void srp_factory_reset_callback(otError err, const otSrpClientHostInfo *host_info,
+                                         const otSrpClientService *services, const otSrpClientService *removed_services,
+                                         void *context);
 
  protected:
   esphome::mdns::MDNSComponent *mdns_{nullptr};

esphome/components/ota/__init__.py

@@ -10,7 +10,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     PlatformFramework,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 AUTO_LOAD = ["md5", "safe_mode"]
@@ -82,7 +82,7 @@ BASE_OTA_SCHEMA = cv.Schema(
 )
 
 
-@coroutine_with_priority(54.0)
+@coroutine_with_priority(CoroPriority.COMMUNICATION)
 async def to_code(config):
     cg.add_define("USE_OTA")
 

esphome/components/pca6416a/__init__.py

@@ -14,6 +14,7 @@ from esphome.const import (
 
 CODEOWNERS = ["@Mat931"]
 DEPENDENCIES = ["i2c"]
+AUTO_LOAD = ["gpio_expander"]
 MULTI_CONF = True
 pca6416a_ns = cg.esphome_ns.namespace("pca6416a")
 

esphome/components/pca6416a/pca6416a.cpp

@@ -51,6 +51,11 @@ void PCA6416AComponent::setup() {
            this->status_has_error());
 }
 
+void PCA6416AComponent::loop() {
+  // Invalidate cache at the start of each loop
+  this->reset_pin_cache_();
+}
+
 void PCA6416AComponent::dump_config() {
   if (this->has_pullup_) {
     ESP_LOGCONFIG(TAG, "PCAL6416A:");
@@ -63,15 +68,25 @@ void PCA6416AComponent::dump_config() {
   }
 }
 
-bool PCA6416AComponent::digital_read(uint8_t pin) {
-  uint8_t bit = pin % 8;
+bool PCA6416AComponent::digital_read_hw(uint8_t pin) {
   uint8_t reg_addr = pin < 8 ? PCA6416A_INPUT0 : PCA6416A_INPUT1;
   uint8_t value = 0;
-  this->read_register_(reg_addr, &value);
-  return value & (1 << bit);
+  if (!this->read_register_(reg_addr, &value)) {
+    return false;
+  }
+
+  // Update the appropriate part of input_mask_
+  if (pin < 8) {
+    this->input_mask_ = (this->input_mask_ & 0xFF00) | value;
+  } else {
+    this->input_mask_ = (this->input_mask_ & 0x00FF) | (uint16_t(value) << 8);
+  }
+  return true;
 }
 
-void PCA6416AComponent::digital_write(uint8_t pin, bool value) {
+bool PCA6416AComponent::digital_read_cache(uint8_t pin) { return this->input_mask_ & (1 << pin); }
+
+void PCA6416AComponent::digital_write_hw(uint8_t pin, bool value) {
   uint8_t reg_addr = pin < 8 ? PCA6416A_OUTPUT0 : PCA6416A_OUTPUT1;
   this->update_register_(pin, value, reg_addr);
 }

esphome/components/pca6416a/pca6416a.h

@@ -3,20 +3,20 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/components/gpio_expander/cached_gpio.h"
 
 namespace esphome {
 namespace pca6416a {
 
-class PCA6416AComponent : public Component, public i2c::I2CDevice {
+class PCA6416AComponent : public Component,
+                          public i2c::I2CDevice,
+                          public gpio_expander::CachedGpioExpander<uint8_t, 16> {
  public:
   PCA6416AComponent() = default;
 
   /// Check i2c availability and setup masks
   void setup() override;
-  /// Helper function to read the value of a pin.
-  bool digital_read(uint8_t pin);
-  /// Helper function to write the value of a pin.
-  void digital_write(uint8_t pin, bool value);
+  void loop() override;
   /// Helper function to set the pin mode of a pin.
   void pin_mode(uint8_t pin, gpio::Flags flags);
 
@@ -25,6 +25,11 @@ class PCA6416AComponent : public Component, public i2c::I2CDevice {
   void dump_config() override;
 
  protected:
+  // Virtual methods from CachedGpioExpander
+  bool digital_read_hw(uint8_t pin) override;
+  bool digital_read_cache(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
+
   bool read_register_(uint8_t reg, uint8_t *value);
   bool write_register_(uint8_t reg, uint8_t value);
   void update_register_(uint8_t pin, bool pin_value, uint8_t reg_addr);
@@ -32,6 +37,8 @@ class PCA6416AComponent : public Component, public i2c::I2CDevice {
   /// The mask to write as output state - 1 means HIGH, 0 means LOW
   uint8_t output_0_{0x00};
   uint8_t output_1_{0x00};
+  /// Cache for input values (16-bit combined for both banks)
+  uint16_t input_mask_{0x00};
   /// Storage for last I2C error seen
   esphome::i2c::ErrorCode last_error_;
   /// Only the PCAL6416A has pull-up resistors

esphome/components/pca9554/__init__.py

@@ -11,7 +11,8 @@ from esphome.const import (
     CONF_OUTPUT,
 )
 
-CODEOWNERS = ["@hwstar", "@clydebarrow"]
+CODEOWNERS = ["@hwstar", "@clydebarrow", "@bdraco"]
+AUTO_LOAD = ["gpio_expander"]
 DEPENDENCIES = ["i2c"]
 MULTI_CONF = True
 CONF_PIN_COUNT = "pin_count"

esphome/components/pca9554/pca9554.cpp

@@ -37,10 +37,9 @@ void PCA9554Component::setup() {
 }
 
 void PCA9554Component::loop() {
-  // The read_inputs_() method will cache the input values from the chip.
-  this->read_inputs_();
-  // Clear all the previously read flags.
-  this->was_previously_read_ = 0x00;
+  // Invalidate the cache at the start of each loop.
+  // The actual read will happen on demand when digital_read() is called
+  this->reset_pin_cache_();
 }
 
 void PCA9554Component::dump_config() {
@@ -54,21 +53,17 @@ void PCA9554Component::dump_config() {
   }
 }
 
-bool PCA9554Component::digital_read(uint8_t pin) {
-  // Note: We want to try and avoid doing any I2C bus read transactions here
-  // to conserve I2C bus bandwidth. So what we do is check to see if we
-  // have seen a read during the time esphome is running this loop. If we have,
-  // we do an I2C bus transaction to get the latest value. If we haven't
-  // we return a cached value which was read at the time loop() was called.
-  if (this->was_previously_read_ & (1 << pin))
-    this->read_inputs_();  // Force a read of a new value
-  // Indicate we saw a read request for this pin in case a
-  // read happens later in the same loop.
-  this->was_previously_read_ |= (1 << pin);
+bool PCA9554Component::digital_read_hw(uint8_t pin) {
+  // Read all pins from hardware into input_mask_
+  return this->read_inputs_();  // Return true if I2C read succeeded, false on error
+}
+
+bool PCA9554Component::digital_read_cache(uint8_t pin) {
+  // Return the cached pin state from input_mask_
   return this->input_mask_ & (1 << pin);
 }
 
-void PCA9554Component::digital_write(uint8_t pin, bool value) {
+void PCA9554Component::digital_write_hw(uint8_t pin, bool value) {
   if (value) {
     this->output_mask_ |= (1 << pin);
   } else {
@@ -127,8 +122,7 @@ bool PCA9554Component::write_register_(uint8_t reg, uint16_t value) {
 
 float PCA9554Component::get_setup_priority() const { return setup_priority::IO; }
 
-// Run our loop() method very early in the loop, so that we cache read values before
-// before other components call our digital_read() method.
+// Run our loop() method early to invalidate cache before any other components access the pins
 float PCA9554Component::get_loop_priority() const { return 9.0f; }  // Just after WIFI
 
 void PCA9554GPIOPin::setup() { pin_mode(flags_); }

esphome/components/pca9554/pca9554.h

@@ -3,22 +3,21 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/components/gpio_expander/cached_gpio.h"
 
 namespace esphome {
 namespace pca9554 {
 
-class PCA9554Component : public Component, public i2c::I2CDevice {
+class PCA9554Component : public Component,
+                         public i2c::I2CDevice,
+                         public gpio_expander::CachedGpioExpander<uint16_t, 16> {
  public:
   PCA9554Component() = default;
 
   /// Check i2c availability and setup masks
   void setup() override;
-  /// Poll for input changes periodically
+  /// Invalidate cache at start of each loop
   void loop() override;
-  /// Helper function to read the value of a pin.
-  bool digital_read(uint8_t pin);
-  /// Helper function to write the value of a pin.
-  void digital_write(uint8_t pin, bool value);
   /// Helper function to set the pin mode of a pin.
   void pin_mode(uint8_t pin, gpio::Flags flags);
 
@@ -32,9 +31,13 @@ class PCA9554Component : public Component, public i2c::I2CDevice {
 
  protected:
   bool read_inputs_();
-
   bool write_register_(uint8_t reg, uint16_t value);
 
+  // Virtual methods from CachedGpioExpander
+  bool digital_read_hw(uint8_t pin) override;
+  bool digital_read_cache(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
+
   /// number of bits the expander has
   size_t pin_count_{8};
   /// width of registers
@@ -45,8 +48,6 @@ class PCA9554Component : public Component, public i2c::I2CDevice {
   uint16_t output_mask_{0x00};
   /// The state of the actual input pin states - 1 means HIGH, 0 means LOW
   uint16_t input_mask_{0x00};
-  /// Flags to check if read previously during this loop
-  uint16_t was_previously_read_ = {0x00};
   /// Storage for last I2C error seen
   esphome::i2c::ErrorCode last_error_;
 };

esphome/components/pcf8574/__init__.py

@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_OUTPUT,
 )
 
+AUTO_LOAD = ["gpio_expander"]
 DEPENDENCIES = ["i2c"]
 MULTI_CONF = True
 

esphome/components/pcf8574/pcf8574.cpp

@@ -16,6 +16,10 @@ void PCF8574Component::setup() {
   this->write_gpio_();
   this->read_gpio_();
 }
+void PCF8574Component::loop() {
+  // Invalidate the cache at the start of each loop
+  this->reset_pin_cache_();
+}
 void PCF8574Component::dump_config() {
   ESP_LOGCONFIG(TAG, "PCF8574:");
   LOG_I2C_DEVICE(this)
@@ -24,17 +28,19 @@ void PCF8574Component::dump_config() {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
-bool PCF8574Component::digital_read(uint8_t pin) {
-  this->read_gpio_();
-  return this->input_mask_ & (1 << pin);
+bool PCF8574Component::digital_read_hw(uint8_t pin) {
+  // Read all pins from hardware into input_mask_
+  return this->read_gpio_();  // Return true if I2C read succeeded, false on error
 }
-void PCF8574Component::digital_write(uint8_t pin, bool value) {
+
+bool PCF8574Component::digital_read_cache(uint8_t pin) { return this->input_mask_ & (1 << pin); }
+
+void PCF8574Component::digital_write_hw(uint8_t pin, bool value) {
   if (value) {
     this->output_mask_ |= (1 << pin);
   } else {
     this->output_mask_ &= ~(1 << pin);
   }
-
   this->write_gpio_();
 }
 void PCF8574Component::pin_mode(uint8_t pin, gpio::Flags flags) {
@@ -91,6 +97,9 @@ bool PCF8574Component::write_gpio_() {
 }
 float PCF8574Component::get_setup_priority() const { return setup_priority::IO; }
 
+// Run our loop() method early to invalidate cache before any other components access the pins
+float PCF8574Component::get_loop_priority() const { return 9.0f; }  // Just after WIFI
+
 void PCF8574GPIOPin::setup() { pin_mode(flags_); }
 void PCF8574GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
 bool PCF8574GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }

esphome/components/pcf8574/pcf8574.h

@@ -3,11 +3,16 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/components/gpio_expander/cached_gpio.h"
 
 namespace esphome {
 namespace pcf8574 {
 
-class PCF8574Component : public Component, public i2c::I2CDevice {
+// PCF8574(8 pins)/PCF8575(16 pins) always read/write all pins in a single I2C transaction
+// so we use uint16_t as bank type to ensure all pins are in one bank and cached together
+class PCF8574Component : public Component,
+                         public i2c::I2CDevice,
+                         public gpio_expander::CachedGpioExpander<uint16_t, 16> {
  public:
   PCF8574Component() = default;
 
@@ -15,20 +20,22 @@ class PCF8574Component : public Component, public i2c::I2CDevice {
 
   /// Check i2c availability and setup masks
   void setup() override;
-  /// Helper function to read the value of a pin.
-  bool digital_read(uint8_t pin);
-  /// Helper function to write the value of a pin.
-  void digital_write(uint8_t pin, bool value);
+  /// Invalidate cache at start of each loop
+  void loop() override;
   /// Helper function to set the pin mode of a pin.
   void pin_mode(uint8_t pin, gpio::Flags flags);
 
   float get_setup_priority() const override;
+  float get_loop_priority() const override;
 
   void dump_config() override;
 
  protected:
-  bool read_gpio_();
+  bool digital_read_hw(uint8_t pin) override;
+  bool digital_read_cache(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
 
+  bool read_gpio_();
   bool write_gpio_();
 
   /// Mask for the pin mode - 1 means output, 0 means input

esphome/components/pi4ioe5v6408/pi4ioe5v6408.cpp

@@ -68,7 +68,7 @@ bool PI4IOE5V6408Component::read_gpio_outputs_() {
 
   uint8_t data;
   if (!this->read_byte(PI4IOE5V6408_REGISTER_OUT_SET, &data)) {
-    this->status_set_warning("Failed to read output register");
+    this->status_set_warning(LOG_STR("Failed to read output register"));
     return false;
   }
   this->output_mask_ = data;
@@ -82,7 +82,7 @@ bool PI4IOE5V6408Component::read_gpio_modes_() {
 
   uint8_t data;
   if (!this->read_byte(PI4IOE5V6408_REGISTER_IO_DIR, &data)) {
-    this->status_set_warning("Failed to read GPIO modes");
+    this->status_set_warning(LOG_STR("Failed to read GPIO modes"));
     return false;
   }
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
@@ -99,7 +99,7 @@ bool PI4IOE5V6408Component::digital_read_hw(uint8_t pin) {
 
   uint8_t data;
   if (!this->read_byte(PI4IOE5V6408_REGISTER_IN_STATE, &data)) {
-    this->status_set_warning("Failed to read GPIO state");
+    this->status_set_warning(LOG_STR("Failed to read GPIO state"));
     return false;
   }
   this->input_mask_ = data;
@@ -117,7 +117,7 @@ void PI4IOE5V6408Component::digital_write_hw(uint8_t pin, bool value) {
     this->output_mask_ &= ~(1 << pin);
   }
   if (!this->write_byte(PI4IOE5V6408_REGISTER_OUT_SET, this->output_mask_)) {
-    this->status_set_warning("Failed to write output register");
+    this->status_set_warning(LOG_STR("Failed to write output register"));
     return;
   }
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
@@ -131,15 +131,15 @@ bool PI4IOE5V6408Component::write_gpio_modes_() {
     return false;
 
   if (!this->write_byte(PI4IOE5V6408_REGISTER_IO_DIR, this->mode_mask_)) {
-    this->status_set_warning("Failed to write GPIO modes");
+    this->status_set_warning(LOG_STR("Failed to write GPIO modes"));
     return false;
   }
   if (!this->write_byte(PI4IOE5V6408_REGISTER_PULL_SELECT, this->pull_up_down_mask_)) {
-    this->status_set_warning("Failed to write GPIO pullup/pulldown");
+    this->status_set_warning(LOG_STR("Failed to write GPIO pullup/pulldown"));
     return false;
   }
   if (!this->write_byte(PI4IOE5V6408_REGISTER_PULL_ENABLE, this->pull_enable_mask_)) {
-    this->status_set_warning("Failed to write GPIO pull enable");
+    this->status_set_warning(LOG_STR("Failed to write GPIO pull enable"));
     return false;
   }
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE

esphome/components/pipsolar/__init__.py

@@ -26,7 +26,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield uart.register_uart_device(var, config)
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)

esphome/components/pipsolar/output/__init__.py

@@ -99,9 +99,9 @@ async def to_code(config):
         }
     ),
 )
-def output_pipsolar_set_level_to_code(config, action_id, template_arg, args):
-    paren = yield cg.get_variable(config[CONF_ID])
+async def output_pipsolar_set_level_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = yield cg.templatable(config[CONF_VALUE], args, float)
+    template_ = await cg.templatable(config[CONF_VALUE], args, float)
     cg.add(var.set_level(template_))
-    yield var
+    return var

esphome/components/pulse_width/pulse_width.cpp

@@ -17,8 +17,8 @@ void IRAM_ATTR PulseWidthSensorStore::gpio_intr(PulseWidthSensorStore *arg) {
 }
 
 void PulseWidthSensor::dump_config() {
-  LOG_SENSOR("", "Pulse Width", this)
-  LOG_UPDATE_INTERVAL(this)
+  LOG_SENSOR("", "Pulse Width", this);
+  LOG_UPDATE_INTERVAL(this);
   LOG_PIN("  Pin: ", this->pin_);
 }
 void PulseWidthSensor::update() {