Segui el tutorial como indicaba y la placa tenia problemas para conectarle, logre una conexion mas rapida y estable asignandole una IP FIJA.
el problema es que luego de un tiempo si bien en la web app de Firebase el estado de los GPIO seguian actualizandose en la placa los leds quedaban congelados, solo respondian si reiniciaba la placa (esp8266) con el boton reset.

Trabaje el codigo con chatgpt pero no pude resolver el problema.

#define ENABLE_USER_AUTH
#define ENABLE_DATABASE
#include <Arduino.h>
#if defined(ESP32)
#include <WiFi.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#endif
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>
#include <ArduinoJson.h>
#include “ExampleFunctions.h”
// Credenciales WiFi y Firebase
#define WIFI_SSID “xxxxxxxxxxxx”
#define WIFI_PASSWORD “xxxxxxxxx”
#define Web_API_KEY “xxx”
#define DATABASE_URL “xxxxx”
#define USER_EMAIL “xxxxxxx”
#define USER_PASS “xxxxxxxxx”
// Objetos de autenticación y Firebase
UserAuth user_auth(Web_API_KEY, USER_EMAIL, USER_PASS);
SSL_CLIENT ssl_client, stream_ssl_client;
FirebaseApp app;
using AsyncClient = AsyncClientClass;
AsyncClient aClient(ssl_client), streamClient(stream_ssl_client);
RealtimeDatabase Database;
// Pines de salida
const int output1 = 12;
const int output2 = 13;
const int output3 = 14;
// Path en RTDB
String listenerPath = “board1/outputs/digital/”;
// Timer
unsigned long lastSendTime = 0;
const unsigned long sendInterval = 10000;
// IP fija
#include <IPAddress.h>
IPAddress local_IP(192, 168, 0, 200);
IPAddress gateway(192, 168, 0, 1);
IPAddress subnet(255, 255, 255, 0);
IPAddress primaryDNS(8, 8, 8, 8);
IPAddress secondaryDNS(8, 8, 4, 4);
// Inicializar WiFi con IP fija
void initWiFi() {
if (!WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS)) {
Serial.println(“Fallo al configurar IP estática”);
}
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.print(“Conectando a WiFi ..”);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(‘.’);
delay(1000);
}
Serial.println(“”);
Serial.print(“Conectado con IP: “);
Serial.println(WiFi.localIP());
}
// Procesamiento de datos desde Firebase
void processData(AsyncResult &aResult) {
if (!aResult.isResult()) return;
if (aResult.isEvent()) {
Firebase.printf(“Event: %s, msg: %s, code: %d\n”, aResult.uid().c_str(), aResult.eventLog().message().c_str(), aResult.eventLog().code());
}
if (aResult.isDebug()) {
Firebase.printf(“Debug: %s, msg: %s\n”, aResult.uid().c_str(), aResult.debug().c_str());
}
if (aResult.isError()) {
Firebase.printf(“Error: %s, msg: %s, code: %d\n”, aResult.uid().c_str(), aResult.error().message().c_str(), aResult.error().code());
}
if (aResult.available()) {
RealtimeDatabaseResult &RTDB = aResult.to<RealtimeDatabaseResult>();
if (RTDB.isStream()) {
Serial.println(“—————————-“);
Firebase.printf(“Task: %s\n”, aResult.uid().c_str());
Firebase.printf(“Event: %s\n”, RTDB.event().c_str());
Firebase.printf(“Path: %s\n”, RTDB.dataPath().c_str());
Firebase.printf(“Data: %s\n”, RTDB.to<const char *>());
Firebase.printf(“Type: %d\n”, RTDB.type());
if (RTDB.type() == 6) { // JSON
DynamicJsonDocument doc(1024);
DeserializationError error = deserializeJson(doc, RTDB.to<String>());
if (error) {
Serial.print(“deserializeJson() failed: “);
Serial.println(error.c_str());
return;
}
for (JsonPair kv : doc.as<JsonObject>()) {
int gpioPin = atoi(kv.key().c_str());
bool state = kv.value().as<bool>();
digitalWrite(gpioPin, state ? HIGH : LOW);
}
} else if (RTDB.type() == 1 || RTDB.type() == 4) { // int o bool
int GPIO_number = RTDB.dataPath().substring(1).toInt();
bool state = RTDB.to<bool>();
digitalWrite(GPIO_number, state);
Serial.println(“GPIO actualizado”);
}
} else {
Serial.println(“—————————-“);
Firebase.printf(“Tarea: %s, payload: %s\n”, aResult.uid().c_str(), aResult.c_str());
}
}
}
void setup() {
Serial.begin(115200);
pinMode(output1, OUTPUT);
pinMode(output2, OUTPUT);
pinMode(output3, OUTPUT);
initWiFi();
// Configuración SSL
ssl_client.setInsecure();
stream_ssl_client.setInsecure();
#if defined(ESP32)
ssl_client.setConnectionTimeout(1000);
ssl_client.setHandshakeTimeout(5);
stream_ssl_client.setConnectionTimeout(1000);
stream_ssl_client.setHandshakeTimeout(5);
#elif defined(ESP8266)
ssl_client.setTimeout(5000);
ssl_client.setBufferSizes(4096, 1024);
stream_ssl_client.setTimeout(5000);
stream_ssl_client.setBufferSizes(4096, 1024);
#endif
// Inicializar Firebase
initializeApp(aClient, app, getAuth(user_auth), processData, “🔐 authTask”);
app.getApp<RealtimeDatabase>(Database);
Database.url(DATABASE_URL);
// Escuchar cambios
streamClient.setSSEFilters(“get,put,patch,keep-alive,cancel,auth_revoked”);
Database.get(streamClient, listenerPath, processData, true, “streamTask”);
}
void loop() {
static bool wifiWasConnected = true;
static bool firebaseInitialized = true;
static unsigned long lastStreamReset = 0;
unsigned long currentTime = millis();
// Si se pierde la conexión WiFi
if (WiFi.status() != WL_CONNECTED) {
if (wifiWasConnected) {
Serial.println(“WiFi perdido. Intentando reconexión…”);
wifiWasConnected = false;
firebaseInitialized = false; // requiere reiniciar Firebase después
}
WiFi.disconnect();
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
unsigned long startAttemptTime = millis();
const unsigned long wifiTimeout = 10000; // 10 segundos máx para reconectar
while (WiFi.status() != WL_CONNECTED && millis() – startAttemptTime < wifiTimeout) {
Serial.print(“.”);
delay(500);
}
if (WiFi.status() == WL_CONNECTED) {
Serial.println(“”);
Serial.println(“WiFi reconectado con éxito.”);
} else {
Serial.println(“”);
Serial.println(“No se pudo reconectar al WiFi.”);
}
return;
}
// Si se recuperó WiFi y aún no se reinició Firebase
if (!wifiWasConnected && WiFi.status() == WL_CONNECTED) {
Serial.println(“WiFi reconectado. Reiniciando Firebase…”);
wifiWasConnected = true;
// Reconfigurar Firebase
initializeApp(aClient, app, getAuth(user_auth), processData, “🔐 authTask”);
app.getApp<RealtimeDatabase>(Database);
Database.url(DATABASE_URL);
streamClient.setSSEFilters(“get,put,patch,keep-alive,cancel,auth_revoked”);
Database.get(streamClient, listenerPath, processData, true, “streamTask”);
firebaseInitialized = true;
lastStreamReset = millis();
}
// Mantener Firebase activo
app.loop();
if (app.ready()) {
// Mostrar cada 10 segundos
if (currentTime – lastSendTime >= sendInterval) {
lastSendTime = currentTime;
Serial.printf(“Tiempo transcurrido: %lu ms\n”, currentTime);
}
// Reforzar el stream cada 5 minutos por seguridad
if (currentTime – lastStreamReset > 300000) {
lastStreamReset = currentTime;
Serial.println(“Renovando stream Firebase por seguridad…”);
Database.get(streamClient, listenerPath, processData, true, “streamTask”);
}
}
}