Smart Room Controller with ESP32 and Firebase

#include <Arduino.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <IRremoteESP8266.h>
#include <IRrecv.h>
#include <IRsend.h>
#include <IRutils.h>
#include <ir_Carrier.h> 
#include <receptor.cpp>

const char *WIFI_SSID = "your-WiFi-SSID-here";
const char *WIFI_PASSWORD = "Your-WiFi-Password-here";

#define API_KEY "Your-API-Key-here"
#define DATABASE_URL "Your-Firebase-Realtime-Database-URL-here"
#define DNS_PRIMARY IPAddress(8, 8, 8, 8)
#define DNS_SECONDARY IPAddress(1, 1, 1, 1)

// ================= PINOS =================

#define LED_PIN 18
#define LDR_PIN 34
#define THERM_PIN 35
#define BUZZER_PIN 16

#define RED_PIN 25
#define GREEN_PIN 26
#define BLUE_PIN 27

const uint16_t kRecvPin = 19;
const uint16_t kIrLed = 4;

// Configurao avanada para capturar ar-condicionado (buffer maior e timeout longo)
const uint16_t kCaptureBufferSize = 1024;
const uint8_t kTimeout = 50; 
IRrecv irrecv(kRecvPin, kCaptureBufferSize, kTimeout, true);

IRsend irsend(kIrLed);
IRCarrierAc64 ac(kIrLed);
decode_results results;

// ================= INSTRUES PARA CAPTURAR CDIGO DO AC =================
// 1. Faa upload deste cdigo no ESP32
// 2. Abra o Monitor Serial (115200 baud)
// 3. Aponte o controle remoto do CARRIER para o receptor IR (pino 19)
// 4. Pressione o boto "LIGAR" do controle
// 5. No Monitor Serial, voc ver algo como:
//    
//    === SINAL IR RECEBIDO ===
//    Tipo: UNKNOWN
//    Cdigo HEX: 0x33CDDA66
//    Bits: 32
//    
//    Copie o cdigo abaixo:
//    uint16_t rawData[68] = { 9020, 4500, 560, 560, ... };
//    ========================
//
// 6. Copie a linha "uint16_t rawData[X] = { ... };"
// 7. Cole no lugar de `codigoACRaw` abaixo
// 8. Crie a vriavel com o tamanho: `const uint16_t codigoACRawLen = X;`
// 9. Descomente as linhas e faa novo upload
// ============================================================================

// ================= FIREBASE =================

const char *FIREBASE_HOST = "https://sistemaambienteinteligente-default-rtdb.firebaseio.com";

HTTPClient http;

const char *SENSORES_PATH = "/ambiente/sensores";
const char *ESTADO_PATH = "/ambiente/estado";
const char *COMANDOS_PATH = "/ambiente/comandos";
const char *IR_CAPTURE_PATH = "/ambiente/ir/ultimo";
const char *AC_RAW_PATH = "/ambiente/acRaw";

String caminhoComando(const char *subPath)
{
  String path(COMANDOS_PATH);
  path.concat(subPath);
  return path;
}

String caminhoAcRaw(const String &cmd, const char *subPath)
{
  String path(AC_RAW_PATH);
  path.concat("/");
  path.concat(cmd);
  path.concat(subPath);
  return path;
}

// ================= VARIAVEIS =================

bool ledStatus = false;
bool modoAutomatico = true;
bool buzzerLigado = false;
bool alertaTemperaturaAnterior = false;

int luminosidade = 0;
float temperatura = 0;

unsigned long ultimoComandoManual = 0;
unsigned long ultimoEnvioFirebase = 0;
unsigned long ultimaLeituraComandos = 0;
unsigned long ultimoDebugSerial = 0;
unsigned long buzzerManualAte = 0;
String comandoAcAprendizado = "";

