Installare PlatformIO con VS Code: guida per Arduino, ESP32, Pico
Installare PlatformIO in VS Code: estensione, platformio.ini per Uno, ESP32 e Pico, lib_deps, upload, monitor seriale e migrazione dall'IDE Arduino.
Installare PlatformIO significa aggiungere una sola estensione a VS Code per programmare schede come Arduino Uno, ESP32 e Raspberry Pi Pico dallo stesso ambiente professionale. In breve: installa VS Code, cerca PlatformIO IDE nella scheda Estensioni, installalo, aspetta che al primo avvio vengano scaricati gli strumenti necessari, poi crea un nuovo progetto da PIO Home scegliendo la tua scheda. Il resto si gioca in un piccolo file di configurazione chiamato platformio.ini: lì scrivi quale scheda, quale framework, quali librerie e quale velocità della porta seriale usare.
L'IDE Arduino è uno strumento ottimo per imparare, ma man mano che il progetto cresce ne senti i limiti: il completamento del codice è basilare, le librerie sono condivise tra tutti i progetti, l'aggiornamento di una libreria può rompere un vecchio progetto e le impostazioni della scheda non vengono salvate con il progetto. PlatformIO risolve questi problemi. In questa guida faremo l'installazione passo passo, creerai il primo progetto, definirai tre schede diverse in un solo progetto con platformio.ini, aggiungerai una libreria, caricherai il codice, aprirai il monitor seriale e vedrai come migrare i progetti esistenti dell'IDE Arduino. Nell'ultima sezione confronteremo i due strumenti in modo imparziale per aiutarti a decidere quale fa per te.

