Bloque 4.3: Integración con APIs y Servicios Web

1. ¿Qué es una API?

API son las siglas de Application Programming Interface (Interfaz de Programación de Aplicaciones). En términos simples, una API es un conjunto de reglas y definiciones que permite que dos aplicaciones o sistemas se comuniquen entre sí.

Imagina una API como un mesero en un restaurante. Tú (el cliente) le dices al mesero (la API) lo que quieres del menú (los datos o una acción). El mesero lleva tu pedido a la cocina (el servidor/backend), la cocina prepara lo que pediste, y el mesero te trae la comida (la respuesta) de vuelta. Tú no necesitas saber cómo se prepara la comida, solo necesitas saber cómo pedirla.

1.1. Analogía: La API como Cajero Automático (ATM)

Para usar un cajero automático:

1. Interfaz Común: Todos los cajeros tienen botones y una pantalla similares. Sabes intuitivamente cómo insertar la tarjeta, ingresar el PIN y seleccionar "Retiro". Esta interfaz estandarizada es como una API.
2. Reglas Definidas: Solo puedes retirar dinero si tienes fondos. El cajero no te permite simplemente tomar dinero; sigue reglas estrictas. Una API también tiene reglas sobre qué solicitudes puede aceptar y cómo deben formularse.
3. Intermediario: El cajero no almacena tu dinero. Se comunica con el banco (el servidor) para verificar tu saldo y autorizar la transacción.
4. Respuesta Estructurada: Si la transacción es exitosa, recibes dinero en efectivo (la respuesta). Si hay un error, el cajero muestra un mensaje de error en la pantalla.

1.2. Tipos Comunes de APIs

En el contexto de IoT y microcontroladores, las REST APIs son las más utilizadas debido a su simplicidad y eficiencia.

2. APIs y Servicios Web en el Contexto de un ESP32

Cuando hablamos de un microcontrolador ESP32 "usando una API", normalmente nos referimos a que el ESP32 actúa como un cliente HTTP que hace solicitudes a un servidor web (el backend de una aplicación o servicio) que expone una API REST.

2.1. El ESP32 como Cliente Web

El ESP32 tiene conectividad WiFi integrada, lo que le permite conectarse a internet. Utilizando librerías como HTTPClient (incluida en el núcleo de ESP32 para Arduino), puede enviar solicitudes HTTP GET, POST, PUT, etc. a un servidor web.

2.2. ¿Por qué Integrar con APIs/Servicios Web?

Conectar tu ESP32 a servicios web abre un mundo de posibilidades:

• Almacenamiento de Datos: En lugar de almacenar datos localmente (con poca capacidad), puedes enviarlos a una base de datos en la nube (como Firebase, MySQL remoto).
• Visualización de Datos: Usar servicios como ThingSpeak, Ubidots o Grafana para crear dashboards en tiempo real.
• Acceso Remoto: Controlar tu ESP32 desde cualquier lugar del mundo a través de una aplicación web que se comunique con él (a menudo a través de un broker MQTT o un servidor intermedio).
• Integración con Otros Servicios:
  • Enviar un correo electrónico o un mensaje de Slack cuando un sensor detecta una condición específica.
  • Obtener datos del clima para ajustar el comportamiento de un sistema de riego.
  • Consultar el precio actual de la electricidad para programar el uso de electrodomésticos.
• Machine Learning/IA: Enviar datos a servicios de análisis en la nube para detectar patrones o anomalías.

2.3. Ejemplo Conceptual: Sistema de Alerta de Clima

Imagina un sistema que monitorea la temperatura con un ESP32 y envía una alerta si la temperatura supera un umbral.