const unsigned long TEMPO_MANUAL = 5000;
const unsigned long INTERVALO_FIREBASE = 3000; // 1000
const unsigned long INTERVALO_COMANDOS = 2000; // 500
const unsigned long INTERVALO_DEBUG = 2000;
const int LIMITE_LUMINOSIDADE = 2100;
const float LIMITE_TEMPERATURA = 35.0;
const uint16_t AC_IR_REPEATS = 2;

int redValue = 0;
int greenValue = 0;
int blueValue = 0;

// ================= CDIGOS IR DO PROJETOR (BPC-1080P M18-W) =================
// Substitua 0x0 pelo cdigo HEX capturado no Monitor Serial
uint64_t projPower = 0xFB38C7;
uint64_t projMute = 0xFB10EF;
uint64_t projPlayPause = 0xFB807F;
uint64_t projSource = 0xFBDA25;
uint64_t projMenu = 0xFB827D;

uint64_t projUp = 0xFB58A7;
uint64_t projDown = 0xFB12ED;
uint64_t projLeft = 0xFBE21D;
uint64_t projRight = 0xFBE01F;
uint64_t projOk = 0xFB609F;

uint64_t projRewind = 0xFB18E7;
uint64_t projForward = 0xFBC03F;
uint64_t projBack = 0xFB50AF;

uint64_t projPrev = 0xFBF20D;
uint64_t projNext = 0xFBD22D;
// ============================================================================

// ================= AR CONDICIONADO (CARRIER) =================

const uint16_t acPowerOnRaw[] = {
  9006, 4452, 528, 602, 532, 578, 554, 1678, 556, 578, 554, 1678, 580,
  578, 532, 600, 554, 574, 576, 580, 532, 1682, 550, 602, 530, 578,
  554, 1678, 556, 578, 554, 602, 530, 598, 552, 580, 554, 602, 530,
  602, 532, 580, 552, 602, 532, 580, 552, 578, 556, 596, 554, 580,
  554, 580, 552, 578, 554, 578, 556, 580, 552, 578, 556, 576, 556,
  594, 556, 578, 554, 578, 554, 580, 554, 578, 554, 576, 556, 578,
  554, 578, 556, 598, 556, 1678, 556, 578, 554, 578, 556, 1666, 556
};
const uint16_t acPowerOnRawLen = sizeof(acPowerOnRaw) / sizeof(acPowerOnRaw[0]);
const uint16_t AC_RAW_FREQUENCY_KHZ = 38;
const uint16_t AC_RAW_MAX_LENGTH = 300;

String uint64ParaHex(uint64_t valor)
{
  String texto = "0x";
  texto += String((uint32_t)(valor >> 32), HEX);
  String parteBaixa = String((uint32_t)valor, HEX);

  while (parteBaixa.length() < 8)
  {
    parteBaixa = "0" + parteBaixa;
  }

  texto += parteBaixa;
  texto.toUpperCase();
  return texto;
}

const char *modoAcTexto(uint8_t modo)
{
  if (modo == kCarrierAc64Cool) return "cool";
  if (modo == kCarrierAc64Fan) return "fan";
  if (modo == kCarrierAc64Heat) return "heat";
  return "unknown";
}

const char *fanAcTexto(uint8_t fan)
{
  if (fan == kCarrierAc64FanAuto) return "auto";
  if (fan == kCarrierAc64FanLow) return "low";
  if (fan == kCarrierAc64FanMedium) return "medium";
  if (fan == kCarrierAc64FanHigh) return "high";
  return "unknown";
}

void preencherEstadoAc(JsonObject estadoAc)
{
  estadoAc["power"] = ac.getPower();
  estadoAc["temp"] = ac.getTemp();
  estadoAc["mode"] = modoAcTexto(ac.getMode());
  estadoAc["fan"] = fanAcTexto(ac.getFan());
  estadoAc["swingV"] = ac.getSwingV();
  estadoAc["sleep"] = ac.getSleep();
  estadoAc["raw"] = uint64ParaHex(ac.getRaw());
}

