Guide · 12 min di lettura

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.

Scheda Arduino Uno programmata con PlatformIO
Con PlatformIO puoi programmare schede come Arduino Uno, ESP32 e Raspberry Pi Pico dallo stesso editor, con un unico file di configurazione.

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:

ConcettoSignificatoEsempio
PlatformPacchetto con compilatore e strumenti di upload di una famiglia di microcontrolloriatmelavr, espressif32, raspberrypi
Board (scheda)Scheda specifica all'interno della piattaforma; mappa dei pin, frequenza di clock e memoriauno, nanoatmega328, esp32dev, pico
FrameworkL'infrastruttura software su cui scrivi il codicearduino, espidf
Ambiente (env)Sezione in cui sono definiti insieme piattaforma, scheda, framework e impostazioni extra[env:uno]
LibreriaPacchetto di codice pronto aggiunto al progetto con lib_depsadafruit/DHT sensor library
PIO HomeSchermata per aprire progetti e cercare schede e librerieIcona della casa nella barra di stato

Installare PlatformIO passo passo

  1. 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.
  2. Apri VS Code e clicca sulla scheda Estensioni (Extensions) a sinistra, oppure usa la scorciatoia Ctrl+Shift+X (Cmd+Shift+X su macOS).
  3. 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.
  4. 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.
  5. 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.
  6. Clicca sull'icona della casa per aprire la schermata PIO Home. Se si apre senza problemi, l'installazione è completata.
Se il tuo nome utente di Windows contiene caratteri speciali (come ş, ğ, ı, ü, à, è) o spazi, la toolchain di PlatformIO può avere problemi nel percorso C:\Users\<nome>\.platformio e la compilazione può fermarsi con strani errori sui percorsi. La soluzione è aggiungere alle variabili d'ambiente di sistema PLATFORMIO_CORE_DIR con una cartella composta solo da caratteri semplici, come C:\platformio. Su Linux, se l'installazione dà errore, assicurati prima che il pacchetto python3-venv sia installato.

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 / fileA cosa serve
platformio.iniIl 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ì:

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
ImpostazioneFunzioneValore di esempio
platformPacchetto della piattaforma da usare; si può fissare anche la versioneatmelavr, [email protected]
boardID della schedauno, megaatmega2560, esp32dev, pico
frameworkFramework softwarearduino
monitor_speedVelocità del monitor seriale (predefinita 9600)115200
upload_portPorta di caricamento (se vuota viene trovata automaticamente)COM5, /dev/ttyUSB0
upload_speedBaud rate di caricamento (soprattutto sulle schede ESP)921600
lib_depsLibrerie da scaricare automaticamenteadafruit/DHT sensor library@^1.4.4
build_flagsFlag e macro aggiuntivi per il compilatore-D LED_PIN=2
monitor_filtersFiltri applicati all'output del monitor serialetime, 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:

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}
Se in compilazione vedi l'errore 'blinkLed' was not declared in this scope, quasi sempre manca il prototipo. Basta copiare sopra setup() la prima riga della funzione, senza il corpo e con il punto e virgola alla fine. Se hai molte funzioni, è più ordinato raccoglierle in un file .h nella cartella include.

Compilare, caricare e usare il monitor seriale

OperazioneBarra di stato / menuComando da terminale
Compila (Build)Segno di spuntapio run
Carica (Upload)Freccia a destrapio run -t upload
Carica e apri il monitorMenu PlatformIO > Upload and Monitorpio run -t upload -t monitor
Monitor serialeIcona della spinapio device monitor
PulisciCestinopio run -t clean
Elenca le portePIO Home > Devicespio device list
Compila un ambiente specificoSelettore ambiente (env:...)pio run -e esp32dev
Installa una libreriaPIO Home > Librariespio 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:

ValoreArduino UnoESP32 DevKitRaspberry Pi Pico
platformatmelavrespressif32raspberrypi
boardunoesp32devpico
frameworkarduinoarduinoarduino (core Arduino Mbed)
LED integratoD13GPIO 2 (sulla maggior parte delle DevKit)GP25
Metodo di uploadUSB-seriale e bootloaderUSB-seriale ed esptoolUSB e modalità BOOTSEL
monitor_speed tipica9600 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 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.

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}

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

  1. In PIO Home crea un nuovo progetto e scegli la stessa scheda che usavi nell'IDE Arduino.
  2. 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.
  3. Aggiungi in cima al file la riga #include per Arduino.h.
  4. Per ogni funzione che hai scritto fuori da setup() e loop(), scrivi un prototipo nella parte alta del file.
  5. 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.
  6. 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?

