ESP32-ML Academy Pro | Simulador Interactivo de TinyML

🎓 Bienvenido a ESP32-ML Academy Pro

La plataforma de aprendizaje más completa para dominar Machine Learning en ESP32. Con 12 módulos teóricos, 6 laboratorios de simulación interactiva, 5 proyectos finales y herramientas profesionales: osciloscopio virtual, simulador FFT, red neuronal interactiva, Edge Impulse simulator y MQTT broker virtual.

🟢 TinyML en ESP32: desde cero hasta producción industrial | 🟡 TensorFlow Lite Micro: inferencias en < 10ms | 🔴 Edge Impulse: entrena sin código | 🟣 MQTT: conecta tu fábrica a la nube | 🔵 FFT: análisis de vibraciones en tiempo real

🎯 Tus Rutas de Aprendizaje

🌱

Fundamentos ML + ESP32

Python, sensores, recolección de datos, primeros modelos con Edge Impulse. Simuladores interactivos incluidos.

Principiante ⏱️ 4 semanas

⚡

Edge AI Avanzado

TinyML optimizado, modelos cuantizados, visión por computadora con ESP32-S3 y cámaras. Laboratorios prácticos.

Intermedio ⏱️ 6 semanas

🏭

IIoT Industrial

Mantenimiento predictivo, anomalías, comunicación OPC-UA, MQTT, despliegue en producción con OTA.

Avanzado ⏱️ 8 semanas

🔬 Laboratorios de Simulación

🔧

Simulador de Sensores

4 sensores con física real: ruido gaussiano, drift, anomalías configurables. Gráfico en tiempo real.

InteractivoTiempo Real

🧠

Red Neuronal Visual

Visualiza propagación forward en una red neuronal completamente interactiva. Ajusta pesos y observa.

VisualEducativo

⚡

Edge Impulse Simulator

Flujo completo: recolección de datos → diseño de impulso → entrenamiento simulado → inferencia.

TinyMLSin Código

📈

Osciloscopio + FFT

Osciloscopio virtual con modo tiempo y frecuencia. Análisis espectral en tiempo real para vibraciones.

SeñalesFFT

💻

Code Lab

Editor con simulación de ejecución. Código Arduino/ESP32 con salida serial simulada y verificación.

ArduinoSimulado

📡

MQTT Simulator

Broker MQTT virtual. Publica, suscríbete y observa mensajes en tiempo real. Simulación completa.

IoTProtocolo

📈 Tu Progreso

esp32-monitor.exe

$ system.status --full

✅ ESP32-ML Academy Pro v2.0

📦 Módulos teóricos: 12 (4 fases)

🧪 Laboratorios de simulación: 6

🎯 Proyectos finales: 5 con simulación

🔧 Simuladores hardware: sensores, FFT, red neuronal, MQTT

💡 Tip: Comienza con "Fase 1: Fundamentos" o prueba el Simulador de Sensores

$ _▊

📋 Estructura de Cada Módulo

1. Teoría Profunda: Conceptos explicados con ejemplos prácticos y comparativas. 2. Simulación Interactiva: Laboratorio web donde experimentas sin riesgo. 3. Código Real: Código Arduino/ESP32 listo para compilar en hardware real. 4. Quiz de Evaluación: 3 preguntas para validar tu comprensión. 5. Recursos Adicionales: Lecturas, videos y documentación complementaria.

📐 Fase 0: Pre-Requisitos (Opcional)

Electrónica básica, conceptos de programación C/C++, familiaridad con Arduino. No es obligatorio pero acelera el aprendizaje.

Gratis Auto-estudio

🌱 Fase 1: Fundamentos (Semanas 1-2)

Python básico, introducción a ML, tipos de algoritmos (supervisado, no supervisado, por refuerzo), herramientas Edge Impulse. Comprensión de la arquitectura ESP32. Sin hardware requerido: todo en simulador web.

Módulos 1-3 Simulador Web 40 horas

🔌 Fase 2: ESP32 + Sensores (Semanas 3-4)

Programación ESP32 con Arduino IDE y PlatformIO. Lectura de sensores analógicos y digitales. Comunicación I2C, SPI, WiFi y Bluetooth. Envío de datos a la nube. Filtros digitales y calibración.

Módulos 4-6 ESP32 DevKit 50 horas

⚡ Fase 3: Edge AI & TinyML (Semanas 5-7)

TensorFlow Lite para microcontroladores. Cuantización de modelos (int8). Clasificación en tiempo real. Detección de anomalías con autoencoders. Visión por computadora con ESP32-S3 y cámara OV2640.

Módulos 7-9 ESP32-S3 70 horas

🏭 Fase 4: Proyectos Industriales (Semanas 8-10)

Mantenimiento predictivo con análisis FFT. Detección de anomalías en motores. Asistente de voz con keyword spotting. Control de calidad con visión artificial. Gateway IIoT con MQTT, Modbus y OPC-UA.

Módulos 10-12 Proyectos Finales 90 horas

🎯

Módulo 1: Introducción a TinyML

¿Qué es TinyML? Diferencias Cloud vs Edge. Arquitectura ESP32 completa. Primeros pasos sin hardware.

Fácil⏱️ 45 min

📊

Módulo 2: Preparación de Datos

Recolección, limpieza, normalización MinMax/Z-score. Ventanas deslizantes. Formatos CSV/JSON/C array.