1. El ESP32 lee el sensor de temperatura.
2. Si la temperatura es alta, el ESP32 hace una solicitud POST a una API web personalizada (por ejemplo, https://mi-api-alertas.com/enviar_alerta) con los datos de la temperatura.
3. El servidor de la API recibe la solicitud, procesa los datos y envía un correo electrónico o notificación push a través de otro servicio (como SendGrid o Firebase Cloud Messaging).

En este escenario, la API web actúa como intermediaria y punto de integración entre el dispositivo físico (ESP32) y el servicio de notificación (correo/telefono).

3. Realizando Solicitudes HTTP desde un ESP32

Veamos cómo se hace esto en la práctica con el ESP32 y el entorno de Arduino. La librería HTTPClient simplifica enormemente el proceso.

3.1. Haciendo una Solicitud GET Simple

Una solicitud GET se usa típicamente para obtener datos de un servidor. Un ejemplo común es consultar un servicio de clima.

Materiales Necesarios

• 1 Placa ESP32 (NodeMCU, DevKit, etc.)

Código del Sketch (Ejemplo de GET)

Este ejemplo consulta una API pública que devuelve un JSON con un "hecho" aleatorio sobre gatos.

 Copiar/*
 * Ejemplo de Solicitud HTTP GET con ESP32
 * Consulta una API pública de hechos de gatos.
 */

#include <WiFi.h>
#include <HTTPClient.h>

// --- Configuración de WiFi ---
const char* ssid = "TU_SSID";
const char* password = "TU_CONTRASEÑA";

void setup() {
  Serial.begin(115200);
  delay(1000); // Breve pausa antes de comenzar

  // Conectamos a la red WiFi
  Serial.print("Conectando a ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("¡Conectado a la red WiFi!");
  Serial.print("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  // Verificamos que estemos conectados
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;

    // 1. Especificamos el servidor y el endpoint
    http.begin("http://catfact.ninja/fact"); // URL de la API

    // 2. Enviamos la solicitud GET
    int httpResponseCode = http.GET();

    // 3. Procesamos la respuesta
    if (httpResponseCode > 0) {
      Serial.print("Código de respuesta HTTP: ");
      Serial.println(httpResponseCode);

      if (httpResponseCode == 200) { // 200 = OK
        // 4. Obtenemos el cuerpo de la respuesta
        String payload = http.getString();
        Serial.println("Respuesta JSON:");
        Serial.println(payload);
        Serial.println("--------------------");
      }
    } else {
      Serial.print("Error en la solicitud GET. Código: ");
      Serial.println(httpResponseCode);
    }

    // 5. Cerramos la conexión
    http.end();
  } else {
    Serial.println("Error: No conectado a WiFi");
  }

  // Esperamos 10 segundos antes de la próxima solicitud
  delay(10000);
}

Explicación del Código

• Conexión WiFi: Igual que en ejemplos anteriores, conectamos el ESP32 a la red.
• #include <HTTPClient.h>: Incluimos la librería necesaria para hacer solicitudes HTTP.
• HTTPClient http;: Creamos un objeto HTTPClient para manejar la solicitud.
• http.begin("URL");: Inicializamos el cliente HTTP con la URL del endpoint de la API.
• int httpResponseCode = http.GET();: Enviamos la solicitud GET y almacenamos el código de respuesta HTTP (200 para éxito, 404 para no encontrado, etc.).
• if (httpResponseCode == 200): Verificamos si la solicitud fue exitosa.
• String payload = http.getString();: Si fue exitosa, obtenemos el cuerpo de la respuesta como un String.
• http.end();: Es crucial cerrar la conexión HTTP después de usarla para liberar recursos.

La respuesta de esta API es un string JSON como: {"fact":"Los gatos duermen entre 12 y 16 horas al día.","length":49}.

3.2. Haciendo una Solicitud POST para Enviar Datos

Una solicitud POST se usa típicamente para enviar datos al servidor, como los valores de sensores.

Código del Sketch (Ejemplo de POST)

Este ejemplo envía una lectura de temperatura simulada a un servicio web. Para este ejemplo, usaremos un servicio de prueba como httpbin.org que simplemente devuelve lo que le enviamos.

 Copiar/*
 * Ejemplo de Solicitud HTTP POST con ESP32
 * Envía datos simulados de un sensor a un servicio web.
 */

#include <WiFi.h>
#include <HTTPClient.h>

// --- Configuración de WiFi ---
const char* ssid = "TU_SSID";
const char* password = "TU_CONTRASEÑA";

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

  // Conectamos a la red WiFi
  Serial.print("Conectando a ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("¡Conectado a la red WiFi!");
}

void loop() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;

    // 1. Especificamos el endpoint POST
    http.begin("https://httpbin.org/post");

    // 2. (Opcional) Establecemos encabezados
    http.addHeader("Content-Type", "application/json");

    // 3. Preparamos los datos a enviar (en formato JSON)
    // Simulamos una lectura de sensor
    float temperatura = 22.5 + (random(0, 100) / 10.0); // Valor entre 22.5 y 32.5
    String jsonPayload = "{\"sensor\":\"DHT22\",\"temperatura\":" + String(temperatura, 2) + ",\"unidad\":\"Celsius\"}";

    Serial.print("Enviando datos: ");
    Serial.println(jsonPayload);

    // 4. Enviamos la solicitud POST con los datos
    int httpResponseCode = http.POST(jsonPayload);

    // 5. Procesamos la respuesta
    if (httpResponseCode > 0) {
      Serial.print("Código de respuesta HTTP: ");
      Serial.println(httpResponseCode);

      if (httpResponseCode == 200) {
        String response = http.getString();
        Serial.println("Respuesta del servidor:");
        Serial.println(response);
        Serial.println("--------------------");
      }
    } else {
      Serial.print("Error en la solicitud POST. Código: ");
      Serial.println(httpResponseCode);
    }

    // 6. Cerramos la conexión
    http.end();
  } else {
    Serial.println("Error: No conectado a WiFi");
  }

  // Esperamos 15 segundos antes de la próxima solicitud
  delay(15000);
}

