mirror of https://github.com/esphome/esphome.git
123 lines
4.3 KiB
C++
123 lines
4.3 KiB
C++
#include "remote_receiver.h"
|
|
#include "esphome/core/hal.h"
|
|
#include "esphome/core/log.h"
|
|
#include "esphome/core/helpers.h"
|
|
|
|
#ifdef USE_LIBRETINY
|
|
|
|
namespace esphome {
|
|
namespace remote_receiver {
|
|
|
|
static const char *const TAG = "remote_receiver.libretiny";
|
|
|
|
void IRAM_ATTR HOT RemoteReceiverComponentStore::gpio_intr(RemoteReceiverComponentStore *arg) {
|
|
const uint32_t now = micros();
|
|
// If the lhs is 1 (rising edge) we should write to an uneven index and vice versa
|
|
const uint32_t next = (arg->buffer_write_at + 1) % arg->buffer_size;
|
|
const bool level = arg->pin.digital_read();
|
|
if (level != next % 2)
|
|
return;
|
|
|
|
// If next is buffer_read, we have hit an overflow
|
|
if (next == arg->buffer_read_at)
|
|
return;
|
|
|
|
const uint32_t last_change = arg->buffer[arg->buffer_write_at];
|
|
const uint32_t time_since_change = now - last_change;
|
|
if (time_since_change <= arg->filter_us)
|
|
return;
|
|
|
|
arg->buffer[arg->buffer_write_at = next] = now;
|
|
}
|
|
|
|
void RemoteReceiverComponent::setup() {
|
|
ESP_LOGCONFIG(TAG, "Setting up Remote Receiver...");
|
|
this->pin_->setup();
|
|
auto &s = this->store_;
|
|
s.filter_us = this->filter_us_;
|
|
s.pin = this->pin_->to_isr();
|
|
s.buffer_size = this->buffer_size_;
|
|
|
|
this->high_freq_.start();
|
|
if (s.buffer_size % 2 != 0) {
|
|
// Make sure divisible by two. This way, we know that every 0bxxx0 index is a space and every 0bxxx1 index is a mark
|
|
s.buffer_size++;
|
|
}
|
|
|
|
s.buffer = new uint32_t[s.buffer_size];
|
|
void *buf = (void *) s.buffer;
|
|
memset(buf, 0, s.buffer_size * sizeof(uint32_t));
|
|
|
|
// First index is a space.
|
|
if (this->pin_->digital_read()) {
|
|
s.buffer_write_at = s.buffer_read_at = 1;
|
|
} else {
|
|
s.buffer_write_at = s.buffer_read_at = 0;
|
|
}
|
|
this->pin_->attach_interrupt(RemoteReceiverComponentStore::gpio_intr, &this->store_, gpio::INTERRUPT_ANY_EDGE);
|
|
}
|
|
void RemoteReceiverComponent::dump_config() {
|
|
ESP_LOGCONFIG(TAG, "Remote Receiver:");
|
|
LOG_PIN(" Pin: ", this->pin_);
|
|
if (this->pin_->digital_read()) {
|
|
ESP_LOGW(TAG, "Remote Receiver Signal starts with a HIGH value. Usually this means you have to "
|
|
"invert the signal using 'inverted: True' in the pin schema!");
|
|
}
|
|
ESP_LOGCONFIG(TAG, " Buffer Size: %u", this->buffer_size_);
|
|
ESP_LOGCONFIG(TAG, " Tolerance: %u%%", this->tolerance_);
|
|
ESP_LOGCONFIG(TAG, " Filter out pulses shorter than: %u us", this->filter_us_);
|
|
ESP_LOGCONFIG(TAG, " Signal is done after %u us of no changes", this->idle_us_);
|
|
}
|
|
|
|
void RemoteReceiverComponent::loop() {
|
|
auto &s = this->store_;
|
|
|
|
// copy write at to local variables, as it's volatile
|
|
const uint32_t write_at = s.buffer_write_at;
|
|
const uint32_t dist = (s.buffer_size + write_at - s.buffer_read_at) % s.buffer_size;
|
|
// signals must at least one rising and one leading edge
|
|
if (dist <= 1)
|
|
return;
|
|
const uint32_t now = micros();
|
|
if (now - s.buffer[write_at] < this->idle_us_) {
|
|
// The last change was fewer than the configured idle time ago.
|
|
return;
|
|
}
|
|
|
|
ESP_LOGVV(TAG, "read_at=%u write_at=%u dist=%u now=%u end=%u", s.buffer_read_at, write_at, dist, now,
|
|
s.buffer[write_at]);
|
|
|
|
// Skip first value, it's from the previous idle level
|
|
s.buffer_read_at = (s.buffer_read_at + 1) % s.buffer_size;
|
|
uint32_t prev = s.buffer_read_at;
|
|
s.buffer_read_at = (s.buffer_read_at + 1) % s.buffer_size;
|
|
const uint32_t reserve_size = 1 + (s.buffer_size + write_at - s.buffer_read_at) % s.buffer_size;
|
|
this->temp_.clear();
|
|
this->temp_.reserve(reserve_size);
|
|
int32_t multiplier = s.buffer_read_at % 2 == 0 ? 1 : -1;
|
|
|
|
for (uint32_t i = 0; prev != write_at; i++) {
|
|
int32_t delta = s.buffer[s.buffer_read_at] - s.buffer[prev];
|
|
if (uint32_t(delta) >= this->idle_us_) {
|
|
// already found a space longer than idle. There must have been two pulses
|
|
break;
|
|
}
|
|
|
|
ESP_LOGVV(TAG, " i=%u buffer[%u]=%u - buffer[%u]=%u -> %d", i, s.buffer_read_at, s.buffer[s.buffer_read_at], prev,
|
|
s.buffer[prev], multiplier * delta);
|
|
this->temp_.push_back(multiplier * delta);
|
|
prev = s.buffer_read_at;
|
|
s.buffer_read_at = (s.buffer_read_at + 1) % s.buffer_size;
|
|
multiplier *= -1;
|
|
}
|
|
s.buffer_read_at = (s.buffer_size + s.buffer_read_at - 1) % s.buffer_size;
|
|
this->temp_.push_back(this->idle_us_ * multiplier);
|
|
|
|
this->call_listeners_dumpers_();
|
|
}
|
|
|
|
} // namespace remote_receiver
|
|
} // namespace esphome
|
|
|
|
#endif
|