Cos'è PlatformIO e come funziona?
PlatformIO è un ecosistema di sviluppo open source per sistemi embedded. Al centro c'è PlatformIO Core, uno strumento a riga di comando scritto in Python; l'estensione di VS Code lo rende comodo con pulsanti, menu e la schermata PIO Home. Quando compili un progetto, PlatformIO legge prima il file platformio.ini, poi scarica dal proprio repository il compilatore necessario (avr-gcc per Uno, la toolchain Xtensa per ESP32, arm-none-eabi-gcc per Pico), il framework e le librerie, e compila il codice. Questi pacchetti vengono scaricati una sola volta e salvati nella cartella .platformio dell'utente; i progetti successivi li riutilizzano. Conoscere i concetti qui sotto ti rende molto più facile leggere il file:
| Concetto | Significato | Esempio |
|---|---|---|
| Platform | Pacchetto con compilatore e strumenti di upload di una famiglia di microcontrollori | atmelavr, espressif32, raspberrypi |
| Board (scheda) | Scheda specifica all'interno della piattaforma; mappa dei pin, frequenza di clock e memoria | uno, nanoatmega328, esp32dev, pico |
| Framework | L'infrastruttura software su cui scrivi il codice | arduino, espidf |
| Ambiente (env) | Sezione in cui sono definiti insieme piattaforma, scheda, framework e impostazioni extra | [env:uno] |
| Libreria | Pacchetto di codice pronto aggiunto al progetto con lib_deps | adafruit/DHT sensor library |
| PIO Home | Schermata per aprire progetti e cercare schede e librerie | Icona della casa nella barra di stato |
Installare PlatformIO passo passo
- Scarica e installa Visual Studio Code dal sito ufficiale. Su Windows, spuntare l'opzione Add to PATH durante l'installazione facilita l'uso del terminale.
- Apri VS Code e clicca sulla scheda Estensioni (Extensions) a sinistra, oppure usa la scorciatoia Ctrl+Shift+X (Cmd+Shift+X su macOS).
- Scrivi PlatformIO IDE nella casella di ricerca e installa con il pulsante Install l'estensione pubblicata da PlatformIO. Anche l'estensione C/C++ necessaria viene installata automaticamente.
- In basso a destra compare la notifica "Installing PlatformIO Core". A seconda della velocità di connessione questo passaggio richiede alcuni minuti; non chiudere VS Code nel frattempo.
- Al termine VS Code ti chiede di riavviare. Dopo il riavvio compaiono l'icona di PlatformIO sul bordo sinistro e l'icona della casa nella barra di stato in basso.
- Clicca sull'icona della casa per aprire la schermata PIO Home. Se si apre senza problemi, l'installazione è completata.
Creare il primo progetto e struttura delle cartelle
In PIO Home premi il pulsante New Project. Nella finestra che si apre dai un nome al progetto (per esempio blink-uno), scrivi Arduino Uno nella casella Board e sceglilo dall'elenco, lascia Arduino come framework e scegli la posizione. Quando premi Finish, PlatformIO scarica per la prima volta il pacchetto della piattaforma per la scheda scelta; per questo il primo progetto può richiedere qualche minuto, mentre i successivi si aprono in pochi secondi. Una volta creato, VS Code apre la cartella e vedi questa struttura:
| Cartella / file | A cosa serve |
|---|---|
| platformio.ini | Il cuore del progetto: impostazioni di scheda, framework, librerie e porta |
| src/ | Il tuo codice sorgente; il programma parte da main.cpp |
| include/ | I tuoi file header (.h) |
| lib/ | Librerie locali specifiche del progetto, aggiunte a mano (ognuna in una sottocartella) |
| test/ | Cartella riservata ai test unitari (unit test) |
| .pio/ | Output di compilazione e librerie scaricate; se la elimini viene ricreata |
| .vscode/ | Impostazioni di VS Code e IntelliSense; generata automaticamente |
Cos'è il file platformio.ini?
platformio.ini è un semplice file di testo in formato INI. Ogni sezione [env:nome] tra parentesi quadre definisce un ambiente di compilazione. La scheda e la velocità della porta che nell'IDE Arduino scegli dal menu Strumenti, qui le scrivi come testo; così, quando sposti il progetto su un altro computer o lo dai a un amico, le impostazioni viaggiano insieme al codice. Le righe che iniziano con il punto e virgola sono commenti. Aggiungendo la velocità del monitor seriale al file creato per Uno, il file appare così:
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| Impostazione | Funzione | Valore di esempio |
|---|---|---|
| platform | Pacchetto della piattaforma da usare; si può fissare anche la versione | atmelavr, [email protected] |
| board | ID della scheda | uno, megaatmega2560, esp32dev, pico |
| framework | Framework software | arduino |
| monitor_speed | Velocità del monitor seriale (predefinita 9600) | 115200 |
| upload_port | Porta di caricamento (se vuota viene trovata automaticamente) | COM5, /dev/ttyUSB0 |
| upload_speed | Baud rate di caricamento (soprattutto sulle schede ESP) | 921600 |
| lib_deps | Librerie da scaricare automaticamente | adafruit/DHT sensor library@^1.4.4 |
| build_flags | Flag e macro aggiuntivi per il compilatore | -D LED_PIN=2 |
| monitor_filters | Filtri applicati all'output del monitor seriale | time, esp32_exception_decoder |
Primo codice: main.cpp e la differenza con Arduino.h
Il file main.cpp nella cartella src corrisponde al file .ino dell'IDE Arduino, ma ci sono due differenze importanti. La prima: all'inizio del file deve esserci la riga #include che aggiunge l'header Arduino.h; l'IDE Arduino la aggiunge da solo in background, PlatformIO no. La seconda: un file .cpp segue le regole del vero C++, quindi prima di chiamare una funzione il compilatore deve conoscerla. L'IDE Arduino genera i prototipi delle funzioni al posto tuo; in PlatformIO o definisci la funzione prima di usarla, oppure scrivi in cima al file un prototipo di una riga. L'esempio seguente è un programma blink che funziona su Uno, ESP32 e 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}Compilare, caricare e usare il monitor seriale
| Operazione | Barra di stato / menu | Comando da terminale |
|---|---|---|
| Compila (Build) | Segno di spunta | pio run |
| Carica (Upload) | Freccia a destra | pio run -t upload |
| Carica e apri il monitor | Menu PlatformIO > Upload and Monitor | pio run -t upload -t monitor |
| Monitor seriale | Icona della spina | pio device monitor |
| Pulisci | Cestino | pio run -t clean |
| Elenca le porte | PIO Home > Devices | pio device list |
| Compila un ambiente specifico | Selettore ambiente (env:...) | pio run -e esp32dev |
| Installa una libreria | PIO Home > Libraries | pio pkg install -l "adafruit/DHT sensor library" |
Perché il monitor seriale funzioni correttamente, il valore monitor_speed in platformio.ini deve essere uguale alla velocità di Serial.begin() nel codice; altrimenti vedi caratteri senza senso sullo schermo. PlatformIO di solito trova da solo la scheda collegata, ma se sul computer ci sono più dispositivi seriali può provare a caricare sulla porta sbagliata. In quel caso elenca le porte con il comando pio device list e scrivi quella giusta nelle righe upload_port e monitor_port. Se il monitor seriale dell'IDE Arduino o un altro programma terminale tiene la porta aperta, il caricamento si ferma con l'errore "Access is denied" o "Resource busy"; basta chiudere quel programma. Per conoscere meglio il monitor seriale puoi leggere anche l'articolo Arduino Serial Monitor. Il comando pio funziona sempre nel terminale PlatformIO Core CLI che si apre dal menu PlatformIO.
Definire Uno, ESP32 e Pico in un solo progetto
Uno dei punti di forza di PlatformIO è poter compilare lo stesso codice per più schede. Scrivi una sezione [env:...] separata per ogni scheda; se metti le impostazioni comuni nella sezione senza nome [env], tutti gli ambienti le ereditano. La tabella seguente riassume i valori fondamentali delle tre schede più diffuse:
| Valore | Arduino Uno | ESP32 DevKit | Raspberry Pi Pico |
|---|---|---|---|
| platform | atmelavr | espressif32 | raspberrypi |
| board | uno | esp32dev | pico |
| framework | arduino | arduino | arduino (core Arduino Mbed) |
| LED integrato | D13 | GPIO 2 (sulla maggior parte delle DevKit) | GP25 |
| Metodo di upload | USB-seriale e bootloader | USB-seriale ed esptool | USB e modalità BOOTSEL |
| monitor_speed tipica | 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 riga default_envs stabilisce quale ambiente usano i pulsanti di compilazione e upload nella barra di stato; se non la scrivi, PlatformIO compila in sequenza tutti gli ambienti del file. Puoi passare al volo a un'altra scheda dal selettore di ambiente nella barra di stato, oppure caricare direttamente sull'ESP32 scrivendo nel terminale pio run -e esp32dev -t upload. Il flag -D LED_PIN=2 nell'ambiente ESP32 definisce la macro LED_PIN nel codice; su Uno e Pico questo flag non c'è, quindi il codice ripiega sul valore di LED_BUILTIN (13 e 25). Così un solo main.cpp funziona su tutte e tre le schede senza modifiche. Per vedere rapidamente la disposizione dei pin delle schede puoi usare lo strumento pinout.
Impostazioni PlatformIO per ESP32
Le schede ESP32 vengono caricate con esptool, come nell'IDE Arduino. upload_speed = 921600 accorcia sensibilmente il tempo di caricamento; se il cavo è lungo o di scarsa qualità e ricevi errori, scendi a 460800 o 115200. Il filtro esp32_exception_decoder traduce in nomi di funzioni e numeri di riga la pila di indirizzi incomprensibili che compare nel monitor seriale quando la scheda va in crash; è prezioso per trovare gli errori Guru Meditation. Se il caricamento si blocca sulla fase "Connecting...", tieni premuto il tasto BOOT sulla scheda e rilascialo quando il caricamento parte; le soluzioni dettagliate sono nell'articolo ESP32 Failed to Connect. Un altro dettaglio da conoscere è la versione del core: la piattaforma ufficiale espressif32 di PlatformIO ha usato a lungo la versione 2.x del core Arduino-ESP32; se ti servono API specifiche della 3.x, puoi passare alla piattaforma pioarduino, mantenuta dalla community. Puoi vedere quale core viene usato dalla versione di framework-arduinoespressif32 nella riga PACKAGES all'inizio dell'output di compilazione. Se vuoi che il codice compili con entrambe le versioni, puoi distinguerle con la macro ESP_ARDUINO_VERSION_MAJOR.
Raspberry Pi Pico e PlatformIO
Con l'impostazione board = pico, la piattaforma ufficiale raspberrypi usa il core RP2040 ufficiale di Arduino basato su Mbed OS. Molti utenti preferiscono invece il core arduino-pico di Earle Philhower, che offre più funzioni e una migliore compatibilità con le librerie; in PlatformIO si usa con un pacchetto di piattaforma separato mantenuto dalla community e con l'impostazione board_build.core = earlephilhower. Qualunque core scelga, al primo caricamento potresti dover collegare la Pico all'USB tenendo premuto il pulsante BOOTSEL; la scheda compare sul computer come un'unità chiamata RPI-RP2 e, dopo il caricamento, PlatformIO la riavvia da solo. Nei caricamenti successivi spesso il pulsante non serve. Nota importante: PlatformIO non supporta MicroPython. Se vuoi programmare la Pico in MicroPython devi usare un editor come Thonny; per i dettagli dai un'occhiata agli articoli Basi di MicroPython e Cos'è Raspberry Pi Pico?.
Aggiungere librerie: lib_deps
In PlatformIO le librerie non si installano per tutto il computer ma per ogni progetto. Il metodo più pulito è aggiungere una riga lib_deps a platformio.ini: alla prima compilazione PlatformIO scarica la libreria dal registro e la mette nella cartella .pio/libdeps/. Puoi anche cercare il nome completo della libreria nella scheda Libraries di PIO Home e aggiungerla con il pulsante Add to Project, che scrive la riga lib_deps al posto tuo. Qui sotto c'è un esempio che collega un sensore DHT11 al pin D2 dell'Uno; per il cablaggio del sensore consulta l'articolo Sensore di temperatura e umidità 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}Nella scrittura delle versioni, ^1.4.4 consente la 1.4.4 e le successive ma inferiori alla 2.0.0; ~1.4.4 accetta solo le patch 1.4.x; se scrivi solo 1.4.4 la versione è completamente bloccata. Bloccare la versione garantisce che, riaprendo il progetto fra un anno, lo stesso codice compili allo stesso modo. Se metti una libreria che non è nel registro o scritta da te nella cartella lib del progetto, come sottocartella con il suo nome, PlatformIO la trova automaticamente. Se vuoi confrontarlo con la logica delle librerie dell'IDE Arduino, puoi leggere l'articolo Aggiungere librerie in Arduino.
Migrare un progetto dall'IDE Arduino a PlatformIO
- In PIO Home crea un nuovo progetto e scegli la stessa scheda che usavi nell'IDE Arduino.
- Incolla il contenuto del file .ino in src/main.cpp; aggiungi le altre schede .ino della stessa cartella in fondo a main.cpp e copia i file .h e .cpp nella cartella src.
- Aggiungi in cima al file la riga #include per Arduino.h.
- Per ogni funzione che hai scritto fuori da setup() e loop(), scrivi un prototipo nella parte alta del file.
- Trova le librerie che usi in PIO Home > Libraries e aggiungile a lib_deps; se indichi lo stesso numero di versione dell'IDE Arduino otterrai lo stesso comportamento.
- Scrivi la velocità di Serial.begin() nella riga monitor_speed e compila il progetto. Correggi uno per uno gli avvisi rimasti nell'elenco degli errori.
In alternativa puoi importare direttamente la cartella esistente con il pulsante Import Arduino Project in PIO Home. PlatformIO converte da solo in .cpp i file .ino della cartella src durante la compilazione e cerca di generare i prototipi. Tuttavia, poiché questa conversione può sbagliare con codice complesso e IntelliSense non funziona al meglio sui file .ino, a lungo termine è più sano passare a main.cpp. Se fai fatica a interpretare i messaggi di compilazione, le spiegazioni dell'articolo Errori di compilazione Arduino valgono anche per PlatformIO.
IDE Arduino o PlatformIO?
| Caratteristica | Arduino IDE 2.x | PlatformIO (VS Code) |
|---|---|---|
| Installazione | Pacchetto unico, pochi minuti | VS Code ed estensione; al primo avvio vengono scaricati gli strumenti |
| Completamento del codice | Livello base | IntelliSense avanzato, vai alla definizione, rinomina globale |
| Impostazioni della scheda | Nel menu Strumenti, non salvate con il progetto | In platformio.ini, si spostano con il progetto |
| Librerie | Condivise su tutto il computer | Separate per progetto, versione bloccabile |
| Più schede | Si cambia ogni volta dal menu | Più ambienti in un solo progetto |
| Struttura dei file | .ino; il nome della cartella deve coincidere con quello del file | src, include, lib; .cpp e .h standard |
| Prototipi delle funzioni | Generati automaticamente | Scritti a mano (automatici nell'importazione di .ino) |
| Versionamento con Git | Possibile, ma le impostazioni della scheda restano fuori | Semplice; si tiene traccia di tutto tranne la cartella .pio |
| Debug e test | Debugger su alcune schede | Debugger (debug probe) e supporto ai test unitari |
| Adatto ai principianti | Molto alto | Medio; richiede un breve periodo di adattamento |
In breve: se stai accendendo il tuo primo LED o fai un progetto scolastico di pochi file, l'IDE Arduino basta ed è meno confusionario. Se si tratta di più schede, codice su più file, versionamento con Git o lavoro di squadra, PlatformIO ti fa risparmiare molto tempo. I due strumenti non si escludono: puoi usarli entrambi sullo stesso computer. Se non hai ancora installato l'IDE Arduino, puoi cominciare dall'articolo Installazione dell'IDE Arduino.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| 'xyz' was not declared in this scope | Manca il prototipo della funzione | Scrivi il prototipo prima di setup() o sposta la funzione più in alto |
| fatal error: DHT.h: No such file or directory | La libreria non è in lib_deps o è stata aggiunta a un altro ambiente | Aggiungi la libreria alla sezione [env] giusta e ricompila |
| Caratteri senza senso nel monitor seriale | monitor_speed diverso dalla velocità di Serial.begin() | Rendi uguali i due valori (es. 115200) |
| La scheda non compare, nessuna porta | Cavo solo di ricarica o driver CH340/CP2102 mancante | Usa un cavo dati, installa il driver, controlla con pio device list |
| Access is denied / Resource busy | La porta è aperta in un altro programma | Chiudi il monitor seriale dell'IDE Arduino e gli altri terminali |
| ESP32: Failed to connect, Wrong boot mode | La scheda non è entrata in modalità download | Avvia il caricamento tenendo premuto il tasto BOOT |
| Il caricamento sulla Pico non parte | La scheda non è in modalità BOOTSEL | Collegala tenendo premuto BOOTSEL e verifica che compaia l'unità RPI-RP2 |
| Linux: Permission denied: /dev/ttyUSB0 | Mancano la regola udev o i permessi dell'utente | Installa il file 99-platformio-udev.rules e aggiungi il tuo utente al gruppo dialout |
| Su Windows la compilazione si ferma con strani errori sui percorsi | Caratteri speciali o spazi nel nome utente | Sposta la cartella core in C:\platformio con PLATFORMIO_CORE_DIR |
| L'installazione resta bloccata su Installing PlatformIO Core | Problema di internet, antivirus o Python | Riavvia VS Code e controlla il log in Output > PlatformIO |
I primi progetti da provare con PlatformIO
- Blink multi-scheda: carica il progetto a tre ambienti visto sopra su Uno, ESP32 e Pico, uno dopo l'altro, per capire la logica del selettore di ambiente.
- Log del sensore con data e ora: scrivi nel monitor seriale i dati del DHT11 con l'orario, usando l'impostazione monitor_filters = time.
- Web server Wi-Fi: nel progetto web server ESP32 dividi il codice in più file .cpp e .h per ottenere una struttura ordinata.
- Aggiornamento wireless: con l'OTA su ESP32 carica il codice via Wi-Fi usando upload_protocol = espota e scrivendo l'indirizzo IP della scheda in upload_port.
- Macchina a stati: scrivi la logica di una macchina a stati Arduino in un file di classe separato sfruttando la struttura delle cartelle di PlatformIO.
- Temporizzazione senza delay: scrivi con millis() un programma che esegue più attività contemporaneamente.
Anche se all'inizio installare PlatformIO richiede un po' più tempo dell'IDE Arduino, con il passare del tempo diventa lo strumento che fa risparmiare più tempo, perché platformio.ini tiene tutte le impostazioni del progetto in un unico posto. Finita l'installazione, compila e carica subito un semplice progetto con un LED, poi passa ai progetti con librerie e a quelli multi-scheda. Nell'app BlueGrays trovi passo passo, con schemi del circuito e codice, progetti per accendere un LED, progetti iniziali per ESP32 e Pico e progetti con sensori come DHT11 e HC-SR04; puoi portare quel codice direttamente nel tuo progetto PlatformIO per provarlo.
Domande frequenti
PlatformIO è gratuito?
Sì. PlatformIO Core e l'estensione PlatformIO IDE per VS Code sono open source e gratuiti. Per hobby, scuola o progetti commerciali non devi pagare alcuna licenza per definizioni delle schede, gestore delle librerie, compilazione e caricamento.
Il codice dell'IDE Arduino funziona in PlatformIO?
Sì, perché con framework = arduino vengono usati lo stesso core Arduino e le stesse funzioni. Devi solo spostare il codice in src/main.cpp, aggiungere in cima la riga include di Arduino.h, scrivere i prototipi delle funzioni e aggiungere a lib_deps le librerie che usi.
Perché l'installazione di PlatformIO ci mette così tanto?
Alla prima installazione vengono scaricati PlatformIO Core, l'ambiente Python e gli strumenti di base; nel primo progetto si scaricano anche il compilatore e il framework della scheda scelta. I pacchetti ESP32 possono pesare centinaia di megabyte, quindi servono 5–15 minuti a seconda della connessione. Una volta scaricati, i progetti successivi si aprono rapidamente.
PlatformIO supporta MicroPython?
No, PlatformIO è pensato per framework basati su C/C++ come Arduino ed ESP-IDF. Se vuoi programmare Raspberry Pi Pico o ESP32 in MicroPython, devi usare un editor come Thonny. La stessa scheda, se vuoi, puoi programmarla anche con PlatformIO nel framework Arduino.
Come si aggiunge una libreria in PlatformIO?
Il modo più semplice è aprire la scheda Libraries in PIO Home, cercare la libreria e scegliere il progetto con Add to Project. Questa operazione aggiunge la riga lib_deps a platformio.ini e la libreria viene scaricata automaticamente alla prima compilazione. Le tue librerie puoi metterle come sottocartelle nella cartella lib del progetto.
Come si sceglie la porta COM in PlatformIO?
Di solito PlatformIO trova da solo la scheda collegata. Se ci sono più dispositivi seriali, puoi fissare la porta dal selettore nella barra di stato oppure scrivendo in platformio.ini le righe upload_port = COM5 e monitor_port = COM5. Vedi quali porte sono collegate con il comando pio device list.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED lampeggiante
Il primissimo ciao dell'elettronica: accendere e spegnere un solo LED. L'Arduino accende e spegne il LED a intervalli brevissimi, così la luce lampeggia veloce.

LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
Il progetto d'apertura della serie Raspberry Pi Pico! Facciamo lampeggiare il LED verde integrato del Pico per verificare che la scheda funzioni: il classico primo esperimento in stile "Hello World". Niente componenti esterni, bastano il Pico e un cavo USB. Il codice è scritto in MicroPython, il linguaggio supportato ufficialmente dalla Raspberry Pi Foundation.

Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

HC-SR04 Misura della distanza (display seriale)
Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

Lampeggio del LED interno dell'ESP32
Far lampeggiare il LED blu integrato nell'ESP32 DevKit V1. Non sono necessari componenti esterni! Il primo progetto da provare quando si acquista un ESP32. Il GPIO 2 è collegato al LED interno.

Accensione di un LED esterno con Raspberry Pi Pico (breadboard)
Il passo successivo al LED integrato del Pico: collegare un LED esterno sulla breadboard e controllarlo dal pin GP14. Impari a usare qualsiasi pin GPIO del Pico come uscita, la polarità del LED (gamba lunga = anodo/+, gamba corta = catodo/–) e perché una resistenza di limitazione della corrente (220Ω) è indispensabile. Senza di essa nel LED passa troppa corrente e può bruciarsi.

Controllo LED ESP32 con pulsante (Push)
Il LED si accende quando il pulsante viene premuto e si spegne quando viene rilasciato. Mostra come vengono utilizzati il pin di ingresso digitale dell'ESP32 e la resistenza di pull-up interna. Grazie alla modalità INPUT_PULLUP, non è necessaria alcuna resistenza esterna.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