CaratteristicaArduino IDE 2.xPlatformIO (VS Code)
InstallazionePacchetto unico, pochi minutiVS Code ed estensione; al primo avvio vengono scaricati gli strumenti
Completamento del codiceLivello baseIntelliSense avanzato, vai alla definizione, rinomina globale
Impostazioni della schedaNel menu Strumenti, non salvate con il progettoIn platformio.ini, si spostano con il progetto
LibrerieCondivise su tutto il computerSeparate per progetto, versione bloccabile
Più schedeSi cambia ogni volta dal menuPiù ambienti in un solo progetto
Struttura dei file.ino; il nome della cartella deve coincidere con quello del filesrc, include, lib; .cpp e .h standard
Prototipi delle funzioniGenerati automaticamenteScritti a mano (automatici nell'importazione di .ino)
Versionamento con GitPossibile, ma le impostazioni della scheda restano fuoriSemplice; si tiene traccia di tutto tranne la cartella .pio
Debug e testDebugger su alcune schedeDebugger (debug probe) e supporto ai test unitari
Adatto ai principiantiMolto altoMedio; 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

SintomoCausa probabileSoluzione
'xyz' was not declared in this scopeManca il prototipo della funzioneScrivi il prototipo prima di setup() o sposta la funzione più in alto
fatal error: DHT.h: No such file or directoryLa libreria non è in lib_deps o è stata aggiunta a un altro ambienteAggiungi la libreria alla sezione [env] giusta e ricompila
Caratteri senza senso nel monitor serialemonitor_speed diverso dalla velocità di Serial.begin()Rendi uguali i due valori (es. 115200)
La scheda non compare, nessuna portaCavo solo di ricarica o driver CH340/CP2102 mancanteUsa un cavo dati, installa il driver, controlla con pio device list
Access is denied / Resource busyLa porta è aperta in un altro programmaChiudi il monitor seriale dell'IDE Arduino e gli altri terminali
ESP32: Failed to connect, Wrong boot modeLa scheda non è entrata in modalità downloadAvvia il caricamento tenendo premuto il tasto BOOT
Il caricamento sulla Pico non parteLa scheda non è in modalità BOOTSELCollegala tenendo premuto BOOTSEL e verifica che compaia l'unità RPI-RP2
Linux: Permission denied: /dev/ttyUSB0Mancano la regola udev o i permessi dell'utenteInstalla il file 99-platformio-udev.rules e aggiungi il tuo utente al gruppo dialout
Su Windows la compilazione si ferma con strani errori sui percorsiCaratteri speciali o spazi nel nome utenteSposta la cartella core in C:\platformio con PLATFORMIO_CORE_DIR
L'installazione resta bloccata su Installing PlatformIO CoreProblema di internet, antivirus o PythonRiavvia VS Code e controlla il log in Output > PlatformIO
A volte IntelliSense sottolinea il codice in rosso ma la compilazione riesce. Di solito significa che in VS Code hai aperto una sottocartella del progetto oppure che l'indice non è aggiornato. Apri sempre la cartella che contiene platformio.ini ed esegui dalla palette dei comandi (Ctrl+Shift+P) il comando PlatformIO: Rebuild IntelliSense Index.

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.

Vedi tutti i progetti
LED lampeggiante
AR-1Principiante

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.

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

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.

4.7(37)
108
Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
PI-1Principiante

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.

5.0(1)
10
Temperatura e umidità con DHT11
AR-55Intermedio

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…

4.7(47)
83
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

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

4.6(50)
82
Lampeggio del LED interno dell'ESP32
ES-4Principiante

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.

4.8(29)
54
Accensione di un LED esterno con Raspberry Pi Pico (breadboard)
PI-2Principiante

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.

4.5(2)
7
Controllo LED ESP32 con pulsante (Push)
ES-2Principiante

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.

4.6(36)
57