Fácil⏱️ 60 min

🧠

Módulo 3: Primer Modelo con Edge Impulse

Crear cuenta, diseñar impulso, DSP, entrenamiento visual, validación, exportar .tflite.

Fácil⏱️ 90 min

🔌

Módulo 4: Programación ESP32

Arduino IDE vs PlatformIO. GPIO, ADC 12-bit, PWM ledc, I2C, SPI. WiFi STA/AP. Bluetooth BLE.

Medio⏱️ 120 min

📡

Módulo 5: Sensores y Actuadores

MPU6050, DHT22, LM35, ACS712, HX711, INMP441. Calibración, filtros media móvil y Kalman.

Medio⏱️ 100 min

☁️

Módulo 6: Comunicación y Edge

MQTT pub/sub, HTTP REST, WebSocket. TLS/SSL. Protocolos industriales: Modbus RTU/TCP, OPC-UA.

Medio⏱️ 110 min

⚡

Módulo 7: TensorFlow Lite Micro

Integrar .tflite en ESP32. Intérprete, manejo de tensores, arena de memoria, optimización.

Difícil⏱️ 150 min

🔍

Módulo 8: Detección de Anomalías

Autoencoders, Isolation Forest, threshold dinámico μ ± kσ. Aplicación a motores industriales.

Difícil⏱️ 140 min

👁️

Módulo 9: Visión con ESP32-S3

Cámara OV2640. Clasificación de imágenes. FOMO. Person detection. Aceleración vectorial.

Difícil⏱️ 180 min

🏭

Módulo 10: Mantenimiento Predictivo

Análisis de vibraciones. Espectro FFT. Clasificación de fallas: desbalance, desalineación, rodamientos.

Difícil⏱️ 200 min

🗣️

Módulo 11: Audio y Comandos de Voz

Wake word detection. Keyword spotting. MFCC features. Redes neuronales para audio en ESP32.

Difícil⏱️ 160 min

🌐

Módulo 12: Despliegue Industrial

OTA updates. Docker edge. SCADA. Grafana. Monitoring. Seguridad. Producción a escala.

Difícil⏱️ 170 min

🎛️ Panel de Sensores Simulados

100 Hz Buffer: 500 pts

Estado:

ACTIVO

🌡️ Temperatura Motor ADC1_CH6

45.0 °C

Valor:

Ruido:

Modo:

📳 Vibración MPU6050 I2C 0x68

0.05 g

Valor:

Ruido:

Modo:

⚡ Corriente ACS712 ADC1_CH4

2.4 A

Valor:

Ruido:

Modo:

🔊 Audio INMP441 I2S

35 dB

Valor:

Ruido:

Modo:

📈 Visualización Multi-Canal en Tiempo Real

Temperatura (°C)

Vibración (g)

Corriente (A)

Audio (dB)

🧠 Predicción del Modelo ML Simulado

Inferencia: ~12ms

El modelo simulado analiza los 4 sensores simultáneamente usando un clasificador de umbral adaptativo con ventana deslizante de 50 muestras. Detecta: NORMAL, ADVERTENCIA, CRÍTICO y DESCONOCIDO.

✅

NORMAL

Confianza: --

⚠️

ADVERTENCIA

Confianza: --

🔴

CRÍTICO

Confianza: --

❓

DESCONOCIDO

Confianza: --

💡 Cómo funciona la predicción

El algoritmo calcula la media móvil y desviación estándar de cada sensor. Si un valor excede μ ± 2σ → ADVERTENCIA. Si excede μ ± 3σ → CRÍTICO. Si múltiples sensores están anormales simultáneamente, la confianza aumenta. Este es un threshold dinámico similar a lo que implementarías con Isolation Forest en producción.

🔮 Red Neuronal Interactiva

3-6-4-2 Listo

Arquitectura:

[0.5, 0.3, 0.8]

Entrada

[--, --]

Salida

0

Activaciones

📖 ¿Qué estás viendo?

Cada círculo es una neurona. Las líneas son conexiones con pesos. El color de la neurona indica su nivel de activación (verde = alta, gris = baja). El grosor de las líneas representa la magnitud del peso. Durante la propagación forward, los valores fluyen de izquierda (input) a derecha (output), multiplicándose por los pesos y aplicando la función de activación (ReLU en capas ocultas, Sigmoid en output).

📊 Funciones de Activación

Función	Fórmula	Uso
ReLU	max(0, x)	Capas ocultas (rápida)
Sigmoid	1/(1+e^(-x))	Output binario [0,1]
Tanh	(e^x - e^(-x))/(e^x + e^(-x))	[-1, 1] normalizado
Softmax	e^(xi)/Σe^(xj)	Clasificación multi-clase

⚡ Comparativa: ESP32 vs Otros Chips

Chip	CPU	RAM	ML Speed
ESP32	240MHz dual	520KB	~10ms inferencia
ESP32-S3	240MHz + AI	512KB + 8MB	~3ms inferencia
Arduino Uno	16MHz	2KB	No aplica
STM32H7	480MHz	1MB	~1ms inferencia

🔄 Flujo de Trabajo Edge Impulse

Paso 1/5

📥

1. Datos

Recolección

→

⚙️

2. Impulso

Diseño DSP+NN

→

🎓

3. Entrenar

Training Epochs

→

✅

4. Testear

Validación

→

🚀