Explicación del Código

• http.addHeader("Content-Type", "application/json");: Antes de enviar el POST, añadimos un encabezado indicando que el contenido es JSON. Esto es importante para que el servidor sepa cómo interpretar los datos.
• String jsonPayload = ...: Creamos un string en formato JSON con los datos del sensor. Es crucial formatearlo correctamente.
• int httpResponseCode = http.POST(jsonPayload);: Enviamos la solicitud POST, pasando el string con los datos como argumento. La librería se encarga de calcular la longitud del contenido y enviarlo en el cuerpo de la solicitud.

Este ejemplo demuestra cómo un dispositivo puede "publicar" sus datos en un servicio web para su posterior procesamiento, almacenamiento o análisis.

3.3. Manejo de Respuestas JSON

Las APIs suelen devolver datos en formato JSON. Aunque podemos imprimir el string JSON completo, es más útil poder extraer valores específicos. Para esto, se pueden usar librerías como ArduinoJson.

Instalando ArduinoJson

Ve al Gestor de Librerías del Arduino IDE (Herramientas > Administrar Bibliotecas...) y busca e instala ArduinoJson por Benoit Blanchon.

Código del Sketch (Parseando JSON)

Modificamos el ejemplo de GET para extraer solo el "hecho" del JSON recibido.

 Copiar/*
 * Ejemplo de Parseo de JSON con ESP32 y ArduinoJson
 * Extrae información de una respuesta JSON de la API de hechos de gatos.
 */

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h> // Incluimos la librería ArduinoJson

// --- Configuración de WiFi ---
const char* ssid = "TU_SSID";
const char* password = "TU_CONTRASEÑA";

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

  Serial.print("Conectando a ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("¡Conectado a la red WiFi!");
}

void loop() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin("http://catfact.ninja/fact");

    int httpResponseCode = http.GET();

    if (httpResponseCode > 0 && httpResponseCode == 200) {
      String payload = http.getString();
      Serial.println("JSON Recibido: " + payload);

      // --- Parseo del JSON ---
      // 1. Creamos un documento JSON. El tamaño debe ser suficiente para la respuesta.
      //    Puedes usar la herramienta de ArduinoJson: https://arduinojson.org/v6/assistant/
      DynamicJsonDocument doc(1024); 

      // 2. Deserializamos el string JSON en el documento
      DeserializationError error = deserializeJson(doc, payload);

      if (error) {
        Serial.print("Error de deserialización: ");
        Serial.println(error.f_str());
        return;
      }

      // 3. Extraemos los valores
      const char* fact = doc["fact"]; // Obtiene el valor de la clave "fact"
      int length = doc["length"];     // Obtiene el valor de la clave "length"

      // 4. Imprimimos los valores extraídos
      Serial.println("--- Datos Extraídos ---");
      Serial.print("Hecho: ");
      Serial.println(fact);
      Serial.print("Longitud: ");
      Serial.println(length);
      Serial.println("----------------------");

    } else {
      Serial.print("Error en la solicitud GET. Código: ");
      Serial.println(httpResponseCode);
    }

    http.end();
  } else {
    Serial.println("Error: No conectado a WiFi");
  }

  delay(15000);
}

