Tutorial ESP32 en español: primer blink y WiFi

La placa llegó, el cable USB-C también, y el Arduino IDE dice “Failed to connect” o no aparece ningún puerto COM. No es que el ESP32 sea caprichoso: es un SoC con bootloader propio, un chip USB-serial aparte y un pinout que cambia según el módulo. Este tutorial en español te lleva del paquete cerrado al primer LED parpadeando, al monitor serie confiable y a un escaneo de redes WiFi — sin prometer que “en cinco minutos ya estás en la nube”.

Pasos del primer proyecto ESP32: código, conexión y luces

Trabajamos con ESP32 (no ESP8266): es lo que encuentras de forma habitual en placas de desarrollo actuales con WiFi y Bluetooth, y es lo que usamos en las fichas de catálogo de referencia. Si todavía no decidiste entre Nano y ESP32, lee antes ESP32 vs Arduino: cuál elegir.

1. Qué necesitas en la mesa

Primer éxito: el LED de la placa parpadeando y el monitor serie respondiendo

No hace falta un laboratorio completo. Con esto alcanza para el día uno:

Idea clave: el LED de la placa demuestra que el toolchain funciona; el LED externo demuestra que entiendes GPIO y corriente de pin. Haz las dos cosas en el mismo día.

No mezcles todavía motores, reles de 5 V o sensores de eco a 5 V. El primer proyecto es toolchain + GPIO + serial + radio. La potencia y el 5 V llegan después, con drivers y level shifting conscientes (ver también proyectos Arduino para principiantes si vienes del mundo Nano).

2. Identificar tu placa y el chip USB-serial

Proyecto curiosidad: lámpara controlada por WiFi desde el celular

Antes de instalar nada, mira la seda de la PCB y el chip pequeño junto al USB:

• CH340 / CH340G / CH9102 — muy frecuentes en clones y en módulos tipo NodeMCU.
• CP2102 — común en DevKit “de marca” y algunas Lolin.
• USB nativo (ESP32-S2/S3) — otra familia; el flujo de drivers cambia. Este tutorial asume el ESP32 “clásico” con UART-USB externo.

Si tu placa es la del catálogo con CH340G y USB-C, el driver CH340 es el erespechoso habitual cuando el PC no ve el puerto. En Windows: Administrador de dispositivos → Puertos (COM y LPT) o “Otros dispositivos” con signo de admiración.

En Linux, el dispositivo suele aparecer como /dev/ttyUSB0 o /dev/ttyACM0; puede hacer falta estar en el grupo dialout. En macOS, busca /dev/cu.usbserial-* o wchusbserial.

No confundas el chip de serie con el ESP32. El IDE habla con el USB-serial; el USB-serial habla con el UART0 del ESP32. Si el driver falla, el ESP32 puede estar sano y tú no tienes canal para flashearlo.

3. Instalar el Arduino IDE y el core de Espressif

1. Instala Arduino IDE 2.x (recomendado) o 1.8.x si tu laboratorio lo exige.
2. Abre File → Preferences (Archivo → Preferencias) y en “Additional boards manager URLs” agrega la URL del package de Espressif (la documentación oficial de Arduino-ESP32 la publica; cópiala de la fuente oficial para no usar un mirror viejo).
3. Abre Boards Manager, busca esp32 by Espressif Systems e instala el paquete.
4. En Tools → Board, elige una entrada cercana a tu hardware. Ejemplos típicos:
   • “ESP32 Dev Module” — genérico que funciona en muchas placas.
   • Entradas “WEMOS LOLIN…” si tu placa es familia Lolin y aparece en la lista.
5. Ajustes iniciales sensatos:
   • Upload Speed: 921600 si flashea bien; baja a 115200 si hay errores de timeout.
   • Flash Frequency / Partition Scheme: deja defaults hasta que un proyecto pida otra cosa.
   • Port: el COM o tty que apareció al conectar el cable de datos.

Si el Boards Manager no encuentra el paquete, el problema es de red, proxy o URL mal pegada — no de la placa. Arregla eso antes de culpar al hardware.

4. Primer sketch: Blink en el LED de la placa

Muchas placas ESP32 traen un LED de usuario en un GPIO fijo (a menudo GPIO2, a veces otro). El pin exacto depende del diseño. Si no sabes cuál es, usa el ejemplo y, si no parpadea, pasa al LED externo de la sección siguiente.

