Arduino o ESP32: diferencias, tabla comparativa y cuál elegir

¿Arduino o ESP32? La respuesta corta: si tu proyecto necesita Wi-Fi, Bluetooth, internet o mucha potencia de cálculo, elige el ESP32; si estás aprendiendo los fundamentos de la electrónica, quieres usar sensores y módulos de 5 V sin complicaciones y seguir cada tutorial al pie de la letra, elige el Arduino Uno. Las dos placas se programan en el Arduino IDE con las mismas órdenes digitalWrite, analogRead y Serial. La diferencia real está en el hardware: velocidad, memoria, tensión de trabajo, pines y conexión inalámbrica.

En esta guía comparamos con datos reales el Arduino Uno R3 con la placa ESP32 más común, la ESP32 DevKit (con el módulo ESP-WROOM-32): qué significan en la práctica las diferencias de procesador y memoria, qué módulos se ven afectados por los 5 V frente a los 3,3 V, cómo cambian la lectura analógica y el PWM y cuántas horas dura cada una con una batería. Después ejecutaremos el mismo código en las dos placas, compararemos brevemente la Raspberry Pi Pico y resumiremos en una tabla qué placa elegir según el tipo de proyecto.

Respuesta corta: ¿cuál y cuándo?

¿Qué son el Arduino Uno y el ESP32?

El Arduino Uno R3 es la placa más conocida de la plataforma Arduino, desarrollada en Italia. En su corazón está el microcontrolador de 8 bits ATmega328P, que funciona a 16 MHz. La placa trabaja a 5 V y su distribución de pines no ha cambiado en años, así que cientos de shields (placas de expansión que se montan encima), libros y cursos son compatibles con ella. Su diseño sencillo te deja ver exactamente qué pasa: cuando escribes HIGH en un pin, ahí hay de verdad 5 V. El nuevo Uno R4 trae un procesador Arm de 32 bits a 48 MHz y 32 KB de RAM, y la versión R4 WiFi añade un ESP32-S3 en la placa para la conexión inalámbrica; en este artículo, cuando decimos "Uno" nos referimos al R3, que sigue siendo el más común. Para conocer mejor la plataforma, lee ¿Qué es Arduino?.

El ESP32, en cambio, es un sistema en chip (SoC) de 32 bits que Espressif lanzó en 2016 con Wi-Fi y Bluetooth en el mismo chip. La placa que tienes en la mano es una placa de desarrollo que lleva este chip: incluye un convertidor USB-serie, un regulador de 3,3 V y los botones EN y BOOT. Un detalle importante: el ESP32 no es un Arduino, pero gracias al núcleo Arduino que ofrece Espressif se programa en el Arduino IDE como si lo fuera. Para la instalación y los primeros proyectos, ¿Qué es el ESP32? es un buen punto de partida.

La gran tabla comparativa: Arduino Uno, ESP32 y Raspberry Pi Pico

Procesador y memoria: ¿qué significan los números en la práctica?

El procesador del Uno ejecuta unos 16 millones de instrucciones por segundo y trabaja con números de 8 bits cada vez; una operación de 32 bits con long o float necesita decenas de instrucciones y no hay unidad de coma flotante (FPU) por hardware. El ESP32 funciona a 240 MHz con números de 32 bits y tiene una FPU de precisión simple. Por eso, en un cálculo con muchos float, el ESP32 puede ser decenas o incluso cientos de veces más rápido que el Uno. No notarás la diferencia al encender un LED o leer un sensor unas cuantas veces por segundo, pero es decisiva para filtrar señales, procesar audio, cifrar datos o calcular animaciones para cientos de LED. Un pequeño consejo: la FPU del ESP32 solo trabaja con float; las operaciones con double se hacen por software y son bastante más lentas.

La diferencia de memoria la notarás mucho más a menudo. Los 2 KB de RAM del Uno se reparten entre tus variables, los búferes de Serial y el espacio que reservan las librerías. Cuando la RAM se agota, el compilador casi nunca avisa; el programa se cuelga al azar o se comporta de forma extraña. Situaciones típicas en las que el Uno se queda rápido sin RAM:

• Pantalla OLED: solo el búfer de imagen de una pantalla SSD1306 de 128×64 ocupa 1 KB, la mitad de la RAM (ver Pantalla OLED).
• LED direccionables: cada LED WS2812B ocupa 3 bytes; una tira de 300 LED necesita 900 bytes (ver WS2812B NeoPixel).
• Datos de internet: el JSON que devuelve un servicio meteorológico puede ocupar varios KB; no cabe en el Uno, pero el ESP32 lo procesa sin problemas.
• Concatenar String: los objetos String que crecen dentro de un bucle fragmentan la poca RAM y pueden provocar un bloqueo horas después.
• Tarjeta SD: la librería SD reserva un búfer de sector de 512 bytes; junto con las librerías de pantalla y sensores, el límite llega enseguida.

La diferencia de tensión: 5 V y 3,3 V

Esta es la diferencia que más se pasa por alto. Los pines del Uno trabajan con lógica de 5 V: una salida HIGH da 5 V y las entradas por encima de 3 V se leen como HIGH. Los pines del ESP32 trabajan con lógica de 3,3 V y no toleran 5 V. Aplicar 5 V a un pin quizá no mate al ESP32 al instante, pero fuerza los diodos de protección internos y puede destruir el chip con el tiempo o de golpe. Al revés hay menos problema: el HIGH de 3,3 V del ESP32 supera por poco el umbral de 3 V del Uno, así que normalmente se lee como HIGH, aunque tampoco es un diseño seguro. Así se comportan los módulos más habituales con cada placa:

Pines, lectura analógica y PWM

En el Uno, los 20 pines se comportan más o menos igual: cada uno puede ser entrada o salida, entrega hasta 20 mA sin problemas y no afecta al arranque. La ESP32 DevKit tiene más pines sobre el papel, pero no todos son iguales: los GPIO 6–11 están conectados a la flash interna y no se pueden usar, los GPIO 34–39 son solo de entrada y los GPIO 0, 2, 5, 12 y 15 deben tener ciertos niveles durante el arranque. En la práctica puedes usar con comodidad unos 20–25 pines. Puedes ver el mapa de pines de tu placa en la herramienta Pinout.

En lectura analógica, el ADC de 10 bits del Uno divide el rango de 0–5 V en 1024 pasos; cada paso es de unos 4,9 mV y la lectura es bastante lineal. El ADC de 12 bits del ESP32 da 4096 pasos, pero con la configuración por defecto no distingue valores por debajo de unos 0,15 V ni por encima de 3,1 V, tiene ruido y los pines ADC2 no funcionan con el Wi-Fi activo. Si necesitas una tensión precisa en el ESP32, usa analogReadMilliVolts() y conecta el sensor a los pines ADC1 (GPIO 32–39). En PWM gana el ESP32: el Uno solo ofrece PWM de 8 bits en 6 pines a 490 o 980 Hz, mientras que el ESP32 puede llevar 16 canales con frecuencia y resolución ajustables a casi cualquier pin de salida. Además tiene 2 DAC (GPIO 25 y 26) que generan una tensión analógica real. Para los fundamentos del PWM, consulta ¿Qué es PWM?.

El mismo código en las dos placas: ¿qué cambia?

La buena noticia: todo lo que has aprendido en Arduino también sirve en el ESP32. El código siguiente lee un potenciómetro, muestra la tensión en el Monitor Serie y enciende el LED de la placa cuando el valor supera la mitad. La línea #if defined(ESP32) detecta para qué placa se compila y solo cambia el número de pin, la tensión de referencia y la resolución del ADC. Conecta los extremos del potenciómetro a 5V y GND en el Uno, o a 3V3 y GND en el ESP32; el pin central va a A0 en el Uno o a GPIO 34 en el ESP32, y abre el Monitor Serie a 115200 baudios. Las principales diferencias fuera del código están en la tabla.

1// Aynı kod Uno ve ESP32'de çalışır / The same sketch runs on Uno and ESP32
2#if defined(ESP32)
3const int LED_PIN = 2;        // DevKit dahili LED / DevKit onboard LED
4const int POT_PIN = 34;       // ADC1 pini, Wi-Fi ile de çalışır / ADC1 pin, works with Wi-Fi too
5const float VREF = 3.3;       // ESP32 pinleri 3,3 V / ESP32 pins are 3.3 V
6const int ADC_MAX = 4095;     // 12 bit
7#else
8const int LED_PIN = 13;       // Uno dahili LED / Uno onboard LED
9const int POT_PIN = A0;
10const float VREF = 5.0;       // Uno referansı 5 V / Uno reference is 5 V
11const int ADC_MAX = 1023;     // 10 bit
12#endif
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17}
18
19void loop() {
20  int raw = analogRead(POT_PIN);
21  float volts = raw * VREF / ADC_MAX;
22  Serial.print("Ham / raw: ");
23  Serial.print(raw);
24  Serial.print("  Gerilim / voltage: ");
25  Serial.println(volts, 2);
26  digitalWrite(LED_PIN, raw > ADC_MAX / 2 ? HIGH : LOW);   // yarıdan fazlaysa LED yanar / LED on above half
27  delay(250);
28}