5. Deploy

Exportar C++

📥 Paso 1: Recolección de Datos

Simula la recolección de muestras para un clasificador de estados de motor. Cada clase necesita al menos 30 muestras de 2 segundos. Haz clic en "Grabar" para cada clase.

42

✅ Normal

28

⚠️ Advertencia

35

🔴 Crítico

20

⚫ Apagado

75%

Datos recolectados

🎓 Paso 3: Entrenamiento del Modelo

Épocas: 50

Learning Rate:

Batch Size:

Listo para entrenar Época 0/50

--

Loss

--

Accuracy

--

Val Loss

--

Val Acc

--

Tiempo/epoca

💡 Conceptos Clave de Edge Impulse

Impulse: Pipeline de procesamiento = extract features (DSP) → classify (NN). DSP: Digital Signal Processing convierte datos crudos en características útiles (ej: FFT para vibraciones). Learning Window: Tamaño de la ventana de datos que el modelo ve. Para vibraciones: 20-50ms. Confusion Matrix: Muestra qué clases se confunden entre sí. Busca >90% en diagonal.

🖥️ Osciloscopio Digital - 2 Canales

Time/Div

Volt/Div CH1

Volt/Div CH2

Señal CH1

Señal CH2

🔊 Análisis Espectral (FFT)

Frecuencia de muestreo: Ventana: Res: 7.8 Hz

0 Hz500 Hz1 kHz1.5 kHz 2 kHz

--

Frecuencia Pico

--

Magnitud Pico

--

THD Est.

--

SNR (dB)

🔍 Diagnóstico de Fallas por Frecuencia

En mantenimiento predictivo, cada tipo de falla mecánica genera frecuencias características: Desbalance: 1x frecuencia de rotación | Desalineación: 2x frecuencia de rotación | Rodamiento (BPFI): frecuencia específica del rodamiento | Engranaje: frecuencia de malla del engranaje. El análisis FFT permite identificar estas firmas espectrales antes de que la falla sea catastrófica.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

/*
 * ESP32 + TFLite Micro - Clasificación multi-sensor
 * Módulo: Mantenimiento predictivo industrial
 * Hardware: ESP32 DevKit v1 + MPU6050 + LM35 + ACS712
 */

#include <WiFi.h>
#include <HTTPClient.h>
#include "model.h"  // Modelo TFLite cuantizado int8

// ========== CONFIGURACIÓN ==========
const char* WIFI_SSID = "TU_WIFI";
const char* WIFI_PASS = "TU_PASSWORD";
const char* API_ENDPOINT = "https://api.factory.io/v1/alerts";

// Pines de sensores
#define PIN_TEMP     34   // ADC1_CH6 - LM35
#define PIN_VIB_X    35   // ADC1_CH7 - MPU6050 Accel X
#define PIN_VIB_Y    32   // ADC1_CH4 - MPU6050 Accel Y
#define PIN_CURRENT  33   // ADC1_CH5 - ACS712-5A

// Parámetros de ML
#define WINDOW_SIZE     50
#define K_ANOMALY       3.0f
#define SAMPLE_MS       100
#define TEMP_THRESHOLD  75.0f
#define VIB_THRESHOLD   2.5f
#define CURR_THRESHOLD  10.0f

// ========== VARIABLES GLOBALES ==========
float tempWindow[WINDOW_SIZE];
float vibWindow[WINDOW_SIZE];
float currWindow[WINDOW_SIZE];
int windowIdx = 0;
bool windowFull = false;

// Métricas del modelo
float tempMean, tempStd, vibMean, vibStd, currMean, currStd;

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  Serial.println("========================================");
  Serial.println("  ESP32-ML Industrial Monitor v2.0");
  Serial.println("  TinyML + TFLite Micro + Edge AI");
  Serial.println("========================================");
  
  // Configurar ADC de alta resolución
  analogReadResolution(12);
  analogSetAttenuation(ADC_11db);
  analogSetPinAttenuation(PIN_TEMP, ADC_11db);
  
  // Conectar WiFi
  Serial.print("[WiFi] Conectando...");
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  int wifiTimeout = 0;
  while (WiFi.status() != WL_CONNECTED && wifiTimeout < 20) {
    delay(500); Serial.print("."); wifiTimeout++;
  }
  if (WiFi.status() == WL_CONNECTED) {
    Serial.printf(" OK (%s)\n", WiFi.localIP().toString().c_str());
  } else {
    Serial.println(" FAIL - Modo offline");
  }
  
  // Inicializar modelo TFLite
  Serial.print("[ML] Cargando modelo TFLite...");
  if (initModel() == 0) {
    Serial.println(" OK (2.3KB)");
  } else {
    Serial.println(" FAIL");
  }
  
  Serial.println("\nSistema listo. Intervalo: 100ms");
  Serial.println("TEMP(°C)  VIB(g)  CURR(A)  ESTADO     CONF");
  Serial.println("-----------------------------------------------");
}

