mirror of
https://github.com/esphome/esphome.git
synced 2026-02-18 15:35:59 -07:00
121 lines
4.2 KiB
C++
121 lines
4.2 KiB
C++
#include "symphony_protocol.h"
|
|
#include "esphome/core/log.h"
|
|
|
|
namespace esphome {
|
|
namespace remote_base {
|
|
|
|
static const char *const TAG = "remote.symphony";
|
|
|
|
// Reference implementation and timing details:
|
|
// IRremoteESP8266 ir_Symphony.cpp
|
|
// https://github.com/crankyoldgit/IRremoteESP8266/blob/master/src/ir_Symphony.cpp
|
|
// The implementation below mirrors the constant bit-time mapping and
|
|
// footer-gap handling used there.
|
|
|
|
// Symphony protocol timing specifications (tuned to handset captures)
|
|
static const uint32_t BIT_ZERO_HIGH_US = 460; // short
|
|
static const uint32_t BIT_ZERO_LOW_US = 1260; // long
|
|
static const uint32_t BIT_ONE_HIGH_US = 1260; // long
|
|
static const uint32_t BIT_ONE_LOW_US = 460; // short
|
|
static const uint32_t CARRIER_FREQUENCY = 38000;
|
|
|
|
// IRremoteESP8266 reference: kSymphonyFooterGap = 4 * (mark + space)
|
|
static const uint32_t FOOTER_GAP_US = 4 * (BIT_ZERO_HIGH_US + BIT_ZERO_LOW_US);
|
|
// Typical inter-frame gap (~34.8 ms observed)
|
|
static const uint32_t INTER_FRAME_GAP_US = 34760;
|
|
|
|
void SymphonyProtocol::encode(RemoteTransmitData *dst, const SymphonyData &data) {
|
|
dst->set_carrier_frequency(CARRIER_FREQUENCY);
|
|
ESP_LOGD(TAG, "Sending Symphony: data=0x%0*X nbits=%u repeats=%u", (data.nbits + 3) / 4, (uint32_t) data.data,
|
|
data.nbits, data.repeats);
|
|
// Each bit produces a mark+space (2 entries). We fold the inter-frame/footer gap
|
|
// into the last bit's space of each frame to avoid over-length gaps.
|
|
dst->reserve(data.nbits * 2u * data.repeats);
|
|
|
|
for (uint8_t repeats = 0; repeats < data.repeats; repeats++) {
|
|
// Data bits (MSB first)
|
|
for (uint32_t mask = 1UL << (data.nbits - 1); mask != 0; mask >>= 1) {
|
|
const bool is_last_bit = (mask == 1);
|
|
const bool is_last_frame = (repeats == (data.repeats - 1));
|
|
if (is_last_bit) {
|
|
// Emit last bit's mark; replace its space with the proper gap
|
|
if (data.data & mask) {
|
|
dst->mark(BIT_ONE_HIGH_US);
|
|
} else {
|
|
dst->mark(BIT_ZERO_HIGH_US);
|
|
}
|
|
dst->space(is_last_frame ? FOOTER_GAP_US : INTER_FRAME_GAP_US);
|
|
} else {
|
|
if (data.data & mask) {
|
|
dst->item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US);
|
|
} else {
|
|
dst->item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
optional<SymphonyData> SymphonyProtocol::decode(RemoteReceiveData src) {
|
|
auto is_valid_len = [](uint8_t nbits) -> bool { return nbits == 8 || nbits == 12 || nbits == 16; };
|
|
|
|
RemoteReceiveData s = src; // copy
|
|
SymphonyData out{0, 0, 1};
|
|
|
|
for (; out.nbits < 32; out.nbits++) {
|
|
if (s.expect_mark(BIT_ONE_HIGH_US)) {
|
|
if (!s.expect_space(BIT_ONE_LOW_US)) {
|
|
// Allow footer gap immediately after the last mark
|
|
if (s.peek_space_at_least(FOOTER_GAP_US)) {
|
|
uint8_t bits_with_this = out.nbits + 1;
|
|
if (is_valid_len(bits_with_this)) {
|
|
out.data = (out.data << 1UL) | 1UL;
|
|
out.nbits = bits_with_this;
|
|
return out;
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
// Successfully consumed a '1' bit (mark + space)
|
|
out.data = (out.data << 1UL) | 1UL;
|
|
continue;
|
|
} else if (s.expect_mark(BIT_ZERO_HIGH_US)) {
|
|
if (!s.expect_space(BIT_ZERO_LOW_US)) {
|
|
// Allow footer gap immediately after the last mark
|
|
if (s.peek_space_at_least(FOOTER_GAP_US)) {
|
|
uint8_t bits_with_this = out.nbits + 1;
|
|
if (is_valid_len(bits_with_this)) {
|
|
out.data = (out.data << 1UL) | 0UL;
|
|
out.nbits = bits_with_this;
|
|
return out;
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
// Successfully consumed a '0' bit (mark + space)
|
|
out.data = (out.data << 1UL) | 0UL;
|
|
continue;
|
|
} else {
|
|
// Completed a valid-length frame followed by a footer gap
|
|
if (is_valid_len(out.nbits) && s.peek_space_at_least(FOOTER_GAP_US)) {
|
|
return out;
|
|
}
|
|
return {};
|
|
}
|
|
}
|
|
|
|
if (is_valid_len(out.nbits) && s.peek_space_at_least(FOOTER_GAP_US)) {
|
|
return out;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
void SymphonyProtocol::dump(const SymphonyData &data) {
|
|
const int32_t hex_width = (data.nbits + 3) / 4; // pad to nibble width
|
|
ESP_LOGI(TAG, "Received Symphony: data=0x%0*X, nbits=%d", hex_width, (uint32_t) data.data, data.nbits);
|
|
}
|
|
|
|
} // namespace remote_base
|
|
} // namespace esphome
|