Guías · 13 min de lectura

Instalar PlatformIO en VS Code: Arduino, ESP32 y Pico

Cómo instalar PlatformIO en VS Code: extensión, platformio.ini para Uno, ESP32 y Pico, lib_deps para librerías, subir código, monitor serie y migración.

Instalar PlatformIO te permite programar placas como Arduino Uno, ESP32 y Raspberry Pi Pico desde un mismo entorno profesional, añadiendo una sola extensión a VS Code. En resumen: instala VS Code, busca PlatformIO IDE en la pestaña de Extensiones, instálala, espera a que se descarguen las herramientas en el primer arranque y crea un proyecto nuevo eligiendo tu placa en la pantalla PIO Home. El resto gira en torno a un pequeño archivo de configuración llamado platformio.ini: ahí se escribe qué placa, qué framework, qué librerías y qué velocidad de puerto serie usa el proyecto.

El IDE de Arduino es una herramienta estupenda para aprender, pero cuando el proyecto crece notas sus límites: el autocompletado es básico, las librerías son comunes a todos los proyectos, una actualización de una librería puede romper un proyecto antiguo y la configuración de la placa no se guarda con el proyecto. PlatformIO resuelve estos problemas. En esta guía harás la instalación paso a paso, crearás tu primer proyecto, definirás tres placas distintas en un solo proyecto con platformio.ini, añadirás una librería, subirás código, abrirás el monitor serie y aprenderás a migrar proyectos existentes del IDE de Arduino. En la última sección compararemos ambas herramientas con imparcialidad para ayudarte a decidir cuál te conviene.

Placa Arduino Uno programada con PlatformIO
Con PlatformIO puedes programar placas como Arduino Uno, ESP32 y Raspberry Pi Pico desde el mismo editor y con un único archivo de configuración.

¿Qué es PlatformIO y cómo funciona?

PlatformIO es un ecosistema de desarrollo de código abierto para sistemas embebidos. En su núcleo hay una herramienta de línea de comandos escrita en Python llamada PlatformIO Core; la extensión de VS Code la hace cómoda con botones, menús y la pantalla PIO Home. Cuando compilas un proyecto, PlatformIO lee primero platformio.ini y después descarga de su propio repositorio el compilador necesario (avr-gcc para Uno, la cadena de herramientas Xtensa para ESP32, arm-none-eabi-gcc para Pico), el framework y las librerías, y compila tu código. Estos paquetes se descargan una sola vez y se guardan en la carpeta .platformio de tu usuario; los proyectos siguientes los reutilizan. Conocer los siguientes conceptos te hará mucho más fácil leer el archivo:

ConceptoSignificadoEjemplo
Platform (plataforma)Paquete de compilador y herramientas de carga de una familia de microcontroladoresatmelavr, espressif32, raspberrypi
Board (placa)Placa concreta dentro de la plataforma; mapa de pines, velocidad de reloj y memoriauno, nanoatmega328, esp32dev, pico
FrameworkInfraestructura de software sobre la que escribes el códigoarduino, espidf
Entorno (env)Sección donde se definen juntos plataforma, placa, framework y ajustes extra[env:uno]
LibreríaPaquete de código ya hecho que se añade al proyecto con lib_depsadafruit/DHT sensor library
PIO HomePantalla para abrir proyectos y buscar placas y libreríasIcono de la casa en la barra de estado

Instalar PlatformIO paso a paso

  1. Descarga e instala Visual Studio Code desde su web oficial. En Windows, marcar la opción Add to PATH durante la instalación facilita el uso del terminal.
  2. Abre VS Code y haz clic en la pestaña Extensiones (Extensions) de la izquierda, o usa el atajo Ctrl+Shift+X (Cmd+Shift+X en macOS).
  3. Escribe PlatformIO IDE en el cuadro de búsqueda e instala con el botón Install la extensión publicada por PlatformIO. La extensión de C/C++ necesaria se instala automáticamente.
  4. Abajo a la derecha aparecerá el aviso "Installing PlatformIO Core". Según tu conexión, este paso tarda unos minutos; no cierres VS Code mientras tanto.
  5. Al terminar, VS Code te pedirá reiniciarse. Tras reiniciar, verás el icono de PlatformIO en el borde izquierdo y el icono de la casa en la barra de estado inferior.
  6. Haz clic en el icono de la casa para abrir la pantalla PIO Home. Si se ve sin problemas, la instalación ha terminado.