void enviarComandoAc(const String &cmdAc)
{
  Serial.print("Enviando AC: ");
  Serial.println(cmdAc);
  Serial.println(ac.toString());
  Serial.print("Raw CarrierAc64: ");
  Serial.println(uint64ParaHex(ac.getRaw()));

  ac.send(AC_IR_REPEATS);
}

void enviarRawAc(const String &cmdAc, const uint16_t rawData[], uint16_t rawLen)
{
  Serial.print("Enviando AC RAW: ");
  Serial.print(cmdAc);
  Serial.print(" | len=");
  Serial.print(rawLen);
  Serial.print(" | freq=");
  Serial.print(AC_RAW_FREQUENCY_KHZ);
  Serial.println("kHz");

  irsend.sendRaw(rawData, rawLen, AC_RAW_FREQUENCY_KHZ);
}

bool csvParaRaw(const String &rawCsv, uint16_t rawData[], uint16_t &rawLen)
{
  rawLen = 0;
  uint32_t valor = 0;
  bool lendoNumero = false;

  for (uint16_t i = 0; i <= rawCsv.length(); i++)
  {
    char c = (i < rawCsv.length()) ? rawCsv[i] : ',';

    if (c >= '0' && c <= '9')
    {
      lendoNumero = true;
      valor = (valor * 10) + (c - '0');
      if (valor > UINT16_MAX)
      {
        return false;
      }
    }
    else if (c == ',' || c == ' ' || c == '\n' || c == '\r' || c == '\t')
    {
      if (lendoNumero)
      {
        if (rawLen >= AC_RAW_MAX_LENGTH)
        {
          return false;
        }

        rawData[rawLen++] = (uint16_t)valor;
        valor = 0;
        lendoNumero = false;
      }
    }
    else
    {
      return false;
    }
  }

  return rawLen > 0;
}

// ================= RGB =================

void atualizarRGB()
{
  ledcWrite(0, redValue);
  ledcWrite(1, greenValue);
  ledcWrite(2, blueValue);
}

int limitarCor(int valor)
{
  return constrain(valor, 0, 255);
}

// ================= BUZZER =================

void definirBuzzer(bool ligar)
{
  if (buzzerLigado == ligar)
  {
    return;
  }

  buzzerLigado = ligar;
  digitalWrite(BUZZER_PIN, ligar ? HIGH : LOW);
}

// ================= WIFI =================

void conectarWifi()
{
  WiFi.mode(WIFI_STA);
  WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE, DNS_PRIMARY, DNS_SECONDARY);
  
  Serial.print("WiFi SSID: ");
  Serial.println(WIFI_SSID);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  Serial.print("Conectando ao WiFi");

  int tentativas = 0;
  while (WiFi.status() != WL_CONNECTED && tentativas < 20)
  {
    delay(500);
    Serial.print(".");
    tentativas++;
  }

  Serial.println();
  
  if (WiFi.status() == WL_CONNECTED) {
    Serial.print("WiFi conectado! IP: ");
    Serial.println(WiFi.localIP());
    
    // Testar DNS
    IPAddress firebaseIp;
    if (WiFi.hostByName(DATABASE_URL, firebaseIp))
    {
      Serial.print("DNS OK - Firebase IP: ");
      Serial.println(firebaseIp);
    }
    else
    {
      Serial.println("ERRO: DNS falhou para Firebase");
    }
  } else {
    Serial.println("ERRO: Falha ao conectar WiFi");
  }
}

// ================= FIREBASE =================

void conectarFirebase()
{
  Serial.println("Firebase via REST API pronto");
}

bool enviarParaFirebase(const String &path, const String &payload)
{
  if (WiFi.status() != WL_CONNECTED)
  {
    return false;
  }

  String url = String(FIREBASE_HOST) + path + ".json";
  
  http.begin(url);
  http.addHeader("Content-Type", "application/json");
  
  int httpResponseCode = http.PUT(payload);
  
  if (httpResponseCode != 200)
  {
    Serial.print("ERRO: HTTP ");
    Serial.print(httpResponseCode);
    Serial.print(" - ");
    Serial.println(url);
  }
  
  http.end();
  return (httpResponseCode == 200);
}

