switch.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/component.h"
#include "esphome/core/entity_base.h"
#include "esphome/core/helpers.h"
#include "esphome/core/preferences.h"
 
namespace esphome::switch_ {
 
#define SUB_SWITCH(name) \
 protected: \
  switch_::Switch *name##_switch_{nullptr}; \
\
 public: \
  void set_##name##_switch(switch_::Switch *s) { this->name##_switch_ = s; }
 
// bit0: on/off. bit1: persistent. bit2: inverted. bit3: disabled.
// bit4: restore from flash. bit5: restore from RTC memory (neither: platform default).
// Code generation ors the storage bit into the restore mode passed to set_restore_mode().
constexpr int RESTORE_MODE_ON_MASK = 0x01;
constexpr int RESTORE_MODE_PERSISTENT_MASK = 0x02;
constexpr int RESTORE_MODE_INVERTED_MASK = 0x04;
constexpr int RESTORE_MODE_DISABLED_MASK = 0x08;
constexpr int RESTORE_MODE_STORAGE_FLASH_MASK = 0x10;
constexpr int RESTORE_MODE_STORAGE_RTC_MASK = 0x20;
constexpr int RESTORE_MODE_STORAGE_MASK = RESTORE_MODE_STORAGE_FLASH_MASK | RESTORE_MODE_STORAGE_RTC_MASK;
 
enum SwitchRestoreMode : uint8_t {
  SWITCH_ALWAYS_OFF = !RESTORE_MODE_ON_MASK,
  SWITCH_ALWAYS_ON = RESTORE_MODE_ON_MASK,
  SWITCH_RESTORE_DEFAULT_OFF = RESTORE_MODE_PERSISTENT_MASK,
  SWITCH_RESTORE_DEFAULT_ON = RESTORE_MODE_PERSISTENT_MASK | RESTORE_MODE_ON_MASK,
  SWITCH_RESTORE_INVERTED_DEFAULT_OFF = RESTORE_MODE_PERSISTENT_MASK | RESTORE_MODE_INVERTED_MASK,
  SWITCH_RESTORE_INVERTED_DEFAULT_ON = RESTORE_MODE_PERSISTENT_MASK | RESTORE_MODE_INVERTED_MASK | RESTORE_MODE_ON_MASK,
  SWITCH_RESTORE_DISABLED = RESTORE_MODE_DISABLED_MASK,
};
 
class Switch : public EntityBase {
 public:
  explicit Switch();
 
  void publish_state(bool state);
 
  SwitchRestoreMode restore_mode{SWITCH_RESTORE_DEFAULT_OFF};
 
  bool state;
 
  void control(bool target_state);
  void turn_on();
  void turn_off();
  void toggle();
 
  void set_inverted(bool inverted) { this->inverted_ = inverted; }
 
  template<typename F> void add_on_state_callback(F &&callback) {
    this->state_callback_.add(std::forward<F>(callback));
  }
 
  optional<bool> get_initial_state();
 
  optional<bool> get_initial_state_with_restore_mode();
 
  void restore();
  void restore(bool when_disabled);
 
  virtual bool assumed_state();
 
  bool is_inverted() const { return this->inverted_; }
 
  void set_restore_mode(SwitchRestoreMode restore_mode) { this->restore_mode = restore_mode; }
 
 protected:
  virtual void write_state(bool state) = 0;
 
  // Pointer first (4 bytes)
  ESPPreferenceObject rtc_;
 
  // LazyCallbackManager (4 bytes on 32-bit - nullptr when empty)
  LazyCallbackManager<void(bool)> state_callback_{};
 
  // Small types grouped together
  Deduplicator<bool> publish_dedup_;  // 3 bytes (bool has_value_ + bool value_unknown_ + bool last_value_)
  bool inverted_{false};              // 1 byte
  // Total: 4 bytes, no padding
};
 
#define LOG_SWITCH(prefix, type, obj) log_switch((TAG), (prefix), LOG_STR_LITERAL(type), (obj))
void log_switch(const char *tag, const char *prefix, const char *type, Switch *obj);
 
template<auto Fn> class ApplySwitch final : public Switch {
 public:
  // Not "= default": placement new would zero-fill .bss that is already zero.
  ApplySwitch() {}
 
 protected:
  void write_state(bool state) override { Fn(this, state); }
};
 
}  // namespace esphome::switch_