Si tu nombre de usuario de Windows contiene caracteres especiales (como ş, ğ, ı, ü, ñ o tildes) o espacios, la cadena de herramientas de PlatformIO puede dar problemas en la ruta C:\Users\<nombre>\.platformio y la compilación puede detenerse con errores de ruta incomprensibles. La solución es añadir a las variables de entorno del sistema PLATFORMIO_CORE_DIR con una carpeta formada solo por letras inglesas, como C:\platformio. Si en Linux la instalación falla, comprueba primero que el paquete python3-venv esté instalado.

Crear el primer proyecto y estructura de carpetas

En PIO Home pulsa el botón New Project. En la ventana que se abre, ponle un nombre al proyecto (por ejemplo blink-uno), escribe Arduino Uno en el cuadro Board y selecciónalo de la lista, deja Arduino como Framework y elige la ubicación. Al pulsar Finish, PlatformIO descarga por primera vez el paquete de plataforma de la placa elegida; por eso el primer proyecto puede tardar unos minutos y los siguientes se abren en segundos. Cuando se crea el proyecto, VS Code abre la carpeta y verás esta estructura:

Carpeta / archivoPara qué sirve
platformio.iniEl corazón del proyecto: placa, framework, librerías y ajustes de puerto
src/Tu código fuente; el programa empieza en main.cpp
include/Tus propios archivos de cabecera (.h)
lib/Librerías locales específicas del proyecto que añades a mano (cada una en su subcarpeta)
test/Carpeta reservada para pruebas unitarias (unit tests)
.pio/Resultados de compilación y librerías descargadas; si la borras, se regenera
.vscode/Ajustes de VS Code e IntelliSense; se genera automáticamente

¿Qué es el archivo platformio.ini?

platformio.ini es un archivo de texto plano en formato INI. Cada sección que empieza con corchetes [env:nombre] define un entorno de compilación. La placa y la velocidad del puerto que en el IDE de Arduino eliges en el menú Herramientas, aquí las escribes como texto; así, cuando mueves el proyecto a otro ordenador o se lo pasas a un amigo, los ajustes viajan con el código. Las líneas que empiezan con punto y coma son comentarios. Al añadir la velocidad del monitor serie al archivo creado para Uno, queda así:

C++ (Arduino IDE)
1; PlatformIO proje ayarları / PlatformIO project settings
2[env:uno]
3platform = atmelavr
4board = uno
5framework = arduino
6; Seri monitör hızı, Serial.begin ile aynı olmalı / Monitor speed, must match Serial.begin
7monitor_speed = 115200
AjusteFunciónValor de ejemplo
platformPaquete de plataforma que se usará; también se puede fijar la versiónatmelavr, [email protected]
boardIdentificador de la placauno, megaatmega2560, esp32dev, pico
frameworkFramework de softwarearduino
monitor_speedVelocidad del monitor serie (por defecto 9600)115200
upload_portPuerto de carga (si lo dejas vacío, se detecta solo)COM5, /dev/ttyUSB0
upload_speedVelocidad en baudios de carga (sobre todo en placas ESP)921600
lib_depsLibrerías que se descargarán automáticamenteadafruit/DHT sensor library@^1.4.4
build_flagsFlags y macros adicionales para el compilador-D LED_PIN=2
monitor_filtersFiltros aplicados a la salida del monitor serietime, esp32_exception_decoder

Primer código: main.cpp y la diferencia con Arduino.h

El archivo main.cpp de la carpeta src equivale al archivo .ino del IDE de Arduino, pero con dos diferencias importantes. La primera: al principio del archivo debe haber una línea #include que incluya la cabecera Arduino.h; el IDE de Arduino la añade por su cuenta en segundo plano, PlatformIO no. La segunda: un archivo .cpp sigue las reglas reales de C++, es decir, el compilador debe conocer una función antes de que la llames. El IDE de Arduino genera los prototipos de funciones por ti; en PlatformIO o defines la función antes de usarla o escribes un prototipo de una línea al principio del archivo. El siguiente ejemplo es un programa blink que funciona en Uno, ESP32 y Pico:

