Fase 4: FreeRTOS y Conectividad IoT

📖 Teoría a Estudiar

El Protocolo WebSocket (WS/WSS)

A pesar del nombre, WebSockets no es HTTP. Es un protocolo independiente diseñado para superar la ineficiencia de HTTP en transmisiones en tiempo real.

El ciclo de vida de un WebSocket consta de dos fases:

1. El Handshake (Apretón de Manos): El celular se conecta al ESP32 haciendo una petición HTTP normal, pero le inyecta un encabezado especial: Connection: Upgrade y Upgrade: websocket. Le está diciendo a tu ESP32: "Dejemos de hablar HTTP y cambiemos a un protocolo más rápido".
2. El Túnel Bi-direccional (Full-Duplex): Si el ESP32 acepta, responde HTTP 101 Switching Protocols. En ese instante, HTTP "muere". La conexión se convierte en un tubo directo de sockets TCP (como el UART). Ya no hay encabezados masivos ni peticiones "GET". El ESP32 puede disparar datos (Frames) al celular en cualquier milisegundo sin que el celular se los pida.

El Reto en FreeRTOS: Async Push

En el framework ESP-IDF, el Servidor HTTP corre en una Tarea de FreeRTOS (Core 0). Pero las ventas fluyen desde tu STM32 hacia la Tarea UART (Core 1). No puedes simplemente enviar un paquete al socket del celular desde la tarea UART porque causarías un Crash de concurrencia. Debes utilizar la función httpd_ws_send_frame_async(), que delega la escritura del paquete de forma segura a la Tarea del Servidor Web.

⚙️ Ejercicios Prácticos

Circuito Lógico: Recordemos el Dual-Core (Día 223). El STM32 envía las tramas de venta constante por UART. La Tarea UART (Core 1) las recibe, y las pasa mediante una Queue hacia el Core 0. El Core 0 ahora no solo las mandará a AWS, sino que hará un "Broadcast" (Difusión) empujándolas a todos los celulares conectados localmente por WebSockets.

Ejercicio 1: Registraremos un URI de tipo WebSocket en nuestro `esp_http_server` y crearemos la función asíncrona para inyectar datos en la conexión desde otra Tarea de FreeRTOS.

/**
 * @file ws_telemetry.c
 * @brief Servidor WebSocket para Streaming Local Zero-Latency
 */

#include <string.h>
#include "esp_http_server.h"

// Variables Globales para WebSockets
static httpd_handle_t global_server = NULL;
static int ws_client_fd = -1; // Guardamos el "File Descriptor" del celular conectado

// =======================================================
// 1. MANEJADOR DEL WEBSOCKET (URI Handler)
// =======================================================
esp_err_t websocket_handler(httpd_req_t *req) {
    
    // Fase 1: El Handshake (La primera conexión)
    if (req->method == HTTP_GET) {
        printf("[WS] ¡Celular Conectado! Handshake 101 completado.\n");
        // Guardamos el ID de este cliente para poder "Empujarle" datos más tarde
        ws_client_fd = httpd_req_to_sockfd(req);
        return ESP_OK;
    }

    // Fase 2: Recepción de datos (Si el celular envía comandos a la máquina)
    httpd_ws_frame_t ws_pkt;
    uint8_t buf[128] = {0};
    memset(&ws_pkt, 0, sizeof(httpd_ws_frame_t));
    ws_pkt.type = HTTPD_WS_TYPE_TEXT;
    ws_pkt.payload = buf;

    // Leemos lo que nos mandó el navegador JS
    esp_err_t ret = httpd_ws_recv_frame(req, &ws_pkt, 128);
    if (ret == ESP_OK) {
        printf("[WS] Recibido de celular: %s\n", ws_pkt.payload);
        // Aquí podríamos recibir comandos manuales como {"cmd":"corte_valvula"}
    }
    return ret;
}

// =======================================================
// 2. FUNCIÓN DE DIFUSIÓN (ASYNC PUSH)
// Llamada desde la Tarea de UART (Core 1) cuando el STM32 manda una trama nueva
// =======================================================
/**
 * @brief Empuja un texto plano (JSON) directamente al celular conectado.
 */
void Transmitir_Telemetria_WS(const char* json_data) {
    
    // Si el servidor web no está activo o no hay nadie viendo el Dashboard, abortamos
    if (global_server == NULL || ws_client_fd == -1) return;

    httpd_ws_frame_t ws_pkt;
    memset(&ws_pkt, 0, sizeof(httpd_ws_frame_t));
    ws_pkt.payload = (uint8_t*)json_data;
    ws_pkt.len = strlen(json_data);
    ws_pkt.type = HTTPD_WS_TYPE_TEXT;

    // MAGIA ESP-IDF: No podemos usar httpd_ws_send_frame normal porque esta función 
    // está siendo llamada por la Tarea de UART (Core 1), y chocaríamos con la 
    // memoria de la Tarea HTTPD (Core 0).
    // Usamos _async, el cual encola el trabajo de forma Thread-Safe hacia el Core 0.
    
    esp_err_t ret = httpd_ws_send_frame_async(global_server, ws_client_fd, &ws_pkt);
    
    if (ret != ESP_OK) {
        // Si el envío falla, asumimos que el celular se alejó o se apagó
        printf("[WS] El cliente se desconectó.\n");
        ws_client_fd = -1;
    }
}

// =======================================================
// 3. REGISTRO EN EL SERVIDOR (Inicialización)
// =======================================================
void registrar_websocket(httpd_handle_t server) {
    global_server = server; // Guardamos el puntero global

    httpd_uri_t ws_uri = {
        .uri        = "/ws",
        .method     = HTTP_GET,
        .handler    = websocket_handler,
        .user_ctx   = NULL,
        .is_websocket = true // <--- Obligatorio para activar el protocolo 101
    };
    httpd_register_uri_handler(server, &ws_uri);
    printf("[WS] Socket Bidireccional Registrado en ruta /ws\n");
}
        

📝 Resumen del Día

• **HTTP GET (Polling)** es ineficiente para telemetría en tiempo real. Abre y cierra conexiones TCP constantemente, saturando la RAM del ESP32 con metadatos y sobrecargando la red WiFi local (Overhead).
• El estándar **WebSocket (WS)** comienza como una petición HTTP convencional, pero al detectarse las cabeceras de Upgrade, el Servidor responde con HTTP 101 Switching Protocols. La conexión HTTP muere y nace un túnel persistente, bidireccional (Full-Duplex) montado sobre TCP.
• En ESP-IDF, al registrar un manejador URI con la bandera is_websocket = true, el framework procesa automáticamente el complejo Handshake criptográfico de WS.
• El reto en arquitecturas FreeRTOS (y doble núcleo) es el Push Asíncrono. Dado que el flujo de gas se detecta en la Tarea UART (Core 1), no se debe invocar funciones de transmisión directamente sobre el socket que pertenece a la Tarea HTTPD (Core 0).
• La API de ESP-IDF resuelve esto brillantemente con httpd_ws_send_frame_async(), una función Thread-Safe que delega la transmisión al núcleo correcto sin causar conflictos de memoria (Race Conditions).