void loop() {
  // Leer sensores con oversampling (promedio de 4)
  float temp = readTemperature();
  float vib  = readVibration();
  float curr = readCurrent();
  
  // Llenar ventana deslizante
  tempWindow[windowIdx] = temp;
  vibWindow[windowIdx]  = vib;
  currWindow[windowIdx] = curr;
  windowIdx = (windowIdx + 1) % WINDOW_SIZE;
  if (windowIdx == 0) windowFull = true;
  
  // Calcular estadísticas cuando la ventana esté llena
  if (windowFull) {
    tempMean = computeMean(tempWindow, WINDOW_SIZE);
    tempStd  = computeStd(tempWindow, WINDOW_SIZE, tempMean);
    vibMean  = computeMean(vibWindow, WINDOW_SIZE);
    vibStd   = computeStd(vibWindow, WINDOW_SIZE, vibMean);
    currMean = computeMean(currWindow, WINDOW_SIZE);
    currStd  = computeStd(currWindow, WINDOW_SIZE, currMean);
    
    // Detección de anomalías con threshold dinámico
    AnomalyResult result = detectAnomaly(temp, vib, curr);
    
    // Mostrar resultados formateados
    const char* estadoStr;
    switch (result.level) {
      case 0: estadoStr = "✅ NORMAL   "; break;
      case 1: estadoStr = "⚠️ ADVERTEN."; break;
      case 2: estadoStr = "🔴 CRITICO  "; break;
      default: estadoStr = "❓ DESCONOC.";
    }
    Serial.printf("%7.2f  %6.3f  %7.2f  %s  %3.0f%%\n",
                  temp, vib, curr, estadoStr, result.confidence * 100);
    
    // Enviar alerta si es crítico
    if (result.level >= 2) {
      sendAlert(temp, vib, curr, result.confidence);
    }
  }
  
  delay(SAMPLE_MS);
}

// ========== FUNCIONES DE SENSORES ==========
float readTemperature() {
  int sum = 0;
  for (int i = 0; i < 4; i++) {
    sum += analogRead(PIN_TEMP);
    delayMicroseconds(50);
  }
  float avg = sum / 4.0;
  float voltage = avg * 3.3 / 4095.0;
  return constrain(voltage * 100.0, 0, 150);  // LM35: 10mV/°C
}

float readVibration() {
  int rawX = analogRead(PIN_VIB_X);
  int rawY = analogRead(PIN_VIB_Y);
  float vX = (rawX * 3.3 / 4095.0 - 1.65) / 0.3;
  float vY = (rawY * 3.3 / 4095.0 - 1.65) / 0.3;
  return constrain(sqrt(vX*vX + vY*vY), 0, 10);
}

float readCurrent() {
  int sum = 0;
  for (int i = 0; i < 8; i++) {
    sum += analogRead(PIN_CURRENT);
    delayMicroseconds(100);
  }
  float avg = sum / 8.0;
  float voltage = avg * 3.3 / 4095.0;
  return constrain((voltage - 2.5) / 0.185, -5, 5);
}

// ========== ESTADÍSTICAS ==========
float computeMean(float* data, int n) {
  float s = 0;
  for (int i = 0; i < n; i++) s += data[i];
  return s / n;
}

float computeStd(float* data, int n, float mean) {
  float s = 0;
  for (int i = 0; i < n; i++) s += sq(data[i] - mean);
  return sqrt(s / n);
}

// ========== DETECCIÓN DE ANOMALÍAS ==========
AnomalyResult detectAnomaly(float temp, float vib, float curr) {
  AnomalyResult r = {0, 0.0};
  float score = 0;
  int triggers = 0;
  
  // Temperatura: μ ± kσ
  if (temp > tempMean + K_ANOMALY * tempStd) { score += 0.4; triggers++; }
  if (vib > vibMean + K_ANOMALY * vibStd)    { score += 0.35; triggers++; }
  if (abs(curr) > currMean + K_ANOMALY * currStd) { score += 0.25; triggers++; }
  
  // Thresholds absolutos de seguridad
  if (temp > 90) { score += 0.3; triggers++; }
  if (vib > 4.0) { score += 0.3; triggers++; }
  if (abs(curr) > 12) { score += 0.2; triggers++; }
  
  r.confidence = constrain(score, 0, 1);
  if (score > 0.7) r.level = 2;
  else if (score > 0.35) r.level = 1;
  else r.level = 0;
  
  return r;
}

// ========== COMUNICACIÓN ==========
void sendAlert(float t, float v, float c, float conf) {
  if (WiFi.status() != WL_CONNECTED) return;
  
  HTTPClient http;
  http.begin(API_ENDPOINT);
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", "Bearer YOUR_TOKEN");
  
  String payload = "{";
  payload += "\"device\":\"ESP32-ML-001\",";
  payload += "\"timestamp\":" + String(millis()) + ",";
  payload += "\"temperature\":" + String(t, 2) + ",";
  payload += "\"vibration\":" + String(v, 3) + ",";
  payload += "\"current\":" + String(c, 2) + ",";
  payload += "\"confidence\":" + String(conf, 2) + ",";
  payload += "\"status\":\"ANOMALY\"}";
  
  int code = http.POST(payload);
  Serial.printf("[HTTP] Alerta enviada: %d\n", code);
  http.end();
}

📤 Consola de Simulación / Salida Serial (115200 baud)

