Arduino IDE vs PlatformIO para ESP32: cuál usar
¿Arduino IDE 2 o PlatformIO para ESP32? Comparativa de versiones de librerías, Arduino-ESP32 3.x, depuración y tests, con el platformio.ini de Gizmo Ticker.
- Autor
Mauro Brambilla- Publicado
- Tiempo de lectura
- 10 min
- Categoría
- Comparativas

En resumen
Usa Arduino IDE 2 para una placa y un sketch. Usa PlatformIO cuando librerías, targets o tests necesiten versiones fijas: su platformio.ini guarda cada versión en el proyecto, no en tu equipo.
Para una placa y un sketch, usa Arduino IDE 2. Para un proyecto ESP32 con varias librerías, más de un target de compilación o tests, usa PlatformIO. Los dos compilan tu código contra el core Arduino-ESP32 de Espressif, así que la diferencia real es dónde viven las versiones: en tu equipo en el IDE, y en un archivo platformio.ini dentro del proyecto en PlatformIO.
Compilo con PlatformIO los tres firmwares de OpenGizmo (Gizmo Ticker, Gizmo Reolink Switch y Gizmo Camera), así que esta comparativa se apoya en sus archivos de configuración reales y en la documentación oficial de ambas herramientas, con la fecha en que comprobé cada dato: noviembre de 2026. También cubre las partes incómodas, como el retraso de Arduino-ESP32 3.x que empujó a la gente hacia un fork, y un camino numerado para pasar un sketch a PlatformIO.
¿Cuál elegir para un proyecto ESP32?
Elige según lo que el proyecto tenga que poder repetir. Si otra persona (o tú dentro de un año) necesita recompilar el mismo firmware desde una computadora limpia, las versiones tienen que estar escritas en el proyecto. Si solo quieres ver parpadear un LED esta noche, no.

| Tema | Arduino IDE 2 | PlatformIO |
|---|---|---|
| Archivo de proyecto | Una carpeta de sketch con un archivo .ino | platformio.ini más las carpetas src/, test/ y lib/ |
| Dónde viven las librerías | Se instalan una vez desde el Library Manager y las comparten todos los sketches | Se descargan por proyecto desde lib_deps a la carpeta libdeps |
| Fijar versiones | No en el IDE; los perfiles de Arduino CLI sí | Líneas platform y lib_deps, con versiones exactas, rangos o tags de Git |
| Varios targets | Un solo menú de placa a la vez | Una sección [env:nombre] por target, elegida con -e |
| Línea de comandos | Arduino CLI es una herramienta aparte | pio run, pio test y pio device monitor son la herramienta base |
| Tests unitarios en tu computadora | Ningún test runner que yo haya encontrado en la documentación | pio test con la plataforma native y Unity |
| Frameworks para ESP32 | Core Arduino-ESP32 | Arduino y ESP-IDF |
| De dónde viene el core de ESP32 | El índice del Boards Manager de Espressif | El core incluido en la plataforma espressif32 |
Arduino IDE 2.3.11 era la última versión el 12 de noviembre de 2026, y la extensión de PlatformIO para Visual Studio Code incluye PlatformIO Core, así que no hace falta instalar la línea de comandos por separado. Ambos datos salen de las versiones de Arduino IDE y de la documentación de PlatformIO para VS Code.
¿Cómo es un platformio.ini real?
Un platformio.ini es el único archivo que dice con qué placa, qué versión de la plataforma y qué librerías se compila un proyecto. Esta es la configuración del firmware de Gizmo Ticker, copiada de microcontroller/platformio.ini con los comentarios recortados:
[platformio]
default_envs = release
[env:release]
extra_scripts = pre:firmware_version.py
board = seeed_xiao_esp32s3
platform = espressif32 @ 8.0.0
framework = arduino
board_build.partitions = huge_app.csv
build_src_flags = -Wformat
monitor_speed = 115200
lib_deps =
majicdesigns/MD_Parola@3.7.5
majicdesigns/MD_MAX72XX@3.5.1
esp32async/ESPAsyncWebServer@3.12.1
esp32async/AsyncTCP@3.5.0
bblanchon/ArduinoJson@7.2.2
bblanchon/StreamUtils@1.9.2
https://github.com/open-gizmo/gizmo-common.git#v2.5.1
[env:debug]
extends = env:release
build_unflags = -DCORE_DEBUG_LEVEL=0
build_flags =
-D PIO_DEV_MODE=1
-D CORE_DEBUG_LEVEL=3
[env:native]
platform = native@1.2.1
test_framework = unity
test_build_src = yes
build_src_filter = -<*> +<server/settings_json.cpp> +<api/market_refresh.cpp> +<api/market_data.cpp>
build_flags =
-std=gnu++17
-D UNITY_INCLUDE_DOUBLE
lib_deps =
throwtheswitch/Unity@2.6.1
bblanchon/ArduinoJson@7.2.2Línea por línea, esto es lo que hace cada parte:
board = seeed_xiao_esp32s3selecciona la definición de placa Seeed Studio XIAO ESP32-S3: 240 MHz, 8 MB de memoria flash, 320 KB de RAM. No es la genéricaesp32dev, que es el perfil ESP32 Dev Module con 4 MB de flash. Cada variante de ESP32 necesita su propio ID.platform = espressif32 @ 8.0.0fija la toolchain y el core Arduino-ESP32 que incluye. Más sobre esto abajo.board_build.partitions = huge_app.csvle da a la app un único slot de 3 MB, que uso en todos los firmwares de OpenGizmo porque ninguno hace actualizaciones inalámbricas. El artículo sobre la tabla de particiones explica el compromiso.lib_depslista cada librería con una versión exacta. La última línea apunta a un tag de Git de nuestra librería compartidagizmo-common.[env:debug]copiareleaseconextendsy sube el nivel de log del core de 0 a 3. El mismo código, otra compilación, elegida conpio run -e debug -t upload.[env:native]compila tres archivos fuente para tu computadora en vez de para la placa, para ejecutar tests. El filtro-<*> +<archivo>dice "nada excepto estos archivos".
Las mismas tres secciones (release, debug, native) están en las configuraciones de Reolink Switch y Camera. La cámara usa board = esp32cam, que activa su PSRAM para los frame buffers.

