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.

¿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:
| Concepto | Significado | Ejemplo |
|---|---|---|
| Platform (plataforma) | Paquete de compilador y herramientas de carga de una familia de microcontroladores | atmelavr, espressif32, raspberrypi |
| Board (placa) | Placa concreta dentro de la plataforma; mapa de pines, velocidad de reloj y memoria | uno, nanoatmega328, esp32dev, pico |
| Framework | Infraestructura de software sobre la que escribes el código | arduino, espidf |
| Entorno (env) | Sección donde se definen juntos plataforma, placa, framework y ajustes extra | [env:uno] |
| Librería | Paquete de código ya hecho que se añade al proyecto con lib_deps | adafruit/DHT sensor library |
| PIO Home | Pantalla para abrir proyectos y buscar placas y librerías | Icono de la casa en la barra de estado |
Instalar PlatformIO paso a paso
- 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.
- 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).
- 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.
- 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.
- 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.
- Haz clic en el icono de la casa para abrir la pantalla PIO Home. Si se ve sin problemas, la instalación ha terminado.
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 / archivo | Para qué sirve |
|---|---|
| platformio.ini | El 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í:
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| Ajuste | Función | Valor de ejemplo |
|---|---|---|
| platform | Paquete de plataforma que se usará; también se puede fijar la versión | atmelavr, [email protected] |
| board | Identificador de la placa | uno, megaatmega2560, esp32dev, pico |
| framework | Framework de software | arduino |
| monitor_speed | Velocidad del monitor serie (por defecto 9600) | 115200 |
| upload_port | Puerto de carga (si lo dejas vacío, se detecta solo) | COM5, /dev/ttyUSB0 |
| upload_speed | Velocidad en baudios de carga (sobre todo en placas ESP) | 921600 |
| lib_deps | Librerías que se descargarán automáticamente | adafruit/DHT sensor library@^1.4.4 |
| build_flags | Flags y macros adicionales para el compilador | -D LED_PIN=2 |
| monitor_filters | Filtros aplicados a la salida del monitor serie | time, 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:
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}Compilar, subir y monitor serie
| Acción | Barra de estado / menú | Comando de terminal |
|---|---|---|
| Compilar (Build) | Marca de verificación | pio run |
| Subir (Upload) | Flecha a la derecha | pio run -t upload |
| Subir y abrir el monitor | Menú PlatformIO > Upload and Monitor | pio run -t upload -t monitor |
| Monitor serie | Icono de enchufe | pio device monitor |
| Limpiar | Papelera | pio run -t clean |
| Listar puertos | PIO Home > Devices | pio device list |
| Compilar un entorno concreto | Selector de entorno (env:...) | pio run -e esp32dev |
| Instalar una librería | PIO Home > Libraries | pio 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:
| Valor | Arduino Uno | ESP32 DevKit | Raspberry Pi Pico |
|---|---|---|---|
| platform | atmelavr | espressif32 | raspberrypi |
| board | uno | esp32dev | pico |
| framework | arduino | arduino | arduino (núcleo Arduino Mbed) |
| LED integrado | D13 | GPIO 2 (en la mayoría de placas DevKit) | GP25 |
| Método de carga | USB-serie y bootloader | USB-serie y esptool | USB y modo BOOTSEL |
| monitor_speed típico | 9600 o 115200 | 115200 | 115200 |
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 = picoLa 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.
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.91#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
- En PIO Home crea un proyecto nuevo y elige la misma placa que usabas en el IDE de Arduino.
- 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.
- Añade al principio del archivo la línea #include de Arduino.h.
- Para cada función que hayas escrito fuera de setup() y loop(), escribe un prototipo en la parte superior del archivo.
- 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.
- 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ística | IDE de Arduino 2.x | PlatformIO (VS Code) |
|---|---|---|
| Instalación | Un solo paquete, unos minutos | VS Code y extensión; en la primera instalación se descargan herramientas |
| Autocompletado | Nivel básico | IntelliSense avanzado, ir a la definición, renombrado masivo |
| Configuración de placa | En el menú Herramientas, no se guarda con el proyecto | En platformio.ini, viaja con el proyecto |
| Librerías | Comunes a todo el ordenador | Separadas por proyecto, con versión fijable |
| Varias placas | Se cambia desde el menú cada vez | Varios entornos en un solo proyecto |
| Estructura de archivos | .ino; el nombre de la carpeta debe coincidir con el del archivo | src, include, lib; .cpp y .h estándar |
| Prototipos de funciones | Se generan automáticamente | Se escriben a mano (automáticos al importar .ino) |
| Control de versiones con Git | Posible, pero los ajustes de placa quedan fuera | Fácil; se rastrea todo salvo la carpeta .pio |
| Depuración y pruebas | Depurador en algunas placas | Depurador (debug probe) y soporte de pruebas unitarias |
| Idoneidad para principiantes | Muy alta | Media; 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íntoma | Causa probable | Solución |
|---|---|---|
| 'xyz' was not declared in this scope | Falta el prototipo de la función | Escribe el prototipo antes de setup() o mueve la función más arriba |
| fatal error: DHT.h: No such file or directory | La librería no está en lib_deps o está en otro entorno | Añade la librería a la sección [env] correcta y vuelve a compilar |
| Caracteres sin sentido en el monitor serie | monitor_speed y la velocidad de Serial.begin() son distintas | Iguala los dos valores (p. ej. 115200) |
| La placa no aparece, no hay puerto | Cable solo de carga o falta el driver CH340/CP2102 | Usa un cable de datos, instala el driver y comprueba con pio device list |
| Access is denied / Resource busy | El puerto está abierto en otro programa | Cierra el monitor serie del IDE de Arduino y otros terminales |
| Failed to connect, Wrong boot mode en ESP32 | La placa no entró en modo de descarga | Inicia la carga manteniendo pulsado el botón BOOT |
| La carga a la Pico no empieza | La placa no está en modo BOOTSEL | Conéctala manteniendo pulsado BOOTSEL y comprueba que aparece la unidad RPI-RP2 |
| Permission denied: /dev/ttyUSB0 en Linux | Falta la regla udev o el permiso de usuario | Instala 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 absurdos | Caracteres especiales o espacios en el nombre de usuario | Mueve la carpeta core a C:\platformio con PLATFORMIO_CORE_DIR |
| La instalación se queda en Installing PlatformIO Core | Problema de internet, antivirus o Python | Reinicia VS Code y revisa el registro de Output > PlatformIO |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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.

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.

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…

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.

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.

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