String lerDoFirebase(const String &path)
{
  if (WiFi.status() != WL_CONNECTED)
  {
    return "";
  }

  String url = String(FIREBASE_HOST) + path + ".json";
  
  http.begin(url);
  http.addHeader("Content-Type", "application/json");
  
  int httpResponseCode = http.GET();
  String response = "";
  
  if (httpResponseCode == 200)
  {
    response = http.getString();
  }
  else
  {
    Serial.print("ERRO ao ler: HTTP ");
    Serial.println(httpResponseCode);
  }
  
  http.end();
  return response;
}

String rawCapturadoParaCsv(const decode_results &captura, uint16_t &rawLenCorrigido)
{
  String rawCsv;
  rawLenCorrigido = getCorrectedRawLength(&captura);
  rawCsv.reserve(rawLenCorrigido * 7);

  uint16_t pos = 0;
  for (uint16_t i = 1; i < captura.rawlen; i++)
  {
    uint32_t usecs = captura.rawbuf[i] * kRawTick;

    while (usecs > UINT16_MAX)
    {
      if (pos > 0) rawCsv += ',';
      rawCsv += String(UINT16_MAX);
      rawCsv += ",0";
      pos += 2;
      usecs -= UINT16_MAX;
    }

    if (pos > 0) rawCsv += ',';
    rawCsv += String(usecs);
    pos++;
  }

  return rawCsv;
}

bool publicarRawAcAprendido(const String &cmdAc, const decode_results &captura, const String &rawCsv, uint16_t rawLen)
{
  if (cmdAc.length() == 0 || rawCsv.length() == 0)
  {
    return false;
  }

  String payload;
  payload.reserve(rawCsv.length() + 180);
  payload += "{\"protocol\":\"";
  payload += typeToString(captura.decode_type, captura.repeat);
  payload += "\",\"bits\":";
  payload += String(captura.bits);
  payload += ",\"value\":\"";
  payload += uint64ParaHex(captura.value);
  payload += "\",\"rawlen\":";
  payload += String(rawLen);
  payload += ",\"raw\":\"";
  payload += rawCsv;
  payload += "\",\"atualizadoEm\":";
  payload += String(millis());
  payload += "}";

  return enviarParaFirebase(caminhoAcRaw(cmdAc, ""), payload);
}

void publicarCapturaIr(const decode_results &captura)
{
  if (WiFi.status() != WL_CONNECTED)
  {
    return;
  }

  uint16_t rawLenCorrigido = 0;
  String rawCsv = rawCapturadoParaCsv(captura, rawLenCorrigido);

  String payload;
  payload.reserve(rawCsv.length() + 180);
  payload += "{\"protocol\":\"";
  payload += typeToString(captura.decode_type, captura.repeat);
  payload += "\",\"bits\":";
  payload += String(captura.bits);
  payload += ",\"value\":\"";
  payload += uint64ParaHex(captura.value);
  payload += "\",\"rawlen\":";
  payload += String(rawLenCorrigido);
  payload += ",\"raw\":\"";
  payload += rawCsv;
  payload += "\",\"atualizadoEm\":";
  payload += String(millis());
  payload += "}";

  enviarParaFirebase(IR_CAPTURE_PATH, payload);

  if (comandoAcAprendizado.length() > 0)
  {
    Serial.print("Salvando RAW aprendido para AC: ");
    Serial.println(comandoAcAprendizado);

    if (publicarRawAcAprendido(comandoAcAprendizado, captura, rawCsv, rawLenCorrigido))
    {
      enviarParaFirebase(caminhoComando("/acLearnCmd"), "\"\"");
      comandoAcAprendizado = "";
    }
  }
}