C++ (Arduino IDE)
1#include <Arduino.h>
2
3// LED_PIN platformio.ini'den gelebilir / LED_PIN may come from platformio.ini
4#ifndef LED_PIN
5#define LED_PIN LED_BUILTIN   // Uno: 13, Pico: GP25
6#endif
7
8void blinkLed(int count);     // prototip / prototype
9
10void setup() {
11  Serial.begin(115200);
12  pinMode(LED_PIN, OUTPUT);
13  Serial.println("PlatformIO hazir / ready");
14}
15
16void loop() {
17  blinkLed(3);
18  delay(1000);
19}
20
21void blinkLed(int count) {
22  for (int i = 0; i < count; i++) {
23    digitalWrite(LED_PIN, HIGH);
24    delay(150);
25    digitalWrite(LED_PIN, LOW);
26    delay(150);
27  }
28  Serial.print("Yanip sondu / Blinked: ");
29  Serial.println(count);
30}
Si al compilar ves el error 'blinkLed' was not declared in this scope, casi siempre lo que falta es el prototipo. Basta con copiar la primera línea de la función, sin el cuerpo y con un punto y coma al final, encima de setup(). Si tienes muchas funciones, es más ordenado reunirlas en un archivo .h de la carpeta include.

Compilar, subir y monitor serie

AcciónBarra de estado / menúComando de terminal
Compilar (Build)Marca de verificaciónpio run
Subir (Upload)Flecha a la derechapio run -t upload
Subir y abrir el monitorMenú PlatformIO > Upload and Monitorpio run -t upload -t monitor
Monitor serieIcono de enchufepio device monitor
LimpiarPapelerapio run -t clean
Listar puertosPIO Home > Devicespio device list
Compilar un entorno concretoSelector de entorno (env:...)pio run -e esp32dev
Instalar una libreríaPIO Home > Librariespio pkg install -l "adafruit/DHT sensor library"

Para que el monitor serie funcione bien, el valor de monitor_speed en platformio.ini debe ser igual a la velocidad de Serial.begin() del código; si no, verás caracteres sin sentido en pantalla. PlatformIO suele encontrar la placa conectada por sí mismo, pero si hay varios dispositivos serie en el ordenador puede intentar subir el programa al puerto equivocado. En ese caso lista los puertos con el comando pio device list y escribe el correcto en las líneas upload_port y monitor_port. Si el monitor serie del IDE de Arduino u otro programa de terminal mantiene el puerto abierto, la carga se detiene con el error "Access is denied" o "Resource busy"; basta con cerrar ese programa. Para conocer mejor el monitor serie, puedes echar un vistazo también al artículo Arduino Serial Monitor. El comando pio siempre funciona en el terminal PlatformIO Core CLI que se abre desde el menú de PlatformIO.

Uno, ESP32 y Pico en un solo proyecto

Uno de los puntos más fuertes de PlatformIO es que puede compilar el mismo código para varias placas. Escribes una sección [env:...] para cada placa; si pones los ajustes comunes en la sección sin nombre [env], todos los entornos los heredan. La siguiente tabla resume los valores básicos de tres placas populares:

ValorArduino UnoESP32 DevKitRaspberry Pi Pico
platformatmelavrespressif32raspberrypi
boardunoesp32devpico
frameworkarduinoarduinoarduino (núcleo Arduino Mbed)
LED integradoD13GPIO 2 (en la mayoría de placas DevKit)GP25
Método de cargaUSB-serie y bootloaderUSB-serie y esptoolUSB y modo BOOTSEL
monitor_speed típico9600 o 115200115200115200
C++ (Arduino IDE)
1[platformio]
2; Varsayılan ortam / Default environment
3default_envs = uno
4
5; Tüm ortamlarda ortak ayarlar / Settings shared by all environments
6[env]
7framework = arduino
8monitor_speed = 115200
9
10[env:uno]
11platform = atmelavr
12board = uno
13
14[env:esp32dev]
15platform = espressif32
16board = esp32dev
17upload_speed = 921600
18monitor_filters = esp32_exception_decoder
19; Dahili LED GPIO 2 / Onboard LED on GPIO 2
20build_flags = -D LED_PIN=2
21
22[env:pico]
23platform = raspberrypi
24board = pico

