infrared.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/core/component.h"
#include "esphome/core/entity_base.h"
#include "esphome/components/remote_base/remote_base.h"
 
#include <vector>
 
namespace esphome::infrared {
 
enum InfraredCapability : uint32_t {
  CAPABILITY_TRANSMITTER = 1 << 0,  // Can transmit signals
  CAPABILITY_RECEIVER = 1 << 1,     // Can receive signals
};
 
class Infrared;
 
class InfraredCall {
 public:
  explicit InfraredCall(Infrared *parent) : parent_(parent) {}
 
  InfraredCall &set_carrier_frequency(uint32_t frequency);
 
  // ===== Raw Timings Methods =====
  // All set_raw_timings_* methods store pointers/references to external data.
  // The referenced data must remain valid until perform() completes.
  // Safe pattern:   call.set_raw_timings_xxx(data); call.perform();  // synchronous
  // Unsafe pattern: call.set_raw_timings_xxx(data); defer([call]() { call.perform(); });  // data may be gone!
 
  InfraredCall &set_raw_timings(const std::vector<int32_t> &timings);
 
  InfraredCall &set_raw_timings_base64url(const std::string &base64url);
 
  InfraredCall &set_raw_timings_packed(const uint8_t *data, uint16_t length, uint16_t count);
 
  InfraredCall &set_repeat_count(uint32_t count);
 
  void perform();
 
  const optional<uint32_t> &get_carrier_frequency() const { return this->carrier_frequency_; }
  const std::vector<int32_t> &get_raw_timings() const { return *this->raw_timings_; }
  bool has_raw_timings() const {
    return this->raw_timings_ != nullptr || this->packed_data_ != nullptr || this->base64url_ptr_ != nullptr;
  }
  bool is_packed() const { return this->packed_data_ != nullptr; }
  bool is_base64url() const { return this->base64url_ptr_ != nullptr; }
  const std::string &get_base64url_data() const { return *this->base64url_ptr_; }
  const uint8_t *get_packed_data() const { return this->packed_data_; }
  uint16_t get_packed_length() const { return this->packed_length_; }
  uint16_t get_packed_count() const { return this->packed_count_; }
  uint32_t get_repeat_count() const { return this->repeat_count_; }
 
 protected:
  uint32_t repeat_count_{1};
  Infrared *parent_;
  optional<uint32_t> carrier_frequency_;
  // Pointer to vector-based timings (caller-owned, must outlive perform())
  const std::vector<int32_t> *raw_timings_{nullptr};
  // Pointer to base64url-encoded string (caller-owned, must outlive perform())
  const std::string *base64url_ptr_{nullptr};
  // Pointer to packed protobuf buffer (caller-owned, must outlive perform())
  const uint8_t *packed_data_{nullptr};
  uint16_t packed_length_{0};
  uint16_t packed_count_{0};
};
 
class InfraredTraits {
 public:
  bool get_supports_transmitter() const { return this->supports_transmitter_; }
  void set_supports_transmitter(bool supports) { this->supports_transmitter_ = supports; }
 
  bool get_supports_receiver() const { return this->supports_receiver_; }
  void set_supports_receiver(bool supports) { this->supports_receiver_ = supports; }
 
 protected:
  bool supports_transmitter_{false};
  bool supports_receiver_{false};
};
 
class Infrared : public Component, public EntityBase, public remote_base::RemoteReceiverListener {
 public:
  Infrared() = default;
 
  void setup() override;
  void dump_config() override;
  float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
 
  void set_receiver(remote_base::RemoteReceiverBase *receiver) { this->receiver_ = receiver; }
  void set_transmitter(remote_base::RemoteTransmitterBase *transmitter) { this->transmitter_ = transmitter; }
 
  bool has_transmitter() const { return this->transmitter_ != nullptr; }
  bool has_receiver() const { return this->receiver_ != nullptr; }
 
  InfraredTraits &get_traits() { return this->traits_; }
  const InfraredTraits &get_traits() const { return this->traits_; }
 
  InfraredCall make_call();
 
  uint32_t get_capability_flags() const;
 
  bool on_receive(remote_base::RemoteReceiveData data) override;
 
 protected:
  friend class InfraredCall;
 
  virtual void control(const InfraredCall &call);
 
  // Underlying hardware components
  remote_base::RemoteReceiverBase *receiver_{nullptr};
  remote_base::RemoteTransmitterBase *transmitter_{nullptr};
 
  // Traits describing capabilities
  InfraredTraits traits_;
};
 
}  // namespace esphome::infrared