void exibirCapturaIr(const decode_results &captura)
{
  Serial.println("\n=== SINAL IR RECEBIDO ===");
  Serial.print("Tipo: ");
  Serial.println(typeToString(captura.decode_type, captura.repeat));
  Serial.print("Codigo HEX: ");
  Serial.println(uint64ParaHex(captura.value));
  Serial.print("Bits: ");
  Serial.println(captura.bits);
  Serial.print("Raw length: ");
  Serial.println(getCorrectedRawLength(&captura));

  Serial.println("\nCopie o codigo abaixo:");
  Serial.println(resultToSourceCode(&captura));
  Serial.println("========================\n");
}

bool firebaseDisponivel()
{
  return WiFi.status() == WL_CONNECTED;
}

void publicarEstadoInicial()
{
  if (!firebaseDisponivel())
  {
    return;
  }

  Serial.println("Publicando estado inicial...");
  
  StaticJsonDocument<256> doc;
  doc["ledManual"] = false;
  doc["led"] = false;
  doc["buzzer"] = false;
  JsonObject rgb = doc.createNestedObject("rgb");
  rgb["r"] = redValue;
  rgb["g"] = greenValue;
  rgb["b"] = blueValue;
  
  String payload;
  serializeJson(doc, payload);
  
  enviarParaFirebase(COMANDOS_PATH, payload);
}

void publicarDadosFirebase()
{
  if (!firebaseDisponivel())
  {
    return;
  }

  // Publicar sensores
  StaticJsonDocument<256> sensores;
  sensores["luminosidade"] = luminosidade;
  sensores["temperatura"] = temperatura;
  sensores["atualizadoEm"] = millis();
  
  String sensorPayload;
  serializeJson(sensores, sensorPayload);
  enviarParaFirebase(SENSORES_PATH, sensorPayload);

  // Publicar estado
  StaticJsonDocument<512> estado;
  estado["led"] = ledStatus;
  estado["modoAutomatico"] = modoAutomatico;
  estado["buzzer"] = buzzerLigado;
  JsonObject rgbState = estado.createNestedObject("rgb");
  rgbState["r"] = redValue;
  rgbState["g"] = greenValue;
  rgbState["b"] = blueValue;
  JsonObject acState = estado.createNestedObject("ac");
  preencherEstadoAc(acState);
  
  String estadoPayload;
  serializeJson(estado, estadoPayload);
  enviarParaFirebase(ESTADO_PATH, estadoPayload);
}

bool lerBoolFirebase(const String &path, bool valorPadrao)
{
  String response = lerDoFirebase(path);
  
  if (response.length() == 0)
  {
    return valorPadrao;
  }
  
  if (response == "true") return true;
  if (response == "false") return false;
  
  return valorPadrao;
}

int lerIntFirebase(const String &path, int valorPadrao)
{
  String response = lerDoFirebase(path);
  
  if (response.length() == 0)
  {
    return valorPadrao;
  }
  
  return response.toInt();
}

String lerStringFirebase(const String &path, String valorPadrao) {
  String response = lerDoFirebase(path);
  
  if (response.length() == 0 || response == "null") {
    return valorPadrao;
  }
  
  response.replace("\"", ""); // Remove as aspas devolvidas pelo JSON
  return response;
}

bool enviarRawAcSalvo(const String &cmdAc)
{
  String rawCsv = lerStringFirebase(caminhoAcRaw(cmdAc, "/raw"), "");

  if (rawCsv.length() == 0)
  {
    Serial.print("RAW do AC ainda nao cadastrado para: ");
    Serial.println(cmdAc);
    return false;
  }

  uint16_t rawData[AC_RAW_MAX_LENGTH];
  uint16_t rawLen = 0;

  if (!csvParaRaw(rawCsv, rawData, rawLen))
  {
    Serial.print("RAW do AC invalido para: ");
    Serial.println(cmdAc);
    return false;
  }

  enviarRawAc(cmdAc, rawData, rawLen);
  return true;
}