Wi-Fi, Bluetooth e internet

Lo que de verdad distingue al ESP32 es la conexión inalámbrica. La placa se conecta a redes Wi-Fi de 2,4 GHz, puede crear su propio punto de acceso, ejecuta un servidor web, envía datos a un sistema domótico por MQTT, obtiene la hora de internet con NTP y puede actualizar su firmware de forma inalámbrica (OTA). En Bluetooth admite tanto el Bluetooth clásico (perfil de puerto serie) como BLE de bajo consumo, y con ESP-NOW varios ESP32 pueden comunicarse sin router. Nada de esto viene integrado en el Uno: para Bluetooth necesitas un módulo como el HC-05, y para Wi-Fi un chip aparte como el ESP-01 y comandos AT. El código siguiente lee el mismo potenciómetro, esta vez por Wi-Fi: abre la dirección que aparece en el Monitor Serie en el navegador de un móvil conectado a la misma red y verás la tensión en milivoltios; la página se actualiza sola cada dos segundos.

1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
5const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
6const int POT_PIN = 34;              // ADC1 pini / ADC1 pin
7
8WebServer server(80);
9
10void handleRoot() {
11  uint32_t mv = analogReadMilliVolts(POT_PIN);   // kalibre edilmiş mV / calibrated mV
12  String html = "<meta name='viewport' content='width=device-width'>"
13                "<meta http-equiv='refresh' content='2'>"
14                "<h1>ESP32</h1><p>Pot: ";
15  html += mv;
16  html += " mV</p>";
17  server.send(200, "text/html", html);
18}
19
20void setup() {
21  Serial.begin(115200);
22  WiFi.begin(ssid, password);
23  while (WiFi.status() != WL_CONNECTED) delay(500);
24  Serial.print("Telefonda aç / open on your phone: http://");
25  Serial.println(WiFi.localIP());
26  server.on("/", handleRoot);
27  server.begin();
28}
29
30void loop() {
31  server.handleClient();
32}

Consumo y funcionamiento con batería

Sobre el papel, el ESP32 es a la vez la placa que más y la que menos consume. Al enviar datos por Wi-Fi tiene picos de hasta 240 mA; por eso se reinicia con el error "Brownout detector was triggered" en un puerto USB débil. En sueño profundo, en cambio, el chip gasta solo unos 10 µA. La placa Uno consume unos 45 mA sin hacer nada; aunque el ATmega328P duerma, el chip USB-serie, el regulador y el LED de encendido siguen gastando unos 30 mA. Hagamos un ejemplo: una batería de 2000 mAh alimenta un Uno que funciona sin parar durante unas 2000 / 45 ≈ 44 horas. Un ESP32 con el Wi-Fi siempre activo (100 mA de media) dura unas 20 horas. Pero si el ESP32 se despierta cada 10 minutos durante 3 segundos, envía una medida a 120 mA y duerme a 10 µA los 597 segundos restantes, la corriente media es (3 × 120 + 597 × 0,01) / 600 ≈ 0,61 mA y la misma batería dura en teoría más de 3000 horas, es decir, más de cuatro meses. Para eso necesitas una placa de bajo consumo o un módulo desnudo; el regulador y el chip USB de las DevKit estándar gastan unos mA incluso en reposo. Puedes calcular tu propio caso con la herramienta Duración de batería.

¿Dónde encaja la Raspberry Pi Pico?

