Universal Device Remote

#include <Arduino.h>
#include <EEPROM.h>
#include <IRrecv.h>
#include <IRsend.h>
#include <IRutils.h>


// Hoisted type definitions
struct CommandSlot {
  uint16_t marker;
  uint16_t length;
  uint16_t raw[MAX_RAW_TICKS];
};


// Forward declarations
uint16_t slotAddress(uint8_t index);
void loadSlots();
void saveSlot(uint8_t index);
void flashBuiltIn(uint8_t count);
bool waitForIrCommand(uint8_t slotIndex);
void sendCommand(uint8_t slotIndex);
void handleButtons();

constexpr uint8_t IR_RX_PIN = 5;       // D1
constexpr uint8_t IR_TX_PIN = 4;       // D2, through 1 kOhm resistor and transistor
constexpr uint8_t POWER_BUTTON_PIN = 12; // D6
constexpr uint8_t UP_BUTTON_PIN = 13;    // D7
constexpr uint8_t DOWN_BUTTON_PIN = 16;  // D0
constexpr uint8_t MUTE_BUTTON_PIN = 3;   // RX

constexpr uint16_t EEPROM_BYTES = 2048;
constexpr uint16_t SLOT_BYTES = 500;
constexpr uint8_t BUTTON_COUNT = 4;
constexpr uint16_t MAX_RAW_TICKS = 240;
constexpr uint16_t LEARN_HOLD_MS = 1800;
constexpr uint16_t DEBOUNCE_MS = 35;



constexpr uint16_t SLOT_MARKER = 0x5249;
const uint8_t buttonPins[BUTTON_COUNT] = {
  POWER_BUTTON_PIN, UP_BUTTON_PIN, DOWN_BUTTON_PIN, MUTE_BUTTON_PIN
};
const char *buttonNames[BUTTON_COUNT] = {"POWER", "UP", "DOWN", "MUTE"};

IRrecv irReceiver(IR_RX_PIN, 1024, 15, true);
IRsend irSender(IR_TX_PIN);
decode_results received;
CommandSlot slots[BUTTON_COUNT];
bool buttonWasDown[BUTTON_COUNT] = {false, false, false, false};
uint32_t pressStartedAt[BUTTON_COUNT] = {0, 0, 0, 0};
uint32_t lastActionAt = 0;

uint16_t slotAddress(uint8_t index) {
  return index * SLOT_BYTES;
}

void loadSlots() {
  for (uint8_t i = 0; i < BUTTON_COUNT; i++) {
    EEPROM.get(slotAddress(i), slots[i]);
    if (slots[i].marker != SLOT_MARKER || slots[i].length == 0 || slots[i].length > MAX_RAW_TICKS) {
      slots[i].marker = 0;
      slots[i].length = 0;
    }
  }
}

void saveSlot(uint8_t index) {
  EEPROM.put(slotAddress(index), slots[index]);
  EEPROM.commit();
}

void flashBuiltIn(uint8_t count) {
  for (uint8_t i = 0; i < count; i++) {
    digitalWrite(LED_BUILTIN, LOW);
    delay(100);
    digitalWrite(LED_BUILTIN, HIGH);
    delay(120);
  }
}

bool waitForIrCommand(uint8_t slotIndex) {
  Serial.printf("Point the original remote at the receiver and press its %s button.\n", buttonNames[slotIndex]);
  const uint32_t deadline = millis() + 12000;
  while (millis() < deadline) {
    if (irReceiver.decode(&received)) {
      const uint16_t copyLength = min<uint16_t>(received.rawlen, MAX_RAW_TICKS);
      if (copyLength > 1) {
        slots[slotIndex].marker = SLOT_MARKER;
        slots[slotIndex].length = copyLength;
        for (uint16_t i = 0; i < copyLength; i++) {
          slots[slotIndex].raw[i] = received.rawbuf[i];
        }
        saveSlot(slotIndex);
        Serial.printf("Saved %s command (%u timing marks).\n", buttonNames[slotIndex], copyLength);
        irReceiver.resume();
        flashBuiltIn(3);
        return true;
      }
      irReceiver.resume();
    }
    delay(1);
  }
  Serial.println("No infrared command received; learning cancelled.");
  flashBuiltIn(1);
  return false;
}

void sendCommand(uint8_t slotIndex) {
  if (slots[slotIndex].marker != SLOT_MARKER || slots[slotIndex].length == 0) {
    Serial.printf("%s has not been learned yet. Hold its button for two seconds to learn it.\n", buttonNames[slotIndex]);
    flashBuiltIn(1);
    return;
  }

  irReceiver.disableIRIn();
  irSender.sendRaw(slots[slotIndex].raw, slots[slotIndex].length, 38);
  irReceiver.enableIRIn();
  Serial.printf("Sent %s.\n", buttonNames[slotIndex]);
  flashBuiltIn(2);
}

void handleButtons() {
  const uint32_t now = millis();
  for (uint8_t i = 0; i < BUTTON_COUNT; i++) {
    const bool down = digitalRead(buttonPins[i]) == LOW;
    if (down && !buttonWasDown[i]) {
      buttonWasDown[i] = true;
      pressStartedAt[i] = now;
    }

    if (!down && buttonWasDown[i]) {
      const uint32_t heldFor = now - pressStartedAt[i];
      buttonWasDown[i] = false;
      if (now - lastActionAt < DEBOUNCE_MS) {
        continue;
      }
      lastActionAt = now;
      if (heldFor >= LEARN_HOLD_MS) {
        waitForIrCommand(i);
      } else {
        sendCommand(i);
      }
    }
  }
}

void setup() {
  Serial.begin(115200);
  EEPROM.begin(EEPROM_BYTES);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);

  for (uint8_t i = 0; i < BUTTON_COUNT; i++) {
    pinMode(buttonPins[i], INPUT_PULLUP);
  }

  loadSlots();
  irSender.begin();
  irReceiver.enableIRIn();
  Serial.println("Learning IR remote ready. Tap a button to send. Hold it for two seconds, then press the matching key on your original remote to learn.");
  flashBuiltIn(2);
}

void loop() {
  handleButtons();
}