// Blink mínimo — ajusta LED_PIN según tu placa
// En varias DevKit/Lolin el LED de usuario está en GPIO2
#ifndef LED_BUILTIN
#define LED_BUILTIN 2
#endif
 
const int LED_PIN = LED_BUILTIN;
 
void setup() {
  pinMode(LED_PIN, OUTPUT);
}
 
void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}

Subida (upload)

1. Selecciona el puerto correcto.
2. Clic en Upload.
3. Si la placa lo pide (algunos diseños), mantén BOOT al inicio del flasheo y suelta cuando empiece a escribir. Muchas placas modernas con auto-reset no lo necesitan.
4. Si ves A fatal error occurred: Failed to connect to ESP32, prueba: otro cable, otra velocidad de upload, botón BOOT, y confirmar que no tienes otro programa abriendo el COM (monitor serie de otra ventana, Putty, etc.).

Cuando el LED parpadea, el 80 % de la fricción del “primer ESP32” ya quedó atrás: driver, core, puerto y bootloader respondieron.

5. Serial: el osciloscopio de pobre (y el más útil)

El monitor serie es tu mejor herramienta de depuración. Ábrelo a 115200 baud (estándar de muchos ejemplos ESP32; algunos usan 9600 — deben coincidir sketch y monitor).

const int LED_PIN = 2;
 
