TunaTek ESP32

Monitor serie y depuración en el ESP32: deja de adivinar

2026-10-07T00:00:00+00:00

Cuando algo no funciona, la tentación es cambiar código a ciegas. Eso alarga el problema. Lo que de verdad ahorra tiempo es ver qué está pasando. Y para eso tienes el monitor serie y los logs.

El monitor serie, bien configurado

void setup() {
  Serial.begin(115200);
  Serial.println("Arrancando…");
}

Tres cosas que casi todos olvidan:

La velocidad debe coincidir (115200 es el estándar). Si ves ��, no coincide.
Tras Serial.begin() da un respiro antes de imprimir; a veces las primeras líneas se pierden.
El monitor resetea la placa al abrirse en muchas configuraciones: no te asustes si «arranca solo».

Si no ves nada:

¿Está el monitor en el puerto correcto?
¿La placa usa USB nativo (S3/C3) y estás mirando el puerto equivocado?
¿Cerraste otro programa que tenía el puerto abierto?

Logs por niveles (si usas ESP-IDF)

En lugar de printf a lo loco, usa niveles:

#include "esp_log.h"
static const char *TAG = "app";

ESP_LOGI(TAG, "info");
ESP_LOGW(TAG, "aviso");
ESP_LOGE(TAG, "error");

Puedes subir o bajar el nivel por componente desde menuconfig, y en producción dejar solo errores. Eso no lo da un printf.

Los mensajes que te están contando el problema

Al arrancar, el ESP32 imprime un montón de información útil:

rst:0x... → por qué se reinició: power-on, watchdog, pánico, brownout.
Brownout detector was triggered → falta de corriente. Cambia el cable, el puerto USB o añade un condensador.
Guru Meditation Error → un panic. Debajo viene un backtrace con las direcciones; con idf.py monitor se traduce solo a nombres de función.
Task watchdog got triggered → tu loop() o una tarea se quedó atascada.

Aprender a leer esas cuatro líneas resuelve la mitad de los problemas.

Técnicas que funcionan

Bisección: comenta la mitad del código. El problema está en la otra mitad. Repite.
Serial.println estratégico: marca por dónde pasa, no valores sueltos. Mejor [sensor] leído: %d.
LED de estado: un LED que parpadea rápido = «estoy aquí». Sin monitor.
Multímetro: mide alimentación y niveles antes de culpar al código.
Analizador lógico (barato): imprescindible para I2C/SPI. Ver el bus es otro nivel.
JTAG (S3/C3): puntos de ruptura de verdad cuando el bug es escurridizo.

Errores típicos

Cambiar código al azar sin mirar el monitor.
Ignorar un brownout pensando que es software.
No leer el backtrace (ahí está la línea exacta).
Usar delay() en el loop y comerse el watchdog.
Depurar a 9600 baudios y esperar que salga todo.

Un `loop()` que no bloquea (y no dispara el watchdog)

unsigned long last = 0;

void loop() {
  if (millis() - last >= 1000) {
    last = millis();
    // trabajo pesado aquí
  }
  // el resto del tiempo, respira
}

Resumen

Configura el monitor a 115200 y comprueba puerto y velocidad.
Usa logs con nivel (ESP-IDF) en lugar de printf sueltos.
rst:, brownout, backtrace y watchdog te dicen qué pasa; apréndelos.
Bisección + LED de estado + multímetro resuelven la mayoría.
Para buses (I2C/SPI), un analizador lógico vale su peso en oro.
Cuando el bug se esconde, JTAG (S3/C3).

Siguiente paso: con esto cierras la Introducción al ESP32. Ahora puedes seguir con Explorar o volver al hub de la serie.

Leer un pulsador bien: pull-up, antirrebote e interrupciones

2026-10-06T00:00:00+00:00

Leer un botón parece lo más fácil del mundo: digitalRead() y ya. Y luego pasa lo de siempre: una pulsación cuenta como cinco, o el pin lee ruido aleatorio cuando nadie toca nada. Ambas cosas tienen explicación y solución.

Primero: nunca dejes un pin «al aire»

Si conectas un botón entre el pin y 3V3 sin nada más, cuando no está pulsado el pin queda flotando y lee basura. Necesitas una resistencia que lo lleve a un nivel conocido:

Pull-up: el pin a HIGH en reposo; al pulsar, a GND. Es lo que uso casi siempre.
Pull-down: el pin a LOW en reposo; al pulsar, a 3V3.

El ESP32 tiene pull-up interno, así que normalmente no hace falta resistencia:

constexpr int BTN = 4;

void setup() {
  Serial.begin(115200);
  pinMode(BTN, INPUT_PULLUP);   // reposo = HIGH, pulsado = LOW
}

void loop() {
  if (digitalRead(BTN) == LOW) {
    Serial.println("pulsado");
  }
}

Ojo: los GPIO34–39 no tienen pull-up interno (son solo entrada). Si usas uno de esos, necesitas resistencia externa.

Por qué «rebota» (y por qué ves 5 pulsaciones)

Un pulsador no pasa de HIGH a LOW limpiamente. Durante unos milisegundos hace contacto y lo pierde varias veces. El ESP32, que va a 240 MHz, lo detecta todo. Eso es el bounce.

Antirrebote por software (mi favorito)

constexpr int BTN = 4;
constexpr unsigned long DEBOUNCE_MS = 30;

bool estable = HIGH;
bool ultimo = HIGH;
unsigned long cambio = 0;

void loop() {
  bool lectura = digitalRead(BTN);
  if (lectura != ultimo) {
    cambio = millis();
    ultimo = lectura;
  }
  if (millis() - cambio > DEBOUNCE_MS && lectura != estable) {
    estable = lectura;
    if (estable == LOW) Serial.println("pulsación válida");
  }
}

La idea: solo aceptas un cambio si se mantiene estable 30 ms. Es suficiente para el 99 % de los botones.

Antirrebote por hardware

Si el botón es crítico o hay mucho ruido, un RC (10 kΩ + 100 nF) y, si hace falta, un Schmitt trigger (74HC14) lo arreglan. Más piezas, pero cero código.

Interrupciones: potentes y peligrosas

Con attachInterrupt() el ESP32 ejecuta tu función al instante. Es ideal para no perder pulsaciones, pero tiene reglas:

volatile bool pulsado = false;

void IRAM_ATTR alPulsar() {   // IRAM_ATTR: debe vivir en IRAM
  pulsado = true;
}

void setup() {
  pinMode(BTN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(BTN), alPulsar, FALLING);
}

void loop() {
  if (pulsado) {
    pulsado = false;
    Serial.println("interrupción");
  }
}

Reglas de oro:

La variable compartida debe ser volatile.
La función debe llevar IRAM_ATTR (si no, puede fallar con el Wi-Fi).
No hagas trabajo pesado dentro de la ISR: marca una bandera y procésala en el loop(). Nada de Serial.print ni delay ahí dentro.
Aun con interrupción, el rebote existe: añade antirrebote igualmente.

Errores típicos

Botón sin pull-up y pines leyendo ruido → crees que el ESP32 está roto.
Usar GPIO34–39 para un botón y descubrir que no hay pull-up interno.
Poner Serial.println dentro de la ISR → cuelgues aleatorios.
Olvidar volatile → el compilador «optimiza» y la bandera nunca cambia.
No hacer antirrebote y contar 5 pulsaciones por cada una.

Resumen

Nunca dejes un pin de entrada flotando: usa INPUT_PULLUP.
Los botones rebotan; con 30 ms de antirrebote se soluciona.
Interrupciones: volatile, IRAM_ATTR, trabajo mínimo y antirrebote también.
GPI34–39 no tienen pull-up: resistencia externa obligatoria.
Con hardware (RC + Schmitt) te ahorras código si el ruido es serio.

Siguiente paso: monitor serie y depuración básica, para dejar de adivinar por qué no funciona. O vuelve al hub de la serie.

Primeros pasos con el ESP32: parpadea un LED

2026-10-05T00:00:00+00:00

El Hello World del hardware es hacer parpadear un LED. Es un ritual sencillo, pero toca todos los puntos importantes de una placa nueva: alimentación, toolchain, GPIO y carga del programa.

Qué necesitas

Elemento	Detalle
Placa	ESP32 DevKitC, ESP32-WROOM-32 o similar
LED	Cualquier color, 2 V de caída típica
Resistencia	220 Ω a 330 Ω
Software	PlatformIO (recomendado) o Arduino IDE 2.x

Consejo: muchos DevKits ya traen un LED en el pin GPIO2. Puedes usarlo para probar sin cablear nada, aunque suele estar invertido.

El pinout, en dos minutos

El ESP32 tiene GPIOs numerados del 0 al 39, pero no todos se pueden usar:

GPIO6–GPIO11 están conectados a la memoria flash SPI. No los toques.
GPIO34–GPIO39 son solo entrada (no tienen pull-up interno).
GPIO1 (TX0) y GPIO3 (RX0) se usan para el puerto serie.
GPIO0 define el modo de arranque; evita usarlo como salida.

Para un LED, cualquier GPIO de salida sirve. Usaremos GPIO2.

Código con Arduino

El core de Arduino simplifica muchísimo el arranque:

#include <Arduino.h>

constexpr int LED_PIN = 2;

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(1000);
  digitalWrite(LED_PIN, LOW);
  delay(1000);
}

`delay()` bloquea (y a veces importa)

delay() detiene la CPU entera. En un parpadeo da igual, pero en cuanto añadas Wi-Fi o varios sensores querrás usar millis():

unsigned long last = 0;
constexpr unsigned long INTERVAL = 1000;

void loop() {
  if (millis() - last >= INTERVAL) {
    last = millis();
    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
  }
}

Lo mismo con ESP-IDF (Rust)

Si prefieres Rust, el crate esp-idf-hal ofrece una API tipada. Así se ve un blink con esp-idf-svc:

use esp_idf_svc::hal::delay::FreeRtos;
use esp_idf_svc::hal::gpio::PinDriver;
use esp_idf_svc::hal::peripherals::Peripherals;

fn main() -> anyhow::Result<()> {
    esp_idf_svc::sys::link_patches();
    let peripherals = Peripherals::take()?;
    let mut led = PinDriver::output(peripherals.pins.gpio2)?;

    loop {
        led.set_high()?;
        FreeRtos::delay_ms(1000);
        led.set_low()?;
        FreeRtos::delay_ms(1000);
    }
}

La gran diferencia: en Rust el compilador te obliga a declarar el pin como salida antes de escribirlo. Muchos errores de hardware desaparecen en tiempo de compilación.

Configuración con PlatformIO

platformio.ini mínimo para el core de Arduino:

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

Y para Rust con esp-idf:

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = espidf
monitor_speed = 115200

Comprobaciones si no funciona

No compila / no encuentra la placa. Instala los drivers cp210x o ch34x según el chip USB de tu placa.
Se sube pero no parpadea. Revisa la polaridad del LED y la resistencia.
Se reinicia en bucle. Suele ser falta de corriente: usa un puerto USB que entregue al menos 500 mA.

Siguiente paso

Con el GPIO dominado, ya tienes lo esencial. El siguiente salto natural es la conectividad (Wi-Fi, MQTT), que iremos cubriendo en el blog. De momento, puedes seguir con el monitor serie y depuración o volver al hub de la serie.

VS Code + ESP-IDF: el entorno oficial con JTAG incluido

2026-10-04T00:00:00+00:00

Si has decidido usar ESP-IDF, la extensión oficial para VS Code te da lo mejor de los dos mundos: la comodidad de un editor moderno y depuración por JTAG de verdad.

Instalación

En VS Code, instala la extensión ESP-IDF (de Espressif).
Ejecuta el setup wizard (icono de ESP-IDF → Setup). La extensión descarga ESP-IDF, el toolchain y Python.
Elige la versión: hoy ESP-IDF 6.1.

Tarda bastante porque baja todo (ESP-IDF es grande). Es normal.

Crear un proyecto

ESP-IDF: New Project → plantilla (sample_project, blink…), nombre y chip. La estructura es la de ESP-IDF:

mi-proyecto/
├── CMakeLists.txt
├── sdkconfig
└── main/
    ├── CMakeLists.txt
    └── main.c

`menuconfig` desde VS Code

ESP-IDF: SDK Configuration Editor abre menuconfig en una vista web integrada: cambias opciones, buscas por texto y guarda el sdkconfig. Mucho más cómodo que la terminal.