======================================== ESP32-ML Industrial Monitor v2.0 TinyML + TFLite Micro + Edge AI ======================================== [WiFi] Conectando.......... OK (192.168.1.105) [ML] Cargando modelo TFLite... OK (2.3KB) Sistema listo. Intervalo: 100ms TEMP(°C) VIB(g) CURR(A) ESTADO CONF ----------------------------------------------- 45.23 0.052 2.415 ✅ NORMAL 98% 45.18 0.048 2.398 ✅ NORMAL 95% 45.31 0.061 2.421 ✅ NORMAL 97% 45.15 0.055 2.405 ✅ NORMAL 99% 45.28 0.049 2.412 ✅ NORMAL 96% [HINT] Presiona ▶️ Simular para ejecutar el código completo con salida serial realista durante 30 iteraciones.

💡 Ejercicios Prácticos

Modifica los umbrales: Cambia TEMP_THRESHOLD a 65°C para un motor más sensible.
Agrega filtro Kalman: Implementa un filtro de Kalman en readTemperature() para reducir ruido.
Almacenamiento SD: Agrega fallback a tarjeta SD cuando WiFi falle (modo offline).
Interfaz web: Crea un AsyncWebServer con dashboard en tiempo real en http://esp32.local.
Modelo real: Reemplaza detectAnomaly() por una llamada a run_classifier() de Edge Impulse.
Deep sleep: Implementa modo de bajo consumo: despierta cada 5 min, mide, envía, duerme.

📤 Publicador (ESP32)

Topic:

Payload (JSON):

QoS: Retain

📥 Suscriptor (Dashboard/Cloud)

Topic Filter:

QoS:

Suscripciones activas

factory/sensor001/# (QoS 1)

📋 Log del Broker MQTT Virtual

🟢 Online 0 mensajes 2 clientes

[10:23:45] BROKER Mosquitto v2.0 iniciado en puerto 1883

[10:23:45] BROKER Cliente ESP32-001 conectado (clientId: esp32_ml_001)

[10:23:46] BROKER Cliente Dashboard-Web conectado (clientId: dashboard_001)

[10:23:46] SUB factory/sensor001/# por Dashboard-Web (QoS 1)

📖 Niveles QoS de MQTT

QoS 0 (At most once): Fire and forget. Rápido pero puede perderse.
QoS 1 (At least once): Asegura entrega pero puede duplicarse. Recomendado para sensores.
QoS 2 (Exactly once): Asegura entrega única. Más lento. Para comandos críticos.

🔤 Wildcards en Topics

+ (plus): Un solo nivel. factory/+/temperature matcha todos los sensores.
# (hash): Múltiples niveles. factory/sensor001/# matcha todos los subtopics.
Nota: # solo puede estar al final del topic filter.

🏭 Smart Factory Guardian

Mantenimiento predictivo con ESP32-S3

Sistema completo de monitoreo industrial con análisis de vibraciones, temperatura y corriente. Usa Edge AI para detectar fallas en motores antes de que ocurran. Incluye dashboard web embebido y alertas por Telegram.

ESP32-S3 Edge Impulse MQTT Grafana FFT

🔧 Mini-Simulador: Estado del Motor

45°C

Temperatura

0.05g

Vibración RMS

✅ OK

Estado ML

👁️ Quality Vision Inspector

Control de calidad con visión artificial

Inspección automatizada de productos usando cámara OV2640 y ESP32-S3. Detecta defectos superficiales, cuenta objetos y clasifica piezas en tiempo real usando FOMO (Faster Objects, More Objects).

ESP32-S3 OV2640 FOMO Edge Impulse

🔧 Mini-Simulador: Detección de Objetos

📦

Caja detectada: 98% confianza

[x: 45, y: 120, w: 80, h: 60]

🗣️ VoiceCommand Industrial

Asistente de voz para operadores

Control de máquinas por comandos de voz. Wake word "Hola Fábrica" activa el sistema. Comandos: encender/apagar, ajustar velocidad, consultar estado, pedir ayuda. Usa MFCC features y keyword spotting con Edge Impulse.

ESP32-S3 INMP441 Keyword Spotting MFCC

🔧 Mini-Simulador: Reconocimiento de Voz

🎤

"Hola Fábrica"

Wake word detectado: 94.2%

Comando: Activar sistema

🌡️ Energy Optimizer

Gestión inteligente de energía

Monitoreo y predicción de consumo eléctrico en tiempo real. Apaga equipos automáticamente cuando detecta inactividad prolongada. Reportes de eficiencia energética con predicción de costos mensuales usando regresión lineal en el ESP32.

ESP32 PZEM-004T Time Series Deep Sleep

🔧 Mini-Simulador: Consumo en Tiempo Real

2.4 kW

Potencia activa

$1.42/h

Costo estimado

📡 IIoT Gateway

Puente entre PLCs y la nube

Gateway industrial que conecta PLCs (Delta, Siemens) con plataformas cloud (AWS IoT, Azure). Soporta Modbus RTU/TCP, OPC-UA, MQTT y HTTP REST. Buffer local con SD para offline, sincronización automática cuando recupera conectividad.

ESP32-S3 Modbus OPC-UA AWS IoT

🔧 Mini-Simulador: Tráfico de Protocolos

[MODBUS] RX: 01 03 00 00 00 02 C4 0B
[MODBUS] TX: 01 03 04 01 90 00 7D... OK
[MQTT] pub → factory/plc01/temp: 25.5°C
[HTTP] POST /api/batch (2048 bytes) → 200
[BUF] 12 msgs en buffer SD (offline mode)

🧠 TinyML

Machine Learning en dispositivos con recursos extremadamente limitados (microcontroladores con KB de RAM y MHz de CPU). Permite ejecutar inferencias de redes neuronales sin conexión a internet. En ESP32, modelos de hasta ~500KB con cuantización int8.