La línea default_envs determina qué entorno usan los botones de compilar y subir de la barra de estado; si no la escribes, PlatformIO compila todos los entornos del archivo por orden. Con el selector de entorno de la barra de estado puedes cambiar de placa al instante, o subir directamente al ESP32 escribiendo pio run -e esp32dev -t upload en el terminal. El flag -D LED_PIN=2 del entorno ESP32 define la macro LED_PIN del código; como Uno y Pico no tienen ese flag, el código usa el valor de LED_BUILTIN (13 y 25). Así, un único main.cpp funciona en las tres placas sin cambiar nada. Para ver rápidamente la distribución de pines de las placas puedes usar la herramienta de pinout.

Ajustes de PlatformIO para ESP32

Las placas ESP32 se cargan con esptool en PlatformIO igual que en el IDE de Arduino. upload_speed = 921600 acorta notablemente el tiempo de carga; si tu cable es largo o de mala calidad y te da errores, baja a 460800 o 115200. El filtro esp32_exception_decoder convierte la pila de direcciones incomprensible que aparece en el monitor serie cuando la placa se cuelga en nombres de funciones y números de línea; es muy valioso para encontrar los errores Guru Meditation. Si la carga se queda atascada en la fase "Connecting...", mantén pulsado el botón BOOT de la placa y suéltalo cuando empiece la carga; encontrarás soluciones detalladas en el artículo ESP32 Failed to Connect. Un detalle que debes saber es la versión del núcleo: la plataforma oficial espressif32 de PlatformIO usó durante mucho tiempo la versión 2.x del núcleo Arduino-ESP32; si necesitas APIs propias de la 3.x, puedes pasarte a la plataforma pioarduino, mantenida por la comunidad. Qué núcleo se usa lo ves en la versión de framework-arduinoespressif32 de la línea PACKAGES al inicio de la salida de compilación. Si quieres que tu código compile con ambas versiones, puedes distinguirlas con la macro ESP_ARDUINO_VERSION_MAJOR.

Raspberry Pi Pico y PlatformIO

La plataforma oficial raspberrypi, con el ajuste board = pico, usa el núcleo RP2040 oficial de Arduino basado en Mbed OS. Muchos usuarios prefieren el núcleo arduino-pico de Earle Philhower, que ofrece más funciones y mejor compatibilidad con librerías; en PlatformIO se usa con un paquete de plataforma aparte mantenido por la comunidad y el ajuste board_build.core = earlephilhower. Elijas el núcleo que elijas, en la primera carga puede que tengas que conectar la Pico al USB manteniendo pulsado el botón BOOTSEL; la placa aparece en el ordenador como una unidad llamada RPI-RP2 y, tras cargar el programa, PlatformIO la reinicia sola. En las cargas siguientes, casi siempre no hace falta pulsar el botón. Una nota importante: PlatformIO no admite MicroPython. Si quieres programar la Pico con MicroPython, debes usar un editor como Thonny; para más detalles consulta los artículos Fundamentos de MicroPython y ¿Qué es la Raspberry Pi Pico?.

Añadir librerías: lib_deps

En PlatformIO las librerías no se instalan para todo el ordenador, sino para cada proyecto por separado. El método más limpio es añadir una línea lib_deps a platformio.ini: en la primera compilación, PlatformIO descarga la librería del registro (registry) y la guarda en la carpeta .pio/libdeps/. También puedes buscar el nombre completo de la librería en la pestaña Libraries de PIO Home y añadirla con el botón Add to Project, que escribe la línea lib_deps por ti. Abajo tienes un ejemplo que conecta un sensor DHT11 al pin D2 del Uno; para el cableado del sensor puedes consultar el artículo Sensor de temperatura y humedad DHT11.