Compilar, flashear y monitorizar

En la barra inferior tienes los botones:

Build, Flash, Monitor y Build + Flash + Monitor.
Selección de puerto serie y velocidad de monitor.
Selección de target (esp32, esp32s3, esp32c3…).

Equivale a:

idf.py build
idf.py -p /dev/ttyUSB0 flash monitor

Depuración por JTAG

Aquí está la joya. Con una placa ESP32-S3/C3 (y su USB nativo) o una sonda externa, tienes puntos de ruptura, step over, inspección de variables y pila de llamadas — sin printf.

En ESP-IDF se configura con idf.py openocd y la extensión lo integra. Es de las cosas que más tiempo ahorran cuando un bug no se deja ver.

Extensiones que pegan bien

C/C++ (IntelliSense) — la extensión la configura.
clang-format — formato automático al guardar.
Error Lens — errores en línea, sin abrir la consola.

Cuándo elegirlo

Sí: vas en serio con ESP-IDF, quieres menuconfig cómodo y depurar por JTAG.
No: si usas Arduino o MicroPython (no aplica) o si te vale la línea de comandos.

Resumen

La extensión ESP-IDF instala el SDK y el toolchain por ti.
menuconfig integrado, con búsqueda.
Botones de build/flash/monitor y selección de chip y puerto.
JTAG para depurar de verdad (S3/C3 o sonda externa).
Versión actual de ESP-IDF: 6.1.

Siguiente paso: el bloque práctico: parpadea un LED con lo que ya tienes montado. O vuelve al hub de la serie.

VS Code + PlatformIO para ESP32: el entorno que uso a diario

2026-10-03T00:00:00+00:00

Si tuviera que quedarme con un solo entorno para el ESP32, sería este. PlatformIO convierte VS Code en un IDE de verdad: build, upload, monitor y depuración, con la configuración del proyecto en un fichero de texto.

Instalación

Instala VS Code.
En Extensions, busca PlatformIO IDE e instálala.
Espera a que termine de preparar el toolchain la primera vez.

Y ya. PlatformIO se encarga de descargar compiladores y herramientas por ti.

Crear un proyecto

PlatformIO Home → New Project: nombre, placa (Espressif ESP32 Dev Module) y framework (Arduino o ESP-IDF). La estructura que genera:

mi-proyecto/
├── platformio.ini     # configuración
├── src/main.cpp       # tu código
└── lib/               # librerías propias

`platformio.ini`: el corazón

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
upload_speed = 921600

Cambiar de placa es cambiar una línea. Esto es oro cuando tienes varios proyectos:

[env:s3]
platform = espressif32
board = esp32-s3-devkitc-1
framework = arduino
monitor_speed = 115200

[env:c3]
platform = espressif32
board = esp32-c3-devkitm-1
framework = arduino

Eliges el entorno en la barra inferior y subes.

Subir y monitorizar

En la barra de estado:

✓ Build — compila.
→ Upload — compila y sube.
🔌 Serial Monitor — abre el monitor a los baudios que pusiste.

O desde la terminal:

pio run -t upload
pio device monitor

Librerías por proyecto

En lugar de instalarlas globalmente, las declaras:

lib_deps =
    adafruit/Adafruit BME280 Library@^2.2.4
    knolleary/PubSubClient@^2.8

Ventaja enorme: el proyecto lleva sus propias versiones. Si mañana una librería rompe, tu código sigue igual.

Depuración

Con una placa que lo soporte (ESP32-S3/C3) y una sonda JTAG:

debug_tool = esp-builtin

Y ya tienes puntos de ruptura de verdad, no printf. Es el salto de calidad cuando el proyecto crece.

Lo que me gusta (y lo que no)

A favor: un entorno para casi todo, configuración versionable, dependencias por proyecto, debugging real, multiplataforma.

En contra: la primera compilación descarga mucho; y si eres nuevo, hay más conceptos que en el Arduino IDE.

Resumen

Instala PlatformIO IDE en VS Code y olvídate del resto.
Toda la configuración vive en platformio.ini (versionable).
lib_deps fija las librerías por proyecto, no globalmente.
Cambiar de placa es cambiar una línea: ideal para tener un env por variante.
Con JTAG tienes depuración real.

Siguiente paso: VS Code + ESP-IDF si vas a fondo con el SDK oficial. O vuelve al hub de la serie.

Arduino IDE 2.x para ESP32: instalación paso a paso (y los errores de siempre)

2026-10-02T00:00:00+00:00

El Arduino IDE 2.x es la forma más rápida de tener un LED parpadeando. Tiene fricciones conocidas (placas, drivers, puerto), así que aquí va la guía con los tropiezos típicos ya resueltos.

1. Instalar el IDE

Descárgalo de arduino.cc (versión 2.x). Trae editor, gestor de librerías, monitor serie y gestor de placas.

2. Añadir el soporte de ESP32

En File → Preferences → Additional boards manager URLs pega:

https://espressif.github.io/arduino-esp32/package_esp32_index.json

Luego ve a Boards Manager, busca esp32 e instala esp32 by Espressif Systems. Tarda un rato: son cientos de MB.

3. Elegir la placa correcta

En Tools → Board escoge la tuya:

ESP32 Dev Module → el clásico.
ESP32S3 Dev Module, ESP32C3 Dev Module, etc. → la variante.
ESP32-WROVER solo si el módulo lleva PSRAM.

Si eliges mal la placa, suele compilar y subir, pero no arranca o se queda en bucle. Es el error número uno.

4. El puerto serie y los drivers

Aquí está el 90 % de los problemas. Mira qué chip USB-serie lleva tu placa:

Chip	Driver
CP2102 (Silicon Labs)	CP210x VCP
CH340 / CH341 (WCH)	CH341SER
USB nativo (S3/C3/C6)	no necesita driver

Si no aparece el puerto en Tools → Port, es el driver. En Linux, además, puede que necesites pertenecer al grupo dialout.

5. Subir el primer programa

void setup() {
  Serial.begin(115200);
  pinMode(2, OUTPUT);
}

void loop() {
  digitalWrite(2, !digitalRead(2));
  delay(500);
  Serial.println("parpadeo");
}

Pulsa Upload. Si se queda en Connecting..., mantén pulsado BOOT unos segundos; es el truco clásico.

6. El monitor serie

Ábrelo con el icono de la lupa y pon 115200 baudios. Si ves caracteres raros («��»), es que la velocidad no coincide.

Errores típicos y su causa

Síntoma	Causa habitual
«No such file» o puerto ausente	Driver USB-serie
`Connecting........` eterno	Botón BOOT, cable malo o placa incorrecta
Se sube pero no hace nada	Placa mal elegida (variante)
Reinicios en bucle	Falta de corriente o `GPIO12` en alto
Basura en el monitor	Velocidad distinta a 115200

Ajustes que ahorran tiempo

Activa «Show verbose output during: upload» cuando algo falle: dice la verdad.
Usa nombre de puerto fijo si tienes varias placas.
Guarda tus placas favoritas para no elegir cada vez.
Para proyectos grandes, salta a VS Code + PlatformIO: el IDE de Arduino se queda corto.

Resumen

Instala el IDE y añade la URL de placas de Espressif.
Instala «esp32 by Espressif» desde el Boards Manager.
Elige la placa correcta (esto rompe más proyectos que el código).
Resuelve el driver del chip USB-serie.
Sube, abre el monitor a 115200 y disfruta.

Siguiente paso: VS Code + PlatformIO cuando el proyecto crezca. O vuelve al hub de la serie.

¿Qué IDE usar para el ESP32? Arduino IDE, VS Code y compañía

2026-10-01T00:00:00+00:00

Elegir IDE parece una decisión pequeña y no lo es: es donde vas a pasar cientos de horas. La buena noticia es que la elección depende casi por completo del framework que hayas elegido.

La tabla

IDE	Framework ideal	A favor	En contra
Arduino IDE 2.x	Arduino	Sencillo, todo incluido	Limitado, sin depuración real
VS Code + PlatformIO	Arduino, ESP-IDF, Rust, MicroPython	Potente, multi-placa, debugging	Más configuración
VS Code + ESP-IDF	ESP-IDF	Oficial, JTAG, menuconfig	Ceñido a ESP-IDF
Thonny	MicroPython	Perfecto para empezar	Solo MicroPython
CLion / RustRover	Rust	Refactor y depuración top	Comercial / pesado

Arduino IDE 2.x

Es el «abre y funciona». Instalas la URL de placas, eliges la placa, pulsas subir. Punto.

A favor: cero fricción, gestión de librerías integrada.
En contra: editor flojo, sin IntelliSense serio, sin depurador por JTAG, y se atraganta con proyectos grandes.
Ideal para: aprender, sketches pequeños, taller.

VS Code + PlatformIO

Mi recomendación general. PlatformIO convierte VS Code en un IDE de verdad:

Un solo entorno para Arduino, ESP-IDF, Rust o MicroPython, con el mismo flujo (build / upload / monitor).
platformio.ini: la configuración del proyecto es texto, versionable.
Multiplataforma y multi-placa: cambias de ESP32 a ESP8266, STM32 o RP2040.
Depuración con debug_tool y hardware adecuado.
Gestión de dependencias por proyecto (no global).

Ideal para: casi todo, sobre todo si vas a tener varios proyectos.

VS Code + extensión ESP-IDF

Si eliges ESP-IDF, esta es la opción oficial: integra idf.py, menuconfig, el monitor serie y depuración por JTAG dentro de VS Code.

A favor: oficial, JTAG de verdad, Kconfig a un clic.
En contra: está pensado solo para ESP-IDF; el flujo es algo distinto al de PlatformIO.
Ideal para: proyectos serios con ESP-IDF.

Thonny (MicroPython)

Para MicroPython, Thonny es lo más amable que existe: un botón para flashear el firmware, REPL integrado y explorador de ficheros de la placa.

Ideal para: enseñar, aprender, prototipos rápidos.

CLion / RustRover / VS Code (Rust)

Si programas en Rust, el flujo es cargo + espflash, así que casi cualquier editor vale. VS Code con rust-analyzer es suficiente; CLion aporta mejor refactor y depurador.

Cómo elegir (sin equivocarte)

Si usas…	Usa…
Arduino core	VS Code + PlatformIO (o Arduino IDE si empiezas)
ESP-IDF	VS Code + ESP-IDF
MicroPython	Thonny
Rust	VS Code + `rust-analyzer`
Varios frameworks	VS Code + PlatformIO

No hace falta decidir para siempre: VS Code + PlatformIO cubre casi todos los frameworks, así que puedes empezar ahí y añadir la extensión de ESP-IDF cuando la necesites.

Extras que marcan la diferencia

Monitor serie con colores y timestamps: es un 30 % de tu tiempo de trabajo.
Depuración JTAG (ESP32-S3/C3): puntos de ruptura reales, no printf.
Formateo automático (clang-format) y linting.
Git integrado: el firmware también se versiona.

Resumen

Arduino IDE 2.x: empeizar rápido. PlatformIO: el más completo y versátil. VS Code + ESP-IDF: el oficial para ESP-IDF. Thonny: MicroPython.
Elige según tu framework, no por costumbre.
PlatformIO es la apuesta más segura si vas a tocar varios frameworks.
La depuración JTAG es el salto de calidad cuando el proyecto crece.

Siguiente paso: Arduino IDE 2.x paso a paso o VS Code + PlatformIO. O vuelve al hub de la serie.

Rust en el ESP32: esp-idf-hal, esp-hal y embassy sin dramas

2026-09-30T00:00:00+00:00

Rust en el ESP32 dejó de ser un experimento hace tiempo. Hoy el ecosistema esp-rs es estable y sorprendentemente agradable, con una ventaja enorme: el compilador te evita errores de memoria y de concurrencia que en C te cuestan una tarde de depuración.

La contrapartida: hay que aprender Rust y montar una toolchain aparte.

Dos rutas, no una

Ruta	Qué es	Ideal para
`esp-idf-hal`	Rust sobre ESP-IDF, con `std`	Reutilizar ESP-IDF, Wi-Fi, proyectos grandes
`esp-hal`	`no_std`, sin ESP-IDF	Control total, binarios pequeños, async
`embassy`	Framework async sobre `esp-hal`	Tareas concurrentes elegantes

La regla: si quieres Wi-Fi fácil y las APIs de Espressif, esp-idf-hal. Si quieres exprimir y no te importa lo no_std, esp-hal + embassy.

