Fase 4: FreeRTOS y Conectividad IoT

📖 Teoría a Estudiar

El Framework ESP-IDF

El IoT Development Framework (ESP-IDF) es el entorno oficial de Espressif. A diferencia de programar el ESP32 en el entorno de Arduino (que esconde todo bajo capas de abstracción orientadas a hobbistas), ESP-IDF es C/C++ puro, profesional y Bare-Metal-Like. Lo más importante: ESP-IDF está construido sobre FreeRTOS de forma nativa.

Al programar tu ESP32 con ESP-IDF, tu máquina de Gas LP pasa a tener dos sistemas operativos en tiempo real (RTOS) ejecutándose en paralelo: El del STM32 (dedicado a la Metrología y Válvulas) y el del ESP32 (dedicado a la Criptografía, WiFi y AWS).

El Adiós al "String Parsing"

El gran problema del Firmware AT es el Overhead de Parsing. El STM32 tenía que gastar recursos en armar cadenas de texto largas (ej. AT+MQTTPUB=0,"tema","datos",1,0), enviarlas por UART, y luego leer un montón de caracteres inútiles esperando encontrar la palabra OK. Si había ruido eléctrico, la palabra OK se corrompía y la FSM fallaba.

En nuestra nueva arquitectura, el STM32 y el ESP32 hablarán mediante un Protocolo Binario Serializado (como Protobuf o simples C Structs empaquetados). El STM32 enviará un paquete de 20 bytes en crudo por SPI o UART. El ESP32, corriendo su propio código en C, recibirá esos bytes directamente a una estructura de memoria, ensamblará el JSON internamente, lo cifrará y lo subirá a MQTT.

⚙️ Ejercicios Prácticos

Configuración de Entorno: Para programar nativamente el ESP32, debes abandonar el ST-Link por un momento y utilizar un cable USB directo al módulo ESP32, o un adaptador UART-TTL conectado a los pines TX0/RX0 y el pin EN/BOOT. Instalaremos el IDE de Espressif (extensión oficial de ESP-IDF para VS Code).

Ejercicio 1: A diferencia de Arduino donde todo empieza en `setup()`, en ESP-IDF (al basarse en FreeRTOS) todo comienza en `app_main()`. Escribiremos el "Hola Mundo" de la arquitectura industrial: Inicializar el NVS (Memoria no volátil), que es un paso obligatorio en ESP-IDF antes de poder usar el hardware de WiFi.


/**
 * @file main.c (ESP-IDF)
 * @brief Punto de entrada nativo para el Coprocesador IoT ESP32
 */

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "nvs_flash.h" // Obligatorio para drivers de red

// =======================================================
// PUNTO DE ENTRADA DEL ESP32 (Equivalente al main de STM32)
// =======================================================
// En ESP-IDF, 'app_main' es simplemente una Tarea de FreeRTOS 
// generada automáticamente por el sistema al arrancar.
void app_main(void)
{
    printf("==========================================\n");
    printf("[ESP32] Coprocesador de Red Iniciado\n");
    printf("[ESP32] Arquitectura Gas LP - Fase 4.1\n");
    printf("==========================================\n");

    // 1. Imprimir diagnóstico de hardware (Opcional, pero profesional)
    esp_chip_info_t chip_info;
    esp_chip_info(&chip_info);
    printf("Silicio: Modelo ESP32, Cores: %d, Rev: %d\n", chip_info.cores, chip_info.revision);

    // 2. INICIALIZACIÓN DEL NVS (Non-Volatile Storage)
    // El driver de WiFi de Espressif necesita obligatoriamente el NVS 
    // para guardar datos de calibración de radiofrecuencia (RF).
    // Sin esto, el WiFi simplemente crasheará.
    
    esp_err_t ret = nvs_flash_init();
    
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        // Si la partición NVS está corrupta o truncada (frecuente en flasheos nuevos),
        // la borramos físicamente y volvemos a intentar inicializarla.
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret); // Macro que aborta el programa si algo sale mal

    printf("[ESP32] NVS Inicializado con éxito. Listo para drivers.\n");

    // 3. Simulación del Bucle Principal del Coprocesador
    // Aquí es donde en el futuro (Días 222+) arrancaremos las Tareas
    // de conexión WiFi, MQTT, y la escucha de binarios desde el STM32.
    while (1) {
        // Yield para que el Watchdog del ESP32 no nos reinicie.
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

🚀 Avance del Proyecto Tesis: Despachador de Gas LP

Objetivo del día: Migración a Cómputo Distribuido y Separación de Preocupaciones (Separation of Concerns).

Usar comandos AT está bien para prototipos de universidad. Sin embargo, en un producto comercial, si el Firmware AT sufre un error de decodificación o el servidor de la nube cambia un protocolo, tienes que reescribir la pesada FSM de tu STM32. Además, procesar cadenas JSON complejas requiere miles de ciclos de reloj que tu microcontrolador debería estar invirtiendo en monitorear la válvula de cierre de gas con precisión de microsegundos.

Al migrar a **ESP-IDF Nativo**, has elevado la arquitectura de tu máquina a un sistema de Cómputo Distribuido. Ahora tienes un procesador maestro de 84 MHz (STM32) dedicado al 100% a la Metrología y la Seguridad Física (SIL), y un procesador secundario de 240 MHz (ESP32) dedicado exclusivamente a soportar la brutal carga criptográfica y el flujo asíncrono de Internet. Se comunicarán entre sí usando una ráfaga binaria pura por SPI o UART. Si mañana decides migrar de AWS a Google Cloud, solo actualizas el código del ESP32; la máquina de estados metrológica del STM32 se mantiene inalterada. Es la modularidad en su máxima expresión, la misma arquitectura utilizada en componentes aeroespaciales y automotrices de alta gama.

📝 Resumen del Día

El uso de módulos de comunicación controlados por Comandos AT es útil para un desarrollo rápido (Time-to-Market), pero introduce un Overhead inaceptable de análisis de cadenas (String Parsing) y consumo asíncrono de CPU en el microcontrolador principal.
ESP-IDF (Espressif IoT Development Framework) es el SDK oficial escrito en C puro, y está construido nativamente sobre FreeRTOS. Programar el ESP32 con ESP-IDF permite explotar sus 2 procesadores a 240MHz y su aceleración criptográfica por hardware.
En la nueva **Arquitectura de Coprocesador**, la creación del JSON y la lógica de reconexión MQTT se transfieren físicamente al silicio del ESP32. El STM32 actúa como cerebro metrológico puro, comunicando variables en crudo (Estructuras Binarias de C) hacia el módulo ESP32.
El primer requisito ineludible en cualquier programa ESP-IDF que utilice redes inalámbricas es la inicialización del NVS (Non-Volatile Storage) mediante la función nvs_flash_init(), la cual previene fallos del driver de radiofrecuencia (RF Calibration Data).