radio_frequency.h

Go to the documentation of this file.

#pragma once
 
// WARNING: This component is EXPERIMENTAL. The API may change at any time
// without following the normal breaking changes policy. Use at your own risk.
// Once the API is considered stable, this warning will be removed.
 
#include "esphome/components/ir_rf_base/ir_rf_base.h"
 
namespace esphome::radio_frequency {
 
using ir_rf_base::CAPABILITY_RECEIVER;
using ir_rf_base::CAPABILITY_TRANSMITTER;
 
enum RadioFrequencyModulation : uint8_t {
  RADIO_FREQUENCY_MODULATION_OOK = 0,  // On-Off Keying / Amplitude Shift Keying
  // Future: RADIO_FREQUENCY_MODULATION_FSK, RADIO_FREQUENCY_MODULATION_GFSK, etc.
};
 
class RadioFrequency;
 
class RadioFrequencyCall : public ir_rf_base::IrRfCall<RadioFrequencyCall, RadioFrequency> {
 public:
  explicit RadioFrequencyCall(RadioFrequency *parent) : IrRfCall(parent) {}
 
  RadioFrequencyCall &set_frequency(uint32_t frequency_hz) {
    this->frequency_hz_ = frequency_hz;
    return *this;
  }
  RadioFrequencyCall &set_modulation(RadioFrequencyModulation modulation) {
    this->modulation_ = modulation;
    return *this;
  }
  const optional<uint32_t> &get_frequency() const { return this->frequency_hz_; }
  RadioFrequencyModulation get_modulation() const { return this->modulation_; }
 
 protected:
  optional<uint32_t> frequency_hz_{};
  RadioFrequencyModulation modulation_{RADIO_FREQUENCY_MODULATION_OOK};
};
 
class RadioFrequencyTraits {
 public:
  uint32_t get_frequency_min_hz() const { return this->frequency_min_hz_; }
  void set_frequency_min_hz(uint32_t freq) { this->frequency_min_hz_ = freq; }
 
  uint32_t get_frequency_max_hz() const { return this->frequency_max_hz_; }
  void set_frequency_max_hz(uint32_t freq) { this->frequency_max_hz_ = freq; }
 
  void set_fixed_frequency_hz(uint32_t freq) {
    this->frequency_min_hz_ = freq;
    this->frequency_max_hz_ = freq;
  }
 
  uint32_t get_supported_modulations() const { return this->supported_modulations_; }
  void set_supported_modulations(uint32_t mask) { this->supported_modulations_ = mask; }
  void add_supported_modulation(RadioFrequencyModulation mod) {
    this->supported_modulations_ |= (1u << static_cast<uint8_t>(mod));
  }
 
 protected:
  uint32_t frequency_min_hz_{0};       // Minimum tunable frequency in Hz (0 = unspecified)
  uint32_t frequency_max_hz_{0};       // Maximum tunable frequency in Hz (0 = unspecified)
  uint32_t supported_modulations_{0};  // Bitmask of supported RadioFrequencyModulation values
};
 
class RadioFrequency : public ir_rf_base::IrRfEntity {
 public:
  RadioFrequency() = default;
 
  void dump_config() override;
 
  RadioFrequencyTraits &get_traits() { return this->traits_; }
  const RadioFrequencyTraits &get_traits() const { return this->traits_; }
 
  RadioFrequencyCall make_call() { return RadioFrequencyCall(this); }
 
  bool on_receive(remote_base::RemoteReceiveData data) override;
 
  template<typename F> void add_on_receive_callback(F &&callback) {
    this->receive_callback_.add(std::forward<F>(callback));
  }
 
  template<typename F> void add_on_control_callback(F &&callback) {
    this->control_callback_.add(std::forward<F>(callback));
  }
 
 protected:
  friend class ir_rf_base::IrRfCall<RadioFrequencyCall, RadioFrequency>;
 
  void on_call_(const RadioFrequencyCall &call) { this->control_callback_.call(call); }
  virtual bool control(const RadioFrequencyCall &call) = 0;
 
  // Traits describing capabilities
  RadioFrequencyTraits traits_;
 
  // Callback manager for receive events (lazy: saves memory when no callbacks registered)
  LazyCallbackManager<void(remote_base::RemoteReceiveData)> receive_callback_;
  // Callback manager for on_control trigger (lazy: same memory savings)
  LazyCallbackManager<void(const RadioFrequencyCall &)> control_callback_;
};
 
}  // namespace esphome::radio_frequency