¿Dónde viven las librerías y cómo se fijan sus versiones?
Fijar versiones significa escribir junto al código la versión exacta con la que compilaste, para que una compilación del año que viene use la misma librería y el mismo core. Las dos herramientas se diferencian en dónde puede vivir ese registro.
Arduino IDE 2: se instala una vez y lo comparten todos los sketches
Añades el core de ESP32 pegando la URL del índice de paquetes de Espressif en las preferencias del IDE y luego instalas la plataforma esp32 desde el Boards Manager, como describe la guía de instalación de Arduino-ESP32. Las librerías vienen del Library Manager. Ambos se instalan en el equipo, una sola vez. Si actualizas una librería para un sketch, todos los demás sketches reciben la versión nueva, y nada en la carpeta del sketch registra con qué versión se escribió.

Eso está bien para un sketch que terminas en una tarde. Duele cuando la actualización de una librería cambia una API y tienes que recordar cuál de tus proyectos usa qué versión.
Perfiles de sketch de Arduino CLI: la respuesta del lado de Arduino
El lado de Arduino tiene una respuesta, pero vive en la herramienta de línea de comandos. En Arduino CLI, un perfil de sketch en un archivo sketch.yaml lista la placa, la versión de la plataforma del core y las versiones de las librerías. La documentación de Arduino dice que una compilación con perfil "is isolated from the system and will rely only on the resources specified in the profile". Un perfil de ejemplo para la XIAO ESP32-S3:
profiles:
release:
fqbn: esp32:esp32:XIAO_ESP32S3
platforms:
- platform: esp32:esp32 (3.3.12)
platform_index_url: https://espressif.github.io/arduino-esp32/package_esp32_index.json
libraries:
- ArduinoJson (7.2.2)
default_profile: releaseLo compilas con arduino-cli compile --profile release. Esa página documenta la CLI; con ella no pude confirmar que la ventana de Arduino IDE 2 exponga los perfiles, así que considera el IDE solo de instalación global.
PlatformIO: las versiones viven en el proyecto
PlatformIO descarga lo que lista lib_deps en la carpeta libdeps del proyecto (el valor por defecto de la opción libdeps_dir es workspace_dir/libdeps), así que dos proyectos nunca comparten una librería. La documentación de lib_deps muestra nombres del registro (owner/name), rangos SemVer como bblanchon/ArduinoJson @ ~5.6,!=5.4 y URLs de Git con un tag (...git#v2.0). OpenGizmo usa versiones exactas y un tag de Git; el workflow de release incluso instala un PlatformIO Core fijo (platformio==6.2.0), de modo que la CI y un clon nuevo resuelven el mismo conjunto.
¿PlatformIO es compatible con el último core Arduino-ESP32?
Sí, a noviembre de 2026, pero tardó. La plataforma espressif32 de PlatformIO incluye un core Arduino-ESP32, y la página de versiones de la plataforma muestra cuál:
| Versión de espressif32 | Fecha | Core Arduino-ESP32 |
|---|---|---|
| 6.13.0 | 26 feb | 2.0.17 |
| 7.0.0 a 7.1.0 | del 30 abr al 31 ago | 2.0.17 |
| 8.0.0 | 19 oct | 3.3.12 |
Así que durante toda la línea 7.x la plataforma oficial se quedó en el core 2.0.17, mientras el índice del Boards Manager de Espressif ya había pasado a la 3.x. Ese desfase es la razón por la que la plataforma comunitaria pioarduino, un fork de la oficial, se hizo popular. La usas reemplazando la línea platform por una URL:
platform = https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zipSu versión stable también incluye ahora Arduino 3.3.12, y añade extras como un modo de compilación híbrido para chips que el core de Arduino no cubre. Como la 8.0.0 oficial ya se puso al día, yo me quedaría con la plataforma oficial, salvo que necesites alguno de esos extras. Las notas de la versión 8.0.0 también advierten que Arduino-ESP32 3.x no tiene la refactorización completa de Bluetooth prevista para la v4.0.
De ahí salen dos reglas prácticas. Fija la plataforma (espressif32 @ 8.0.0, o ~8.0.0 para aceptar versiones de parche), porque subir la plataforma es subir el core, y pasar del core 2 al core 3 cambia las API. Y lee la página de la versión antes de actualizar. Los tres repositorios de OpenGizmo fijan espressif32 @ 8.0.0, así que compilan sobre el core 3.3.12.
¿Cómo se comparan las opciones de depuración?
La mayor parte de la depuración en ESP32 es logging con Serial, y ambas herramientas lo hacen. La diferencia con PlatformIO es que el nivel de log es un perfil de compilación: pio run -e debug -t upload seguido de pio device monitor te da el firmware del ticker con los mensajes propios del core activados, y release mantiene el log serial apagado. El README del ticker documenta los tres perfiles de compilación.
La depuración por hardware (breakpoints y ejecución paso a paso) necesita un probe. La página de la XIAO ESP32-S3 de PlatformIO dice que la placa no tiene un probe de depuración integrado y no está lista para depurar, y lista herramientas externas que eliges con la opción debug_tool, entre ellas esp-builtin. Arduino IDE 2 tiene su propio depurador; en su documentación no pude confirmar que las placas ESP32 estén cubiertas, así que compruébalo antes de comprar un probe. Yo no uso un depurador por hardware en los firmwares de OpenGizmo: me apoyo en el perfil debug y en el log serial.
¿Se puede probar el código del ESP32 sin una placa?
Si la lógica no toca el hardware, sí. Los tests unitarios de PlatformIO pueden ejecutar los mismos tests en tu computadora (la plataforma native) o en una placa conectada, con frameworks como Unity. En la configuración de arriba, [env:native] compila solo tres archivos, y pio test -e native los ejecuta:
server/settings_json.cpp, la correspondencia entre los ajustes y el JSON de la API webapi/market_refresh.cpp, que decide cuándo volver a pedir los preciosapi/market_data.cpp, que lee la respuesta de CoinGecko
Esos tests viven en microcontroller/test/, y el workflow de release ejecuta pio test -e native antes de compilar el firmware. El límite es real: los tests native cubren la lógica que compila en un PC. Todo lo que hable con la matriz, el Wi-Fi o la memoria flash sigue necesitando una placa. En la documentación de Arduino IDE 2 no encontré un test runner, así que de ese lado tendrías que probar a mano en la placa o automatizarlo con otra herramienta.
¿Cómo se pasa un sketch de Arduino a PlatformIO?
Un sketch de un solo archivo se convierte en unos pocos pasos. Las reglas de conversión vienen de la guía ino to cpp de PlatformIO.
- Instala Visual Studio Code y luego la extensión PlatformIO IDE desde la vista Extensions. Incluye PlatformIO Core.
- En PlatformIO Home elige New Project, selecciona tu placa (
seeed_xiao_esp32s3para una XIAO ESP32-S3,esp32devpara un ESP32 DevKit clásico) y el framework Arduino. Obtienes unplatformio.iniysrc/main.cpp. - Pega tu sketch en
src/main.cpp. Añade#include <Arduino.h>arriba y declara cada función propia antes de llamarla. No declaressetupniloop. - Pasa cada librería a
lib_deps. Busca en el PlatformIO Registry, copia la formaowner/namey añade la versión que usabas, por ejemplobblanchon/ArduinoJson@7.2.2. - Fija la plataforma:
platform = espressif32 @ 8.0.0. Traslada las opciones del menú Tools que importaban, como el esquema de particiones (board_build.partitions) y la velocidad serial (monitor_speed = 115200). - Ejecuta
pio run. Corrige prototipos o includes que falten hasta que la compilación termine bien. - Conecta la placa y ejecuta
pio run -t upload, luegopio device monitorpara leer la salida serial.
Cuando funcione, añade un [env:debug] que use extends sobre tu entorno principal, como en el ejemplo de arriba. Es la mejora más barata que te da el cambio.
¿Qué te cuesta PlatformIO y cuándo gana Arduino IDE?
La objeción más fuerte a PlatformIO es su coste de arranque. Aprendes un archivo ini, una estructura de carpetas y unos cuantos comandos antes del primer parpadeo, y la experiencia del editor depende de una extensión de VS Code. Las actualizaciones de core y plataforma son explícitas, lo cual es bueno para la repetibilidad y significa que te toca leer las notas de cada versión. Para un solo sketch, nada de eso se amortiza.
Arduino IDE 2 gana cuando el proyecto es un sketch en una placa, cuando sigues un tutorial escrito para él, o cuando quieres el core más nuevo de Espressif directo del índice del Boards Manager el día que sale. Su documentación es el mejor punto de partida para la primera semana.
Hay también una tercera respuesta: saltarte los dos. Los proyectos de OpenGizmo traen firmware ya compilado que flasheas desde el navegador, y la guía de ESP Web Tools explica cómo. Solo necesitas una toolchain para cambiar el código.
Entonces, ¿con cuál empezar?
Empieza con Arduino IDE 2 si quieres una primera carga hoy. Pasa a PlatformIO cuando te descubras queriendo un segundo perfil de placa, un test o poder recompilar una versión antigua. La conversión del sketch de arriba es corta, y lib_deps más una plataforma fijada te dan compilaciones que siguen funcionando.
Lo que comprobé: los archivos de configuración de los tres repositorios de firmware de OpenGizmo, las notas de versión de espressif32 y la documentación oficial enlazada arriba, a noviembre de 2026. Lo que no comprobé: si el depurador de Arduino IDE 2 funciona con placas ESP32, y si su interfaz gráfica expone los perfiles de sketch. Después, lee la guía del pinout de la XIAO ESP32-S3 para la placa que usan estas configuraciones, o la guía para construir Gizmo Ticker para ver el proyecto completo construido con este setup.
Preguntas frecuentes
Encuentra respuestas rápidas a las preguntas más comunes sobre este tema.
Para proyectos con varias librerías, más de un target de compilación o tests, sí: PlatformIO guarda las versiones de plataforma, placa y librerías en un archivo platformio.ini dentro del proyecto. Para un solo sketch en una sola placa, Arduino IDE 2 es más rápido de arrancar y tiene menos partes móviles.
Autor
Mauro Brambilla¿Listo para montar tu propio gizmo?
Elige un proyecto open source con ESP32 y sigue su guía paso a paso, desde la lista de componentes y el cableado hasta el firmware y el primer arranque.