Toolchain

El instalador oficial es espup:

cargo install espup
espup install          # instala targets Xtensa y RISC-V
. $HOME/export-esp.sh  # o el script que genera

Y para flashear, cargo-espflash:

cargo install cargo-espflash
cargo espflash flash --monitor

Versión actual del HAL: esp-hal 1.2.0.

Ejemplo: blink con `esp-idf-hal` (con `std`)

use esp_idf_svc::hal::delay::FreeRtos;
use esp_idf_svc::hal::gpio::PinDriver;
use esp_idf_svc::hal::peripherals::Peripherals;

fn main() -> anyhow::Result<()> {
    esp_idf_svc::sys::link_patches();
    let peripherals = Peripherals::take()?;
    let mut led = PinDriver::output(peripherals.pins.gpio2)?;

    loop {
        led.set_high()?;
        FreeRtos::delay_ms(1000);
        led.set_low()?;
        FreeRtos::delay_ms(1000);
    }
}

Fíjate en el detalle: el compilador te obliga a declarar el pin como salida antes de escribir. En C, un pinMode olvidado es un bug silencioso; aquí no compila.

Async con `embassy`

Lo mejor del camino no_std es embassy: tareas asíncronas de verdad, sin loop() ni máquinas de estado a mano.

#[embassy_executor::task]
async fn parpadeo(mut led: Output<'static, Gpio2>) {
    loop {
        led.toggle();
        Timer::after_millis(500).await;
    }
}

Dos tareas que «duermen» a la vez sin bloquearse: es la forma moderna de escribir firmware concurrente.

Ventajas reales

Seguridad: sin use-after-free, sin carreras de datos, sin null.
Concurrencia honesta: si compila, normalmente no se pisa la memoria.
Binarios pequeños en no_std.
cargo: dependencias, tests y documentación en un solo sitio.

Inconvenientes

Curva de aprendizaje de Rust (préstamos, async, no_std).
Ecosistema más joven que Arduino: menos librerías listas.
Toolchain aparte: espup, targets, versión de Rust concreta.
Menos ejemplos y tutoriales que en C/C++.

¿Cuándo elegirlo?

Sí:

Te importa la fiabilidad y quieres menos bugs raros.
Ya sabes Rust (o quieres aprenderlo en serio).
Necesitas async real o binarios muy pequeños.
Es un proyecto a largo plazo donde el mantenimiento importa.

No:

Es tu primer contacto con microcontroladores: empieza en Arduino o MicroPython.
Necesitas una librería concreta que solo existe en C++.
Vas con prisa.

Resumen

Dos rutas: esp-idf-hal (con std, sobre ESP-IDF) y esp-hal (no_std), más embassy para async.
Toolchain con espup y flasheo con cargo-espflash.
El compilador evita errores que en C son silenciosos.
esp-hal va por la 1.2.0 y el ecosistema ya es maduro.
Merece la pena si te importa el mantenimiento y la seguridad.

Siguiente paso: cambiamos de tercio con los IDE: cuál usar y por qué. O vuelve al hub de la serie.

MicroPython y Lua en el ESP32: programar sin compilar

2026-09-29T00:00:00+00:00

Hay una forma de programar el ESP32 en la que no compilas nada: flasheas un firmware, abres una consola y escribes Python. En cinco minutos tienes un LED parpadeando. Se llama MicroPython y es la mejor puerta de entrada que existe.

La otra cara: es más lento y no todo está cubierto. Vamos a verlo con honestidad.

Qué es MicroPython

Es una implementación de Python 3 hecha para microcontroladores. Ocupa poco, cabe en el ESP32 y te da un REPL (consola interactiva) por USB o Wi-Fi.

Flashear y conectar

Se instala con esptool (el firmware lo publica micropython.org):

esptool.py --chip esp32 -p /dev/ttyUSB0 erase_flash
esptool.py --chip esp32 -p /dev/ttyUSB0 write_flash -z 0x1000 esp32-*.bin

Y para hablar con la placa, mpremote:

mpremote connect /dev/ttyUSB0
>>> import machine, time
>>> led = machine.Pin(2, machine.Pin.OUT)
>>> while True:
...     led.value(not led.value()); time.sleep(1)

Eso es todo. Sin compilar, sin setup(), sin loop(). Perfecto para aprender.

Subir tu código

El ESP32 aparece como un sistema de ficheros (en boot.py y main.py):

mpremote cp main.py :main.py     # copiar
mpremote run main.py             # ejecutar sin copiar

main.py se ejecuta solo al arrancar.

Lo bueno

Curva mínima si sabes Python (o si no, también).
Iteración instantánea: pruebas una línea y ves el resultado.
Ideal para enseñar y para taller.
Buenos módulos: machine, network, time, socket, json.

Lo malo (importante)

Velocidad: es interpretado, así que olvídate de timing fino o de procesar audio/vídeo.
Memoria: el intérprete ocupa parte de la RAM; con PSRAM mejora, pero no es C.
Periféricos: no todos los del ESP32 están expuestos. Si algo falta, normalmente hay que bajar a C.
Tiempo real: no hay tareas con prioridad real como en FreeRTOS.
Producción: para un producto serio, casi siempre se acaba en C/C++ o Rust.

¿Y Lua (NodeMCU)?

Fue popular con el ESP8266. Hoy está prácticamente aparcado: menos soporte, menos librerías y MicroPython es más cómodo y está más vivo. Para proyectos nuevos, no lo recomiendo.

Comparativa rápida

	MicroPython	Arduino	ESP-IDF
Compilar	No	Sí	Sí
Velocidad	Baja	Alta	Alta
RAM disponible	Menos	Mucha	Mucha
Tareas	No	1 loop	N tareas
Curva	Muy baja	Baja	Alta
Ideal para	Aprender, prototipos	Todo	Producto

Cuándo usarlo (y cuándo no)

Sí:

Estás aprendiendo o enseñando.
Quieres probar una idea en 10 minutos.
El proyecto es un sensor que publica y no necesita velocidad.

No:

Necesitas timing preciso o DSP.
Vas a producción con requisitos de memoria o consumo.
Necesitas un periférico que no está expuesto en Python.

Resumen

MicroPython: Python en el ESP32, sin compilar, con REPL y sistema de ficheros. Versión actual: 1.29.
Es la mejor forma de empezar y de prototipar rápido.
Es más lento y usa más RAM: no sirve para todo.
Lua/NodeMCU ya no merece la pena para proyectos nuevos.
Puedes empezar en MicroPython y bajar a C/Rust cuando el proyecto lo pida.

Siguiente paso: Rust en el ESP32, el otro extremo: máxima seguridad y control. O vuelve al hub de la serie.

ESP-IDF a fondo: proyectos, tareas, logs y particiones

2026-09-28T00:00:00+00:00

Si el core de Arduino esconde el ESP32, ESP-IDF lo enseña todo. Es el SDK oficial de Espressif y la base sobre la que se construye todo lo demás. Tiene más curva, sí, pero también te da el control que un producto necesita.

Vamos con lo importante sin perderse en la documentación.

Estructura de un proyecto

mi-proyecto/
├── CMakeLists.txt          # proyecto (casi siempre igual)
├── sdkconfig               # configuración generada
└── main/
    ├── CMakeLists.txt      # registra el main
    └── main.c

El CMakeLists.txt raíz:

cmake_minimum_required(VERSION 3.16)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(mi-proyecto)

Y el de main/:

idf_component_register(SRCS "main.c"
                       INCLUDE_DIRS ".")

Los comandos que vas a usar

idf.py set-target esp32s3   # elige el chip
idf.py menuconfig           # configura (Kconfig)
idf.py build                # compila
idf.py flash monitor        # flashea y abre el monitor

menuconfig es una de las mejores cosas de ESP-IDF: cambias opciones (Wi-Fi, logs, particiones, PSRAM) sin tocar el código, y quedan guardadas en sdkconfig.

Hola mundo con logs

#include "esp_log.h"

static const char *TAG = "app";

void app_main(void) {
    ESP_LOGI(TAG, "Arrancando…");
    ESP_LOGW(TAG, "Esto es un aviso");
    ESP_LOGE(TAG, "Y esto un error");
}

Nada de printf: usa los niveles de log. Puedes subir o bajar el nivel por componente desde menuconfig, y en producción apagarlos casi todos.

Tareas: el corazón de ESP-IDF

Aquí está la gran diferencia con Arduino. En lugar de un loop(), creas tareas de FreeRTOS con prioridad y tamaño de pila propios:

void tarea_sensor(void *arg) {
    while (1) {
        leer_sensor();
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void app_main(void) {
    xTaskCreate(tarea_sensor, "sensor", 4096, NULL, 5, NULL);
}

Ventajas reales:

Paralelismo de verdad: una tarea mide, otra publica por MQTT.
vTaskDelay no bloquea el resto del sistema.
Controlas pila y prioridad, que es lo que evita los reinicios raros.

Particiones y OTA

La flash no es un bloque único: está particionada (tabla partitions.csv). Por defecto hay dos ranuras de aplicación (app0 y app1) para poder hacer OTA (actualización por Wi-Fi) con rollback si algo falla.

# Name,   Type, SubType, Offset,  Size
nvs,      data, nvs,     0x9000,  0x4000
factory,  app,  factory, 0x10000, 1M

Ejemplo de partición con OTA:

# Name,   Type, SubType,  Size
nvs,      data, nvs,      0x4000
otadata,  data, ota,      0x2000
phy_init, data, phy,      0x1000
factory,  app,  factory,  1M
ota_0,    app,  ota_0,    1M
ota_1,    app,  ota_1,    1M

Wire: ¿Arduino o ESP-IDF?

	Arduino core	ESP-IDF
Curva	Baja	Alta
Control	Medio	Total
Tareas	1 loop	N tareas
Memoria	Automática	Tú decides
OTA	Fácil	Completo (rollback)
Logs	`Serial`	Niveles por componente

Cuándo merece la pena

Sí: producto, batería, timing fino, OTA serio, muchos periféricos.
No: si solo quieres leer un sensor y publicar, Arduino te lleva en una tarde y te sobra.

Consejo: puedes mezclar. El core de Arduino es ESP-IDF por debajo, así que desde un sketch puedes llamar a APIs de ESP-IDF cuando las necesites.

Resumen

ESP-IDF es el SDK oficial: CMake + idf.py + menuconfig.
Usa tareas de FreeRTOS, no un loop().
Logs por niveles con ESP_LOGx en lugar de printf.
La flash está particionada; el OTA con rollback viene casi gratis.
Versión actual: 6.1.

Siguiente paso: MicroPython y Lua para el extremo opuesto: cero compilación. O vuelve al hub de la serie.

Arduino core para ESP32 a fondo: instalar, entender y no pelearse

2026-09-27T00:00:00+00:00

El «Arduino core para ESP32» es la razón por la que medio mundo usa este chip. Te deja escribir pinMode() y digitalWrite() como en un Arduino UNO, pero por debajo hay un ESP32 con FreeRTOS. Entender esa capa es la diferencia entre copiar ejemplos y saber lo que haces.

Qué es exactamente

No es un Arduino emulado. Desde la versión 3.x, el core es un envoltorio sobre ESP-IDF: tus setup() y loop() corren dentro de un FreeRTOS task real (se llama loopTask), en el núcleo 1, con 8 KB de pila por defecto.

Eso explica dos cosas muy típicas:

Si tu loop() se queda colgado, salta el watchdog y la placa se reinicia.
Si tu proyecto crece, puedes crear tareas con xTaskCreatePinnedToCore().

Instalación (dos caminos)

Arduino IDE — añade la URL de placas en Preferences:

https://espressif.github.io/arduino-esp32/package_esp32_index.json

Luego instala «esp32 by Espressif» desde el Boards Manager y elige tu placa.

PlatformIO (mi recomendación) — platformio.ini:

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

`setup()` y `loop()` por dentro

void setup() {
  Serial.begin(115200);
  pinMode(2, OUTPUT);
}

void loop() {
  digitalWrite(2, !digitalRead(2));
  delay(1000);
}

Funciona, pero conviene saber:

delay() bloquea el task. Con Wi-Fi o varios sensores, usa millis().
setup() se ejecuta una vez; si quieres tareas paralelas, créalas ahí.
El watchdog vigila el loop: si tardas demasiado, reinicio.

Versión anti-bloqueo:

unsigned long last = 0;
constexpr unsigned long INTERVAL = 1000;

void loop() {
  if (millis() - last >= INTERVAL) {
    last = millis();
    digitalWrite(2, !digitalRead(2));
  }
}

Librerías: no todas valen

Las de Arduino genéricas suelen funcionar si no tocan registros del AVR.
Las que usan timers o interrupciones específicas pueden fallar.
Para sensores, busca la versión «ESP32» o usa la librería del fabricante.
Wire (I2C) y SPI existen, pero puedes elegir pines.

Diferencias con un Arduino UNO

Cosa	Arduino UNO	ESP32
Voltaje	5 V	3,3 V
Bits	8	32
EEPROM	1 KB	no hay (usa `Preferences`)
ADC	10 bits	12 bits (y ADC2 con Wi-Fi, ojo)
Wi-Fi	❌	✅
Núcleos	1	2

Guardar algo en la «EEPROM» del ESP32 se hace así:

#include <Preferences.h>
Preferences prefs;

void setup() {
  prefs.begin("mi-app", false);
  int arranques = prefs.getInt("n", 0) + 1;
  prefs.putInt("n", arranques);
  prefs.end();
}

Buenas prácticas

No bloquees el loop: usa millis(), tareas o vTaskDelay.
Serial a 115200 y espera un momento tras begin() si lo necesitas.
No abuses de String: fragmenta la memoria. Usa char[] y snprintf.
Separa el código en ficheros; un .ino de 2000 líneas es un dolor.
Depura con logs, no con Serial.println por todas partes.

¿Cuándo pasar a ESP-IDF?

Cuando necesites control fino de tareas y memoria, timing preciso, particiones OTA serias o exprimir el consumo. El core de Arduino esconde mucho, y a veces eso está bien… hasta que deja de estarlo.

Resumen

Es un envoltorio sobre ESP-IDF; tus setup/loop son un task de FreeRTOS.
delay() bloquea; aprende a usar millis() desde el principio.
3,3 V, sin EEPROM (usa NVS/Preferences), ADC de 12 bits.
No todas las librerías de Arduino compilan: revisa la compatibilidad.
Versión actual del core: 3.3.11 (sobre ESP-IDF 5.5.5).

Siguiente paso: ESP-IDF a fondo para cuando necesites el control total. O vuelve al hub de la serie.

¿Qué framework usar en el ESP32? Arduino, ESP-IDF, MicroPython o Rust

2026-09-26T00:00:00+00:00

Aquí llega la pregunta que más se repite: ¿con qué programo el ESP32? La respuesta corta es «depende», y la respuesta útil es esta tabla. Elige por dónde te sitúas y qué quieres conseguir.

Los cinco caminos

Framework	Lenguaje	Curva	Control	Ideal para
Arduino core	C++	Muy baja	Medio	Empezar, prototipos, sensores
ESP-IDF	C (C++)	Alta	Total	Producto, RTOS, rendimiento
MicroPython	Python	Muy baja	Bajo	Aprender, pruebas rápidas
Rust	Rust	Media-alta	Alto	Robustez, seguridad, no_std
Lua (NodeMCU)	Lua	Baja	Bajo	Legado, scripts muy simples

Empecemos por lo importante: no hay uno mejor, hay uno mejor para ti ahora mismo.

Arduino core: el que casi todos empiezan

Escribes setup() y loop(), usas pinMode(), digitalWrite() y ya está. Hay miles de librerías y ejemplos.

A favor: arrancas en una tarde, comunidad enorme, todo el mundo te puede ayudar.
En contra: te oculta cosas (tareas, memoria, particiones), y cuando algo raro pasa, no sabes por dónde empezar.
Versión actual: 3.3.11 (construida sobre ESP-IDF 5.5.5).

Úsalo si estás empezando, haces un prototipo o vienes del mundo Arduino.

ESP-IDF: el «de verdad»

Es el SDK oficial de Espressif. Aquí sí controlas todo: FreeRTOS, tareas, colas, particiones, menuconfig, logs, consumo, seguridad.

A favor: control total, mejor rendimiento, todo documentado por el fabricante, base de todo lo demás.
En contra: más conceptos que aprender y más código para lo mismo.
Versión actual: 6.1.

Úsalo si vas a producción, necesitas timing fino o quieres exprimir el hardware.

MicroPython: entender en 5 minutos

Flasheas el firmware, abres un REPL y escribes Python. Perfecto para aprender y para trastear sin compilar.

A favor: inmediato, divertido, ideal para enseñar.
En contra: más lento, más RAM, y no todos los periféricos están cubiertos.
Versión actual: 1.29.

Úsalo si quieres resultados ya, o si vienes de Python.

Rust: potencia con red de seguridad

El ecosistema esp-rs te da dos caminos: esp-idf-hal (sobre ESP-IDF, con std) y esp-hal / embassy (no_std, más ligero y asíncrono).

A favor: el compilador te evita errores de memoria y de concurrencia, código muy robusto, async real con embassy.
En contra: curva de aprendizaje, toolchain aparte (espup), ecosistema más joven.
Versión actual: esp-hal 1.2.0.

Úsalo si te importa la fiabilidad, vienes de Rust o quieres aprender algo serio.

Lua (NodeMCU): el pasado

Fue popular con el ESP8266. Hoy está prácticamente abandonado frente a MicroPython. Solo tiene sentido para mantener proyectos antiguos.

La decisión, en 20 segundos

Tu situación	Empieza con
Es mi primer microcontrolador	Arduino core
Sé programar, pero no C/C++	MicroPython
Necesito control y rendimiento	ESP-IDF
Quiero seguridad y robustez	Rust (`esp-idf-hal`)
Voy a un producto a batería	ESP-IDF (o Rust)
Quiero enseñar a alguien	MicroPython

Truco: no tienes que elegir para siempre. Mucha gente empieza con Arduino y salta a ESP-IDF cuando el proyecto lo exige. Los conceptos (GPIO, I2C, tareas) se comparten.

Lo que importa más que el framework

Entender el hardware: ADC, pines reservados, consumo.
Saber depurar: logs, printf, medir señales.
Leer el datasheet cuando algo no cuadra.

Con eso, cambiar de framework es un fin de semana. Sin eso, ninguno te salva.

Resumen

Arduino: empezar rápido. ESP-IDF: control y producción. MicroPython: aprender y prototipar. Rust: robustez.
Lua ya no merece la pena para proyectos nuevos.
La versión actual de cada uno está en la tabla de arriba.
Elige por tu experiencia y tu objetivo, no por moda.

Siguiente paso: vamos al detalle con el Arduino core, el más usado. O vuelve al hub de la serie.

ESP8266 vs ESP32: cuándo (no) merece la pena el pequeño

2026-09-25T00:00:00+00:00

El ESP8266 puso el Wi-Fi barato en manos de todo el mundo. Fue el chip que convirtió al maker en alguien capaz de tener una web en su salón por dos dólares. Y todavía se vende, todavía se usa y todavía tiene su público.

La pregunta honesta es: ¿tiene sentido comprarlo hoy? Casi siempre no, y aquí está el porqué.

Las diferencias que importan

	ESP8266	ESP32 (clásico)
Núcleos	1 × Xtensa L106 @ 160 MHz	2 × LX6 @ 240 MHz
RAM útil	~50 KB	~320 KB
Wi-Fi	Wi-Fi 4	Wi-Fi 4
Bluetooth	❌	BT 4.2 + BLE
GPIOs usables	~11	~25
ADC	1 canal de 10 bits	18 canales de 12 bits
DAC	❌	✅
USB nativo	❌	❌

No es solo «menos potente»: es que hay 10 veces menos memoria y muy pocos pines. Eso condiciona todo lo que puedes hacer.

Dónde el ESP8266 todavía brilla

Precio puro: en AliExpress se encuentra por menos de 2 €.
Simplicidad: para leer un sensor y publicar por Wi-Fi con un único endpoint, sobra.
Legado: hay toneladas de código y tutoriales funcionando.
Consumo muy bajo en deep sleep si el proyecto es sencillo.

Dónde se queda corto (y duele)

Memoria: un parser JSON grande o TLS te deja sin RAM y con reinicios aleatorios.
Un solo núcleo: el Wi-Fi y tu código comparten la CPU, así que cualquier tarea larga provoca watchdog resets.
Pines: con el ADC y la flash, te quedan muy pocos GPIOs.
TLS: los handshakes modernos son caros para este chip.
Actualidad: el ecosistema ya está centrado en el ESP32.

La comparación que de verdad importa hoy

Si el ESP8266 te tienta por precio, compáralo con el ESP32-C3, no con el ESP32 clásico:

	ESP8266	ESP32-C3
Precio	~1,5 €	~2–3 €
Núcleo	Xtensa	RISC-V @ 160 MHz
RAM	~50 KB	400 KB
Bluetooth	❌	BLE 5
USB nativo	❌	Sí (Serial/JTAG)
ADC	10 bits	12 bits

La diferencia de precio es de unos céntimos y el C3 es mejor en todo. Por eso recomiendo olvidarse del 8266 si el proyecto es nuevo.

¿Cuándo usar cada uno?

Usa el ESP8266 si…

El precio es lo único que importa (producción de volumen, juguetes).
Tienes código viejo funcionando y no quieres tocarlo.
El proyecto es un sensor mínimo que nunca crecerá.

Usa un ESP32 (C3) si…

Necesitas BLE, más pines o más memoria.
Vas a hacer TLS, OTA o lógica no trivial.
Quieres USB nativo y depuración decente.
Piensas que el proyecto crezca (y siempre crece).

Migrar del 8266 al ESP32-C3

Si vienes del 8266 y saltas al C3, ojo con esto:

ESP8266WiFi.h pasa a WiFi.h (y algunas APIs cambian de nombre).
El ADC es distinto: en el 8266 es A0 (10 bits); en el C3 usa ADC1 con 12 bits.
El deep sleep es más flexible: se pueden despertar GPIOs concretos.
Las librerías del 8266 no siempre compilan: busca su equivalente para ESP32.
El mapeo de pines no se parece en nada: no copies el cableado.

Resumen

El ESP8266 fue revolucionario, pero hoy está desfasado frente al C3.
Tiene ~50 KB de RAM, un núcleo y pocos pines: se queda corto enseguida.
Solo gana cuando el precio lo es todo o hay código heredado.
Para proyectos nuevos, un ESP32-C3 cuesta casi lo mismo y es muy superior.
Si migras, espera cambios en Wi-Fi, ADC y pines.

Siguiente paso: con esto cerramos las variantes. Toca elegir framework: Arduino, ESP-IDF, MicroPython o Rust. O vuelve al hub de la serie.

ESP32-P4 a fondo: el ESP32 sin radio para pantallas y alto rendimiento

2026-09-24T00:00:00+00:00

El ESP32-P4 rompe el molde de la familia: no tiene Wi-Fi, ni Bluetooth, ni 802.15.4. Nada de radios. A cambio, es el ESP32 más potente que existe y el primero pensado como procesador de aplicación: pantallas, interfaces, vídeo ligero y cálculo.

Suena raro para un ESP32… hasta que entiendes la jugada: tú decides la radio. Se le pone al lado un C6 y tienes lo mejor de los dos mundos.

Qué es

Cosa	Valor
Núcleos	2 × RISC-V @ 400 MHz
SRAM	768 KB on-chip (+ 8 KB TCM)
Radio	ninguna (Wi-Fi/BT por un chip aparte)
GPIOs	55
USB	OTG 2.0 de alta velocidad
Otros	MIPI-CSI/DSI, Ethernet, SDIO, CAN
IA	Extensiones de IA + FPU

Dos detalles que lo separan del resto: MIPI-CSI/DSI (interfaces de cámara y pantalla de verdad, no SPI) y USB de alta velocidad.

La radio se la pones tú

El P4 no trae conectividad a propósito. Lo normal es emparejarlo con un C6 (que sí tiene Wi-Fi 6, BLE y 802.15.4) y repartir el trabajo:

El P4 se encarga de la pantalla, la cámara y la lógica.
El C6 se encarga de hablar con el mundo.

Por eso el kit oficial, la ESP32-P4-Function-EV-Board, viene ya con un C6 incorporado.

Pines: muchísimos

Con 55 GPIOs programables, este chip no tiene el problema de pines de sus hermanos pequeños. Trae además bloques para SPI, I2C, I2S, UART, CAN, SDIO, Ethernet (RMII) y las interfaces MIPI. Para el mapeo exacto, el datasheet de Espressif es la referencia.

Aviso importante: sí tiene ADC, pero olvídate del Wi-Fi que rompía el ADC2 en otros modelos — aquí no hay radio que interfiera.

Placas

ESP32-P4-Function-EV-Board — placa de evaluación con C6 integrado, pantalla MIPI y cámara. La forma más fácil de empezar.
ESP32-P4-Module — para tus propias PCB.

El P4 (2024) cierra la línea: sin radio, pero como procesador de aplicación. Ilustración propia.

¿Cuándo elegirlo (y cuándo no)?

Sí, elige el P4 si…

Vas a manejar pantallas grandes o táctiles (MIPI, no SPI lento).
Necesitas cámara de verdad, con MIPI-CSI.
Quieres USB de alta velocidad, Ethernet o mucho cálculo.
Divides el proyecto en procesador + radio (P4 + C6).

No lo elijas si…

Quieres algo simple con Wi-Fi: un C3 o un C6.
Buscas lo más barato: el P4 no lo es.
No necesitas pantalla ni mucho cálculo: estarías pagando de más.
Esperas conectividad a bordo: no la tiene (y eso confunde a mucha gente).

Errores típicos

Comprarlo esperando que traiga Wi-Fi integrado (no trae; necesitas el C6).
Intentar montar una pantalla seria por SPI cuando tienes MIPI-DSI.
Olvidar que es un chip nuevo: requiere toolchain reciente (ESP-IDF 5.3+, hoy 6.1).

Resumen

Dos RISC-V a 400 MHz, 768 KB de SRAM y 55 GPIOs.
MIPI-CSI/DSI, USB 2.0 HS y Ethernet.
Sin radio: se combina con un C6.
Es el chip para HMI, pantallas y alto rendimiento, no para un sensor tonto.
Si dudas entre P4 y S3: el S3 es más barato y ya lleva radio; el P4 es para cuando necesitas pantalla de verdad.

Siguiente paso: cerramos el bloque de variantes con ESP8266 vs ESP32 y, después, los frameworks. O vuelve al hub de la serie.

ESP32-H2 a fondo: el ESP32 sin Wi-Fi para nodos Matter a batería

2026-09-23T00:00:00+00:00

Puede sonar a broma: un ESP32 sin Wi-Fi. Pero cuando lo piensas dos veces, tiene todo el sentido. El H2 está pensado para domótica de bajo consumo: sensores, interruptores y nodos Matter/Thread que tienen que durar meses con una pila.

Menos radios encendidas = menos batería. Y si ya tienes un border router en casa, un dispositivo no necesita Wi-Fi propio.

Qué es

Es un SoC RISC-V de un solo núcleo centrado en lo inalámbrico de bajo consumo, y con la flash dentro del propio chip (2 o 4 MB), lo que simplifica mucho el diseño.

Cosa	Valor
Núcleo	1 × RISC-V de bajo consumo
SRAM	320 KB (+ 4 KB de memoria LP)
ROM	128 KB
Wi-Fi	ninguno
Bluetooth	BLE 5
802.15.4	Thread / Zigbee / Matter
GPIOs	19 programables, con ADC
USB	Serial/JTAG nativo
Flash	2 o 4 MB integradas (SiP)

Por qué no tiene Wi-Fi (y por qué está bien)

El H2 es un chip de nodo, no de pasarela. En una red Thread todos los dispositivos hablan entre sí y solo uno (el border router) necesita salir a Internet. Los demás pueden gastar su energía en lo importante: medir y dormir.

Resultado: un H2 bien dormido consume muchísimo menos que un C6 con Wi-Fi activo. Y encima no compite por el espectro con la red Wi-Fi de casa.

Pines: lo que debes saber

El H2 trae 19 GPIOs programables con soporte de ADC, SPI, UART, I2C, I2S, RMT, GDMA y PWM. El mapeo exacto depende del módulo, así que para el detalle fino conviene mirar el datasheet. Lo que sí conviene tener claro:

Un bloque de pines hace de ADC; úsalo para sensores analógicos.
Hay pines de strapping y pines ocupados por la flash interna: no los uses.
USB Serial/JTAG para flashear y depurar sin chip externo.

Placas y módulos

ESP32-H2-MINI-1 — el módulo pequeño (el habitual, con flash integrada).
ESP32-H2-DevKitM-1 — la placa de desarrollo.
ESP32-H2-WROOM-1 — el módulo clásico.

ESP32-H2: BLE 5 + Zigbee/Thread, sin Wi-Fi. Ilustración propia.

¿Cuándo elegirlo (y cuándo no)?

Sí, elige el H2 si…

Haces domótica Matter/Thread/Zigbee y quieres máxima autonomía.
Necesitas un nodo pequeño y barato que solo hable 802.15.4/BLE.
Quieres flash integrada para reducir componentes en tu PCB.
Ya tienes un border router y no necesitas Wi-Fi en el nodo.

No lo elijas si…

El dispositivo necesita salir a Internet por sí mismo → C6.
Haces Wi-Fi normal → C3.
Necesitas cámara, audio o IA → S3.
Necesitas muchos GPIOs → S3 o P4.

Errores típicos

Comprarlo pensando que tiene Wi-Fi (no lo tiene, y no hay firmware que lo arregle).
Intentar usarlo como pasarela: para eso necesitas un C6 (o un C6 + H2).
Olvidar que su gracia es dormir: si lo tienes despierto todo el rato, pierdes la ventaja.

Resumen

RISC-V single de bajo consumo, 320 KB de SRAM y flash integrada.
BLE 5 + 802.15.4 (Thread/Zigbee/Matter) y sin Wi-Fi.
19 GPIOs con ADC y USB Serial/JTAG.
Es el chip ideal para nodos Matter a batería.
Para pasarela o Wi-Fi, mejor un C6.

Siguiente paso: el ESP32-P4, el nuevo chip sin radio para pantallas y alto rendimiento. O vuelve al hub de la serie.

ESP32-C6 a fondo: Wi-Fi 6, Matter y Thread en un solo chip

2026-09-22T00:00:00+00:00

El ESP32-C6 es el chip de la domótica moderna. No por ser el más potente, sino porque trae algo que ninguno de sus hermanos tiene: radio 802.15.4, que es la base de Thread, Zigbee y Matter. Y encima llega con Wi-Fi 6.

Si vas a montar una casa conectada de verdad (la que habla con Apple Home, Google Home o Home Assistant sin inventos), este es el chip.

Qué es

El C6 usa dos núcleos RISC-V: uno de alto rendimiento (HP, 160 MHz) y uno de bajo consumo (LP, 20 MHz) que puede quedarse vigilando sensores mientras el resto duerme.

Cosa	Valor
Núcleos	RISC-V HP 160 MHz + LP 20 MHz
SRAM	512 KB
Wi-Fi	Wi-Fi 6 (802.11ax, 2,4 GHz)
Bluetooth	BLE 5
802.15.4	Thread / Zigbee / Matter
GPIOs	30
USB	Serial/JTAG nativo

Lo que lo hace único: 802.15.4 + Wi-Fi 6

802.15.4 es la radio de Matter, Thread y Zigbee. Sin ella, tu dispositivo no puede hablar el idioma de la casa conectada moderna.
Wi-Fi 6 no es marketing: mejora la convivencia con muchas redes cerca y añade TWT (Target Wake Time), que permite negociar con el router cuándo despertar. Traducción: menos consumo para el mismo Wi-Fi.

Y puede usar Wi-Fi y 802.15.4 a la vez, así que puedes montar un border router de Thread… o simplemente ser un dispositivo Matter que sale a Internet por Wi-Fi.

Pinout: lo esencial

Pin(es)	Para qué
GPIO12 / GPIO13	USB D− / D+
GPIO0–6	ADC1
GPIO8, GPIO9, GPIO15	Strapping
GPIO24–30	Flash interna (no usar)
GPIO5 / GPIO6	UART (RX / TX) habitual

Como en toda la familia: sin DAC, sin touch y el ADC2 no funciona con Wi-Fi (aquí, usa ADC1).

Placas y módulos

ESP32-C6-WROOM-1 — módulo estándar.
ESP32-C6-MINI-1 — versión pequeña.
ESP32-C6-DevKitC-1 — placa de desarrollo.
ESP32-C6-DevKitM-1 — la reducida.

ESP32-C6: Wi-Fi 6 + BLE 5 + 802.15.4 (Thread/Zigbee/Matter). Foto: Popolon (CC BY-SA 4.0).

¿Cuándo elegirlo (y cuándo no)?

Sí, elige el C6 si…

Vas a hacer Matter, Thread o Zigbee.
Quieres Wi-Fi 6 y buen consumo con TWT.
Necesitas un dispositivo compatible con los ecosistemas de casa modernos.
Quieres montar un border router de Thread.

No lo elijas si…

Solo haces Wi-Fi normal y barato: un C3 cuesta menos.
Necesitas cámara, audio o IA: eso es el S3.
Necesitas Bluetooth clásico o DAC: el clásico.
No necesitas Wi-Fi: el H2 es más barato para un nodo 802.15.4/BLE.

Errores típicos

Comprar un C6 «para probar» sin toolchain reciente: Matter necesita ESP-IDF 5.1+ (hoy vamos por la 6.1).
Esperar un DAC o touch que no existen.
Confundir Matter (protocolo de aplicación) con Thread (red): el C6 trae la radio para ambos.

Resumen

RISC-V doble (HP + LP), 512 KB de SRAM.
Wi-Fi 6 + BLE 5 + 802.15.4: el único de la familia con Matter por hardware.
30 GPIOs y USB Serial/JTAG.
Es la elección para domótica moderna; para todo lo demás, C3 o S3.
Necesita toolchain actualizado (ESP-IDF 5.1+, idealmente 6.x).

Siguiente paso: el ESP32-H2, su hermano sin Wi-Fi para nodos Matter a batería. O vuelve al hub de la serie.

ESP32-C3 a fondo: el que recomiendo para empezar (y por qué)

2026-09-21T00:00:00+00:00

Si me preguntas «¿qué ESP32 compro para empezar?», la respuesta corta es ESP32-C3. Es moderno, barato, con Bluetooth 5 y USB nativo, y para el 90 % de los proyectos de sensores y domótica es más que suficiente.

No es perfecto: tiene pocos pines y le faltan cosas. Vamos a ver exactamente qué te da y qué no.

Qué es

El C3 es el ESP32 «de nueva generación»: en vez de los núcleos Xtensa de siempre, usa RISC-V, la arquitectura libre que Espressif adoptó para sus chips más recientes.

Cosa	Valor
Núcleo	1 × RISC-V @ 160 MHz
SRAM	400 KB
Wi-Fi	802.11 b/g/n (2,4 GHz)
Bluetooth	BLE 5
GPIOs	22
ADC	2 × 12 bits (6 canales)
DAC	ninguno
Touch	no tiene
USB	Serial/JTAG nativo

Lo bueno

Barato: suele costar lo mismo que un ESP8266 y es mejor en todo.
BLE 5: perfecto para hablar con el móvil (no tiene Bluetooth clásico).
USB nativo: olvídate del CH340 y disfruta de JTAG integrado, que permite depurar con puntos de ruptura sin hardware extra.
Consumo bajo: en deep sleep queda por debajo del clásico, ideal para nodos a batería.
RISC-V: toolchain moderna y soporte de primera en ESP-IDF, Arduino y Rust.

Lo malo

Solo 22 GPIOs, y de esos hay que descontar los de la flash.
Sin DAC y sin touch: si necesitas salida analógica real o botones capacitivos, vuelve al clásico o al S2.
Un solo núcleo: no repartes tareas entre dos CPUs.
Bluetooth solo BLE, nada de clásico.

Pinout: lo esencial

Pin(es)	Para qué
GPIO18 / GPIO19	USB D− / D+ (USB Serial/JTAG)
GPIO0–4	ADC1
GPIO5	ADC2
GPIO2, GPIO8, GPIO9	Strapping (ojo con el 9: es el botón BOOT)
GPIO11–17	Flash interna (no usar)
GPIO20 / GPIO21	UART (RX / TX)

Como siempre: ADC2 no funciona con Wi-Fi encendido, así que para sensores tira de ADC1 (GPIO0–4).

Pinout del ESP32-C3. Fuente: Wikimedia Commons, CC BY-SA 4.0.

Placas y módulos

ESP32-C3-WROOM-02 — el módulo estándar.
ESP32-C3-MINI-1 — pequeño, para PCB propia.
ESP32-C3-DevKitM-1 — la placa pequeña, tipo stick.
ESP32-C3-DevKitC-02 — con más pines y botones.

Un ESP32-C3 tipo NodeMCU: pequeño, barato y con USB-C. Foto: Popolon (CC BY-SA 4.0).

¿Cuándo elegirlo (y cuándo no)?

Sí, elige el C3 si…

Estás empezando y no quieres gastar de más.
Haces domótica, sensores o relés con Wi-Fi y BLE.
Quieres USB nativo y JTAG sin chip extra.
Buscas un nodo a batería con buen deep sleep.

No lo elijas si…

Necesitas Bluetooth clásico → ESP32 clásico.
Necesitas DAC o touch → clásico o S2.
Necesitas muchos GPIOs → S2 o S3.
Necesitas cámara, audio o IA → S3.
Necesitas Matter/Thread/Zigbee → C6 o H2.

Errores típicos

Contar con 22 GPIOs y olvidar que GPIO11–17 son de la flash.
Poner el botón BOOT en GPIO9 y que el chip arranque en modo descarga.
Buscar el DAC o el touch en la documentación del C3 (no existen).
Leer sensores por ADC2 con el Wi-Fi conectado.

Resumen

1 núcleo RISC-V a 160 MHz, 400 KB de SRAM, Wi-Fi 4 + BLE 5.
USB Serial/JTAG nativo y buen consumo en deep sleep.
22 GPIOs, sin DAC y sin touch.
Es la mejor compra para empezar en 2026: barato, moderno y bien soportado.
Si necesitas más músculo o pines, salta al S3 o al S2.

Siguiente paso: el ESP32-C6, con Wi-Fi 6 y radio para Matter. O vuelve al hub de la serie.

ESP32-S3 a fondo: núcleos, PSRAM, IA y USB para proyectos serios

2026-09-20T00:00:00+00:00

Si el S2 fue el experimento, el ESP32-S3 es la versión que salió bien: dos núcleos, Bluetooth, USB nativo y, encima, instrucciones vectoriales que aceleran la IA. Es el chip de las placas con cámara, de los asistentes de voz y de casi cualquier proyecto «grande» con ESP32.

Eso sí: es el más caro de la familia y, si no vas a usar lo que trae, estarás pagando de más.

Qué es

Cosa	Valor
Núcleos	2 × Xtensa LX7 @ 240 MHz
SRAM	512 KB
Wi-Fi	802.11 b/g/n (2,4 GHz)
Bluetooth	BLE 5 (sin Bluetooth clásico)
GPIOs	hasta 45
ADC	20 canales de 12 bits
Touch	14 canales
USB	OTG nativo
PSRAM	hasta 8 MB (según módulo)

Fíjate en dos cosas: no tiene DAC (a diferencia del clásico y el S2) y su Bluetooth es solo BLE, igual que el C3.

Lo que lo hace especial: las instrucciones vectoriales

El S3 añade SIMD de 128 bits pensado para redes neuronales. En la práctica, eso significa que un modelo pequeño de detección de voz o de gestos corre varias veces más rápido que en un clásico, sin GPU ni acelerador externo.

Es la razón por la que las placas con cámara y los «asistentes» caseros llevan S3 y no C3.

PSRAM: quad vs octal (y el precio en pines)

Aquí hay una trampa que muerde a mucha gente. Los módulos S3 vienen en varias combinaciones, por ejemplo N8R2 (8 MB flash + 2 MB PSRAM) o N8R8 (8 MB + 8 MB), y la PSRAM puede ser quad u octal:

Quad PSRAM — usa menos pines.
Octal PSRAM — más rápida, pero se come GPIO33–GPIO37.

Y en cualquier configuración, GPIO26–GPIO32 están ocupados por la flash (y por la PSRAM si existe). Traducción: no cuentes con 45 GPIOs si el módulo lleva memoria. Mira siempre el datasheet del módulo concreto.

Pinout: lo esencial

Pin(es)	Para qué
GPIO19 / GPIO20	USB D− / D+
GPIO1–10	ADC1
GPIO11–20	ADC2
GPIO1–14	Touch
GPIO0, 3, 45, 46	Strapping
GPIO26–32	Flash/PSRAM (no usar)
GPIO33–37	extra si el módulo lleva PSRAM octal

Los periféricos de siempre siguen ahí (SPI, I2C, I2S, UART, PWM, RMT) y se añade una interfaz de cámara (LCD_CAM) capaz de mover vídeo.

Placas y módulos

ESP32-S3-WROOM-1 / 1U — el módulo estándar (la «U», con antena externa).
ESP32-S3-MINI-1 — pequeño, para PCB propia.
ESP32-S3-DevKitC-1 / DevKitM-1 — las placas de desarrollo.
ESP32-S3-EYE — placa con cámara y pantalla, para visión.
ESP32-S3-DevKitC-1 N16R8 — la versión con más memoria.

ESP32-S3: la variante más capaz para IA en el borde y multimedia. Foto: VectorVoyager (CC BY-SA 4.0).

¿Cuándo elegirlo (y cuándo no)?

Sí, elige el S3 si…

Vas a hacer visión, audio o IA en el propio dispositivo.
Necesitas cámara o mover pantallas.
Quieres dos núcleos y USB nativo.
Necesitas PSRAM para buffers grandes.

No lo elijas si…

Solo quieres leer sensores y publicar por Wi-Fi: un C3 hace lo mismo por mucho menos.
Necesitas Bluetooth clásico (solo tiene BLE): eso es el clásico.
Necesitas DAC: el S3 no tiene; usa el clásico o el S2.

Errores típicos

Comprar un S3 sin PSRAM y luego querer hacer visión o audio.
Comprar PSRAM octal y descubrir que pierdes GPIO33–37.
Asumir que tiene Bluetooth clásico (solo tiene BLE).
Contar con GPIO26–32 cuando están ocupados por la memoria.

Resumen

2 núcleos LX7, 512 KB de SRAM, BLE 5 y USB OTG.
Las instrucciones vectoriales lo hacen el mejor ESP32 para IA y multimedia.
PSRAM quad u octal: la octal es más rápida pero ocupa más pines.
No tiene DAC ni Bluetooth clásico.
Es la opción «grande»: si no necesitas cámara/IA, un C3 te sobra.

Siguiente paso: el ESP32-C3, el que recomiendo para empezar. O vuelve al hub de la serie.

ESP32-S2 a fondo: el ESP32 con USB de verdad (y sin Bluetooth)

2026-09-19T00:00:00+00:00

El ESP32-S2 es el hermano raro de la familia. Llegó en 2019 con una idea muy clara: USB nativo, muchos pines y Wi-Fi… pero sin Bluetooth. Y esa decisión lo parte en dos: para unos es perfecto, para otros es un pisapapeles.

Vamos a ver para qué sirve de verdad.

Qué es (y en qué se diferencia del clásico)

El S2 usa un solo núcleo Xtensa LX7 a 240 MHz (el clásico tiene dos). Parece una desventaja, pero a cambio llega con USB OTG integrado, que es un periférico bastante más interesante de lo que parece.

Cosa	Valor
Núcleo	1 × Xtensa LX7 @ 240 MHz
SRAM	320 KB
Wi-Fi	802.11 b/g/n (2,4 GHz)
Bluetooth	ninguno
GPIOs	43
ADC	20 canales de 12 bits
DAC	2 canales de 8 bits (GPIO17 y GPIO18)
Touch	14 canales
USB	OTG nativo

Lo bueno: USB OTG

No es un «USB para el puerto serie». Es un controlador USB completo, y eso te deja hacer cosas que con el clásico necesitan un chip extra:

HID: emular teclado, ratón o mando.
CDC: un puerto serie propio, con tu nombre y tu VID/PID.
MSC: que el ordenador vea el ESP32 como una memoria USB.
Host: leer un pendrive, un teclado USB o un lector.

Y como es USB nativo, olvídate del CH340 y de sus drivers. Un cable y listo.

Lo malo: no tiene Bluetooth

Aquí está el peaje. Si tu proyecto necesita enviar datos a un móvil por BLE, o hablar con un altavoz por Bluetooth clásico, el S2 no te sirve. Punto. No es cuestión de firmware: la radio no existe.

Espressif lo dejó fuera para abaratar y simplificar. Tiene sentido en su momento… pero hoy significa que, si dudas, casi siempre querrás un C3 o un S3 en su lugar.

Pinout: qué pines importan

No hay un pinout oficial en Commons para el S2, así que aquí van los datos que de verdad vas a consultar (y el resto, en el datasheet de Espressif):

Pin(es)	Para qué
GPIO19 / GPIO20	USB D− / D+ (no los toques si usas USB)
GPIO1–10	ADC1
GPIO11–20	ADC2
GPIO17 / GPIO18	DAC 1 y DAC 2
GPIO1–14	Touch
GPIO0, 45, 46	Strapping (arranque)
GPIO26–32	Flash interna (no usar)

Dos avisos que se repiten del clásico:

ADC2 no funciona mientras el Wi-Fi está encendido. Usa ADC1.
Los pines de strapping (sobre todo GPIO45 y GPIO46) mejor déjalos en paz.

Placas y módulos

Lo que vas a encontrar:

ESP32-S2-WROOM / WROOM-1 — el módulo estándar.
ESP32-S2-MINI-1 — versión pequeña, ideal para PCB propia.
ESP32-S2-Saola-1 — la placa de desarrollo tipo DevKitC.
ESP32-S2-Kaluga-1 — kit con pantalla y cámara.
ESP32-S2-DevKitM-1 — la versión reducida.

ESP32-S2: USB OTG nativo, Wi-Fi 4 y sin Bluetooth. Ilustración propia.

¿Cuándo elegirlo (y cuándo no)?

Sí, elige el S2 si…

Necesitas USB de verdad: HID, CDC, almacenamiento, host.
Quieres muchos GPIOs (43) y no te importa el Bluetooth.
Vas a usar DAC o touch y quieres USB nativo de propina.
Trabajas con un teclado o un dispositivo USB que quieres emular.

No lo elijas si…

Necesitas BLE (muy común): vete a un C3 o S3.
Quieres lo más barato posible: el C3 es más moderno y suele costar igual o menos.
Necesitas dos núcleos: el S2 tiene uno.

Errores típicos

Comprarlo asumiendo que tiene BLE porque «todos los ESP32 lo tienen».
Usar GPIO19/20 para otra cosa y luego preguntarse por qué no aparece el USB.
Intentar leer un sensor por ADC2 con Wi-Fi encendido.
Olvidar que los GPIO45/46 son de arranque y que ponerlos a LOW puede impedir que arranque.

Resumen

1 núcleo LX7, 320 KB de SRAM, USB OTG y 43 GPIOs.
Sin Bluetooth: es su limitación más importante.
Tiene DAC y touch, como el clásico.
Es la opción clara cuando el USB es el protagonista del proyecto.
Si dudas entre S2 y C3, casi siempre gana el C3.

Siguiente paso: el ESP32-S3 — mismo USB, pero con dos núcleos, Bluetooth y aceleración para IA. O vuelve al hub de la serie para ver el índice completo.

El ESP32 clásico a fondo: pines, ADC, DAC y cuándo merece la pena

2026-09-18T00:00:00+00:00

Cuando la gente dice «ESP32», casi siempre se refiere a este: el de 2016, dos núcleos y 38 pines. Sigue siendo el que más tutoriales tiene, el más barato con Bluetooth clásico y, aunque ya hay opciones más modernas, sigue teniendo mucho sentido en 2026.

Pero tiene una serie de rincones —pines que no se pueden usar, un ADC que no es tan bonito como promete el marketing— que conviene conocer antes de soldar nada. He perdido más de una tarde por no saberlos, así que vamos a ahorrártelas.

El chip: no todos los «ESP32» son el mismo

Dentro del módulo hay un chip concreto, y no todos son iguales:

Chip	Qué tiene de especial
ESP32-D0WDQ6	El original, 2 núcleos, QFN 6×6 mm
ESP32-D0WD	Igual pero en encapsulado 5×5 mm
ESP32-D0WD-V3	La revisión actual, la que montan los módulos nuevos
ESP32-D0WDR2	Con 2 MB de PSRAM dentro del propio chip
ESP32-S0WD	Un solo núcleo (rara de ver)

Para lo que nos importa aquí: 2 núcleos Xtensa LX6 a 240 MHz, 520 KB de SRAM y 448 KB de ROM. Ese es el «ESP32 clásico».

Los módulos: WROOM, WROVER y compañía

El chip desnudo no se suelda a mano. Va dentro de un módulo con la flash, el cristal y la antena. Los que vas a encontrar:

ESP32-WROOM-32E — el estándar. 4 MB de flash, antena en la propia PCB. Deja libres GPIO16 y GPIO17.
ESP32-WROVER-E — igual, pero con 8 MB de PSRAM extra. Ojo: la PSRAM se come GPIO16 y GPIO17, así que si usas esos pines, no puedes usar WROVER.
ESP32-WROOM-32UE / WROVER-IE — sin antena de PCB, con conector U.FL para poner una antena externa. La solución cuando el ESP32 va dentro de una caja metálica.

El ESP32-WROOM-32: chip, flash y antena dentro de una sola pieza. Foto: Ubahnverleih (CC0).

Dato de 2026: para diseños nuevos, Espressif recomienda la serie E (ESP32-WROOM-32E / WROVER-E). Los módulos antiguos sin la «E» están marcados como not recommended for new designs.

Y en la cara de atrás se ve dónde está cada cosa:

Por detrás: el chip ESP32 a la izquierda y la memoria flash a la derecha. Foto: Ubahnverleih (CC0).

La placa que vas a comprar

El módulo se monta en una placa de desarrollo (devkit) que le añade USB, regulador y dos botones: EN (reset) y BOOT (para flashear). La de siempre es la ESP32-DevKitC.

ESP32-DevKitC: el módulo, el puerto micro-USB, el regulador y los dos botones. Foto: Ubahnverleih (CC0).

Un aviso que vale dinero: estas placas no llevan USB nativo. El puerto es un chip puente (CP2102 o CH340) que habla con el ESP32 por UART. Si tienes problemas para flashear, casi siempre es el driver de ese chip, no el ESP32.

Especificaciones, sin adornos

Cosa	Valor
Núcleos	2 × Xtensa LX6 @ hasta 240 MHz
SRAM	520 KB
Wi-Fi	802.11 b/g/n (2,4 GHz)
Bluetooth	4.2 clásico (BR/EDR) + BLE
GPIOs	34 en total, ~25 usables
ADC	18 canales de 12 bits (ADC1 + ADC2)
DAC	2 canales de 8 bits
Touch	10 pines capacitivos
Periféricos	3×UART, 2×I2C, SPI, 2×I2S, CAN (TWAI), SD/MMC, PWM, RMT

Lo de Bluetooth clásico es exclusivo del clásico: ni el S2, ni el C3, ni el S3 lo tienen. Si tu proyecto habla con un altavoz o un mando antiguo por Bluetooth «de toda la vida», este es tu chip.

El pinout de 38 pines

Pinout del ESP32 (DevKitC, 38 pines). Fuente: Wikimedia Commons, CC BY-SA 4.0.

Si vienes de Arduino, aquí hay un cambio de mentalidad: no todos los pines sirven para todo. Hay pines de solo entrada, pines que definen cómo arranca el chip y pines que están literalmente ocupados por dentro. Vamos por partes.

Los pines que sí molan

El DAC (GPIO25 y GPIO26)

El clásico lleva dos salidas analógicas de verdad (8 bits). El C3, por ejemplo, no tiene ninguna. Puedes sacar una tensión real, generar una onda o hacer un sintetizador mediocre pero divertido.

Touch: 10 pines que detectan tu dedo

Sin sensor extra, el chip mide la capacidad de GPIO0, 2, 4, 12, 13, 14, 15, 27, 32 y 33. Perfecto para botones sin partes móviles. (Este periférico desapareció en el S2 y el S3, así que si lo necesitas, tienes que volver al clásico.)

ADC1: el que funciona con Wi-Fi

GPIO32 a GPIO39 son el ADC1. Son los únicos que puedes usar mientras el Wi-Fi está encendido. Grábate esto, porque es la causa número uno de «mi sensor da valores aleatorios».

Y algunos extras poco conocidos

Sensor Hall interno, sin usar ningún pin.
Sensor de temperatura interno (poco preciso, pero existe).
CAN (TWAI) por hardware, sin módulo externo.

Los pines que te van a arruinar el día

GPIO6 a GPIO11: la flash

Están conectados a la memoria flash. No los uses, nunca. Si los tocas, el ESP32 deja de arrancar y parece muerto. No está muerto: vuelve a flashear y respira.

Los pines de arranque (strapping)

Al encenderse, el chip mira estos pines para decidir cómo arrancar:

Pin	Qué hace si está mal
GPIO0	A `LOW` entra en modo flash; como salida puede impedir el arranque
GPIO2	Debe estar `LOW` o flotante al arrancar
GPIO12	Si está `HIGH` al arrancar, adiós (tiene que ver con la tensión de flash)
GPIO15	Debe estar `HIGH`; si no, se silencia el log de arranque

Regla práctica: no pongas nada crítico en esos pines y, si lo haces, revisa el estado al arrancar.

GPIO34 a GPIO39: solo entrada

No tienen pull-up ni pull-down internos y no se pueden usar como salida. Son perfectos para un sensor que solo hay que leer, pero si intentas encender un LED con ellos, no funciona y te pasarás un rato pensando que el LED está roto.

El ADC miente (y cómo domarlo)

Este es el detalle que más frustra a la gente. El ADC del ESP32 tiene 12 bits, pero:

No es lineal. Cerca de 0 V y cerca de los 3,3 V se desvía bastante.
Tiene offset. Con la atenuación de 11 dB, arriba del rango se satura antes de lo que dice el datasheet.
Necesita calibración. ESP-IDF incluye una API de calibración por eFuse. Úsala.
ADC2 no funciona con Wi-Fi activo. Repetimos: usa ADC1.

Si necesitas medidas decentes y estables, un ADS1115 externo por I2C te ahorrará muchos quebraderos de cabeza.

PSRAM: cuándo la necesitas

La PSRAM es memoria extra (típicamente 8 MB en el WROVER). La necesitas si vas a guardar buffers grandes: imágenes, audio, JSONs enormes o buffers de red.

Si tu proyecto son sensores y un par de LEDs, no la necesitas y el WROOM es más barato. Y recuerda el peaje: la PSRAM ocupa GPIO16 y GPIO17.

¿Cuándo elegir el clásico (y cuándo no)?

Sí, elige el clásico si…

Necesitas Bluetooth clásico (no solo BLE).
Quieres DAC, touch o CAN sin añadir nada.
Necesitas muchos GPIOs y que GPIO16/17 estén libres.
Sigues un tutorial que asume el clásico y no quieres pelearte con pines distintos.

Mejor otra cosa si…

Quieres lo más barato y moderno: un C3 hace casi lo mismo por menos.
Necesitas USB nativo (HID, JTAG): S2, S3, C3 o C6.
Necesitas cámara, audio o IA: ESP32-S3.
Quieres Matter/Thread/Zigbee: C6 o H2.

Herramientas actuales (2026)

Si vas a programarlo, estas son las versiones vivas a día de hoy:

Herramienta	Versión actual
ESP-IDF	6.1
Arduino core	3.3.11 (sobre ESP-IDF 5.5.5)
PlatformIO (`platform-espressif32`)	7.1.3
MicroPython	1.29
`esp-hal` (Rust)	1.2.0

Errores típicos con el clásico

Intentar usar GPIO6–11 «porque están libres en el dibujo».
Poner un LED en GPIO34–39 y no entender por qué no enciende.
Leer un potenciómetro por ADC2 y flipar con los valores al encender el Wi-Fi.
Usar GPIO12 como salida y que la placa arranque cuando le da la gana.
Comprar un WROVER para usar GPIO16/17 y descubrir que están ocupados.
Culpar al código cuando el problema es el driver CH340.

Resumen

El ESP32 clásico son 2 núcleos LX6, 520 KB de SRAM, Wi-Fi 4 y Bluetooth clásico + BLE.
Los módulos que verás: WROOM-32E (sin PSRAM) y WROVER-E (con PSRAM, pero se come GPIO16/17).
Tiene cosas únicas: DAC, touch, CAN y Bluetooth clásico.
Cuidado con GPIO6–11, los pines de strapping (0, 2, 12, 15) y los GPIO34–39 (solo entrada).
El ADC2 no funciona con Wi-Fi; usa ADC1 y, si necesitas precisión, un ADS1115.

Siguiente paso: si quieres algo más pequeño, barato y con USB nativo, en la Parte 3 le toca el turno al ESP32-S2. Y si todavía no tienes placa, empieza por la Parte 1: qué es el ESP32 y su familia.

Créditos de las imágenes

Fotografías de Wikimedia Commons:

Módulo ESP32-WROOM-32 (frontal y trasera) y ESP32-DevKitC — Ubahnverleih (CC0)
Pinout del ESP32 DevKitC — Vishnu Maiea (CC BY-SA 4.0)

¿Qué es el ESP32? La familia completa, pinouts y dónde comprarla

2026-09-17T00:00:00+00:00

El ESP32 es, probablemente, el microcontrolador con Wi-Fi y Bluetooth más popular del mundo del maker. Cuesta menos que un café, tiene más potencia que un Arduino UNO por un factor de 20 y existe en una docena de sabores distintos: ESP32, S2, S3, C3, C6, H2, P4… Elegir mal la variante es el error número uno de quien empieza.

Esta guía es la que me habría gustado leer al principio: qué es exactamente, en qué se diferencia cada miembro de la familia, cómo leer un pinout sin equivocarte, cuál comprar según tu proyecto y dónde conseguirla.

El ESP32 en 30 segundos

Un ESP32 es un chip (SoC) que incluye:

Un procesador de 32 bits (1 o 2 núcleos, Xtensa o RISC-V).
Wi-Fi y, según la variante, Bluetooth clásico, BLE y/o Zigbee/Thread.
Memoria SRAM y, en algunos modelos, PSRAM externa.
Un montón de periféricos: GPIO, ADC, DAC, PWM, I2C, SPI, UART, I2S, CAN…
Todo por 2–5 dólares en una placa lista para conectar por USB.

Esa combinación —potencia, radio y precio— es lo que lo convirtió en el estándar de facto del IoT doméstico.

SoC, módulo y placa: no son lo mismo

Antes de seguir, un detalle que confunde a mucha gente:

Término	Qué es	Ejemplo
SoC	El chip desnudo	`ESP32-D0WDQ6`
Módulo	El SoC + flash + antena + apantallamiento	`ESP32-WROOM-32`
Placa / devkit	El módulo + USB + regulador + botones	`ESP32-DevKitC-32E`

Un módulo ESP32-WROOM-32: el SoC, la memoria flash y la antena en una pieza. Foto: Ubahnverleih (CC0).

Cuando compras en AliExpress o Mercado Libre casi siempre compras un devkit (la placa completa). Cuando diseñas tu propia PCB, compras el módulo.

La familia ESP32

Estos son todos los miembros relevantes, en orden cronológico:

La familia ESP, del ESP8266 (2014) al ESP32-P4 (2024).

Y aquí la tabla que de verdad importa a la hora de comprar:

Variante	Año	Núcleo	Radio	GPIOs	USB nativo	Ideal para
ESP8266	2014	Xtensa L106 ×1 @ 160 MHz	Wi-Fi 4	~11 usables	❌	Proyectos Wi-Fi al mínimo coste
ESP32 (clásico)	2016	Xtensa LX6 ×2 @ 240 MHz	Wi-Fi 4 + BT 4.2	~34 (25 usables)	❌	Uso general, más barato
ESP32-S2	2019	Xtensa LX7 ×1 @ 240 MHz	Wi-Fi 4	~43	✅	USB, HID, muchos pines
ESP32-C3	2020	RISC-V ×1 @ 160 MHz	Wi-Fi 4 + BLE 5	~22	✅	Reemplazo moderno y barato
ESP32-S3	2020	Xtensa LX7 ×2 @ 240 MHz	Wi-Fi 4 + BLE 5	~45	✅	IA, cámara, audio, USB
ESP32-C6	2022	RISC-V ×1 @ 160 MHz (+ núcleo LP)	Wi-Fi 6 + BLE 5 + 802.15.4	~30	✅	Matter, Thread, Zigbee
ESP32-H2	2023	RISC-V ×1 @ 96 MHz	BLE 5 + 802.15.4	~26	✅	Matter/Zigbee sin Wi-Fi
ESP32-P4	2024	RISC-V ×2 @ 400 MHz	sin radio	muchos	✅	HMI, pantallas, alto rendimiento

Regla rápida: ¿no sabes cuál? Compra un ESP32-C3 si quieres algo barato y moderno, o un ESP32-S3 si necesitas potencia, cámara o USB.

Variante por variante

ESP8266 — el abuelo que aún sirve

No es un ESP32, pero es su antecesor y sigue vendiéndose por menos de 2 $. Tiene un núcleo, sin Bluetooth y con pocos GPIO, pero suficiente para un sensor de temperatura que publica por Wi-Fi.

ESP8266: el chip que puso el Wi-Fi barato en manos de los makers. Foto: Suyash Dwivedi (CC BY-SA 4.0).

Míralo solo si el precio es lo único que importa. Por un poco más tienes un C3, que es mejor en todo.

ESP32 clásico — el todoterreno

El de 2016. Dos núcleos a 240 MHz, más GPIOs que casi cualquiera y la única variante con Bluetooth clásico (además de BLE). Es el que encontrarás en la mayoría de tutoriales antiguos y sigue siendo una elección perfecta para empezar.

Un ESP32-DevKitC: módulo WROOM, USB, regulador y dos botones. Foto: Edwiyanto (CC BY-SA 4.0).

Contras: no tiene USB nativo (lleva un chip CH340 o CP2102 para el puerto serie) y consume más en reposo que las variantes modernas.

ESP32-S2 — el que no tiene Bluetooth

El S2 fue el primer ESP32 con USB OTG nativo y muchos GPIOs (~43). Su pecado: no tiene Bluetooth. Si no lo necesitas, es una gran opción para HID (teclados, ratones) o proyectos con muchísimos pines.

ESP32-S2: USB OTG nativo, Wi-Fi 4 y sin Bluetooth. Ilustración.

ESP32-S3 — el potente

El favorito para proyectos ambiciosos: dos núcleos LX7, BLE 5, USB nativo y, sobre todo, instrucciones vectoriales que aceleran cargas de IA (detección de voz, visión). Es el que llevan las placas con cámara y las que mueven pantallas.

ESP32-S3: la variante más capaz para IA en el borde y multimedia. Foto: VectorVoyager (CC BY-SA 4.0).

Contras: más caro que un C3 y, si no vas a usar cámara/IA, es matar moscas a cañonazos.

ESP32-C3 — el equilibrado

Mi recomendación por defecto en 2026. Es RISC-V, con BLE 5, USB Serial/JTAG nativo y un precio casi de ESP8266. Para sensores, relés, domótica y casi cualquier proyecto normal, sobra.

Un ESP32-C3 tipo NodeMCU: pequeño, barato y con USB-C. Foto: Popolon (CC BY-SA 4.0).

Contras: menos GPIOs (~22) y sin Bluetooth clásico (solo BLE).

ESP32-C6 — el de Matter

El primer ESP32 con Wi-Fi 6 y, lo importante, con radio 802.15.4: eso significa Thread, Zigbee y Matter. Si quieres montar domótica moderna y compatible, es el chip.

ESP32-C6: Wi-Fi 6 + BLE 5 + 802.15.4 (Thread/Zigbee/Matter). Foto: Popolon (CC BY-SA 4.0).

Contras: requiere toolchain reciente (ESP-IDF 5.1+) y algunos módulos aún tienen poca disponibilidad en tiendas locales.

ESP32-H2 — el que no tiene Wi-Fi

Igual que el C6 pero sin Wi-Fi: solo BLE y 802.15.4. Suena raro, pero para un nodo Matter alimentado por batería es perfecto (menos radio, menos consumo).

ESP32-H2: BLE 5 + Zigbee/Thread, sin Wi-Fi. Ilustración.

ESP32-P4 — el nuevo (sin radio)

El P4 (2024) es distinto: sin Wi-Fi ni Bluetooth, pero con dos núcleos a 400 MHz y soporte de pantallas/cámaras de gama alta. Se usa como host de aplicación, normalmente acompañado de un C6 que le da la conectividad.

¿Cómo sé qué placa tengo en la mano?

Busca el nombre impreso en el módulo metálico:

ESP-WROOM-32 o ESP32-WROOM-32 → ESP32 clásico.
ESP32-WROVER → clásico con PSRAM (más memoria, ideal para cámaras).
ESP32-S3-WROOM-1 → S3.
ESP32-C3-MINI-1 o ESP32-C3-WROOM-02 → C3.
ESP32-C6-WROOM-1 → C6.
ESP32-S2-… → S2.
ESP32-H2-… → H2.

Si no ves nada, mira el patrón de pines: los GPIO34–39 del clásico son solo de entrada, y eso es inconfundible cuando probamos un sensor.

Pinouts (los mapas de pines)

Un pinout es el mapa que te dice qué función tiene cada pin. No todos los pines son iguales: algunos solo entran, otros definen el arranque y otros están prohibidos.

Pinout del ESP32 (DevKitC). Fuente: Wikimedia Commons, CC BY-SA 4.0.

Avisos que valen oro en el ESP32 clásico:

GPIO6–11: conectados a la flash. No los uses nunca.
GPIO34–39: solo entrada, sin pull-up interno.
GPIO0, 2, 12, 15: afectan al modo de arranque. Evítalos como salida.
GPIO1 (TX0) y GPIO3 (RX0): el puerto serie. Úsalos con cuidado.
ADC2 no funciona mientras el Wi-Fi está activo: usa ADC1 (GPIO32–39).

Y el del C3, cada vez más común:

Pinout del ESP32-C3. Fuente: Wikimedia Commons, CC BY-SA 4.0.

Los pinouts oficiales y actualizados están siempre en docs.espressif.com. Ante la duda, esa es la fuente de verdad.

¿Cuál me compro? (según tu proyecto)

Quiero…	Compra
Empezar y aprender	ESP32-C3 o ESP32 clásico
Domótica con Home Assistant	ESP32-C3 o, si quieres Matter, C6
Cámara, audio o IA	ESP32-S3 (+ PSRAM)
Un nodo Matter/Zigbee a batería	ESP32-C6 o H2
Muchísimos pines o USB HID	ESP32-S2
Lo más barato posible para un sensor	ESP8266 o ESP32-C3
Pantalla grande / HMI	ESP32-P4 + C6

Para tu primera placa, compra dos: una C3 barata para trastear y una S3 con PSRAM si piensas en cámaras o pantallas. Así no te quedas corto.

Dónde comprar

Aquí va la parte que casi ningún tutorial en español explica bien. El precio y el envío cambian mucho según la tienda y el país, así que toma esto como una guía de dónde mirar y con qué cuidado, no como un ranking fijo.

🇲🇽 México

Mercado Libre — lo más práctico: envío nacional, pago local y precios competitivos. Ojo con los vendedores: revisa reputación y que las fotos sean del producto real (no un render genérico).
Amazon México — envío rápido (Prime) y devoluciones fáciles; el precio suele ser algo más alto que en Mercado Libre.
UNIT Electronics — tienda mexicana especializada en electrónica y desarrollo. Buena para comprar módulos sueltos, sensores y accesorios en el mismo pedido, aunque el catálogo de placas varía.
Tiendas de robótica/maker locales — muchas ciudades tienen su tienda (CDMX, Guadalajara, Monterrey); vale la pena si necesitas el componente hoy.

🌎 Internacional

AliExpress — el más barato con diferencia. Contra: envío lento (2–6 semanas) y calidad irregular. Ideal para pedir varias placas y sensores de golpe.
LCSC — componentes y módulos originales a buen precio; útil si haces varias unidades o diseñas PCB.
Adafruit / SparkFun — placas propias de gran calidad y documentación excelente. Caro con envío a Latinoamérica, pero es el estándar para prototipos serios.
Mouser / Digi-Key / Farnell — distribuidores oficiales: te aseguras el chip original y tienes datasheet garantizado. Envío a México posible, pero con coste y trámites.
Espressif (tienda oficial) — módulos originales; útil si fabricas.

Cómo evitar clones malos

Pregunta por el chip USB-serie. CH340 funciona, pero algunos drivers son problemáticos en macOS. CP2102 suele dar menos guerra.
30 vs 38 pines. Muchas placas clásicas baratas traen solo 30 pines: pierdes GPIOs. Si puedes, elige la de 38.
USB-C vs micro-USB. Micro-USB en 2026 es un dolor; paga un poco más por C.
PSRAM real. Si compras un S3 para cámara, verifica que anuncia PSRAM (8 MB en las buenas).
Antena. Las placas con conector U.FL/IPEX permiten antena externa si vas a usar el ESP32 dentro de un gabinete metálico.
Botones BOOT y EN. Que existan: sin BOOT a veces no puedes flashear.

Errores comunes al empezar

Comprar una placa sin USB nativo pensando que el puerto serie es nativo.
Elegir el ESP8266 “porque es más barato” cuando el C3 cuesta casi lo mismo y es mejor.
Comprar una S3 sin PSRAM para un proyecto de cámara.
Olvidar que en el clásico los GPIO34–39 son solo entrada.
Intentar usar ADC2 con Wi-Fi encendido.

Resumen

El ESP32 es un SoC con radio, mucha potencia y precio ridículo.
La familia es amplia: ESP8266 → ESP32 → S2 → C3 → S3 → C6 → H2 → P4.
Para empezar: C3 (barato) o S3 (potente). Para domótica moderna: C6.
El pinout no es opcional: hay pines prohibidos y pines de solo entrada.
Compra donde puedas devolver, y desconfía de las placas “demasiado baratas”.

Siguiente paso: elige tu placa y monta el entorno. Los siguientes capítulos de la serie Primeros pasos con ESP32 irán apareciendo en el blog; mientras, puedes explorar por categorías o buscar cualquier tema con Ctrl + K.

Créditos de las imágenes

Todas las fotografías provienen de Wikimedia Commons y se usan bajo su licencia (CC0 o CC BY-SA 4.0), con atribución al autor:

Módulo ESP32-WROOM-32 — Ubahnverleih (CC0)
ESP32-DevKitC — Edwiyanto (CC BY-SA 4.0)
ESP32-S3 — VectorVoyager (CC BY-SA 4.0)
ESP32-C3 — Popolon (CC BY-SA 4.0)
ESP32-C6 — Popolon (CC BY-SA 4.0)
ESP32-CAM — Nowforever (CC BY-SA 4.0)
ESP8266 — Suyash Dwivedi (CC BY-SA 4.0)
Pinout ESP32 DevKitC — Vishnu Maiea (CC BY-SA 4.0)
Pinout ESP32-C3 — Srdocdoc (CC BY-SA 4.0)

Ilustraciones de ESP32-S2, ESP32-H2 y de la familia: propias.

Introducción al ESP32

2026-09-16T00:00:00+00:00

Esta serie es la puerta de entrada al ESP32. Está pensada para que la sigas en orden, pero cada artículo funciona también por sí solo.

Empezamos por entender qué es y qué variante te conviene, seguimos con los frameworks (Arduino, ESP-IDF, MicroPython, Rust) y los editores, y terminamos escribiendo el primer programa sobre hardware real.

Todo el código está probado en placas reales, con mediciones y pinouts, y sin copiar y pegar de otros tutoriales.

Explorar

2026-01-16T00:00:00+00:00

Acerca de

2026-01-15T00:00:00+00:00

Hola 👋

Este es un blog dedicado al ESP32: el microcontrolador con Wi-Fi y Bluetooth que se ha convertido en el corazón de incontables proyectos de IoT.

Aquí encontrarás:

Tutoriales paso a paso desde el primer blink hasta IoT en producción.
Proyectos completos con esquemas, código y decisiones de diseño.
Notas de ingeniería: energía, antenas, RTOS, seguridad y depuración.

Todo el contenido se escribe en Markdown dentro de este mismo repositorio y se compila con Zola, un generador de sitios estáticos escrito en Rust. Sin base de datos, sin CMS: solo texto y Git.

Stack de este sitio

Capa	Tecnología
Generador	Zola (Rust)
Plantillas	Tera
Resaltado de código	Giallo
Fórmulas	KaTeX
Búsqueda	elasticlunr (índice generado por Zola)

Si quieres proponer un tema o corregir algo, abre un issue o un pull request.