C++ (Arduino IDE)
1[env:uno]
2platform = atmelavr
3board = uno
4framework = arduino
5monitor_speed = 115200
6; Kütüphaneler ilk derlemede otomatik iner / Libraries download on first build
7lib_deps =
8    adafruit/DHT sensor library@^1.4.4
9    adafruit/Adafruit Unified Sensor@^1.1.9
C++ (Arduino IDE)
1#include <Arduino.h>
2#include <DHT.h>
3
4#define DHT_PIN 2        // Uno D2 pini / Uno pin D2
5#define DHT_TYPE DHT11
6
7DHT dht(DHT_PIN, DHT_TYPE);
8
9void setup() {
10  Serial.begin(115200);
11  dht.begin();
12}
13
14void loop() {
15  delay(2000);                        // DHT11 en fazla 1 Hz / DHT11 max 1 Hz
16  float h = dht.readHumidity();
17  float t = dht.readTemperature();
18  if (isnan(h) || isnan(t)) {
19    Serial.println("Sensor okunamadi / Read failed");
20    return;
21  }
22  Serial.print("Sicaklik / Temp: ");
23  Serial.print(t, 1);
24  Serial.print(" C  Nem / Hum: ");
25  Serial.print(h, 0);
26  Serial.println(" %");
27}

En la escritura de versiones, ^1.4.4 permite las versiones 1.4.4 y superiores pero menores que 2.0.0; ~1.4.4 acepta solo parches 1.4.x; si escribes solo 1.4.4, la versión queda totalmente fijada. Fijar la versión garantiza que, cuando abras el proyecto dentro de un año, el mismo código compile igual. Si pones una librería que no está en el registro o que has escrito tú en la carpeta lib del proyecto, como una subcarpeta con su propio nombre, PlatformIO la encuentra automáticamente. Si quieres compararlo con la lógica de librerías del IDE de Arduino, puedes leer el artículo Cómo añadir librerías en Arduino.

Migrar un proyecto del IDE de Arduino a PlatformIO

  1. En PIO Home crea un proyecto nuevo y elige la misma placa que usabas en el IDE de Arduino.
  2. Pega el contenido del archivo .ino en src/main.cpp; añade al final de main.cpp las demás pestañas .ino de la misma carpeta y copia los archivos .h y .cpp a la carpeta src.
  3. Añade al principio del archivo la línea #include de Arduino.h.
  4. Para cada función que hayas escrito fuera de setup() y loop(), escribe un prototipo en la parte superior del archivo.
  5. Busca las librerías que uses en PIO Home > Libraries y añádelas a lib_deps; si escribes el número de versión del IDE de Arduino, obtendrás el mismo comportamiento.
  6. Escribe la velocidad de Serial.begin() en la línea monitor_speed y compila el proyecto. Corrige uno por uno los avisos que queden en la lista de errores.

Como alternativa, puedes importar directamente la carpeta existente con el botón Import Arduino Project de PIO Home. PlatformIO convierte por sí mismo a .cpp los archivos .ino de la carpeta src durante la compilación e intenta generar los prototipos. Sin embargo, como esta conversión puede fallar en códigos complejos y IntelliSense no rinde del todo en archivos .ino, a largo plazo es más sano pasarse a main.cpp. Si te cuesta interpretar los mensajes de compilación, las explicaciones del artículo Errores de compilación de Arduino también valen para PlatformIO.

¿IDE de Arduino o PlatformIO?

CaracterísticaIDE de Arduino 2.xPlatformIO (VS Code)
InstalaciónUn solo paquete, unos minutosVS Code y extensión; en la primera instalación se descargan herramientas
AutocompletadoNivel básicoIntelliSense avanzado, ir a la definición, renombrado masivo
Configuración de placaEn el menú Herramientas, no se guarda con el proyectoEn platformio.ini, viaja con el proyecto
LibreríasComunes a todo el ordenadorSeparadas por proyecto, con versión fijable
Varias placasSe cambia desde el menú cada vezVarios entornos en un solo proyecto
Estructura de archivos.ino; el nombre de la carpeta debe coincidir con el del archivosrc, include, lib; .cpp y .h estándar
Prototipos de funcionesSe generan automáticamenteSe escriben a mano (automáticos al importar .ino)
Control de versiones con GitPosible, pero los ajustes de placa quedan fueraFácil; se rastrea todo salvo la carpeta .pio
Depuración y pruebasDepurador en algunas placasDepurador (debug probe) y soporte de pruebas unitarias
Idoneidad para principiantesMuy altaMedia; requiere un breve periodo de adaptación