La tercera opción fuerte es la Raspberry Pi Pico. Su chip RP2040 tiene dos núcleos Cortex-M0+ a 133 MHz, 264 KB de RAM y 2 MB de flash, y cuesta unos 4 dólares. Como el ESP32, funciona a 3,3 V y ofrece 26 GPIO, pero solo tiene 3 entradas analógicas. Sus mayores ventajas son un soporte de MicroPython muy maduro, la carga sencilla del firmware porque aparece en el ordenador como una memoria USB, y las unidades llamadas PIO, que generan protocolos con temporización precisa sin cargar al procesador. Si quieres conexión inalámbrica, elige la Pico W (Wi-Fi y Bluetooth); si quieres más potencia, la Pico 2 con el chip RP2350. Tienes más detalles en ¿Qué es la Raspberry Pi Pico?. La misma lectura del potenciómetro en la Pico con MicroPython queda así (pin central a GP26, extremos a 3V3 y GND):

1from machine import ADC, Pin
2import time
3
4pot = ADC(26)                  # GP26 = ADC0, potansiyometre orta ucu / pot wiper
5led = Pin("LED", Pin.OUT)      # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
6
7while True:
8    raw = pot.read_u16()                   # 0–65535 (12 bit ölçüm ölçeklenir / 12-bit reading, scaled)
9    volts = raw * 3.3 / 65535
10    print("Ham / raw:", raw, " Gerilim / voltage: {:.2f}".format(volts))
11    led.value(raw > 32767)                 # yarıdan fazlaysa yanar / on above half
12    time.sleep(0.25)

Precio y facilidad de aprendizaje

El precio por sí solo rara vez decide. Un Uno R3 original cuesta unos 25–30 $, mientras que los clones con chip USB CH340 se encuentran por 5–10 $; las ESP32 DevKit clónicas cuestan 4–8 $ y la Pico, 4 $. Así que entre un ESP32 y un clon del Uno casi no hay diferencia de precio; el coste real está en los extras: usar módulos de 5 V con el ESP32 requiere unas cuantas resistencias o un convertidor de nivel de 1–2 $, y añadir Wi-Fi al Uno exige un módulo aparte. En cuanto al aprendizaje, gana el Uno: eliges la placa y pulsas Subir, los mensajes de error y los ejemplos son los mismos desde hace años y no hay problemas de niveles con los módulos de 5 V. Con el ESP32 primero instalas el paquete de placas de Espressif y, si hace falta, el driver del chip USB (CP2102 o CH340), eliges el modelo de placa correcto y, en algunas placas, mantienes pulsado BOOT durante la subida; además, parte de los ejemplos de internet se escribió para versiones antiguas del núcleo y puede no compilar (en el núcleo 3.x, por ejemplo, ledcAttach sustituye a ledcSetup). Son obstáculos que se superan en unas horas, pero si montas circuitos por primera vez, en el Uno es más fácil saber si un fallo viene del código o del cableado.

¿Qué placa para cada proyecto?

Errores frecuentes y falsos mitos

• "El ESP32 siempre es mejor": es más potente, pero sus pines de 3,3 V, los pines que afectan al arranque, el botón BOOT y las caídas de tensión pueden agotar a un principiante. Para aprender lo básico, el Uno da menos sorpresas.
• Conectar un sensor de 5 V directamente al ESP32: conectar señales de 5 V, como la salida ECHO del HC-SR04, sin divisor puede dañar el pin.
• Leer un pin ADC2 con el Wi-Fi activo: los GPIO 0, 2, 4, 12–15 y 25–27 no leen valores analógicos mientras funciona el Wi-Fi; pasa el sensor a GPIO 32–39.
• Olvidar la RAM del Uno: si el código compila pero la placa se cuelga al azar, puede que se haya agotado la RAM; pon los textos fijos dentro de F("...") y evita concatenar String en bucles.
• Alimentar el ESP32 con un USB débil: si la placa se reinicia al activar el Wi-Fi, usa un buen cable de datos y un adaptador de al menos 1 A.
• Confundir la Pico con la Pico W: la Pico normal no tiene Wi-Fi; para un proyecto inalámbrico, compra el modelo con la W en el nombre.

En resumen, el Arduino Uno es la placa para aprender, el ESP32 la placa para conectarse y la Raspberry Pi Pico la placa para experimentar con Python. Si te preguntas qué modelo de la familia Arduino te conviene, echa un vistazo a ¿Qué Arduino comprar?. En la app BlueGrays encontrarás decenas de proyectos para Arduino, ESP32 y Pico, desde encender un LED hasta un servidor web Wi-Fi y desde un reloj NTP hasta una pantalla del tiempo, cada uno con su esquema y su código paso a paso.