ir_transmit.cpp

#include "ir_transmit.h"
#include <IRutils.h>
#include <WiFi.h>
#include "esp_task_wdt.h"

// Mutex para proteger seção crítica de transmissão IR
static portMUX_TYPE irMux = portMUX_INITIALIZER_UNLOCKED;

IRTransmitManager::IRTransmitManager() 
  : _irsend(IR_SEND_PIN),
    _ac(IR_SEND_PIN) {
}

void IRTransmitManager::begin() {
  _irsend.begin();
  // Desabilitar Wi-Fi sleep mode para reduzir jitter nas transmissões IR
  WiFi.setSleep(false);
  Serial.println("[IR-TX] Transmissor iniciado no GPIO " + String(IR_SEND_PIN));
  Serial.println("[IR-TX] WiFi sleep desabilitado");
}

bool IRTransmitManager::sendByProtocol(const String& protocol, const String& hexCode, 
                                        uint16_t bits, uint16_t repeat) {
  decode_type_t type = _stringToProtocol(protocol);
  if (type == decode_type_t::UNKNOWN) {
    Serial.println("[IR-TX] Protocolo desconhecido: " + protocol);
    return false;
  }
  
  if (hasACState(type)) {
    uint16_t stateLen = bits / 8;
    uint8_t state[stateLen];
    
    String hex = hexCode;
    hex.replace("0x", "");
    hex.replace("0X", "");
    
    for (uint16_t i = 0; i < stateLen && (i * 2 + 1) < hex.length(); i++) {
      String byteStr = hex.substring(i * 2, i * 2 + 2);
      state[i] = (uint8_t)strtoul(byteStr.c_str(), NULL, 16);
    }
    
    yield();
    portENTER_CRITICAL(&irMux);
    bool success = _irsend.send(type, state, stateLen);
    portEXIT_CRITICAL(&irMux);
    yield();
    
    Serial.println("[IR-TX] State enviado (protegido): " + protocol + " " + 
                   String(success ? "OK" : "FALHA"));
    return success;
  } else {
    uint64_t value = strtoull(hexCode.c_str(), NULL, 16);
    
    yield();
    portENTER_CRITICAL(&irMux);
    bool success = _irsend.send(type, value, bits, repeat);
    portEXIT_CRITICAL(&irMux);
    yield();
    
    Serial.println("[IR-TX] Enviado (protegido): " + protocol + " " + 
                   String(success ? "OK" : "FALHA"));
    return success;
  }
}

bool IRTransmitManager::sendRaw(uint16_t timings[], uint16_t count, uint16_t freqKhz) {
  // Feed do watchdog antes de entrar na seção crítica
  yield();
  
  // Seção crítica: desabilita todas as interrupções do core atual
  // Isso protege o timing da transmissão contra interrupções do Wi-Fi,
  // WebServer, WebSocket e outras tasks do FreeRTOS
  portENTER_CRITICAL(&irMux);
  _irsend.sendRaw(timings, count, freqKhz);
  portEXIT_CRITICAL(&irMux);
  
  // Feed do watchdog ao sair
  yield();
  
  Serial.println("[IR-TX] Raw enviado (protegido): " + String(count) + " timings @ " + 
                 String(freqKhz) + "kHz");
  return true;
}

bool IRTransmitManager::replayFromJSON(const String& json) {
  // Extrair raw timings do JSON
  // Procurar "timings":[...]
  int start = json.indexOf("\"timings\":[");
  if (start < 0) return false;
  start = json.indexOf("[", start);
  int end = json.indexOf("]", start);
  if (end < 0) return false;
  
  String timingsStr = json.substring(start + 1, end);
  
  // Contar timings
  uint16_t count = 1;
  for (int i = 0; i < timingsStr.length(); i++) {
    if (timingsStr.charAt(i) == ',') count++;
  }
  
  // Parse timings
  uint16_t timings[count];
  int idx = 0;
  int pos = 0;
  while (pos < timingsStr.length() && idx < count) {
    int comma = timingsStr.indexOf(',', pos);
    if (comma < 0) comma = timingsStr.length();
    String val = timingsStr.substring(pos, comma);
    val.trim();
    timings[idx++] = (uint16_t)val.toInt();
    pos = comma + 1;
  }
  
  return sendRaw(timings, count, 38);
}

decode_type_t IRTransmitManager::_stringToProtocol(const String& name) {
  // Usar a função da biblioteca para converter string -> enum
  String upper = name;
  upper.toUpperCase();
  
  for (int i = 0; i <= (int)decode_type_t::kLastDecodeType; i++) {
    String pName = typeToString((decode_type_t)i);
    pName.toUpperCase();
    if (pName == upper) {
      return (decode_type_t)i;
    }
  }
  return decode_type_t::UNKNOWN;
}