component.h

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <cstdint>
#include <functional>
#include <string>
 
#include "esphome/core/optional.h"
 
namespace esphome {
 
namespace setup_priority {
 
extern const float BUS;
extern const float IO;
extern const float HARDWARE;
extern const float DATA;
extern const float HARDWARE_LATE;
extern const float PROCESSOR;
extern const float BLUETOOTH;
extern const float AFTER_BLUETOOTH;
extern const float WIFI;
extern const float ETHERNET;
extern const float BEFORE_CONNECTION;
extern const float AFTER_WIFI;
extern const float AFTER_CONNECTION;
extern const float LATE;
 
}  // namespace setup_priority
 
static const uint32_t SCHEDULER_DONT_RUN = 4294967295UL;
 
#define LOG_UPDATE_INTERVAL(this) \
  if (this->get_update_interval() == SCHEDULER_DONT_RUN) { \
    ESP_LOGCONFIG(TAG, "  Update Interval: never"); \
  } else if (this->get_update_interval() < 100) { \
    ESP_LOGCONFIG(TAG, "  Update Interval: %.3fs", this->get_update_interval() / 1000.0f); \
  } else { \
    ESP_LOGCONFIG(TAG, "  Update Interval: %.1fs", this->get_update_interval() / 1000.0f); \
  }
 
extern const uint32_t COMPONENT_STATE_MASK;
extern const uint32_t COMPONENT_STATE_CONSTRUCTION;
extern const uint32_t COMPONENT_STATE_SETUP;
extern const uint32_t COMPONENT_STATE_LOOP;
extern const uint32_t COMPONENT_STATE_FAILED;
extern const uint32_t STATUS_LED_MASK;
extern const uint32_t STATUS_LED_OK;
extern const uint32_t STATUS_LED_WARNING;
extern const uint32_t STATUS_LED_ERROR;
 
enum class RetryResult { DONE, RETRY };
 
extern const uint32_t WARN_IF_BLOCKING_OVER_MS;
 
class Component {
 public:
  virtual void setup();
 
  virtual void loop();
 
  virtual void dump_config();
 
  virtual float get_setup_priority() const;
 
  float get_actual_setup_priority() const;
 
  void set_setup_priority(float priority);
 
  virtual float get_loop_priority() const;
 
  void call();
 
  virtual void on_shutdown() {}
  virtual void on_safe_shutdown() {}
 
  uint32_t get_component_state() const;
 
  virtual void mark_failed();
 
  void mark_failed(const char *message) {
    this->status_set_error(message);
    this->mark_failed();
  }
 
  bool is_failed() const;
 
  bool is_ready() const;
 
  virtual bool can_proceed();
 
  bool status_has_warning() const;
 
  bool status_has_error() const;
 
  void status_set_warning(const char *message = "unspecified");
 
  void status_set_error(const char *message = "unspecified");
 
  void status_clear_warning();
 
  void status_clear_error();
 
  void status_momentary_warning(const std::string &name, uint32_t length = 5000);
 
  void status_momentary_error(const std::string &name, uint32_t length = 5000);
 
  bool has_overridden_loop() const;
 
  void set_component_source(const char *source) { component_source_ = source; }
  const char *get_component_source() const;
 
  bool should_warn_of_blocking(uint32_t blocking_time);
 
 protected:
  friend class Application;
 
  virtual void call_loop();
  virtual void call_setup();
  virtual void call_dump_config();
 
  void set_interval(const std::string &name, uint32_t interval, std::function<void()> &&f);  // NOLINT
 
  void set_interval(uint32_t interval, std::function<void()> &&f);  // NOLINT
 
  bool cancel_interval(const std::string &name);  // NOLINT
 
  void set_retry(const std::string &name, uint32_t initial_wait_time, uint8_t max_attempts,       // NOLINT
                 std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor = 1.0f);  // NOLINT
 
  void set_retry(uint32_t initial_wait_time, uint8_t max_attempts, std::function<RetryResult(uint8_t)> &&f,  // NOLINT
                 float backoff_increase_factor = 1.0f);                                                      // NOLINT
 
  bool cancel_retry(const std::string &name);  // NOLINT
 
  void set_timeout(const std::string &name, uint32_t timeout, std::function<void()> &&f);  // NOLINT
 
  void set_timeout(uint32_t timeout, std::function<void()> &&f);  // NOLINT
 
  bool cancel_timeout(const std::string &name);  // NOLINT
 
  void defer(const std::string &name, std::function<void()> &&f);  // NOLINT
 
  void defer(std::function<void()> &&f);  // NOLINT
 
  bool cancel_defer(const std::string &name);  // NOLINT
 
  uint32_t component_state_{0x0000};  
  float setup_priority_override_{NAN};
  const char *component_source_{nullptr};
  uint32_t warn_if_blocking_over_{WARN_IF_BLOCKING_OVER_MS};
  std::string error_message_{};
};
 
class PollingComponent : public Component {
 public:
  PollingComponent() : PollingComponent(0) {}
 
  explicit PollingComponent(uint32_t update_interval);
 
  virtual void set_update_interval(uint32_t update_interval);
 
  // ========== OVERRIDE METHODS ==========
  // (You'll only need this when creating your own custom sensor)
  virtual void update() = 0;
 
  // ========== INTERNAL METHODS ==========
  // (In most use cases you won't need these)
  void call_setup() override;
 
  virtual uint32_t get_update_interval() const;
 
  // Start the poller, used for component.suspend
  void start_poller();
 
  // Stop the poller, used for component.suspend
  void stop_poller();
 
 protected:
  uint32_t update_interval_;
};
 
class WarnIfComponentBlockingGuard {
 public:
  WarnIfComponentBlockingGuard(Component *component, uint32_t start_time);
 
  // Finish the timing operation and return the current time
  uint32_t finish();
 
  ~WarnIfComponentBlockingGuard();
 
 protected:
  uint32_t started_;
  Component *component_;
};
 
}  // namespace esphome