void setup() {
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(115200);
  delay(500); // da tiempo al USB-serial a enumerar
  Serial.println();
  Serial.println(F("ESP32 listo — primer proyecto"));
  Serial.printf("Chip model: %s rev %d\n", ESP.getChipModel(), ESP.getChipRevision());
  Serial.printf("CPU cores: %d @ 

Si el monitor muestra basura, el baud no coincide. Si no muestra nada, el puerto está mal o el sketch no llegó a correr (flasheo fallido, placa en reset, cable solo de carga).

Idea clave: imprime estado antes de meter WiFi. Un nodo que “no conecta” sin logs es una caja negra; con Serial.printf ves si se quedó en DNS, en contraseña o en IP.

6. LED externo: comprobar un GPIO de verdad

elige un pin “tranquilo”. En ESP32 clásico, evita al principio los strapping pins (0, 2, 5, 12, 15 en varias revisiones) si vas a pelearte con el boot. Para un LED de prueba, GPIO4 o GPIO18 suelen ser razonables en muchas DevKit — verifica el pinout de tu módulo.

Conexión:

• GPIO → resistencia 220 Ω–1 kΩ → ánodo del LED → cátodo del LED → GND de la placa.

const int LED_EXT = 4; // confirma en el silkscreen de TU placa
 
void setup() {
  pinMode(LED_EXT, OUTPUT);
  Serial.begin(115200);
}
 
void loop() {
  digitalWrite(LED_EXT, HIGH);
  Serial.println(F("LED ON"));
  delay(400);
  digitalWrite(LED_EXT, LOW);
  Serial.println(F("LED OFF"));
  delay(400);

Si el LED de la placa parpadea pero el externo no:

• Pin incorrecto (silkscreen engañoso o “D4” ≠ GPIO4 en tu módulo).
• LED al revés.
• Estás midiendo en un pin de solo entrada o no conectado al header.

Nunca inyectes 5 V a un GPIO del ESP32. La lógica es 3.3 V. El pin marcado 5V en la placa, si existe, es de alimentación del regulador / salida del USB, no un nivel lógico de datos.

7. Escaneo WiFi (primer contacto con la radio)

Con blink y serial estables, el siguiente hito es comprobar la antena y el stack de red sin todavía depender de tu router con contraseña complicada: listar redes visibles.

#include <WiFi.h>
 
void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println(F("Escaneando redes 2.4 GHz..."));
 
  // Modo estación; no hace falta contraseña para escanear
  WiFi.mode(WIFI_STA);
  WiFi.disconnect(true, true);
  delay(100);
 
  int n = WiFi.scanNetworks(/*async=*/false, /*hidden=*/true);

Interpretación de taller:

• Cero redes en un edificio con WiFi: antena dañada (raro en módulo nuevo), placa defectuosa, o estás en un entorno con solo 5 GHz visible para tú (el ESP32 clásico usa 2.4 GHz).
• Redes sí, pero no la tuya: el SSID está en 5 GHz solamente, o el nombre es el de la banda que no ves en el celular.
• RSSI muy bajo (−90 dBm): alejate del microondas, del USB 3 ruidoso o acercate al AP.

Conectar a una red concreta es el siguiente paso natural (WiFi.begin(ssid, pass) + espera de WL_CONNECTED). Dejalo para cuando el scan sea estable: así separas “la radio funciona” de “la contraseña o el DHCP fallan”.

8. Problemas frecuentes y orden de depuración

Si tu proyecto va hacia sensores de movimiento en red, el radar RCWL y el PIR se eligen por física del sensor, no por el micro: RCWL-0516 vs PIR. El ESP32 solo aporta el canal de aviso.

Para alimentación desde baterías o boost, no improvises con cualquier módulo: el elevador MT3608 tiene límites y un potenciómetro que castiga si lo giras a ciegas. Para bajar de 12 V a 5 V/3.3 V regulados en prototipo, el LM2596 es el buck de banco habitual — mide siempre la salida.

9. Después del primer proyecto: qué no hacer todavía

• No conectes un L298 y motores al mismo USB del notebook “porque el ESP32 tiene 5 V”. Los motores piden fuente aparte y GND común.
• No asumas que un sketch de Arduino Uno de 5 V se pega con cinta. Revisa los niveles.
• No dejes while(!Serial) eterno en un ESP32 que no siempre espera CDC como un Leonardo; en algunas placas te quedas colgado sin monitor.
• No publiques en internet credenciales en el código si el repo es público; para un lab casero, un secrets.h fuera de git alcanza.

Cuando quieras comparar si este camino te sirve o si debiste empezar en Nano, vuelve a ESP32 vs Arduino. Si el siguiente paso es un robot, el driver y la mecánica importan más que el WiFi: robot seguidor de línea.

10. Checklist de cierre del día uno

1. El PC ve un puerto serie al conectar el cable de datos.
2. El core ESP32 está instalado y la placa seleccionada.
3. Blink en LED de placa OK.
4. Serial.println legible a 115200.
5. LED externo en un GPIO documentado OK.
6. WiFi.scanNetworks lista al menos el router de 2.4 GHz de la casa o del lab.

Si los seis puntos están en verde, ya no eres “el que no pudo instalar el ESP32”: eres el maker con base para sensores, MQTT y deep sleep. El catálogo de Tecnoelite tiene las placas Lolin y NodeMCU ESP32 cuando necesites reponer o armar un segundo nodo; revisa la ficha para el conector (USB-C) y si trae cargador de LiPo según tu diseño.

Preguntas frecuentes

¿Por qué este tutorial no usa ESP8266?

Porque en el catálogo actual de proyectos nuevos el camino más habitual es ESP32: más memoria, dual-core en la mayoría de módulos, Bluetooth además de WiFi, y menos saltos cuando el proyecto crece. El ESP8266 sigue vivo en placas antiguas; si ya tienes una, los conceptos de driver y serial te sirven, aunque el pinout y algunas librerías cambian al pasar a ESP32.

¿Qué placa elijo: Lolin con LiPo o NodeMCU ESP32?

Si vas a prototipar portátil con batería, la Lolin con cargador reduce módulos externos. Si priorizas USB-C, shield de expansión y uso en banco, la NodeMCU ESP32 suele ser más cómoda. Ambas sirven para este tutorial.

¿Puedo usar PlatformIO en lugar del Arduino IDE?

Sí. PlatformIO con board = esp32dev (o la board específica) es excelente cuando el proyecto crece. Para el primer día, el IDE oficial reduce variables: un solo instalador, Boards Manager, y el mismo flujo que la mayoría de tutoriales en español.

¿Es normal que el ESP32 se caliente un poco con WiFi?

Un leve calor en el módulo al transmitir es normal. Calor excesivo, olor o reinicios bajo carga de RF apuntan a fuente débil (USB de puerto limitado), cortos o un regulador al límite. Prueba otro puerto USB o un hub con alimentación.

¿Cómo conecto un sensor ultrasónico sin quemar el ESP32?

Muchos HC-SR04 entregan eco a 5 V. Usa un divisor resistivo en el pin de eco, un módulo a 3.3 V, o un sensor cuya hoja de datos confirme interfaz compatible. El AJ-SR04M se usa mucho en 5 V con Nano; en ESP32 verifica el modo y los niveles antes de cablear directo.

¿El botón BOOT borra mi programa?

No en el sentido de “formatear la flash por tocarlo”. BOOT pone al chip en modo descarga cuando el reset ocurre en la secuencia correcta. Tu aplicación sigue en flash hasta que subes otra o borras particiones a propósito. Si la placa no arranca la app, a veces es un sketch que crashea al inicio: sube un Blink mínimo para recuperar la calma.