void lerComandosFirebase()
{
  if (!firebaseDisponivel())
  {
    return;
  }

  // ===== CAPTURAR CDIGOS IR =====
  // Descomente para clonar controle do Carrier
  
  if (false && irrecv.decode(&results)) {
    Serial.print("Cdigo capturado: 0x");
    Serial.println(results.value, HEX);
    Serial.print("Protocolo: ");
    Serial.println(results.decode_type);
    irrecv.resume();
  }
  

  String novoComandoAcAprendizado = lerStringFirebase(caminhoComando("/acLearnCmd"), "");

  if (novoComandoAcAprendizado.length() > 0 && novoComandoAcAprendizado != comandoAcAprendizado)
  {
    comandoAcAprendizado = novoComandoAcAprendizado;
    Serial.print("Modo aprendizado AC aguardando captura para: ");
    Serial.println(comandoAcAprendizado);
  }

  bool ledManual = lerBoolFirebase(caminhoComando("/ledManual"), false);

  if (ledManual)
  {
    ledStatus = lerBoolFirebase(caminhoComando("/led"), ledStatus);
    digitalWrite(LED_PIN, ledStatus ? HIGH : LOW);

    modoAutomatico = false;
    ultimoComandoManual = millis();

    // Resetar comando
    enviarParaFirebase(caminhoComando("/ledManual"), "false");
  }

  bool testarBuzzer = lerBoolFirebase(caminhoComando("/buzzer"), false);

  if (testarBuzzer)
  {
    buzzerManualAte = millis() + 300;
    enviarParaFirebase(caminhoComando("/buzzer"), "false");
  }

  int novoR = limitarCor(lerIntFirebase(caminhoComando("/rgb/r"), redValue));
  int novoG = limitarCor(lerIntFirebase(caminhoComando("/rgb/g"), greenValue));
  int novoB = limitarCor(lerIntFirebase(caminhoComando("/rgb/b"), blueValue));

  if (novoR != redValue || novoG != greenValue || novoB != blueValue)
  {
    redValue = novoR;
    greenValue = novoG;
    blueValue = novoB;
    atualizarRGB();
  }

  // ================= COMANDOS DO PROJETOR =================
  String cmdProjetor = lerStringFirebase(caminhoComando("/projetorCmd"), "");
  
  if (cmdProjetor.length() > 0) {
    Serial.print("Comando do Projetor Recebido: ");
    Serial.println(cmdProjetor);

    // Mapeamento dos botes (envia o protocolo NEC, que  padro para a maioria dos projetores)
    if (cmdProjetor == "power") irsend.sendNEC(projPower, 32);
    else if (cmdProjetor == "mute") irsend.sendNEC(projMute, 32);
    else if (cmdProjetor == "play") irsend.sendNEC(projPlayPause, 32);
    else if (cmdProjetor == "source") irsend.sendNEC(projSource, 32);
    else if (cmdProjetor == "menu") irsend.sendNEC(projMenu, 32);
    else if (cmdProjetor == "up") irsend.sendNEC(projUp, 32);
    else if (cmdProjetor == "down") irsend.sendNEC(projDown, 32);
    else if (cmdProjetor == "left") irsend.sendNEC(projLeft, 32);
    else if (cmdProjetor == "right") irsend.sendNEC(projRight, 32);
    else if (cmdProjetor == "ok") irsend.sendNEC(projOk, 32);
    else if (cmdProjetor == "rewind") irsend.sendNEC(projRewind, 32);
    else if (cmdProjetor == "forward") irsend.sendNEC(projForward, 32);
    else if (cmdProjetor == "back") irsend.sendNEC(projBack, 32);
    else if (cmdProjetor == "prev") irsend.sendNEC(projPrev, 32);
    else if (cmdProjetor == "next") irsend.sendNEC(projNext, 32);

    // Limpa o comando no Firebase escrevendo uma string vazia ("")
    enviarParaFirebase(caminhoComando("/projetorCmd"), "\"\""); 
  }

  // ================= COMANDOS DO AR CONDICIONADO (CARRIER) =================
  String cmdAc = lerStringFirebase(caminhoComando("/acCmd"), "");
  
  if (cmdAc.length() > 0) {
    Serial.print("Comando do AC Recebido: ");
    Serial.println(cmdAc);

    bool comandoAcReconhecido = true;
    bool enviarCarrierAc = true;
    bool comandoAcEnviado = false;

    // Altera o estado interno do ESP32 baseado no boto pressionado
    if (cmdAc == "power") {
      enviarCarrierAc = false;
      if (ac.getPower())
      {
        comandoAcEnviado = enviarRawAcSalvo("powerOff");
        if (comandoAcEnviado) ac.off();
        else
        {
          comandoAcEnviado = enviarRawAcSalvo("power");
          if (comandoAcEnviado) ac.off();
        }
        if (!comandoAcEnviado)
        {
          Serial.println("RAW powerOff nao cadastrado; usando powerOn como fallback.");
          ac.on();
          enviarRawAc("powerOn", acPowerOnRaw, acPowerOnRawLen);
          comandoAcEnviado = true;
        }
      }
      else
      {
        ac.on();
        enviarRawAc("powerOn", acPowerOnRaw, acPowerOnRawLen);
        comandoAcEnviado = true;
      }
    } 
    else if (cmdAc == "tempUp") {
      ac.on();
      ac.setTemp(ac.getTemp() + 1); // Aumenta a temperatura
    } 
    else if (cmdAc == "tempDown") {
      ac.on();
      ac.setTemp(ac.getTemp() - 1); // Diminui a temperatura
    } 
    else if (cmdAc == "mode") {
      ac.on();
      // Alterna entre Frio -> Desumidificar -> Automtico -> Quente -> Ventilao
      uint8_t mode = ac.getMode();
      if (mode == kCarrierAc64Cool) ac.setMode(kCarrierAc64Fan);
      else if (mode == kCarrierAc64Fan) ac.setMode(kCarrierAc64Heat);
      else ac.setMode(kCarrierAc64Cool);
    } 
    else if (cmdAc == "fan") {
      ac.on();
      // Alterna velocidade: Auto -> Baixa -> Mdia -> Alta
      uint8_t fan = ac.getFan();
      if (fan == kCarrierAc64FanAuto) ac.setFan(kCarrierAc64FanLow);
      else if (fan == kCarrierAc64FanLow) ac.setFan(kCarrierAc64FanMedium);
      else if (fan == kCarrierAc64FanMedium) ac.setFan(kCarrierAc64FanHigh);
      else ac.setFan(kCarrierAc64FanAuto);
    } 
    else if (cmdAc == "sweep") {
      ac.on();
      ac.setSwingV(!ac.getSwingV()); // Alterna o movimento vertical das aletas
    }
    else if (cmdAc == "sleep") {
      ac.on();
      ac.setSleep(!ac.getSleep());
    }
    else if (cmdAc == "louver") {
      ac.setSleep(false);
      ac.setOnTimer(0);
      ac.setOffTimer(0);
    }
    else {
      comandoAcReconhecido = false;
      Serial.print("Comando do AC desconhecido: ");
      Serial.println(cmdAc);
    }

    if (comandoAcReconhecido && enviarCarrierAc && !comandoAcEnviado)
    {
      comandoAcEnviado = enviarRawAcSalvo(cmdAc);
    }

    if (comandoAcReconhecido && !comandoAcEnviado)
    {
      Serial.print("Comando AC reconhecido, mas sem RAW cadastrado: ");
      Serial.println(cmdAc);
    }

    // Limpa o comando no Firebase escrevendo uma string vazia ("")
    enviarParaFirebase(caminhoComando("/acCmd"), "\"\""); 
  }
  
}