Explicación del Código

• #include <ArduinoJson.h>: Incluimos la librería ArduinoJson.
• DynamicJsonDocument doc(1024);: Creamos un documento JSON con un tamaño estimado (1024 bytes). Para aplicaciones más complejas, puedes usar la herramienta de asistente de ArduinoJson para calcular el tamaño necesario.
• DeserializationError error = deserializeJson(doc, payload);: Convertimos el string JSON (payload) en una estructura de datos manejable dentro del doc. Si hay un error en el formato JSON, se captura aquí.
• const char* fact = doc["fact"];: Accedemos directamente al valor asociado con la clave "fact" en el JSON. ArduinoJson hace que esto sea muy intuitivo.

Este proceso de parseo es fundamental para trabajar con datos estructurados provenientes de APIs.

4. Proyecto Integrador: Sistema de Clima Local con Node-RED

Vamos a crear un proyecto más completo que combine todo lo aprendido. Este sistema leerá temperatura y humedad de un sensor DHT22 conectado a un ESP32, expondrá una API simple para consultar el último valor leído desde un navegador web, y enviará los datos a Node-RED, una plataforma de programación visual para el Internet de las Cosas (IoT) y más.

4.1. Arquitectura del Proyecto

1. ESP32 (Servidor): Lee el sensor DHT22 y actúa como servidor HTTP para servir datos a navegadores (API de lectura) en formato HTML o JSON.
2. Navegador Web: Hace una solicitud GET al ESP32 para obtener el último valor de temperatura/humedad directamente.
3. ESP32 (Cliente): Actúa como cliente HTTP para enviar datos en formato JSON a un endpoint en Node-RED.
4. Node-RED: Recibe los datos del ESP32, los procesa (en este caso, simplemente los muestra en el panel de debug, pero se pueden añadir nodos para almacenarlos, graficarlos, etc.).

4.2. Parte 1: Configurar Node-RED para recibir datos

Instalación de Node-RED:

Node-RED es una herramienta de programación visual que se puede ejecutar en tu computadora, una Raspberry Pi o en la nube. Aquí te muestro cómo instalarlo localmente usando npm (Node Package Manager).

1. Instalar Node.js: Ve a https://nodejs.org/ y descarga e instala la versión LTS para tu sistema operativo.
2. Instalar Node-RED: Abre una terminal o consola de comandos y ejecuta:

   npm install -g node-red

3. Iniciar Node-RED: En la terminal, ejecuta:

   node-red

   Node-RED se iniciará y podrás acceder a su editor en tu navegador en http://localhost:1800.

Configurando un Flujo Simple en Node-RED

1. Accede al Editor: Abre tu navegador y ve a http://localhost:1800.
2. Añade un Nodo "http in":
   • En el panel izquierdo, busca el nodo http.
   • Arrastra el nodo http in al flujo principal.
   • Haz doble clic en el nodo para configurarlo:
     • Method: Selecciona post.
     • URL: Escribe /sensor-data.
     • Haz clic en Done.
3. Añade un Nodo "Debug":
   • Busca el nodo debug en el panel izquierdo.
   • Arrástralo al flujo.
   • Conecta la salida del nodo http in a la entrada del nodo debug (arrastra desde un puerto a otro).
4. Despliega el Flujo:
   • Haz clic en el botón Deploy en la esquina superior derecha.

