// IR Remote Cloner — learns buttons from an infrared remote and replays them.
//
// How to use it:
//   1. Hold LEARN and press a slot button (1-4). The LED pulses blue.
//   2. Point your TV remote at the front and press the button to copy.
//      Green flash = saved. Red = nothing received within 10 seconds.
//   3. Press the slot button any time to send that code.

#include <Arduino.h>
#include <Adafruit_NeoPixel.h>
#include "esp_sleep.h"
#include "driver/gpio.h"

#define RAW_BUFFER_LENGTH 200   // Enough for long air-conditioner codes
#define DECODE_NEC
#define DECODE_SONY
#define DECODE_RC5
#define DECODE_RC6
#define DECODE_SAMSUNG
#define DECODE_PANASONIC
#define DECODE_DISTANCE_WIDTH   // Catch-all for many other remotes
#include <IRremote.hpp>

#include "pins.h"
#include "slot_store.h"

namespace {

constexpr uint32_t LEARN_TIMEOUT_MS = 10000;
constexpr uint32_t IDLE_SLEEP_MS    = 30000;
constexpr uint32_t DEBOUNCE_MS      = 25;
constexpr uint8_t  IR_KHZ           = 38;

Adafruit_NeoPixel statusLed(1, PIN_STATUS_LED, NEO_GRB + NEO_KHZ800);
SlotStore store;
Slot slots[SLOT_COUNT];
uint32_t lastActivity = 0;

// ---- Status LED ----------------------------------------------------------

void setColor(uint8_t r, uint8_t g, uint8_t b) {
  statusLed.setPixelColor(0, statusLed.Color(r, g, b));
  statusLed.show();
}

void flash(uint8_t r, uint8_t g, uint8_t b, uint8_t times = 2) {
  for (uint8_t i = 0; i < times; i++) {
    setColor(r, g, b);
    delay(120);
    setColor(0, 0, 0);
    delay(120);
  }
}

// ---- Buttons -------------------------------------------------------------

bool isPressed(uint8_t pin) {
  if (digitalRead(pin) == HIGH) return false;
  delay(DEBOUNCE_MS);
  return digitalRead(pin) == LOW;
}

void waitForRelease(uint8_t pin) {
  while (digitalRead(pin) == LOW) delay(5);
}

int8_t pressedSlot() {
  for (uint8_t i = 0; i < SLOT_COUNT; i++) {
    if (isPressed(PIN_BTN_SLOT[i])) return i;
  }
  return -1;
}

// ---- Learning ------------------------------------------------------------

bool learnInto(uint8_t index) {
  Slot captured;
  IrReceiver.resume();
  const uint32_t start = millis();

  while (millis() - start < LEARN_TIMEOUT_MS) {
    // Slow blue pulse while waiting for the remote.
    setColor(0, 0, ((millis() / 4) % 120) + 20);

    if (!IrReceiver.decode()) continue;

    IRData &data = IrReceiver.decodedIRData;
    if (data.flags & IRDATA_FLAGS_IS_REPEAT) {   // Ignore "button held" repeats
      IrReceiver.resume();
      continue;
    }

    if (data.protocol != UNKNOWN) {
      captured.kind = SlotKind::Decoded;
      captured.decoded = data;
      Serial.printf("Slot %u: learned ", index + 1);
      IrReceiver.printIRResultShort(&Serial);
    } else {
      // Unknown protocol: keep the raw timings and replay them as-is.
      captured.kind = SlotKind::Raw;
      captured.rawLength = data.rawlen - 1;
      IrReceiver.compensateAndStoreIRResultInArray(captured.raw);
      Serial.printf("Slot %u: learned raw code (%u timings)\n", index + 1, captured.rawLength);
    }

    IrReceiver.resume();
    slots[index] = captured;
    store.save(index, captured);
    return true;
  }
  return false;
}

// ---- Sending -------------------------------------------------------------

void sendSlot(uint8_t index) {
  const Slot &slot = slots[index];
  if (slot.kind == SlotKind::Empty) {
    flash(255, 120, 0, 1);                       // Amber: nothing learned yet
    return;
  }

  IrReceiver.stop();                             // Don't hear our own signal
  setColor(255, 106, 27);                        // Forge orange while sending
  if (slot.kind == SlotKind::Decoded) {
    IRData copy = slot.decoded;
    IrSender.write(&copy, /* repeats = */ 1);
  } else {
    IrSender.sendRaw(slot.raw, slot.rawLength, IR_KHZ);
  }
  delay(40);
  setColor(0, 0, 0);
  IrReceiver.start();
}

// ---- Power ---------------------------------------------------------------

uint16_t batteryMillivolts() {
  return analogReadMilliVolts(PIN_VBAT_SENSE) * 2;  // 1:2 divider
}

void sleepUntilButton() {
  setColor(0, 0, 0);
  gpio_wakeup_enable(static_cast<gpio_num_t>(PIN_BTN_LEARN), GPIO_INTR_LOW_LEVEL);
  for (uint8_t pin : PIN_BTN_SLOT) {
    gpio_wakeup_enable(static_cast<gpio_num_t>(pin), GPIO_INTR_LOW_LEVEL);
  }
  esp_sleep_enable_gpio_wakeup();
  esp_light_sleep_start();                       // Resumes here on any press
  lastActivity = millis();
}

}  // namespace

void setup() {
  Serial.begin(115200);

  pinMode(PIN_BTN_LEARN, INPUT_PULLUP);
  for (uint8_t pin : PIN_BTN_SLOT) pinMode(pin, INPUT_PULLUP);

  statusLed.begin();
  statusLed.setBrightness(40);

  store.begin();
  for (uint8_t i = 0; i < SLOT_COUNT; i++) {
    if (!store.load(i, slots[i])) slots[i].kind = SlotKind::Empty;
  }

  IrReceiver.begin(PIN_IR_RX, DISABLE_LED_FEEDBACK);
  IrSender.begin(PIN_IR_TX);

  if (batteryMillivolts() < 3400) flash(255, 0, 0, 3);  // Low battery warning
  else flash(0, 255, 60, 1);                             // Ready

  lastActivity = millis();
}

void loop() {
  const bool learnHeld = isPressed(PIN_BTN_LEARN);
  const int8_t slot = pressedSlot();

  if (slot >= 0) {
    lastActivity = millis();
    if (learnHeld) {
      const bool ok = learnInto(slot);
      ok ? flash(0, 255, 60) : flash(255, 0, 0);
    } else {
      sendSlot(slot);
    }
    waitForRelease(PIN_BTN_SLOT[slot]);
  }

  if (millis() - lastActivity > IDLE_SLEEP_MS) sleepUntilButton();
}
Bluetooth Macro Pad

Bluetooth Macro Pad