// ================= CONTROLE =================

void lerSensores()
{
  luminosidade = analogRead(LDR_PIN);

  int leituraTemp = analogRead(THERM_PIN);
  temperatura = map(leituraTemp, 0, 4095, 0, 50);
}

void atualizarAutomatico()
{
  if (!modoAutomatico && (millis() - ultimoComandoManual) > TEMPO_MANUAL)
  {
    modoAutomatico = true;
  }

  if (!modoAutomatico)
  {
    return;
  }

  ledStatus = luminosidade < LIMITE_LUMINOSIDADE;
  digitalWrite(LED_PIN, ledStatus ? HIGH : LOW);
}

void atualizarAlertas()
{
  bool alertaTemperatura = temperatura > LIMITE_TEMPERATURA;
  bool alertaEscuridao = modoAutomatico && luminosidade < LIMITE_LUMINOSIDADE;
  bool buzzerManual = millis() < buzzerManualAte;

  if (alertaTemperatura && !alertaTemperaturaAnterior)
  {
    Serial.println("ALERTA: TEMPERATURA ALTA");
  }

  alertaTemperaturaAnterior = alertaTemperatura;

  definirBuzzer(alertaTemperatura || alertaEscuridao || buzzerManual);
}

void exibirDebugSerial()
{
  Serial.print("Luminosidade: ");
  Serial.println(luminosidade);
  Serial.print("Temperatura: ");
  Serial.println(temperatura);
  Serial.print("LED: ");
  Serial.println(ledStatus ? "LIGADO" : "DESLIGADO");
  Serial.print("Modo: ");
  Serial.println(modoAutomatico ? "AUTOMATICO" : "MANUAL");
}

