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.

Publicado
Tiempo de lectura
10 min
Categoría
Comparativas
Una infografía que compara Arduino IDE y PlatformIO, con sus interfaces de desarrollo y una placa ESP32.

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.

Un maker programando un sketch de ESP32 en PlatformIO dentro de VS Code, con main.cpp abierto junto a la barra lateral Home, Libraries y Debug

TemaArduino IDE 2PlatformIO
Archivo de proyectoUna carpeta de sketch con un archivo .inoplatformio.ini más las carpetas src/, test/ y lib/
Dónde viven las libreríasSe instalan una vez desde el Library Manager y las comparten todos los sketchesSe descargan por proyecto desde lib_deps a la carpeta libdeps
Fijar versionesNo en el IDE; los perfiles de Arduino CLI síLíneas platform y lib_deps, con versiones exactas, rangos o tags de Git
Varios targetsUn solo menú de placa a la vezUna sección [env:nombre] por target, elegida con -e
Línea de comandosArduino CLI es una herramienta apartepio run, pio test y pio device monitor son la herramienta base
Tests unitarios en tu computadoraNingún test runner que yo haya encontrado en la documentaciónpio test con la plataforma native y Unity
Frameworks para ESP32Core Arduino-ESP32Arduino y ESP-IDF
De dónde viene el core de ESP32El índice del Boards Manager de EspressifEl 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:

microcontroller/platformio.ini
microcontroller/platformio.ini
[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.2
Lín. 38, col. 1UTF-8ini

Línea por línea, esto es lo que hace cada parte:

  • board = seeed_xiao_esp32s3 selecciona 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érica esp32dev, que es el perfil ESP32 Dev Module con 4 MB de flash. Cada variante de ESP32 necesita su propio ID.
  • platform = espressif32 @ 8.0.0 fija la toolchain y el core Arduino-ESP32 que incluye. Más sobre esto abajo.
  • board_build.partitions = huge_app.csv le 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_deps lista cada librería con una versión exacta. La última línea apunta a un tag de Git de nuestra librería compartida gizmo-common.
  • [env:debug] copia release con extends y sube el nivel de log del core de 0 a 3. El mismo código, otra compilación, elegida con pio 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.

Un solo platformio.ini con tres entornos: release compila el firmware de la XIAO ESP32-S3, debug añade los logs del core, native ejecuta tests Unity en la computadora

¿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ó.

Un maker escribiendo un sketch.ino en Arduino IDE junto a una placa Arduino y una protoboard

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:

sketch.yaml
sketch.yaml
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: release
Lín. 9, col. 1UTF-8YAML

Lo 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 espressif32FechaCore Arduino-ESP32
6.13.026 feb2.0.17
7.0.0 a 7.1.0del 30 abr al 31 ago2.0.17
8.0.019 oct3.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:

Código
Código
platform = https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip
Lín. 1, col. 1UTF-8ini

Su 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 web
  • api/market_refresh.cpp, que decide cuándo volver a pedir los precios
  • api/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.

  1. Instala Visual Studio Code y luego la extensión PlatformIO IDE desde la vista Extensions. Incluye PlatformIO Core.
  2. En PlatformIO Home elige New Project, selecciona tu placa (seeed_xiao_esp32s3 para una XIAO ESP32-S3, esp32dev para un ESP32 DevKit clásico) y el framework Arduino. Obtienes un platformio.ini y src/main.cpp.
  3. Pega tu sketch en src/main.cpp. Añade #include <Arduino.h> arriba y declara cada función propia antes de llamarla. No declares setup ni loop.
  4. Pasa cada librería a lib_deps. Busca en el PlatformIO Registry, copia la forma owner/name y añade la versión que usabas, por ejemplo bblanchon/ArduinoJson@7.2.2.
  5. 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).
  6. Ejecuta pio run. Corrige prototipos o includes que falten hasta que la compilación termine bien.
  7. Conecta la placa y ejecuta pio run -t upload, luego pio device monitor para 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.

Publicado Actualizado

¿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.

Lee también

Explora las categorías