En la industria, el diseño arquitectónico dicta que el procesador que lee los sensores letales jamás debe ser el mismo que desencripta los paquetes Wi-Fi. Esto se llama Segregación de Dominios. El STM32 es tu Dominio de Misión Crítica (Real-Time). El módulo ESP32 es tu Dominio de Red (Best-Effort). Si un atacante satura el ESP32 enviándole miles de pings maliciosos (DDoS) hasta colgarlo, el STM32 no se entera y sigue cerrando la válvula con precisión de microsegundos.
No enviaremos los datos financieros usando peticiones HTTP simples. Usaremos MQTT (Message Queuing Telemetry Transport). HTTP requiere abrir y cerrar conexiones pesadas por cada ticket. MQTT mantiene una tubería constante y ligera (TCP Keep-Alive) con el servidor (Broker). Además, usaremos QoS 1 (At least once). Si el Despachador envía el ticket de venta a la oficina, el equipo guardará el ticket en su EEPROM y lo seguirá retransmitiendo sin cesar hasta que el servidor devuelva un paquete oficial de PUBACK (Acknowledgment).
Paso 1: El Protocolo Binario (Payload).
El STM32 no le envía cadenas de texto largas (como JSON) al ESP32 por UART, ya que el parseo de strings (ej. sprintf) fragmenta la RAM. El STM32 empaqueta un struct en C con formato binario estricto (Litros, Temperatura, Precio, CRC16) y se lo arroja por el puerto Serial. El ESP32 es quien gastará su RAM en convertir ese binario a un JSON pesado para AWS.
Paso 2: Heartbeat (Latido de Vida).
Cada 5 segundos, el ESP32 debe enviarle un byte específico por UART al STM32 (ej. 0xAA). Si el STM32 no recibe este "latido" durante 15 segundos, asume que la pila TCP del ESP32 colapsó o fue hackeada.
Paso 3: El Corte de Energía (Hardware Reset).
Al confirmar el colapso, el STM32 pone en nivel BAJO (0V) el pin EN (Enable) del ESP32 durante 500ms y lo vuelve a subir a ALTO (3.3V). Esto purga por completo la memoria RAM del chip de internet y lo obliga a arrancar en frío y reconectarse al Router, logrando la auto-sanación de la máquina.
El código a continuación corre en el STM32. Observa cómo delega el problema de internet, pero mantiene el poder físico sobre el chip esclavo.
/**
* @file iot_coprocessor_manager.c
* @brief Gestión del módulo ESP32 (Dominio de Red) desde el STM32 (Dominio Seguro)
*/
#include "stm32f4xx_hal.h"
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
// Pines Físicos (Configurados en KiCad)
#define ESP_EN_PORT GPIOB
#define ESP_EN_PIN GPIO_PIN_12
extern UART_HandleTypeDef huart2;
// Variables de monitoreo (Supervisadas por el RTOS Timer)
volatile uint32_t Last_Heartbeat_Tick = 0;
const uint32_t ESP32_TIMEOUT_MS = 15000; // 15 Segundos
// =========================================================================
// RECEPCIÓN DE LATIDO (HEARTBEAT) DESDE EL ESP32
// =========================================================================
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
// Si la interrupción UART recibió un paquete del ESP32
if(huart->Instance == USART2) {
Last_Heartbeat_Tick = HAL_GetTick(); // Alimentar el "Watchdog del ESP32"
// ... procesar el paquete recibido (Ej. Cambio de Precio) ...
}
}
// =========================================================================
// RUTINA DE AUTO-SANACIÓN DEL MÓDULO IoT (HARD RESET)
// =========================================================================
/**
* @brief Función ejecutada por la Tarea de Mantenimiento del STM32.
* Vigila si el coprocesador de internet sigue vivo.
*/
void Task_Check_IoT_Health(void) {
uint32_t time_since_last_beat = HAL_GetTick() - Last_Heartbeat_Tick;
if (time_since_last_beat > ESP32_TIMEOUT_MS) {
printf("\r\n[!] ADVERTENCIA: Coprocesador ESP32 no responde (Timeout).\r\n");
printf(" Ejecutando HARD RESET del Dominio de Red...\r\n");
// 1. Quitar alimentación / Activar pin de reinicio del ESP32 (EN = LOW)
HAL_GPIO_WritePin(ESP_EN_PORT, ESP_EN_PIN, GPIO_PIN_RESET);
// 2. Esperar a que los capacitores del módulo se descarguen
// Nota: Dentro del RTOS, se usa vTaskDelay() en lugar de HAL_Delay.
HAL_Delay(500);
// 3. Encender el ESP32 nuevamente (EN = HIGH)
HAL_GPIO_WritePin(ESP_EN_PORT, ESP_EN_PIN, GPIO_PIN_SET);
printf(" ESP32 Reiniciado en frío. Esperando asociación Wi-Fi...\r\n");
// Dar tiempo de gracia para arrancar (unos 5 segundos)
Last_Heartbeat_Tick = HAL_GetTick() + 5000;
}
}
// =========================================================================
// ENVÍO DE TICKET DE VENTA SEGURO
// =========================================================================
/**
* @brief Envía el bloque de datos al ESP32. El STM32 NO espera a que se suba a AWS.
*/
void Send_Transaction_To_Cloud(uint32_t volume_mL, uint32_t price_cents) {
// 1. Se empaqueta en una estructura binaria simple
uint8_t payload[16];
// ... [Copia de datos a payload] ...
// 2. Se inyecta al UART usando DMA (Direct Memory Access) para no bloquear la CPU.
HAL_UART_Transmit_DMA(&huart2, payload, sizeof(payload));
// El STM32 ya terminó su trabajo aquí. El ESP32 es el responsable de
// encriptar el 'payload' en TLS y usar MQTT QoS 1 para asegurar la entrega.
}
Objetivo del día: Telemetría Inmune a Fallos y Arquitectura Dual-Core (Micro-Servicios en Hardware).
En el Día 1 soñabas con un equipo inteligente. El instinto te decía que compraras un ESP32 o una Raspberry Pi, le conectaras el caudalímetro y un relé, y programaras todo en Python o C++ de Arduino. Afortunadamente, actuaste como Arquitecto. Si hubieras usado la Raspberry Pi para manejar el gas, la latencia impredecible de su sistema operativo Linux habría cerrado la electroválvula fracciones de segundo más tarde de lo debido en cada venta, regalando miles de litros de gas al año. Si hubieras usado el ESP32, un ataque cibernético a la red Wi-Fi de la gasolinera habría colapsado el núcleo de procesamiento, congelando las medidas de seguridad térmica de la API 54.
Al implementar la **Segregación de Dominios**, has convertido el defecto de las telecomunicaciones en una fortaleza. Tu Despachador de Gas LP opera exactamente como el hardware militar o aeroespacial. El STM32 manda. No sabe qué es el internet, ni le importa. Si tu placa ESP32 estalla o se quema, la máquina sigue despachando y cobrando gas con precisión matemática absoluta en modo "Offline". Y, mediante el ruteo del pin `Enable`, le has dado al STM32 la autoridad de apagar físicamente el chip Wi-Fi y reiniciarlo si detecta que la red ha caído. Este nivel de autonomía (Auto-Sanación) es la piedra angular del IoT Industrial.