En resumen: si estás encendiendo tu primer LED o haces un proyecto escolar de pocos archivos, el IDE de Arduino basta y confunde menos. Si hay varias placas, código con muchos archivos, control de versiones con Git o trabajo en equipo, PlatformIO te ahorra mucho tiempo. Las dos herramientas no se excluyen; puedes usar ambas en el mismo ordenador. Si aún no has instalado el IDE de Arduino, puedes empezar con el artículo Instalación del IDE de Arduino.

Errores frecuentes y sus soluciones

SíntomaCausa probableSolución
'xyz' was not declared in this scopeFalta el prototipo de la funciónEscribe el prototipo antes de setup() o mueve la función más arriba
fatal error: DHT.h: No such file or directoryLa librería no está en lib_deps o está en otro entornoAñade la librería a la sección [env] correcta y vuelve a compilar
Caracteres sin sentido en el monitor seriemonitor_speed y la velocidad de Serial.begin() son distintasIguala los dos valores (p. ej. 115200)
La placa no aparece, no hay puertoCable solo de carga o falta el driver CH340/CP2102Usa un cable de datos, instala el driver y comprueba con pio device list
Access is denied / Resource busyEl puerto está abierto en otro programaCierra el monitor serie del IDE de Arduino y otros terminales
Failed to connect, Wrong boot mode en ESP32La placa no entró en modo de descargaInicia la carga manteniendo pulsado el botón BOOT
La carga a la Pico no empiezaLa placa no está en modo BOOTSELConéctala manteniendo pulsado BOOTSEL y comprueba que aparece la unidad RPI-RP2
Permission denied: /dev/ttyUSB0 en LinuxFalta la regla udev o el permiso de usuarioInstala el archivo 99-platformio-udev.rules y añade tu usuario al grupo dialout
En Windows la compilación se detiene con errores de ruta absurdosCaracteres especiales o espacios en el nombre de usuarioMueve la carpeta core a C:\platformio con PLATFORMIO_CORE_DIR
La instalación se queda en Installing PlatformIO CoreProblema de internet, antivirus o PythonReinicia VS Code y revisa el registro de Output > PlatformIO
A veces IntelliSense marca el código con subrayados rojos ondulados, pero la compilación se completa con éxito. Normalmente significa que has abierto una subcarpeta del proyecto en VS Code o que el índice no se ha actualizado. Abre siempre la carpeta donde está platformio.ini y ejecuta desde la paleta de comandos (Ctrl+Shift+P) el comando PlatformIO: Rebuild IntelliSense Index.

Primeros proyectos para probar con PlatformIO

  • Blink multiplaca: sube el proyecto de tres entornos de arriba a Uno, ESP32 y Pico, uno tras otro, para entender la lógica del selector de entorno.
  • Registro de sensor con marca de tiempo: imprime en el monitor serie los datos del DHT11 con hora usando el ajuste monitor_filters = time.
  • Servidor web Wi-Fi: en el proyecto de servidor web con ESP32, divide el código en varios archivos .cpp y .h para lograr una estructura ordenada.
  • Actualización inalámbrica: con ESP32 OTA, sube el código por Wi-Fi usando upload_protocol = espota y escribiendo la IP de la placa en la línea upload_port.
  • Máquina de estados: escribe la lógica de la máquina de estados en Arduino en un archivo de clase aparte y aprovecha la estructura de carpetas de PlatformIO.
  • Temporización sin delay: escribe con millis() un programa que ejecute varias tareas a la vez.

Aunque instalar PlatformIO al principio lleva algo más de tiempo que el IDE de Arduino, como el archivo platformio.ini guarda todos los ajustes del proyecto en un solo lugar, con el tiempo se convierte en la herramienta que más tiempo te ahorra. Cuando termines la instalación, lo primero es compilar y subir un proyecto sencillo de LED y después pasar a proyectos con librerías y varias placas. En la app de BlueGrays encontrarás, paso a paso y con esquemas y códigos, proyectos para encender LEDs, proyectos de inicio con ESP32 y Pico y proyectos de sensores como DHT11 y HC-SR04; puedes llevar esos códigos directamente a tu propio proyecto de PlatformIO para probarlos.

Preguntas frecuentes

¿PlatformIO es gratis?

Sí. PlatformIO Core y la extensión PlatformIO IDE para VS Code son de código abierto y gratuitas. En proyectos de ocio, escolares o comerciales no tienes que pagar ninguna licencia por las definiciones de placas, el gestor de librerías ni las funciones de compilación y carga.

