ESP32

Qué es

El ESP32 es un microcontrolador que parece un Arduino al que le han atornillado una radio y le han quitado los frenos. Tiene un procesador de 32 bits y doble núcleo que funciona muchas veces más rápido que un Uno, mucha más memoria y —la característica estrella— Wi-Fi y Bluetooth integrados. Esa combinación es la que domina la robótica de afición y el IoT: un robot puede alojar una página web para controlarse a sí mismo, enviar los datos de los sensores al teléfono o recibir órdenes por Bluetooth, todo desde un único chip barato.

Y lo crucial: lo programas con el mismo IDE y el mismo lenguaje Arduino que quizá ya conoces. Lo que aprendiste en un Uno se traslada directamente; simplemente ganas conectividad y margen.

Cómo funciona

En su corazón hay dos núcleos CPU Xtensa de hasta 240 MHz. Tener dos núcleos importa en robótica: un núcleo puede ejecutar tu lazo de control con tiempos estables mientras el otro se ocupa del Wi-Fi, así que la red nunca detiene las ruedas. Alrededor de la CPU están los periféricos habituales de un microcontrolador —GPIO, canales PWM, varios ADC, I²C, SPI, UART—, más la radio.

El hecho práctico más importante es la tensión: el ESP32 trabaja con lógica de 3,3 V, no con los 5 V del Uno. Sus pines no toleran 5 V. Una salida de sensor de 5 V —como el pin Echo de un HC-SR04— debe bajarse a 3,3 V antes de tocar un pin del ESP32, o corres riesgo de dañarlo. Esta única diferencia tropieza a casi todo el mundo que viene de un Uno.

Cuándo usarlo

Recurre a un ESP32 cuando tu robot necesite ser inalámbrico —control remoto, telemetría, un panel de control en el navegador— o cuando necesite cómputo que una placa de 8 bits no puede dar, como procesar más sensores o ejecutar lógica ligera en el propio dispositivo. La variante ESP32-CAM añade una cámara y abre la puerta a proyectos de visión sencillos.

Quédate con un Arduino Uno cuando estés aprendiendo los fundamentos, cuando la tolerancia de 5 V haga el cableado más seguro, o cuando el proyecto sea simple y sin conexión: llevar un par de motores por una línea no necesita Wi-Fi.

Cableado y errores comunes

• Es de 3,3 V y no tolera 5 V. Convierte el nivel de cualquier señal de 5 V antes de que llegue a un GPIO. Esta es, con diferencia, la forma más habitual de que un principiante dañe un ESP32.
• Wi-Fi más motores pueden provocar un brownout. La radio absorbe picos de corriente bruscos; compartir una alimentación floja con los motores provoca reinicios. Alimenta los motores aparte a través de un controlador de motores y dale al ESP32 un riel de 3,3 V estable.
• No todos los pines están libres. Varios GPIO son solo de entrada, están atados al comportamiento de arranque, o van conectados a la flash interna. Consulta el patillaje antes de asignar pines, o la placa no arrancará.
• Rarezas del ADC. Uno de los dos ADC no está disponible mientras el Wi-Fi está activo, y las lecturas son menos lineales que las de un Uno: calibra si necesitas precisión.

Los pines que no debes usar

Un ESP32 tiene unos 34 GPIO, y eso induce a error, porque un número significativo de ellos es inusable, usable solo bajo condiciones, o hará que la placa no arranque. Esta tabla es lo único que merece la pena leer antes de cablear nada.

Los pines de uso general más seguros en una placa de desarrollo estándar de 30 pines son GPIO 4, 5, 13, 14, 16, 17, 18, 19, 21, 22, 23, 25, 26, 27, 32, 33. Empieza por ahí y evitarás todas las trampas de arriba.

Los pines de modo de arranque son el fallo más confuso, porque la placa funciona perfectamente hasta que conectas algo. Una resistencia de pull-up en GPIO 12 — totalmente razonable para un botón — significa que la placa simplemente no arrancará, sin error y sin salida por serie.

Los pines de solo entrada pillan a la gente de otra manera: los GPIO 34–39 no tienen pull-up ni pull-down internos, así que un botón conectado a uno de ellos flota y lee al azar. Necesitan una resistencia externa.

3,3 V, y lo que eso te cuesta

