ESPDuino-32 pines: equivalencias con el Uno, shields y Wi-Fi
Pines del ESPDuino-32: tabla de equivalencias con el Arduino Uno, la trampa de 3,3 V, qué shields no funcionan, la placa en el IDE de Arduino y un primer Wi-Fi.
El ESPDuino-32 es una placa de desarrollo que lleva un ESP32 al tamaño y a la distribución de pines de un Arduino Uno: por fuera parece un Uno, pero tiene un procesador de doble núcleo a 240 MHz, Wi-Fi y Bluetooth. Es un diseño de DOIT y una placa casi idéntica se vende como WEMOS D1 R32. En esta guía relacionamos uno por uno los pines del ESPDuino-32 con los del Uno, vemos qué shields del Uno funcionan y cuáles no, y explicamos cómo elegir la placa en el IDE de Arduino.
Su gran atractivo es que puedes montar los shields del Uno que ya tienes y sumarle Wi-Fi a tu proyecto. Pero hay una trampa importante: el Uno trabaja a 5 V, mientras que todos los pines de señal del ESPDuino-32 trabajan a 3,3 V y no toleran 5 V. Los shields y los sensores no conocen esa diferencia, y con una conexión equivocada puedes quemar un pin o incluso la placa entera. Conozcamos primero la placa.

¿Qué es el ESPDuino-32? Comparación con el Uno y el ESP32 DevKit
En el corazón del ESPDuino-32 está el módulo ESP32-WROOM-32, el mismo de las placas ESP32 clásicas. En cuanto al software es un ESP32 común y corriente: todos los sketches y librerías escritos para el ESP32 funcionan en él. La diferencia está en el diseño de la placa: los pines llegan a headers con el formato del Uno y se suman un conector DC, un regulador de 3,3 V y un conversor USB-serie (casi siempre un CH340). Si nunca usaste un ESP32, tienes lo básico en ¿Qué es el ESP32?
| Característica | Arduino Uno R3 | ESPDuino-32 | ESP32 DevKit |
|---|---|---|---|
| Procesador | ATmega328P, 8 bits, 16 MHz | ESP32, doble núcleo, 240 MHz | ESP32, doble núcleo, 240 MHz |
| RAM | 2 KB | 520 KB | 520 KB |
| Flash | 32 KB | 4 MB | 4 MB |
| Nivel lógico | 5 V | 3,3 V | 3,3 V |
| Inalámbrico | No | Wi-Fi + Bluetooth | Wi-Fi + Bluetooth |
| Entradas analógicas | 6 canales, 10 bits | 6 canales en el header del Uno, 12 bits | Hasta 18 canales, 12 bits |
| Tamaño y shields | 68,6 × 53,4 mm, shields del Uno | Mismo tamaño que el Uno, acepta shields | Entra en la protoboard, sin shields |
| Chip USB | ATmega16U2 | Casi siempre CH340 | CP2102 o CH340 |
¿Cuál te conviene comprar? Si tienes shields del Uno, quieres atornillar la placa en una caja usando los agujeros del Uno o sigues un libro o curso pensado para el Uno, el ESPDuino-32 te facilita la vida. Si trabajas en protoboard, necesitas pines del ESP32 que no llegan al header del Uno, como GPIO 32 y 33, o el tamaño del equipo importa, el ESP32 DevKit clásico es mejor opción. El código es el mismo en las dos; solo cambian los números de pin.
Pines del ESPDuino-32: ¿qué GPIO hay detrás de cada pin del Uno?
Aunque la placa está rotulada D2, D3, A0 como un Uno, en el código casi siempre tienes que escribir el número de GPIO. La tabla muestra el GPIO del ESP32 que corresponde a cada pin del Uno y qué cuidar al usarlo. También puedes consultar la lista completa de pines del ESP32 en la herramienta Pinout.
| Pin del Uno | GPIO del ESP32 | Estado | Nota |
|---|---|---|---|
| D0 (RX) | GPIO 3 | No usar | Línea serie del USB |
| D1 (TX) | GPIO 1 | No usar | Línea serie del USB |
| D2 | GPIO 26 | Seguro | También sirve como salida DAC2 |
| D3 | GPIO 25 | Seguro | También sirve como salida DAC1 |
| D4 | GPIO 17 | Seguro | También se usa como TX de Serial2 |
| D5 | GPIO 16 | Seguro | También se usa como RX de Serial2 |
| D6 | GPIO 27 | Seguro | Entrada táctil (T7) |
| D7 | GPIO 14 | Con cuidado | Saca una señal PWM breve al arrancar |
| D8 | GPIO 12 | Con cuidado | Pin de arranque: si está en HIGH al encender, la placa no arranca |
| D9 | GPIO 13 | Seguro | Entrada y salida de uso general |
| D10 | GPIO 5 | Con cuidado | SPI SS; saca una señal PWM breve al arrancar |
| D11 | GPIO 23 | Seguro | SPI MOSI |
| D12 | GPIO 19 | Seguro | SPI MISO |
| D13 | GPIO 18 | Seguro | SPI SCK; a diferencia del Uno, no tiene LED |
| A0 | GPIO 2 | Con cuidado | ADC2 (no lee con Wi-Fi encendido), LED integrado, pin de arranque |
| A1 | GPIO 4 | Con cuidado | ADC2 (no lee con Wi-Fi encendido) |
| A2 | GPIO 35 | Solo entrada | ADC1, funciona junto con el Wi-Fi |
| A3 | GPIO 34 | Solo entrada | ADC1, funciona junto con el Wi-Fi |
| A4 | GPIO 36 (VP) | Solo entrada | ADC1; no es SDA como en el Uno |
| A5 | GPIO 39 (VN) | Solo entrada | ADC1; no es SCL como en el Uno |
| SDA | GPIO 21 | Seguro | Línea de datos I2C |
| SCL | GPIO 22 | Seguro | Línea de reloj I2C |
En la parte analógica hay dos trampas más. La primera: A0 (GPIO 2) y A1 (GPIO 4) pertenecen a la unidad ADC2 del ESP32, que no puede leer mientras el Wi-Fi está encendido; en proyectos con Wi-Fi conecta los sensores analógicos a A2–A5 (ADC1). La segunda: el ADC del ESP32 es de 12 bits, así que analogRead() devuelve 0–4095 en lugar de 0–1023, y la escala completa es de unos 3,3 V, no de 5 V. Las cuentas tipo "valor × 5,0 / 1023" de los sketches del Uno tienen que cambiar; mejor todavía, usa analogReadMilliVolts(), que entrega un resultado calibrado en milivoltios.
La trampa de 3,3 V: ¿funcionan los shields del Uno en el ESPDuino-32?
Que un shield encaje no quiere decir que funcione. Un shield da problemas en el ESPDuino-32 de tres maneras: manda una señal de 5 V al ESP32 y daña el pin, espera lógica de 5 V y no siempre toma 3,3 V como HIGH, o deja en los pines A2–A5, que son solo de entrada, una tarea que necesita una salida. Como el pin 5V de la placa entrega 5 V igual que el Uno, el shield sí se alimenta; los problemas aparecen siempre en los pines de señal. Así les va a los shields más comunes:

| Shield | Estado | Por qué |
|---|---|---|
| CNC Shield V3 (A4988 / DRV8825) | Casi siempre funciona | STEP y DIR caen en GPIO que pueden ser salidas; las versiones de GRBL para ESP32 traen un mapa de pines listo para esta placa |
| Shield de relés (módulo relé) | Casi siempre funciona | Los relés se alimentan del pin 5V y el transistor que los maneja conduce también con una señal de 3,3 V |
| Shield data logger (tarjeta SD + RTC) | En parte | Una SD en D10–D13 funciona, porque esos son los pines SPI del ESP32; el RTC falla si su I2C solo llega a A4/A5 |
| Shield de motores L293D | Inestable | El 74HC595 a 5 V apenas lee entradas de 3,3 V y su línea de datos está en D8 (GPIO 12), que además puede impedir el arranque |
| Shield LCD Keypad | Riesgoso | Los botones llegan a A0 por una escalera de resistencias conectada a 5 V, así que GPIO 2 recibe 5 V cuando no hay botón presionado |
| Shield TFT paralelo de 2,4 pulgadas | No funciona | Sus líneas de control están en A0–A4; A2, A3 y A4 son solo de entrada y no pueden manejar la pantalla |
| Shields viejos que toman el I2C solo de A4/A5 | No funciona | En el ESPDuino-32 el I2C está en los pines SDA/SCL separados (GPIO 21/22) |
Pines de arranque (strapping): cuidado con D8 y A0
Al encender, el ESP32 revisa el nivel de algunos pines para decidir cómo arrancar. En el ESPDuino-32 dos de ellos llegan al header del Uno. Si D8 (GPIO 12) está en HIGH al arrancar, el ESP32 intenta iniciar su memoria flash con el voltaje equivocado y la placa no arranca. A0 (GPIO 2) tiene que estar al aire o en LOW mientras subes el código. Si conectaste a D8 un módulo o shield con pull-up y la placa no arranca, ese es tu primer sospechoso. D7 (GPIO 14) y D10 (GPIO 5) también sacan una señal PWM breve al arrancar, así que un relé en esos pines puede hacer un clic corto al encender.
Instalación del ESPDuino-32 y elección de placa en el IDE de Arduino
- Instala en el IDE de Arduino el paquete de placas esp32 de Espressif; los pasos están en ¿Qué es el ESP32?
- Conecta la placa por USB. Si no aparece el puerto, instala el driver de su chip USB (casi siempre un CH340) y verifica que tu cable sea de datos.
- En Herramientas > Placa > esp32 elige WEMOS D1 R32: en esta definición los nombres D2–D13 y A0–A5 coinciden exactamente con lo rotulado en la placa. DOIT ESPduino32 o ESP32 Dev Module también funcionan, pero entonces tienes que usar solo números de GPIO.
- Elige el puerto de la placa; si la carga falla con Upload Speed en 921600, bájala a 115200.
- Pulsa Subir y abre el Monitor Serie a 115200 baudios. Si la placa no entra en modo de carga, revisa las soluciones de ESP32 Failed to Connect.
Primera prueba: LED integrado, D13 y una lectura analógica
El LED azul integrado de la placa está en GPIO 2, no en D13 como en el Uno. El sketch de abajo enciende por turnos el LED integrado y un LED conectado a D13 (GPIO 18) con una resistencia de 220 Ω, y muestra en el Monitor Serie el valor de un potenciómetro conectado a A2 (GPIO 35). Conecta las patas extremas del potenciómetro a 3V3 y GND, no a 5V; la pata central va a A2.
1// ESPDuino-32: Uno adları yerine GPIO numaraları / GPIO numbers instead of Uno pin names
2const int ONBOARD_LED = 2; // kart üstü mavi LED (A0 ile aynı pin) / onboard blue LED (same pin as A0)
3const int LED_D13 = 18; // Uno D13 = GPIO 18
4const int POT_A2 = 35; // Uno A2 = GPIO 35 (ADC1, yalnız giriş / input only)
5
6void setup() {
7 Serial.begin(115200);
8 pinMode(ONBOARD_LED, OUTPUT);
9 pinMode(LED_D13, OUTPUT);
10 analogReadResolution(12); // 0–4095 (varsayılan / default)
11}
12
13void loop() {
14 int raw = analogRead(POT_A2); // 0–4095, Uno'daki gibi 0–1023 değil / not 0–1023 like the Uno
15 int mv = analogReadMilliVolts(POT_A2); // kalibre edilmiş mV / calibrated millivolts
16 Serial.printf("A2 ham / raw: %d gerilim / voltage: %d mV\n", raw, mv);
17
18 digitalWrite(ONBOARD_LED, HIGH); // LED'ler sırayla / LEDs take turns
19 digitalWrite(LED_D13, LOW);
20 delay(500);
21 digitalWrite(ONBOARD_LED, LOW);
22 digitalWrite(LED_D13, HIGH);
23 delay(500);
24}Primer proyecto Wi-Fi: controlar un LED desde el celular
Ahora veamos lo que de verdad diferencia a esta placa del Uno. El sketch de abajo conecta el ESPDuino-32 a la red de tu casa y levanta un pequeño servidor web. Escribe la IP que aparece en el Monitor Serie en el navegador de un celular conectado a la misma red y verás un botón que enciende y apaga el LED de D13 y la lectura del potenciómetro de A2 en milivoltios. Pusimos el potenciómetro en A2 a propósito: con el Wi-Fi encendido, A0 y A1 no pueden leer valores analógicos.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
5const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
6
7const int LED_PIN = 18; // Uno D13 = GPIO 18
8const int POT_PIN = 35; // Uno A2 = GPIO 35 (ADC1: Wi-Fi ile çalışır / works with Wi-Fi)
9
10WebServer server(80);
11bool ledOn = false;
12
13String page() {
14 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
15 html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
16 html += "<title>ESPDuino-32</title></head>";
17 html += "<body style='font-family:sans-serif;text-align:center'><h1>ESPDuino-32</h1>";
18 html += "<p>LED (D13): <b>" + String(ledOn ? "ON" : "OFF") + "</b></p>";
19 html += "<p><a href='/toggle'><button style='font-size:24px;padding:12px 32px'>LED</button></a></p>";
20 html += "<p>A2: " + String(analogReadMilliVolts(POT_PIN)) + " mV</p>";
21 html += "</body></html>";
22 return html;
23}
24
25void handleRoot() {
26 server.send(200, "text/html", page());
27}
28
29void handleToggle() {
30 ledOn = !ledOn;
31 digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
32 server.sendHeader("Location", "/"); // ana sayfaya dön / back to the main page
33 server.send(303);
34}
35
36void setup() {
37 Serial.begin(115200);
38 pinMode(LED_PIN, OUTPUT);
39
40 WiFi.mode(WIFI_STA);
41 WiFi.begin(WIFI_SSID, WIFI_PASS);
42 Serial.print("Baglaniyor / Connecting");
43 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
44 delay(500);
45 Serial.print(".");
46 }
47 Serial.println();
48 Serial.print("IP: ");
49 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
50
51 server.on("/", handleRoot);
52 server.on("/toggle", handleToggle);
53 server.begin();
54}
55
56void loop() {
57 server.handleClient(); // gelen istekleri işle / handle incoming requests
58}El sketch define dos direcciones: / envía la página principal y /toggle cambia el estado del LED y redirige el navegador de vuelta a la página principal. Cada vez que recargas la página, el potenciómetro se vuelve a leer. Para una interfaz que se actualice en vivo sin recargar, usa el método de ESP32 Async Web Server y WebSocket. Si la placa no se conecta, comprueba que tu red sea de 2,4 GHz; el ESP32 no ve redes de 5 GHz.
Alimentación: USB, conector DC y pin 3V3
| Fuente | Voltaje | Nota |
|---|---|---|
| USB | 5 V | Suficiente para desarrollo y circuitos pequeños |
| Conector DC (jack) | Normalmente 7–12 V (revisa lo impreso en tu placa) | El regulador se calienta; con 9 V trabaja más frío que con 12 V |
| Pin VIN | El voltaje del conector DC | Para alimentar la placa con una fuente externa |
| Pin 5V | Salida de 5 V | Alimenta shields y módulos de 5 V; acuérdate de bajar sus señales a 3,3 V |
| Pin 3V3 | Salida de 3,3 V | Para sensores; no conectes motores ni tiras LED largas |
Cuando transmite por Wi-Fi, el ESP32 puede pedir picos de casi 250 mA. Un cable o un puerto USB flojos dejan caer el voltaje en esos momentos y la placa se reinicia con "Brownout detector was triggered". Si te pasa, usa un cable corto y de buena calidad o alimenta la placa por el conector DC; los detalles están en ESP32 Brownout y Guru Meditation.
Errores comunes y cómo solucionarlos
- Un sketch del Uno no funciona: los números de pin están pensados para el Uno. pinMode(13, OUTPUT) en el ESPDuino-32 maneja GPIO 13, que es D9 y no D13; busca el número de GPIO en la tabla.
- analogRead da siempre 4095 o siempre 0: el sensor está alimentado con 5 V y su salida pasa de 3,3 V, o el sensor está en un pin ADC2 (A0, A1) con el Wi-Fi encendido.
- La pantalla I2C no aparece: está conectada a A4/A5; pasa los cables a los pines SDA/SCL (GPIO 21/22).
- La placa no arranca o se reinicia una y otra vez: algo conectado a D8 (GPIO 12) pone el pin en HIGH al encender; pasa esa pieza a otro pin.
- Con el shield puesto se calienta la placa o alguna pieza: el shield está mandando 5 V a un pin; desconecta la placa de inmediato y baja esa línea con un divisor o un conversor de nivel.
- SoftwareSerial o la librería Servo no compilan: en lugar de las librerías exclusivas de AVR usa sus equivalentes para ESP32: el puerto serie por hardware Serial2 y ESP32Servo.
El ESPDuino-32 es el camino más familiar para pasar del Uno al ESP32: el mismo tamaño y los mismos headers, pero con una frecuencia de reloj 15 veces mayor y conexión inalámbrica. Ten a mano Pines del Arduino Uno para recordar las diferencias. Todos los proyectos ESP32 de la app BlueGrays funcionan también en esta placa, así que puedes armar paso a paso el LED, el semáforo, la conexión Wi-Fi y el servidor web con su diagrama de circuito y su código; solo tienes que relacionar los pines con la tabla de arriba.
Preguntas frecuentes
¿El ESPDuino-32 es lo mismo que el WEMOS D1 R32?
En la práctica, sí. Los dos montan un módulo ESP32-WROOM-32 en una placa del tamaño del Uno y comparten la misma asignación de pines en los headers. El IDE de Arduino tiene una definición para cada uno, y la de WEMOS D1 R32 es más cómoda porque relaciona los rótulos D y A de la placa con los GPIO correctos.
¿Puedo usar shields del Arduino Uno en el ESPDuino-32?
Encajan físicamente, pero que funcionen depende del shield. Los que no mandan señales de 5 V al ESP32, no usan A2–A5 como salidas y no toman el I2C solo de A4/A5 suelen funcionar; los shields LCD Keypad y TFT paralelo no funcionan sin modificaciones.
¿El ESPDuino-32 funciona con 5 V?
La placa se alimenta con 5 V por USB o por el pin 5V, y también acepta un voltaje mayor por el conector DC. Sus pines de señal, en cambio, trabajan a 3,3 V y no toleran 5 V, así que los sensores con salida de 5 V necesitan un divisor de voltaje o un conversor de nivel.
¿En qué pin está el LED integrado del ESPDuino-32?
El LED azul integrado está conectado a GPIO 2, que en la placa aparece también como A0. A diferencia del Uno, en D13 no hay ningún LED, y la constante LED_BUILTIN vale 2.
¿Qué placa elijo en el IDE de Arduino para el ESPDuino-32?
Elige WEMOS D1 R32 si quieres usar en el código los rótulos del Uno, como D2 o A0. DOIT ESPduino32 o ESP32 Dev Module suben el código igual de bien, pero con ellas tienes que escribir los pines como números de GPIO.
¿Por qué no funciona analogRead en mi ESPDuino-32?
Lo más común es que el sensor esté en A0 o A1 con el Wi-Fi encendido; esos pines pertenecen al ADC2, que no puede leer mientras el Wi-Fi está activo. Pasa el sensor a A2–A5 (ADC1) y recuerda que el resultado va de 0 a 4095 con una escala completa de unos 3,3 V.
Proyectos para hacer después de leer esto
Ver todos los proyectos
LED Parpadeante con ESP32
Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

