Reduce CPU overhead by allowing components to disable their loop() (#9089)

tests/integration/fixtures/external_components/loop_test_component/__init__.py

@@ -0,0 +1,78 @@
+from esphome import automation
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_COMPONENTS, CONF_ID, CONF_NAME
+
+CODEOWNERS = ["@esphome/tests"]
+
+loop_test_component_ns = cg.esphome_ns.namespace("loop_test_component")
+LoopTestComponent = loop_test_component_ns.class_("LoopTestComponent", cg.Component)
+
+CONF_DISABLE_AFTER = "disable_after"
+CONF_TEST_REDUNDANT_OPERATIONS = "test_redundant_operations"
+
+COMPONENT_CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(LoopTestComponent),
+        cv.Required(CONF_NAME): cv.string,
+        cv.Optional(CONF_DISABLE_AFTER, default=0): cv.int_,
+        cv.Optional(CONF_TEST_REDUNDANT_OPERATIONS, default=False): cv.boolean,
+    }
+)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(LoopTestComponent),
+        cv.Required(CONF_COMPONENTS): cv.ensure_list(COMPONENT_CONFIG_SCHEMA),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+# Define actions
+EnableAction = loop_test_component_ns.class_("EnableAction", automation.Action)
+DisableAction = loop_test_component_ns.class_("DisableAction", automation.Action)
+
+
+@automation.register_action(
+    "loop_test_component.enable",
+    EnableAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(LoopTestComponent),
+        }
+    ),
+)
+async def enable_to_code(config, action_id, template_arg, args):
+    parent = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, parent)
+    return var
+
+
+@automation.register_action(
+    "loop_test_component.disable",
+    DisableAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(LoopTestComponent),
+        }
+    ),
+)
+async def disable_to_code(config, action_id, template_arg, args):
+    parent = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, parent)
+    return var
+
+
+async def to_code(config):
+    # The parent config doesn't actually create a component
+    # We just create each sub-component
+    for comp_config in config[CONF_COMPONENTS]:
+        var = cg.new_Pvariable(comp_config[CONF_ID])
+        await cg.register_component(var, comp_config)
+
+        cg.add(var.set_name(comp_config[CONF_NAME]))
+        cg.add(var.set_disable_after(comp_config[CONF_DISABLE_AFTER]))
+        cg.add(
+            var.set_test_redundant_operations(
+                comp_config[CONF_TEST_REDUNDANT_OPERATIONS]
+            )
+        )

tests/integration/fixtures/external_components/loop_test_component/loop_test_component.cpp

@@ -0,0 +1,43 @@
+#include "loop_test_component.h"
+
+namespace esphome {
+namespace loop_test_component {
+
+void LoopTestComponent::setup() { ESP_LOGI(TAG, "[%s] Setup called", this->name_.c_str()); }
+
+void LoopTestComponent::loop() {
+  this->loop_count_++;
+  ESP_LOGI(TAG, "[%s] Loop count: %d", this->name_.c_str(), this->loop_count_);
+
+  // Test self-disable after specified count
+  if (this->disable_after_ > 0 && this->loop_count_ == this->disable_after_) {
+    ESP_LOGI(TAG, "[%s] Disabling self after %d loops", this->name_.c_str(), this->disable_after_);
+    this->disable_loop();
+  }
+
+  // Test redundant operations
+  if (this->test_redundant_operations_ && this->loop_count_ == 5) {
+    if (this->name_ == "redundant_enable") {
+      ESP_LOGI(TAG, "[%s] Testing enable when already enabled", this->name_.c_str());
+      this->enable_loop();
+    } else if (this->name_ == "redundant_disable") {
+      ESP_LOGI(TAG, "[%s] Testing disable when will be disabled", this->name_.c_str());
+      // We'll disable at count 10, but try to disable again at 5
+      this->disable_loop();
+      ESP_LOGI(TAG, "[%s] First disable complete", this->name_.c_str());
+    }
+  }
+}
+
+void LoopTestComponent::service_enable() {
+  ESP_LOGI(TAG, "[%s] Service enable called", this->name_.c_str());
+  this->enable_loop();
+}
+
+void LoopTestComponent::service_disable() {
+  ESP_LOGI(TAG, "[%s] Service disable called", this->name_.c_str());
+  this->disable_loop();
+}
+
+}  // namespace loop_test_component
+}  // namespace esphome

tests/integration/fixtures/external_components/loop_test_component/loop_test_component.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+#include "esphome/core/automation.h"
+
+namespace esphome {
+namespace loop_test_component {
+
+static const char *const TAG = "loop_test_component";
+
+class LoopTestComponent : public Component {
+ public:
+  void set_name(const std::string &name) { this->name_ = name; }
+  void set_disable_after(int count) { this->disable_after_ = count; }
+  void set_test_redundant_operations(bool test) { this->test_redundant_operations_ = test; }
+
+  void setup() override;
+  void loop() override;
+
+  // Service methods for external control
+  void service_enable();
+  void service_disable();
+
+  int get_loop_count() const { return this->loop_count_; }
+
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+ protected:
+  std::string name_;
+  int loop_count_{0};
+  int disable_after_{0};
+  bool test_redundant_operations_{false};
+};
+
+template<typename... Ts> class EnableAction : public Action<Ts...> {
+ public:
+  EnableAction(LoopTestComponent *parent) : parent_(parent) {}
+
+  void play(Ts... x) override { this->parent_->service_enable(); }
+
+ protected:
+  LoopTestComponent *parent_;
+};
+
+template<typename... Ts> class DisableAction : public Action<Ts...> {
+ public:
+  DisableAction(LoopTestComponent *parent) : parent_(parent) {}
+
+  void play(Ts... x) override { this->parent_->service_disable(); }
+
+ protected:
+  LoopTestComponent *parent_;
+};
+
+}  // namespace loop_test_component
+}  // namespace esphome