Los pines del ESP32 no toleran 5 V, y esta es la forma más común de que la gente dañe uno. Cualquier señal de 5 V necesita un tratamiento:

Vale la pena internalizar la asimetría: las salidas suelen ser seguras, las entradas no. El pin Echo de un HC-SR04 es el caso clásico: empuja 5 V completos hacia un pin cuya tensión máxima absoluta es de 3,6 V.

El problema del ADC

El ADC del ESP32 es la parte más débil del chip, y fingir lo contrario te cuesta horas.

El ADC2 no funciona mientras el Wi-Fi está activo. Lo usa la radio. Cualquier analogRead en un pin del ADC2 devuelve basura o se bloquea en cuanto se conecta el Wi-Fi, y como un robot inalámbrico es justo la razón para usar un ESP32, esto deja el ADC2 casi descartado. Usa solo ADC1: GPIO 32–39.

La respuesta no es lineal. El ADC de 12 bits es visiblemente no lineal en ambos extremos, y las lecturas por debajo de unos 0,1 V y por encima de unos 3,1 V están comprimidas. El chip trae datos de calibración de fábrica que las funciones esp_adc_cal del ESP-IDF te aplican; el analogRead de Arduino no los usa por defecto.

Si necesitas precisión real de un sensor analógico, la respuesta pragmática es un ADC I²C externo como un ADS1115. Cuesta unos pocos dólares y elimina el problema entero.

Alimentarlo sin brownouts

Aquí es donde más a menudo fallan los proyectos de robot con ESP32, y la causa no es obvia.

La radio no absorbe una corriente constante: la absorbe a ráfagas. Una ráfaga de transmisión puede ser de 500 mA durante unos cientos de microsegundos frente a una media de 40–80 mA. Una alimentación que da buena lectura en un multímetro puede desplomarse igualmente en esos picos, y el ESP32 responde reiniciándose con un mensaje Brownout detector was triggered.

Ese último punto merece enunciarse sin rodeos: alimenta con 5 V por el pin VIN/5V y deja que el regulador de la placa haga los 3,3 V. Inyectar 3,3 V directamente omite el regulador y su filtrado, que es justo para lo que existe.

Dos núcleos, y cómo usarlos de verdad

El doble núcleo es la ventaja real del ESP32 para robótica, y el framework de Arduino la esconde: tu loop() corre en el núcleo 1, y la pila de Wi-Fi corre en el núcleo 0.

Puedes fijar una tarea a un núcleo explícitamente:

void controlLoop(void *param) {
  const TickType_t period = pdMS_TO_TICKS(10);   // exactly 100 Hz
  TickType_t last = xTaskGetTickCount();
  for (;;) {
    readSensors();
    updatePid();
    driveMotors();
    vTaskDelayUntil(&last, period);              // no drift, unlike delay()
  }
}

void setup() {
  xTaskCreatePinnedToCore(
    controlLoop, "control", 4096, nullptr,
    2,          // priority above the default
    nullptr,
    1);         // core 1 — leave core 0 for Wi-Fi
}

Este es el patrón que hace que un ESP32 sea realmente bueno para robótica y no solo conectado: un lazo de control con tiempos estrictos en un núcleo, y un servidor web en el otro que no puede detenerlo. vTaskDelayUntil es el detalle importante: a diferencia de delay(), compensa lo que haya tardado el cuerpo del bucle, así que el periodo se mantiene exactamente en 10 ms.

Resolución de problemas

¿ESP32 o Arduino Uno?

Ambos usan el mismo lenguaje y el mismo IDE, que es el punto: la transición te cuesta casi nada en código y bastante en disciplina de cableado.

La recomendación honesta: aprende en un Uno, construye en un ESP32. La tolerancia de 5 V del Uno y la ausencia total de trampas de pines hacen que tus errores iniciales sean recuperables. Cuando sepas qué es un lazo de control y por qué las masas deben ser comunes, el ESP32 te da quince veces la velocidad de reloj, 260 veces la memoria y una radio, por aproximadamente el mismo dinero.

La variante ESP32-CAM merece conocerse por separado: añade una cámara y una ranura SD por unos pocos dólares, y es con diferencia la vía más barata de entrada a la visión robótica, al precio de quedarte sin casi ningún GPIO libre.