fan.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
 
#include "esphome/core/entity_base.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "esphome/core/optional.h"
#include "esphome/core/preferences.h"
#include "esphome/core/string_ref.h"
#include "fan_traits.h"
 
namespace esphome::fan {
 
#define LOG_FAN(prefix, type, obj) \
  if (log_entity_header(TAG, prefix, LOG_STR_LITERAL(type), (obj))) { \
    (obj)->dump_traits_(TAG, prefix); \
  }
 
enum class FanDirection { FORWARD = 0, REVERSE = 1 };
 
enum class FanRestoreMode {
  NO_RESTORE,
  ALWAYS_OFF,
  ALWAYS_ON,
  RESTORE_DEFAULT_OFF,
  RESTORE_DEFAULT_ON,
  RESTORE_INVERTED_DEFAULT_OFF,
  RESTORE_INVERTED_DEFAULT_ON,
};
 
const LogString *fan_direction_to_string(FanDirection direction);
 
class Fan;
 
class FanCall {
 public:
  explicit FanCall(Fan &parent) : parent_(parent) {}
 
  FanCall &set_state(bool binary_state) {
    this->binary_state_ = binary_state;
    return *this;
  }
  FanCall &set_state(optional<bool> binary_state) {
    this->binary_state_ = binary_state;
    return *this;
  }
  optional<bool> get_state() const { return this->binary_state_; }
  FanCall &set_oscillating(bool oscillating) {
    this->oscillating_ = oscillating;
    return *this;
  }
  FanCall &set_oscillating(optional<bool> oscillating) {
    this->oscillating_ = oscillating;
    return *this;
  }
  optional<bool> get_oscillating() const { return this->oscillating_; }
  FanCall &set_speed(int speed) {
    this->speed_ = speed;
    return *this;
  }
  optional<int> get_speed() const { return this->speed_; }
  FanCall &set_direction(FanDirection direction) {
    this->direction_ = direction;
    return *this;
  }
  FanCall &set_direction(optional<FanDirection> direction) {
    this->direction_ = direction;
    return *this;
  }
  optional<FanDirection> get_direction() const { return this->direction_; }
  FanCall &set_preset_mode(const std::string &preset_mode);
  FanCall &set_preset_mode(const char *preset_mode);
  FanCall &set_preset_mode(const char *preset_mode, size_t len);
  const char *get_preset_mode() const { return this->preset_mode_; }
  bool has_preset_mode() const { return this->preset_mode_ != nullptr; }
 
  void perform();
 
 protected:
  void validate_();
 
  Fan &parent_;
  optional<bool> binary_state_;
  optional<bool> oscillating_;
  optional<int> speed_;
  optional<FanDirection> direction_{};
  const char *preset_mode_{nullptr};  // Pointer to string in traits (after validation)
};
 
struct FanRestoreState {
  static constexpr uint8_t NO_PRESET = UINT8_MAX;
 
  bool state;
  int speed;
  bool oscillating;
  FanDirection direction;
  uint8_t preset_mode{NO_PRESET};
 
  FanCall to_call(Fan &fan);
  void apply(Fan &fan);
} __attribute__((packed));
 
class Fan : public EntityBase {
 public:
  bool state{false};
  bool oscillating{false};
  int speed{0};
  FanDirection direction{FanDirection::FORWARD};
 
  FanCall turn_on() { return this->make_call().set_state(true); }
  FanCall turn_off() { return this->make_call().set_state(false); }
  FanCall toggle() { return this->make_call().set_state(!this->state); }
  FanCall make_call() { return FanCall(*this); }
 
  template<typename F> void add_on_state_callback(F &&callback) {
    this->state_callback_.add(std::forward<F>(callback));
  }
 
  void publish_state();
 
  virtual FanTraits get_traits() = 0;
 
  void set_supported_preset_modes(std::initializer_list<const char *> preset_modes) {
    this->supported_preset_modes_.assign_copy(preset_modes.begin(), preset_modes.size());
  }
  void set_supported_preset_modes(const std::vector<const char *> &preset_modes) {
    this->supported_preset_modes_.assign_copy(preset_modes.data(), preset_modes.size());
  }
  void set_supported_preset_modes(const FanPresetModes &preset_modes) {
    this->supported_preset_modes_.assign_copy(preset_modes.data(), preset_modes.size());
  }
  void set_supported_preset_modes_static(const char *const *preset_modes, size_t count) {
    this->supported_preset_modes_.assign_static(preset_modes, count);
  }
 
  void set_restore_mode(FanRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
 
  StringRef get_preset_mode() const { return StringRef::from_maybe_nullptr(this->preset_mode_); }
 
  bool has_preset_mode() const { return this->preset_mode_ != nullptr; }
 
 protected:
  friend FanCall;
  friend struct FanRestoreState;
 
  virtual void control(const FanCall &call) = 0;
 
  optional<FanRestoreState> restore_state_();
  void save_state_();
 
  void dump_traits_(const char *tag, const char *prefix);
 
  bool set_preset_mode_(const char *preset_mode, size_t len);
  bool set_preset_mode_(const char *preset_mode);
  bool set_preset_mode_(const std::string &preset_mode);
  bool set_preset_mode_(StringRef preset_mode);
  void clear_preset_mode_();
  void apply_preset_mode_(const FanCall &call);
  const char *find_preset_mode_(const char *preset_mode);
  const char *find_preset_mode_(const char *preset_mode, size_t len);
 
  void wire_preset_modes_(FanTraits &traits) { traits.set_supported_preset_modes_(&this->supported_preset_modes_); }
 
  LazyCallbackManager<void()> state_callback_{};
  ESPPreferenceObject rtc_;
  FanRestoreMode restore_mode_{FanRestoreMode::NO_RESTORE};
 
 private:
  FanPresetModes supported_preset_modes_;
  const char *preset_mode_{nullptr};
};
 
}  // namespace esphome::fan