Parpadeo del LED interno del ESP32
Parpadeo del LED azul incorporado en el ESP32 DevKit V1. ¡No se necesitan componentes externos! El primer proyecto que debe probar cuando compra un ESP32. GPIO 2 está conectado al LED interno.

ESP32 Semáforo
Simulación de un semáforo real con 3 LED rojo-amarillo-verde. Los tiempos se aproximan a la lógica del tráfico real: rojo largo, amarillo corto, verde largo. Ejemplo clásico de control GPIO secuencial.

Lectura de la intensidad luminosa con el módulo LDR del ESP32
Visualización en tiempo real en el monitor serie del valor bruto del ADC del módulo LDR y del porcentaje relativo de luz calculado a partir de referencias de oscuridad y claridad. Este porcentaje no es una medición en lux. Explica el funcionamiento de la calibración del módulo. Es recomendable realizarlo antes del Proyecto 10, ya que se utiliza para determinar el valor umbral.

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
Añadimos un servicio mDNS (Multicast DNS) al ESP32 para que accedas a él con un nombre de host legible como bluegrays-esp.local en lugar de una dirección IP. Aunque cambie la IP que asigna el DHCP, el dispositivo siempre responde al mismo nombre. Un pequeño servidor web en la placa te permite controlar el LED desde el navegador en http://bluegrays-esp.local/.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