¿El código del IDE de Arduino funciona en PlatformIO?

Sí, porque al elegir framework = arduino se usa el mismo núcleo y las mismas funciones de Arduino. Solo tienes que pasar el código a src/main.cpp, añadir arriba el #include de Arduino.h, escribir los prototipos de las funciones y añadir las librerías que uses a lib_deps.

¿Por qué tarda tanto en instalarse PlatformIO?

En la primera instalación se descargan PlatformIO Core, el entorno de Python y las herramientas básicas; en el primer proyecto se descarga además el compilador y el framework de la placa elegida. Como los paquetes del ESP32 pueden ocupar cientos de megabytes, según la conexión puede tardar de 5 a 15 minutos. Una vez descargados los paquetes, los proyectos siguientes se abren rápido.

¿PlatformIO es compatible con MicroPython?

No, PlatformIO está pensado para frameworks basados en C/C++ como Arduino y ESP-IDF. Si quieres programar la Raspberry Pi Pico o el ESP32 con MicroPython, debes usar un editor como Thonny. Si quieres, también puedes programar la misma placa con PlatformIO usando el framework Arduino.

¿Cómo se añade una librería en PlatformIO?

Lo más fácil es abrir la pestaña Libraries en PIO Home, buscar la librería y elegir tu proyecto con Add to Project. Esto añade la línea lib_deps a platformio.ini y la librería se descarga sola en la primera compilación. Tus propias librerías puedes ponerlas como subcarpetas en la carpeta lib del proyecto.

¿Cómo se elige el puerto COM en PlatformIO?

PlatformIO suele detectar la placa conectada automáticamente. Si hay varios dispositivos serie, puedes fijar el puerto con el selector de puerto de la barra de estado o escribiendo en platformio.ini las líneas upload_port = COM5 y monitor_port = COM5. Con el comando pio device list ves qué puertos están conectados.

Ver todos los proyectos
Parpadeo de LED
AR-1Principiante

Parpadeo de LED

El primer hola de la electrónica: encender y apagar un solo LED. El Arduino enciende y apaga el LED a intervalos cortos, así que la luz parpadea rápido.

4.6(200)
1246
LED Parpadeante con ESP32
ES-1Principiante

LED Parpadeante con ESP32

Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

4.7(37)
108
Parpadeo LED Integrado Raspberry Pi Pico (Pico y Pico W)
PI-1Principiante

Parpadeo LED Integrado Raspberry Pi Pico (Pico y Pico W)

¡El proyecto de apertura de la serie Raspberry Pi Pico! Hacemos parpadear el LED verde integrado de la Pico para comprobar que la placa funciona: el clásico primer experimento tipo "Hello World". No hacen falta componentes externos, solo la Pico y un cable USB. El código está escrito en MicroPython, el lenguaje con soporte oficial de la Raspberry Pi Foundation.

5.0(1)
10
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

HC-SR04 Medición de distancia (pantalla en serie)

El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

4.6(50)
82
Parpadeo del LED interno del ESP32
ES-4Principiante

Parpadeo del LED interno del ESP32

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

4.8(29)
54
Encendido de un LED externo con la Raspberry Pi Pico (placa de pruebas)
PI-2Principiante

Encendido de un LED externo con la Raspberry Pi Pico (placa de pruebas)

El siguiente paso tras el LED integrado de la Pico: conectar un LED externo en la protoboard y controlarlo con el pin GP14. Aprenderás a usar cualquier pin GPIO de la Pico como salida, la polaridad del LED (pata larga = ánodo/+, pata corta = cátodo/–) y por qué es imprescindible una resistencia limitadora de corriente (220Ω). Sin ella, pasa demasiada corriente por el LED y puede quemarse.

4.5(2)
7
Control de LED con pulsador en ESP32 (Push)
ES-2Principiante

Control de LED con pulsador en ESP32 (Push)

El LED se enciende cuando se pulsa el botón y se apaga cuando se suelta. Muestra cómo se utiliza el pin de entrada digital del ESP32 y la resistencia pull-up interna. Gracias al modo INPUT_PULLUP, no se necesita ninguna resistencia externa.

4.6(36)
57