// Modelo TFLite Micro ocupa solo ~16KB de código const int kTensorArenaSize = 20 * 1024; // 20KB suficiente uint8_t tensor_arena[kTensorArenaSize];

⚡ Edge AI

Inteligencia artificial ejecutada directamente en el dispositivo ("edge") en lugar de en la nube. Reduce latencia de 100-500ms a 1-50ms, mejora privacidad al no enviar datos crudos, y permite funcionamiento offline con batería.

📊 Cuantización (Quantization)

Proceso de reducir la precisión numérica de los pesos de una red neuronal de float32 a int8. Reduce el modelo 4x en tamaño y acelera 2-3x la inferencia en hardware sin FPU. Un modelo de 2MB pasa a ~500KB.

// Post-training quantization converter.optimizations = [tf.lite.Optimize.DEFAULT] converter.target_spec.supported_types = [tf.int8] // 4x smaller

🎯 Edge Impulse

Plataforma web gratuita (hasta ciertos límites) para desarrollar modelos ML para edge devices. Flujo: recolectar datos → diseñar impulso (DSP+NN) → entrenar → validar → exportar código C++ para Arduino/ESP32. Soporta audio, imagen, sensores y tabular.

📡 TensorFlow Lite Micro

Versión reducida de TensorFlow optimizada para microcontroladores. Solo incluye el intérprete de inferencia (no entrenamiento). Ocupa ~16KB de código flash y funciona en ARM Cortex-M, ESP32 y RISC-V. Requiere "arena" de RAM para tensores temporales.

🔍 Ventana Deslizante (Sliding Window)

Técnica para procesar series temporales: en lugar de analizar un punto, toma N muestras consecutivas (ej: 2 segundos a 100Hz = 200 puntos) como entrada al modelo. Se desliza con un "stride" (solapamiento). Esencial para señales de sensores.

# Window de 2 segundos, stride de 0.5 segundos window_size = 200 # 2s @ 100Hz stride = 50 # 0.5s overlap features = data[i:i+window_size] # Extract

🧮 Feature Extraction

Proceso de transformar datos crudos en características relevantes para el modelo. Para señales de sensor: media, desviación estándar, máximo, mínimo, RMS, skewness, kurtosis. Para audio: MFCC (Mel-Frequency Cepstral Coefficients). Reduce dimensionalidad y mejora precisión.

⚖️ F1-Score

Métrica que equilibra precision y recall: F1 = 2 * (precision * recall) / (precision + recall). Útil cuando las clases están desbalanceadas. Un F1 > 0.85 es generalmente aceptable para producción industrial.

🔧 ESP32

Microcontrolador dual-core Xtensa LX6 @ 240MHz con WiFi, Bluetooth, 520KB SRAM, 4-16MB flash, 34 GPIO, 18 canales ADC 12-bit. Soporta deep sleep (5μA), FreeRTOS, y TFLite Micro. El ESP32-S3 añade aceleración vectorial para AI.

📳 MPU6050

Acelerómetro y giroscopio de 6 ejes con interfaz I2C. Rango configurable: ±2g a ±16g (acelerómetro), ±250°/s a ±2000°/s (giroscopio). Dirección I2C: 0x68 (AD0=GND) o 0x69 (AD0=VCC). Consumo: 3.5mA activo.

Wire.begin(); mpu.initialize(); // Lectura directa en raw (16-bit signed) int16_t ax, ay, az; mpu.getAcceleration(&ax, &ay, &az); float vib_g = sqrt(ax*ax + ay*ay + az*az) / 16384.0;

🌡️ LM35

Sensor de temperatura analógico con salida lineal de 10mV/°C. No requiere calibración externa. Rango: -55°C a 150°C. Precisión: ±0.5°C. Alimentación: 4-30V. Se conecta directamente a ADC del ESP32.

⚡ ACS712

Sensor de corriente Hall-effect basado en efecto Hall. Versiones de 5A, 20A y 30A. Salida: VCC/2 cuando I=0, sensibilidad 185mV/A (5A), 100mV/A (20A). Resolución efectiva limitada por ruido del ADC (~50mA).

