ESPHome  2024.3.1
remote_base.h
Go to the documentation of this file.
1 #include <utility>
2 #include <vector>
3 
4 #pragma once
5 
7 #include "esphome/core/hal.h"
10 
11 #ifdef USE_ESP32
12 #include <driver/rmt.h>
13 #endif
14 
15 namespace esphome {
16 namespace remote_base {
17 
18 using RawTimings = std::vector<int32_t>;
19 
21  public:
22  void mark(uint32_t length) { this->data_.push_back(length); }
23  void space(uint32_t length) { this->data_.push_back(-length); }
24  void item(uint32_t mark, uint32_t space) {
25  this->mark(mark);
26  this->space(space);
27  }
28  void reserve(uint32_t len) { this->data_.reserve(len); }
29  void set_carrier_frequency(uint32_t carrier_frequency) { this->carrier_frequency_ = carrier_frequency; }
30  uint32_t get_carrier_frequency() const { return this->carrier_frequency_; }
31  const RawTimings &get_data() const { return this->data_; }
32  void set_data(const RawTimings &data) { this->data_ = data; }
33  void reset() {
34  this->data_.clear();
35  this->carrier_frequency_ = 0;
36  }
37 
38  protected:
40  uint32_t carrier_frequency_{0};
41 };
42 
44  public:
45  explicit RemoteReceiveData(const RawTimings &data, uint8_t tolerance)
46  : data_(data), index_(0), tolerance_(tolerance) {}
47 
48  const RawTimings &get_raw_data() const { return this->data_; }
49  uint32_t get_index() const { return index_; }
50  int32_t operator[](uint32_t index) const { return this->data_[index]; }
51  int32_t size() const { return this->data_.size(); }
52  bool is_valid(uint32_t offset) const { return this->index_ + offset < this->data_.size(); }
53  int32_t peek(uint32_t offset = 0) const { return this->data_[this->index_ + offset]; }
54  bool peek_mark(uint32_t length, uint32_t offset = 0) const;
55  bool peek_space(uint32_t length, uint32_t offset = 0) const;
56  bool peek_space_at_least(uint32_t length, uint32_t offset = 0) const;
57  bool peek_item(uint32_t mark, uint32_t space, uint32_t offset = 0) const {
58  return this->peek_space(space, offset + 1) && this->peek_mark(mark, offset);
59  }
60 
61  bool expect_mark(uint32_t length);
62  bool expect_space(uint32_t length);
63  bool expect_item(uint32_t mark, uint32_t space);
64  bool expect_pulse_with_gap(uint32_t mark, uint32_t space);
65  void advance(uint32_t amount = 1) { this->index_ += amount; }
66  void reset() { this->index_ = 0; }
67 
68  protected:
69  int32_t lower_bound_(uint32_t length) const { return int32_t(100 - this->tolerance_) * length / 100U; }
70  int32_t upper_bound_(uint32_t length) const { return int32_t(100 + this->tolerance_) * length / 100U; }
71 
72  const RawTimings &data_;
73  uint32_t index_;
74  uint8_t tolerance_;
75 };
76 
78  public:
79  explicit RemoteComponentBase(InternalGPIOPin *pin) : pin_(pin){};
80 
81  protected:
82  InternalGPIOPin *pin_;
83 };
84 
85 #ifdef USE_ESP32
87  public:
88  explicit RemoteRMTChannel(uint8_t mem_block_num = 1);
89 
90  void config_rmt(rmt_config_t &rmt);
91  void set_clock_divider(uint8_t clock_divider) { this->clock_divider_ = clock_divider; }
92 
93  protected:
94  uint32_t from_microseconds_(uint32_t us) {
95  const uint32_t ticks_per_ten_us = 80000000u / this->clock_divider_ / 100000u;
96  return us * ticks_per_ten_us / 10;
97  }
98  uint32_t to_microseconds_(uint32_t ticks) {
99  const uint32_t ticks_per_ten_us = 80000000u / this->clock_divider_ / 100000u;
100  return (ticks * 10) / ticks_per_ten_us;
101  }
103  rmt_channel_t channel_{RMT_CHANNEL_0};
104  uint8_t mem_block_num_;
105  uint8_t clock_divider_{80};
106 };
107 #endif
108 
110  public:
112  class TransmitCall {
113  public:
114  explicit TransmitCall(RemoteTransmitterBase *parent) : parent_(parent) {}
115  RemoteTransmitData *get_data() { return &this->parent_->temp_; }
116  void set_send_times(uint32_t send_times) { send_times_ = send_times; }
117  void set_send_wait(uint32_t send_wait) { send_wait_ = send_wait; }
118  void perform() { this->parent_->send_(this->send_times_, this->send_wait_); }
119 
120  protected:
122  uint32_t send_times_{1};
123  uint32_t send_wait_{0};
124  };
125 
127  this->temp_.reset();
128  return TransmitCall(this);
129  }
130  template<typename Protocol>
131  void transmit(const typename Protocol::ProtocolData &data, uint32_t send_times = 1, uint32_t send_wait = 0) {
132  auto call = this->transmit();
133  Protocol().encode(call.get_data(), data);
134  call.set_send_times(send_times);
135  call.set_send_wait(send_wait);
136  call.perform();
137  }
138 
139  protected:
140  void send_(uint32_t send_times, uint32_t send_wait);
141  virtual void send_internal(uint32_t send_times, uint32_t send_wait) = 0;
142  void send_single_() { this->send_(1, 0); }
143 
146 };
147 
149  public:
150  virtual bool on_receive(RemoteReceiveData data) = 0;
151 };
152 
154  public:
155  virtual bool dump(RemoteReceiveData src) = 0;
156  virtual bool is_secondary() { return false; }
157 };
158 
160  public:
162  void register_listener(RemoteReceiverListener *listener) { this->listeners_.push_back(listener); }
163  void register_dumper(RemoteReceiverDumperBase *dumper);
164  void set_tolerance(uint8_t tolerance) { tolerance_ = tolerance; }
165 
166  protected:
167  void call_listeners_();
168  void call_dumpers_();
170  this->call_listeners_();
171  this->call_dumpers_();
172  }
173 
174  std::vector<RemoteReceiverListener *> listeners_;
175  std::vector<RemoteReceiverDumperBase *> dumpers_;
176  std::vector<RemoteReceiverDumperBase *> secondary_dumpers_;
178  uint8_t tolerance_;
179 };
180 
182  public Component,
183  public RemoteReceiverListener {
184  public:
186  void dump_config() override;
187  virtual bool matches(RemoteReceiveData src) = 0;
188  bool on_receive(RemoteReceiveData src) override;
189 };
190 
191 /* TEMPLATES */
192 
193 template<typename T> class RemoteProtocol {
194  public:
195  using ProtocolData = T;
196  virtual void encode(RemoteTransmitData *dst, const ProtocolData &data) = 0;
197  virtual optional<ProtocolData> decode(RemoteReceiveData src) = 0;
198  virtual void dump(const ProtocolData &data) = 0;
199 };
200 
201 template<typename T> class RemoteReceiverBinarySensor : public RemoteReceiverBinarySensorBase {
202  public:
204 
205  protected:
206  bool matches(RemoteReceiveData src) override {
207  auto proto = T();
208  auto res = proto.decode(src);
209  return res.has_value() && *res == this->data_;
210  }
211 
212  public:
213  void set_data(typename T::ProtocolData data) { data_ = data; }
214 
215  protected:
216  typename T::ProtocolData data_;
217 };
218 
219 template<typename T>
220 class RemoteReceiverTrigger : public Trigger<typename T::ProtocolData>, public RemoteReceiverListener {
221  protected:
222  bool on_receive(RemoteReceiveData src) override {
223  auto proto = T();
224  auto res = proto.decode(src);
225  if (res.has_value()) {
226  this->trigger(*res);
227  return true;
228  }
229  return false;
230  }
231 };
232 
234  public:
236  RemoteTransmittable(RemoteTransmitterBase *transmitter) : transmitter_(transmitter) {}
237  void set_transmitter(RemoteTransmitterBase *transmitter) { this->transmitter_ = transmitter; }
238 
239  protected:
240  template<typename Protocol>
241  void transmit_(const typename Protocol::ProtocolData &data, uint32_t send_times = 1, uint32_t send_wait = 0) {
242  this->transmitter_->transmit<Protocol>(data, send_times, send_wait);
243  }
245 };
246 
247 template<typename... Ts> class RemoteTransmitterActionBase : public RemoteTransmittable, public Action<Ts...> {
248  TEMPLATABLE_VALUE(uint32_t, send_times)
249  TEMPLATABLE_VALUE(uint32_t, send_wait)
250 
251  protected:
252  void play(Ts... x) override {
253  auto call = this->transmitter_->transmit();
254  this->encode(call.get_data(), x...);
255  call.set_send_times(this->send_times_.value_or(x..., 1));
256  call.set_send_wait(this->send_wait_.value_or(x..., 0));
257  call.perform();
258  }
259  virtual void encode(RemoteTransmitData *dst, Ts... x) = 0;
260 };
261 
262 template<typename T> class RemoteReceiverDumper : public RemoteReceiverDumperBase {
263  public:
264  bool dump(RemoteReceiveData src) override {
265  auto proto = T();
266  auto decoded = proto.decode(src);
267  if (!decoded.has_value())
268  return false;
269  proto.dump(*decoded);
270  return true;
271  }
272 };
273 
274 #define DECLARE_REMOTE_PROTOCOL_(prefix) \
275  using prefix##BinarySensor = RemoteReceiverBinarySensor<prefix##Protocol>; \
276  using prefix##Trigger = RemoteReceiverTrigger<prefix##Protocol>; \
277  using prefix##Dumper = RemoteReceiverDumper<prefix##Protocol>;
278 #define DECLARE_REMOTE_PROTOCOL(prefix) DECLARE_REMOTE_PROTOCOL_(prefix)
279 
280 } // namespace remote_base
281 } // namespace esphome
void register_listener(RemoteReceiverListener *listener)
Definition: remote_base.h:162
void set_data(const RawTimings &data)
Definition: remote_base.h:32
RemoteTransmitData temp_
Use same vector for all transmits, avoids many allocations.
Definition: remote_base.h:145
int32_t operator[](uint32_t index) const
Definition: remote_base.h:50
const RawTimings & get_raw_data() const
Definition: remote_base.h:48
void set_carrier_frequency(uint32_t carrier_frequency)
Definition: remote_base.h:29
uint16_t x
Definition: tt21100.cpp:17
bool is_valid(uint32_t offset) const
Definition: remote_base.h:52
void item(uint32_t mark, uint32_t space)
Definition: remote_base.h:24
RemoteReceiveData(const RawTimings &data, uint8_t tolerance)
Definition: remote_base.h:45
std::vector< RemoteReceiverDumperBase * > dumpers_
Definition: remote_base.h:175
void set_data(typename T::ProtocolData data)
Definition: remote_base.h:213
std::vector< RemoteReceiverDumperBase * > secondary_dumpers_
Definition: remote_base.h:176
void set_transmitter(RemoteTransmitterBase *transmitter)
Definition: remote_base.h:237
RemoteComponentBase(InternalGPIOPin *pin)
Definition: remote_base.h:79
RemoteComponentBase * remote_base_
Definition: remote_base.h:102
std::vector< int32_t > RawTimings
Definition: remote_base.h:18
RemoteTransmitterBase * transmitter_
Definition: remote_base.h:244
int32_t lower_bound_(uint32_t length) const
Definition: remote_base.h:69
int32_t peek(uint32_t offset=0) const
Definition: remote_base.h:53
std::vector< RemoteReceiverListener * > listeners_
Definition: remote_base.h:174
void transmit(const typename Protocol::ProtocolData &data, uint32_t send_times=1, uint32_t send_wait=0)
Definition: remote_base.h:131
RemoteReceiverBase(InternalGPIOPin *pin)
Definition: remote_base.h:161
bool on_receive(RemoteReceiveData src) override
Definition: remote_base.h:222
bool dump(RemoteReceiveData src) override
Definition: remote_base.h:264
void set_clock_divider(uint8_t clock_divider)
Definition: remote_base.h:91
std::string size_t len
Definition: helpers.h:292
void transmit_(const typename Protocol::ProtocolData &data, uint32_t send_times=1, uint32_t send_wait=0)
Definition: remote_base.h:241
bool peek_item(uint32_t mark, uint32_t space, uint32_t offset=0) const
Definition: remote_base.h:57
uint16_t length
Definition: tt21100.cpp:12
This is a workaround until we can figure out a way to get the tflite-micro idf component code availab...
Definition: a01nyub.cpp:7
bool matches(RemoteReceiveData src) override
Definition: remote_base.h:206
void advance(uint32_t amount=1)
Definition: remote_base.h:65
const RawTimings & get_data() const
Definition: remote_base.h:31
void set_tolerance(uint8_t tolerance)
Definition: remote_base.h:164
uint32_t to_microseconds_(uint32_t ticks)
Definition: remote_base.h:98
RemoteTransmittable(RemoteTransmitterBase *transmitter)
Definition: remote_base.h:236
int32_t upper_bound_(uint32_t length) const
Definition: remote_base.h:70
uint32_t from_microseconds_(uint32_t us)
Definition: remote_base.h:94