¿Alguna vez quisiste ver los datos de tu ESP32 desde el celular, estés donde estés, sin montar un servidor propio? Firebase resuelve justo eso: una base de datos en la nube que se actualiza en tiempo real y que, para proyectos personales, es gratis. En esta guía vas a conectar un ESP32 a la Realtime Database (RTDB) de Google Firebase y enviar datos desde el monitor serial hasta la nube. Al terminar vas a saber crear el proyecto en Firebase, conseguir las dos credenciales que el ESP32 necesita (la URL de la base y la Web API Key) y subir un sketch que empuja datos en vivo.

Concepto: por qué Firebase y no un servidor propio

Montar tu propia nube implica un servidor, una base de datos, una API y mantener todo eso funcionando. Firebase te salta todos esos pasos: Google hospeda la base de datos, y tu ESP32 se comunica con ella usando solo dos credenciales. No hay máquinas virtuales, ni gateways, ni configuración de red que administrar. Para prototipos IoT es la vía más rápida de sacar datos de un microcontrolador y verlos en la nube.

Un detalle técnico que conviene entender desde el principio: la RTDB guarda todo como un gran árbol JSON. Cuando tu ESP32 escribe en una ruta como /serialData/message, Firebase crea o actualiza ese nodo del árbol al instante, y cualquier cliente conectado (tu navegador, una app, otro ESP32) ve el cambio en tiempo real. Esa es la magia del "realtime".

Paso a paso en la consola de Firebase

Entra a la consola de Firebase con tu cuenta de Google y crea un proyecto nuevo. Dale un nombre y confirma. Puedes dejar Google Analytics desactivado: no afecta en nada a este proyecto.

Pantalla de bienvenida de la consola de Firebase para crear un proyecto ESP32

Con el proyecto creado, ve a Database & Storage > Realtime Database y pulsa Create Database. Elige la ubicación y, en las reglas de seguridad, parte con "Start in locked mode". Habilita y termina la creación.

Creación de la Realtime Database y configuración de reglas de seguridad en Firebase

En modo bloqueado, lectura y escritura están en false. Para que el ESP32 pueda escribir, ve a la pestaña Rules y cambia .read y .write de false a true, luego pulsa Publish. Esto es cómodo para probar, pero ojo: deja tu base abierta a cualquiera. Más abajo, en "Variantes y mejoras", te explico cómo cerrarla para producción.

Ahora copia la Database URL desde la pestaña Data: ese enlace va directo a tu código.

Copiando la URL de la Realtime Database de Firebase para el código del ESP32

Falta configurar la autenticación. Ve a Security > Authentication > Get started y, en los métodos de inicio de sesión, activa Anonymous. Guarda y verifica que quede como Enabled.

Habilitando la autenticación anónima en Firebase para el ESP32

¿Por qué autenticación anónima si ya pusiste las reglas en true? Porque son dos cosas distintas: las reglas dicen qué se puede leer o escribir, pero Firebase igual exige que el dispositivo complete primero un handshake de login. Si la autenticación anónima está apagada, Google bloquea ese handshake y los datos nunca llegan, aunque las reglas estén abiertas. El modo anónimo le da al ESP32 una identidad temporal sin pedir usuario ni contraseña.

Por último, la segunda credencial: la Web API Key. Ve a Settings > General, baja hasta Your apps, crea una Web App, dale un nombre y regístrala. No necesitas seguir los pasos siguientes; copia la API Key que aparece en el snippet.

Generando la Web API Key en la configuración de Firebase para el ESP32

Hardware: lo mínimo indispensable

Para este proyecto no hay circuito que armar. Solo necesitas un ESP32 conectado al computador con un cable USB de datos (importante: que sea de datos y no solo de carga, error clásico que impide subir el código). En el IDE de Arduino elige la placa y el puerto correctos, y listo.

ESP32 conectado al computador por cable USB para el proyecto Firebase

Software: instalar la librería y entender el código

Instala desde el gestor de librerías del IDE de Arduino la librería Firebase_ESP_Client de Mobizt (muy mantenida y con miles de estrellas en GitHub). Después, revisa el sketch por partes.

Primero, las librerías y cabeceras. Los archivos TokenHelper.h y RTDBHelper.h vienen incluidos con la librería de Mobizt:

C++ 
#include <WiFi.h>
#include <Firebase_ESP_Client.h>
#include "addons/TokenHelper.h"
#include "addons/RTDBHelper.h"

Luego, las credenciales y los objetos de Firebase. Reemplaza el SSID, la contraseña de tu WiFi, la API Key y la Database URL por los tuyos:

C++ 
#define WIFI_SSID "your_ssid"
#define WIFI_PASSWORD "your_password"
#define API_KEY "your_api_key"
#define DATABASE_URL "your_database_url"
FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig config;