// ================= SETUP =================

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

  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);

  ledcSetup(0, 5000, 8);
  ledcAttachPin(RED_PIN, 0);

  ledcSetup(1, 5000, 8);
  ledcAttachPin(GREEN_PIN, 1);

  ledcSetup(2, 5000, 8);
  ledcAttachPin(BLUE_PIN, 2);

  atualizarRGB();

  conectarWifi();
  conectarFirebase();
  publicarEstadoInicial();

  // Inicializa o receptor e o Transmissor IR
  irrecv.enableIRIn();
  irsend.begin();

  // Inicializa o estado virtual do Ar Condicinado Carrier
  ac.begin();
  ac.off();
  ac.setTemp(24);
  ac.setMode(kCarrierAc64Cool); 
  ac.setFan(kCarrierAc64FanAuto);
  ac.setSwingV(false);
  ac.setSleep(false);

  Serial.println("Mdulos IR e AC Carrier inicializados. Aguardando sinais para clonar...");
}

// ================= LOOP =================

void loop()
{
  if (irrecv.decode(&results)) {
    Serial.println("\n=== SINAL IR RECEBIDO ===");
    Serial.print("Tipo: ");
    Serial.println(typeToString(results.decode_type));
    Serial.print("Cdigo HEX: 0x");
    Serial.println(results.value, HEX);
    Serial.print("Bits: ");
    Serial.println(results.bits);
    
    // Mostrar dados RAW j no formato C++
    Serial.println("\nCopie o cdigo abaixo:");
    Serial.println(resultToSourceCode(&results));
    publicarCapturaIr(results);
    Serial.println("========================\n");
    
    irrecv.resume(); // Pronto para o prximo sinal
  }
  
  lerSensores();
  atualizarAutomatico();
  atualizarAlertas();

  unsigned long agora = millis();

  if (agora - ultimaLeituraComandos >= INTERVALO_COMANDOS)
  {
    ultimaLeituraComandos = agora;
    lerComandosFirebase();
  }

  if (agora - ultimoEnvioFirebase >= INTERVALO_FIREBASE)
  {
    ultimoEnvioFirebase = agora;
    publicarDadosFirebase();
  }

  if (agora - ultimoDebugSerial >= INTERVALO_DEBUG)
  {
    ultimoDebugSerial = agora;
    exibirDebugSerial();
  }

  delay(20);
}