float readACS712(int pin, float sensibility) { int raw = analogRead(pin); float v = raw * 3.3 / 4095.0; return (v - 2.5) / sensibility; // sensibility = 0.185 for 5A }

🎵 INMP441

Micrófono MEMS digital de alta calidad con interfaz I2S. Resolución 24-bit, frecuencia de muestreo hasta 48kHz. Bajo consumo (1.4mA). Ideal para wake word detection y keyword spotting en ESP32.

🔌 ADC (Analog-to-Digital Converter)

Conversor analógico-digital del ESP32: 12-bit (valores 0-4095), 18 canales en 2 unidades (ADC1 y ADC2). ADC1 (GPIO 32-39) usable con WiFi. ADC2 (GPIO 0,2,4,12-15,25-27) no usable durante WiFi. Atenuación configurable: 0dB, 2.5dB, 6dB, 11dB.

📡 MQTT (Message Queuing Telemetry Transport)

Protocolo pub/sub ligero para IoT. Header de solo 2 bytes. Soporta 3 niveles QoS. Funciona sobre TCP/IP (puertos 1883 sin TLS, 8883 con TLS). Ideal para ESP32 por su bajo overhead y soporte de bibliotecas async.

// Estructura típica de topics factory/line001/machine042/sensor/temperature factory/+/+/sensor/+ // wildcard nivel único factory/line001/# // wildcard multi-nivel

🔧 Modbus RTU/TCP

Protocolo de comunicación industrial estándar. Modbus RTU usa RS-485 (serial) con formato binario. Modbus TCP usa Ethernet/WiFi (puerto 502). Cada dispositivo tiene una dirección única (1-247). Soporta coils, discrete inputs, holding registers e input registers.

🏭 OPC-UA (Open Platform Communications - Unified Architecture)

Protocolo industrial moderno que reemplaza OPC clásico. Plataforma independiente, seguro (certificados X.509), y orientado a servicios. Usa puerto 4840. Modelo de información basado en nodos. Más complejo que Modbus pero mucho más flexible y escalable.

🌐 HTTP REST

Protocolo web estándar para APIs. En ESP32 se usa con WiFiClientSecure para HTTPS. Ideal para enviar datos a plataformas cloud (AWS, Azure, ThingSpeak). Métodos: GET (leer), POST (crear), PUT (actualizar), DELETE (eliminar). Formato JSON estándar.

🏭 IIoT (Industrial Internet of Things)

Internet de las Cosas aplicado a entornos industriales. Conecta sensores, actuadores, PLCs y sistemas SCADA para monitoreo y control en tiempo real. Énfasis en confiabilidad (99.9%+ uptime), seguridad (TLS, VPN), y baja latencia.

📈 FFT (Fast Fourier Transform)

Algoritmo que convierte señales del dominio del tiempo al dominio de frecuencias. Complejidad O(n log n). Esencial para analizar vibraciones mecánicas y detectar fallas: desbalance (1x RPM), desalineación (2x RPM), rodamientos (BPFI frecuencias características).

// ArduinoFFT library FFT.Windowing(FFT_WIN_TYP_HAMMING, FFT_FORWARD); FFT.Compute(FFT_FORWARD); FFT.ComplexToMagnitude(); float peakFreq = FFT.MajorPeak();

🎵 MFCC (Mel-Frequency Cepstral Coefficients)

Características acústicas extraídas de señales de audio que simulan la percepción humana. Proceso: pre-énfasis → framing → ventana Hamming → FFT → banco de filtros Mel → log → DCT → 13 coeficientes. Usadas en keyword spotting y reconocimiento de voz.

🔧 OTA (Over-The-Air)

Actualización de firmware vía WiFi sin cable USB. Crítico para despliegues industriales. ESP32 soporta OTA básica (HTTP) y segura (HTTPS con verificación de certificado). Requiere partición dual (ota_0, ota_1) de al menos 1.5MB cada una.

// Simple OTA #include <ArduinoOTA.h> ArduinoOTA.setHostname("esp32-factory-001"); ArduinoOTA.begin(); // En loop: ArduinoOTA.handle(); // Verifica y aplica actualizaciones

⚡ Deep Sleep

Modo de ultra-bajo consumo del ESP32: 5-10μA. La CPU se apaga y solo el ULP coprocesor o RTC timer pueden despertar. Ideal para sensores de batería. Se usa esp_sleep_enable_timer_wakeup(us) para programar el despertar. Se pierde estado de RAM excepto RTC memory (8KB).

📊 SCADA (Supervisory Control and Data Acquisition)

Sistema de supervisión y adquisición de datos para procesos industriales. Monitorea en tiempo real, genera alarmas, almacena históricos y permite control remoto. Integra con ESP32 vía Modbus, OPC-UA o MQTT. Ejemplos: Ignition, WinCC, FactoryTalk.

🔍 Mantenimiento Predictivo (PdM)

Estrategia de mantenimiento basada en el estado real del equipo (condition-based), no en calendario fijo. Usa sensores + ML para predecir fallas antes de que ocurran. Reduce costos de mantenimiento 30-40% y elimina paradas no planificadas en un 70%.

🧮 Fórmulas de Conversión

Sensor	Fórmula	Rango	Unidad
LM35	Vout * 100	0-150	°C
DHT22	Lectura directa	-40-80	°C
MPU6050 Accel	Raw / 16384 * 9.81	±2-16g	m/s²
MPU6050 Gyro	Raw / 131.0	±250-2000	°/s
ACS712-5A	(V - 2.5) / 0.185	±5	A
ACS712-20A	(V - 2.5) / 0.100	±20	A
ACS712-30A	(V - 2.5) / 0.066	±30	A
PZEM-004T	Serial (Modbus)	0-100A, 0-260V	A/V/W/Wh
HX711	Raw / cal_factor	0-200	kg
ADS1115	Raw * 0.000125 ( PGA=±4.096V )	±4.096	V

📍 Pines ESP32 DevKit v1

Pin	Función	ADC	Notas
GPIO 34	Input only	ADC1_CH6	ADC recomendado
GPIO 35	Input only	ADC1_CH7	ADC recomendado
GPIO 32	I/O + Touch9	ADC1_CH4	ADC + Touch
GPIO 33	I/O + Touch8	ADC1_CH5	ADC + Touch
GPIO 36	Input (VP)	ADC1_CH0	ADC preferido
GPIO 39	Input (VN)	ADC1_CH3	ADC preferido
GPIO 25	DAC1	-	8-bit DAC
GPIO 26	DAC2	-	8-bit DAC
GPIO 21	I2C SDA	-	SDA por defecto
GPIO 22	I2C SCL	-	SCL por defecto
GPIO 18	SPI SCK	-	VSPI
GPIO 19	SPI MISO	-	VSPI
GPIO 23	SPI MOSI	-	VSPI
GPIO 5	SPI CS0	-	VSPI CS
GPIO 16/17	UART2	-	RX2/TX2
GPIO 1/3	UART0	-	TX0/RX0 (USB)

⚡ Umbrales de Anomalías

Equipo	Temp. Max	Vib. Max	Corriente Max
Motor 1HP	75°C	2.5g	6A
Motor 5HP	80°C	4.0g	22A
Motor 10HP	85°C	5.5g	43A
Bomba centrífuga	70°C	3.0g	15A
Compresor	85°C	5.0g	30A
Ventilador	60°C	1.5g	8A
Reductor	75°C	3.5g	Varía
Generador	90°C	4.5g	Varía

⌨️ Comandos Útiles

# PlatformIO

$ pio run --target upload # Compilar y subir

$ pio device monitor --baud 115200

$ pio run --target clean # Limpiar

$ pio run --target compiledb # IntelliSense

# Arduino CLI

$ arduino-cli compile --fqbn esp32:esp32:esp32 .

$ arduino-cli upload -p /dev/ttyUSB0 --fqbn esp32:esp32:esp32 .

# ESP-IDF

$ idf.py set-target esp32

$ idf.py build flash monitor

# Git

$ git add . && git commit -m "feat: add ml inference"

🧠 Fórmulas de ML Útiles

Fórmula	Uso
z = (x - μ) / σ	Normalización Z-score
x_norm = (x - min) / (max - min)	Normalización MinMax [0,1]
RMS = √(Σx²/n)	Root Mean Square (vibración)
Crest Factor = Peak / RMS	Detección de impactos
THD = √(ΣV_h²) / V_1	Total Harmonic Distortion
SNR = 20*log10(V_signal/V_noise)	Relación señal/ruido (dB)
Confianza = e^(logit) / Σe^(logits)	Softmax para clasificación

📡 Topics MQTT Típicos

# Estructura jerárquica recomendada

PUB factory/line001/machine042/sensor/temp

PUB factory/line001/machine042/sensor/vibration

PUB factory/line001/machine042/ml/anomaly

SUB factory/line001/machine042/cmd/reset

SUB factory/line001/+/cmd/firmware_update

PUB factory/line001/machine042/status/heartbeat

PUB factory/line001/machine042/status/uptime

📘 Documentación Oficial

📘

ESP-IDF Docs

SDK oficial de Espressif. APIs, drivers, ejemplos completos y guías de optimización para ESP32, ESP32-S3 y ESP32-C3.

OficialGratis

🎯

Edge Impulse Docs

Guías paso a paso, tutoriales en video, referencia de API y showcase de proyectos de la comunidad.

OficialGratis

🧠

TensorFlow Lite Micro

Documentación oficial de Google. APIs, guía de optimización de memoria, y ejemplos para ARM, ESP32 y RISC-V.

OficialOpen Source

🔧

PlatformIO ESP32

Configuración de proyectos, debugging con GDB, librerías compatibles y CI/CD para ESP32.

OficialOpen Source

📝

Arduino Reference

Referencia completa del lenguaje Arduino: funciones, variables, estructuras y librerías.

OficialGratis

🐍

MicroPython ESP32

Alternativa a C/C++: Python en ESP32. Ideal para prototipos rápidos y scripting.

AlternativaOpen Source

🛠️ Herramientas Recomendadas

🎮

Wokwi Simulator

Simulador online gratuito de ESP32 con sensores virtuales. Prueba código sin hardware. Soporta debugging paso a paso.

SimuladorGratis

📮

Postman

Testea APIs REST de tu ESP32. Envía requests HTTP, inspecciona respuestas JSON, automatiza pruebas con colecciones.

TestingFreemium

📊

Grafana

Visualización de datos de sensores en tiempo real. Dashboards profesionales con alertas. Integra con InfluxDB, Prometheus.

MonitoringOpen Source

🔴

Node-RED

Programación visual para IoT. Conecta ESP32 con servicios cloud usando flujos de nodos drag-and-drop.

Low-CodeOpen Source

🦟

Eclipse Mosquitto

Broker MQTT open source ligero. Soporta TLS, autenticación, ACLs y bridging. Ideal para despliegues locales.

BrokerOpen Source

💾

InfluxDB

Base de datos de series temporales optimizada para métricas de IoT. Consultas con InfluxQL. Integra con Grafana.

DatabaseOpen Source

👥 Comunidades

👥

r/esp32 (Reddit)

Comunidad de 70k+ miembros. Proyectos compartidos, troubleshooting, noticias y discusiones avanzadas.

ComunidadGratis

💬

Edge Impulse Forum

Foro oficial con soporte técnico directo del equipo. Showcase de proyectos y tutoriales avanzados.

ForoGratis

🔧

PlatformIO Community

Foro de soporte para PlatformIO. Resolución de problemas de compilación, librerías y boards.

ForoGratis

💜

ESP32 Discord

Servidor oficial de Espressif en Discord. Canales en español e inglés. Respuestas en tiempo real.

ChatGratis