El setup() conecta al WiFi, carga las credenciales en el objeto de configuración, hace el registro anónimo e inicia Firebase. Todo esto corre una sola vez al encender la placa:

C++ 
void setup() {
Serial.begin(115200);
// Connect to Wi-Fi
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.print("Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
  Serial.print(".");
  delay(300);
}
Serial.println();
Serial.print("Connected with IP: ");
Serial.println(WiFi.localIP());
Serial.println();
// Assign the API key (required)
config.api_key = API_KEY;
// Assign the RTDB URL (required)
config.database_url = DATABASE_URL;
// Sign up as an anonymous user (easiest for testing)
if (Firebase.signUp(&config, &auth, "", "")) {
  Serial.println("Firebase SignUp Successok");
} else {
  Serial.printf("%s\n", config.signer.signupError.message.c_str());
}
// Assign the callback function for the long running token generation task
config.token_status_callback = tokenStatusCallback;
// Initialize the Firebase library
Firebase.begin(&config, &auth);
Firebase.reconnectWiFi(true);
Serial.println("--- Setup Complete ---");
Serial.println("Type something in the Serial Monitor and press Enter:");
}

El loop() revisa que Firebase esté listo y que su token no haya expirado; cuando escribes algo en el monitor serial, lo empuja a la ruta /serialData/message de la RTDB:

C++ 
void loop() {
 // Check if Firebase is ready and if there is data in the Serial Monitor
 if (Firebase.ready() && Serial.available() > 0) {

   // Read the incoming string until a newline character
   String inputData = Serial.readStringUntil('\n');
   inputData.trim(); // Remove any accidental spaces or newline characters
   if (inputData.length() > 0) {
     Serial.print("Sending to Firebase: ");
     Serial.println(inputData);
     // Send the string to the database path "/serialData/message"
     if (Firebase.RTDB.setString(&fbdo, "/serialData/message", inputData)) {
       Serial.println("Data sent successfully!");
       Serial.println("Path: " + fbdo.dataPath());
       Serial.println("Type: " + fbdo.dataType());
     } else {
       Serial.print("Failed to send data. Reason: ");
       Serial.println(fbdo.errorReason());
     }
     Serial.println("-------------------------------------");
   }
 }
}

Prueba: ver los datos llegar en vivo

Sube el código, abre el monitor serial y deja también abierta la pestaña Data de la RTDB en el navegador. Escribe cualquier texto en el monitor serial y presiona Enter: apenas lo haces, el dato aparece reflejado en la base de datos de Firebase. Si sale "Data sent successfully!", ya tienes tu ESP32 hablando con la nube, gratis.

Datos del ESP32 reflejados al instante en la Realtime Database de Firebase

Solución de problemas frecuentes

  • El código no sube / error de upload: el ESP32 no entró en modo flasheo o el cable está flojo. Mantén presionado el botón BOOT cuando aparezca "Connecting..." y revisa que el cable sea de datos.
  • Error de token 400 / INVALID_EMAIL: la autenticación anónima está deshabilitada. Actívala en Authentication > Sign in method > Anonymous.
  • Failed to send data. Reason: Permission denied: las reglas de la RTDB bloquean la escritura. Pon .read y .write en true en la pestaña Rules (solo para pruebas).

Variantes y mejoras

Enviar texto del monitor serial es solo el "hola mundo". Con la misma base, puedes escalar el proyecto:

  • Estación de datos con sensor real: reemplaza el input del serial por un DHT22 y sube temperatura y humedad cada cierto tiempo con Firebase.RTDB.setFloat(...). En pocas líneas tienes un registrador de clima en la nube.
  • Dashboard web en tiempo real: crea una página simple con el SDK web de Firebase que lea la misma ruta y grafique los valores en vivo. Como la RTDB emite eventos de cambio, el gráfico se actualiza solo, sin recargar.
  • Cierra la base para producción: las reglas en true dejan tu base abierta al mundo. Para un proyecto real, cambia a reglas basadas en el UID anónimo ("auth.uid !== null") para que solo dispositivos autenticados escriban.

Personalización para Chile

Este proyecto se arma con componentes que consigues en Chile en MechatronicStore:

  • Placa ESP32 DevKit. cualquier variante DevKit sirve; solo elige la placa y el puerto correctos en el IDE.
  • Cable USB de datos micro USB. asegúrate de que sea de datos, no solo de carga.

Firebase es gratis en su plan Spark, así que el único costo del proyecto es el hardware. Si en otros tutoriales ves placas "Sparkfun" o "Adafruit", el ESP32 DevKit genérico cumple exactamente la misma función a una fracción del precio.

Recursos

Versión chilena con componentes en stock local en MechatronicStore. Contenido inspirado en el tutorial original de Circuit Digest y re escrito con contexto y explicaciones propias.