Ahora Node-RED tiene un endpoint simple (http://TU_IP_LOCAL:1800/sensor-data) que escucha solicitudes POST y muestra los datos recibidos en el panel de Debug.

Materiales

• 1 Placa ESP32
• 1 Sensor DHT22
• Protoboard y cables
• Computadora con Node.js y Node-RED instalados

Código del Sketch (Cliente HTTP para enviar datos a Node-RED)

 Copiar/*
 * Cliente HTTP para ESP32 con DHT22
 * Lee datos del sensor y los envía a un endpoint de Node-RED.
 */

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h> // Necesitamos JSON para enviar datos estructurados
#include <DHT.h>

// --- Configuración de WiFi ---
const char* ssid = "TU_SSID";
const char* password = "TU_CONTRASEÑA";

// --- Configuración de Node-RED ---
// Reemplaza con la IP de la computadora donde corre Node-RED
const char* nodered_server = "http://192.168.1.100";
const int nodered_port = 1800;
String endpoint = "/sensor-data";

// --- Configuración del Sensor DHT ---
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  dht.begin();
  
  // Conectamos a la red WiFi
  Serial.print("Conectando a ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("¡Conectado a la red WiFi!");
  Serial.print("Dirección IP del ESP32: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  if (WiFi.status() == WL_CONNECTED) {
    // Leemos datos del sensor
    float h = dht.readHumidity();
    float t = dht.readTemperature();

    // Verificamos si las lecturas son válidas
    if (isnan(h) || isnan(t)) {
      Serial.println("¡Error leyendo el sensor DHT!");
      delay(10000);
      return;
    }

    Serial.print("Temperatura: ");
    Serial.print(t);
    Serial.print(" °C, Humedad: ");
    Serial.print(h);
    Serial.println(" %");

    // --- Preparamos los datos en formato JSON ---
    DynamicJsonDocument doc(256);
    doc["sensor"] = "DHT22";
    doc["temperatura"] = t;
    doc["humedad"] = h;
    doc["unidad_temp"] = "Celsius";
    doc["unidad_hum"] = "%";
    doc["timestamp"] = millis();

    String jsonData;
    serializeJson(doc, jsonData);

    // --- Enviamos datos a Node-RED ---
    HTTPClient http;
    String url = String(nodered_server) + ":" + nodered_port + endpoint;
    http.begin(url);
    http.addHeader("Content-Type", "application/json");

    int httpResponseCode = http.POST(jsonData);

    if (httpResponseCode > 0) {
      Serial.print("Código de respuesta HTTP: ");
      Serial.println(httpResponseCode);
      if (httpResponseCode == 200) {
        Serial.println("Datos enviados a Node-RED exitosamente.");
      }
    } else {
      Serial.print("Error al enviar datos. Código: ");
      Serial.println(httpResponseCode);
    }
    http.end();

  } else {
    Serial.println("Error: No conectado a WiFi");
  }

  delay(15000); // Enviamos datos cada 15 segundos
}

4.3. Parte 2: Exponer una API Simple desde el ESP32 (Servidor Web)

Ahora haremos que el ESP32 también actúe como un servidor web básico para servir sus propios datos.

Código del Sketch (Servidor Web)

 Copiar/*
 * ESP32 como Servidor Web
 * Lee datos del sensor y los sirve en una página web y en formato JSON.
 */

#include <WiFi.h>
#include <WebServer.h> // Librería para el servidor web
#include <DHT.h>

// --- Configuración de WiFi ---
const char* ssid = "TU_SSID";
const char* password = "TU_CONTRASEÑA";

// --- Configuración del Sensor DHT ---
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

// --- Configuración del Servidor Web ---
WebServer serverWeb(80); // El servidor escuchará en el puerto 80

// --- Variables para almacenar las últimas lecturas ---
float ultimaTemperatura = 0.0;
float ultimaHumedad = 0.0;

// --- Handler para la ruta raíz "/" ---
void handleRoot() {
  String html = "<!DOCTYPE html><html>";
  html += "<head><meta charset='UTF-8'><title>Datos del Sensor</title>";
  html += "<meta name='viewport' content='width=device-width, initial-scale=1.0'>";
  html += "<style>body{font-family: Arial, sans-serif; text-align: center; padding: 20px;}";
  html += "h1{color: #333;} .data{font-size: 24px; margin: 20px 0;}";
  html += ".temp{color: #ff6b6b;} .hum{color: #4ecdc4;}</style></head>";
  html += "<body>";
  html += "<h1>Datos del Sensor DHT22</h1>";
  html += "<div class='data'><span class='temp'>Temperatura: " + String(ultimaTemperatura, 2) + " °C</span></div>";
  html += "<div class='data'><span class='hum'>Humedad: " + String(ultimaHumedad, 2) + " %</span></div>";
  html += "<p><a href='/datos'>Ver datos en JSON</a> | Última actualización: " + String(millis() / 1000) + "s</p>";
  html += "</body></html>";

  serverWeb.send(200, "text/html", html);
}

// --- Handler para la ruta "/datos" (API JSON) ---
void handleDatos() {
  String json = "{";
  json += "\"temperatura\":" + String(ultimaTemperatura, 2) + ",";
  json += "\"humedad\":" + String(ultimaHumedad, 2) + ",";
  json += "\"unidad_temp\":\"Celsius\",";
  json += "\"unidad_hum\":\"%\",";
  json += "\"timestamp\":" + String(millis());
  json += "}";
  
  // Establecemos el encabezado Content-Type para JSON
  serverWeb.sendHeader("Content-Type", "application/json");
  serverWeb.send(200, "application/json", json);
}

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

  // Conectamos a la red WiFi
  Serial.print("Conectando a ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("¡Conectado a la red WiFi!");
  Serial.print("Dirección IP: ");
  Serial.println(WiFi.localIP());

  // --- Configuramos las rutas del servidor web ---
  serverWeb.on("/", handleRoot);    // Página principal HTML
  serverWeb.on("/datos", handleDatos); // API JSON
  serverWeb.onNotFound([]() {       // Página 404 para rutas no definidas
    serverWeb.send(404, "text/plain", "Página no encontrada");
  });

  // --- Iniciamos el servidor ---
  serverWeb.begin();
  Serial.println("Servidor HTTP iniciado");
}

void loop() {
  // --- Manejamos las solicitudes entrantes al servidor ---
  serverWeb.handleClient();

  // --- Lógica de lectura de datos (cada 5 segundos) ---
  static unsigned long lastRead = 0;
  if (millis() - lastRead > 5000) {
    lastRead = millis();

    // Leemos datos del sensor
    float h = dht.readHumidity();
    float t = dht.readTemperature();

    if (!isnan(h) && !isnan(t)) {
      ultimaTemperatura = t;
      ultimaHumedad = h;
      
      Serial.print("Temperatura: ");
      Serial.print(t);
      Serial.print(" °C, Humedad: ");
      Serial.print(h);
      Serial.println(" %");
    } else {
      Serial.println("¡Error leyendo el sensor DHT!");
    }
  }
}

Explicación del Código del Servidor

• #include <WebServer.h>: Incluimos la librería para crear un servidor web.
• WebServer serverWeb(80);: Creamos un objeto servidor que escuchará en el puerto 80 (puerto estándar para HTTP).
• serverWeb.on("/", handleRoot);: Definimos una "ruta". Cuando alguien accede a http://IP_DEL_ESP32/, se ejecutará la función handleRoot.
• handleRoot() y handleDatos(): Son funciones "handler" que definen qué contenido se debe servir para cada ruta. handleRoot genera una página HTML simple, mientras que handleDatos genera una respuesta JSON.
• serverWeb.begin();: Inicia el servidor web.
• serverWeb.handleClient();: Esta línea en el loop() es crucial. Le dice al servidor que revise si hay nuevas solicitudes de clientes web y las procese.

Cómo Probarlo

1. Carga el sketch del servidor en tu ESP32.
2. Abre el Monitor Serial para ver la dirección IP asignada (por ejemplo, 192.168.1.120).
3. Abre un navegador web en un dispositivo conectado a la misma red WiFi.
4. Ingresa la dirección IP en la barra de direcciones:
   • http://192.168.1.120/ te mostrará la página web con los datos.
   • http://192.168.1.120/datos te devolverá los datos en formato JSON.
5. Ejecuta el flujo de Node-RED y carga el sketch del cliente ESP32. Abre el panel de Debug en Node-RED para ver los datos que llegan desde el ESP32.

Este proyecto demuestra cómo un microcontrolador puede servir sus propios datos a través de una API web simple y cómo otro dispositivo (Node-RED en este caso) puede consumir esos datos.

5. Otras Plataformas y Servicios Populares

Además de las herramientas vistas, existen muchas otras plataformas que facilitan la integración con APIs y el desarrollo de aplicaciones IoT.

6. Galería de Videos Recomendados

7. Referencias y Lecturas Recomendadas

• Documentación de ArduinoJson - La guía oficial y herramientas para trabajar con JSON en Arduino/ESP.
• Random Nerd Tutorials: ESP32 HTTP GET and POST - Tutoriales prácticos y muy bien explicados.
• ThingSpeak - Plataforma de análisis de datos IoT con documentación y ejemplos.
• Fielding, R., & Reschke, J. (2014). RFC 7231: Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content. IETF. (Especificación oficial de HTTP, base de las REST APIs).