Come installare Arduino IDE 2 su Windows, Mac e Linux: guida

Installare Arduino IDE è il primo passo di qualsiasi progetto Arduino e, seguendo l'ordine giusto, richiede 10–15 minuti: scarichi il programma dal sito ufficiale di Arduino (arduino.cc/en/software), lo installi sul tuo sistema operativo, colleghi la scheda con un cavo USB, scegli scheda e porta e carichi il tuo primo sketch di prova, Blink. Quando il piccolo LED sulla scheda inizia a lampeggiare una volta al secondo, l'installazione è completa. Questa guida si basa sull'attuale Arduino IDE 2 (versione 2.3.10 a ottobre 2026); troverai anche una tabella con le differenze rispetto alla vecchia 1.8.19.

Qui trovi istruzioni passo passo, separate per Windows, macOS e Linux. Poi ti presentiamo uno per uno i driver e la porta COM, il selettore della scheda, i pulsanti Verifica e Carica, il Monitor seriale, il Gestore librerie e il Gestore schede. Vedrai anche come aggiungere i pacchetti delle schede ESP32 e Raspberry Pi Pico, come impostare lingua e dimensione del carattere, quando conviene l'Arduino Cloud Editor che non richiede installazione e come risolvere gli errori di installazione più comuni.

Che cos'è Arduino IDE e quale versione scaricare?

Arduino IDE (Integrated Development Environment, ambiente di sviluppo integrato) è il programma gratuito e open source in cui scrivi il codice, lo compili, ne vedi gli errori e lo carichi sulla scheda via USB. Dietro le quinte avvia per te il compilatore C++, i pacchetti delle schede e gli strumenti di caricamento come avrdude o esptool; a te basta premere due pulsanti. La versione sviluppata attivamente oggi è Arduino IDE 2: offre completamento automatico, tema scuro, debugger integrato e un Plotter seriale rinnovato. La vecchia 1.8.19 si può ancora scaricare, ma riceve solo correzioni di sicurezza critiche: se stai iniziando, installa direttamente l'IDE 2.

Requisiti di sistema e scelta del file giusto

Nella pagina di download trovi diversi file a seconda del sistema operativo. Arduino IDE 2 funziona solo su sistemi a 64 bit; se usi Windows a 32 bit o un macOS molto vecchio, l'unica scelta è la 1.8.19. Per sapere che processore ha il tuo Mac, apri menu Apple > Informazioni su questo Mac: se c'è scritto Chip: Apple M…, scegli Apple Silicon; se c'è scritto Processore: Intel, scegli la versione Intel.

Installare Arduino IDE su Windows

1. Scarica dalla pagina di download il programma di installazione per Windows (.exe) e fai doppio clic. Se compare una pagina che chiede una donazione, puoi proseguire con il download anche senza donare.
2. Accetta la licenza con I Agree. Poi scegli se installare per tutti gli utenti del computer (Anyone who uses this computer) o solo per te (Only for me); su un computer della scuola o condiviso, la prima opzione richiede i permessi di amministratore.
3. Lascia la cartella di installazione predefinita e fai clic su Install. Alla fine lascia spuntata la casella Run Arduino IDE e fai clic su Finish.
4. Se Windows chiede "Installare il software di questo dispositivo?" per i driver USB di Arduino e delle schede compatibili, fai clic su Installa; questi driver permettono di riconoscere schede come la Uno originale, la Mega e la Leonardo. Se il firewall chiede l'accesso alla rete, consenti anche quello.
5. Quando l'IDE si apre, in basso a destra compaiono le notifiche dell'installazione del pacchetto Arduino AVR Boards e delle librerie integrate. Resta connesso a internet e aspetta che finiscano; il supporto per Uno, Nano e Mega arriva con questo pacchetto.

Quando colleghi la scheda, in Gestione dispositivi dovrebbe comparire una nuova porta COM sotto Porte (COM e LPT). Una Uno originale compare come Arduino Uno (COMx), i cloni economici con chip CH340 come USB-SERIAL CH340 (COMx). Se un clone resta sotto Altri dispositivi come USB2.0-Serial con un punto esclamativo giallo, manca il driver CH340; di solito Windows Update lo installa da solo, altrimenti installa il pacchetto CH341SER del produttore del chip, WCH. Il chip CP2102, diffuso su molte schede ESP32, richiede il driver CP210x VCP di Silicon Labs. Spieghiamo nel dettaglio come diagnosticare i problemi di porta e driver in Arduino non carica lo sketch.

Installare Arduino IDE su macOS

1. Scarica il file .dmg adatto al tuo processore e fai doppio clic. Nella finestra che si apre, trascina l'icona di Arduino IDE nella cartella Applicazioni.
2. Apri l'app dal Launchpad o con Spotlight (Cmd + Spazio). Quando ti chiede se sei sicuro di voler aprire un'app scaricata da internet, fai clic su Apri.
3. L'IDE potrebbe chiedere l'accesso alla cartella Documenti/Arduino, dove salva i tuoi sketch; concedilo, altrimenti non potrà salvarli.
4. La prima volta che colleghi una scheda a un MacBook con Apple Silicon può comparire la richiesta "Consentire la connessione dell'accessorio?". Se non fai clic su Consenti, la scheda non comparirà mai nell'elenco delle porte.
5. Nell'elenco delle porte una Uno originale compare come /dev/cu.usbmodem…, i cloni CH340 come /dev/cu.usbserial-… o /dev/cu.wchusbserial…. Le versioni recenti di macOS includono già i driver per CH340 e CP2102; installarci sopra vecchi driver di solito peggiora le cose.

Sui Mac con Apple Silicon, gli strumenti di alcuni pacchetti di schede sono ancora compilati per processori Intel. Se durante la compilazione o il caricamento vedi l'errore bad CPU type in executable, apri il Terminale e installa Rosetta 2 con softwareupdate --install-rosetta; questo livello di traduzione di Apple permette a quegli strumenti Intel di funzionare sui chip della serie M. Se l'errore persiste, aggiorna all'ultima versione il pacchetto della scheda in questione dal Gestore schede.

Installare Arduino IDE su Linux (AppImage)

1. Scarica l'AppImage. Un AppImage è un'applicazione racchiusa in un solo file, che non richiede installazione; se vuoi, spostalo in una posizione fissa della tua cartella home.
2. Rendi il file eseguibile: clic destro e, in Proprietà > Permessi, spunta Consenti l'esecuzione del file come programma. Nel terminale, chmod +x arduino-ide_*_Linux_64bit.AppImage fa la stessa cosa.
3. Fai doppio clic sul file per avviare l'IDE. Se ottieni dlopen(): error loading libfuse.so.2 o AppImages require FUSE to run, manca la libreria FUSE 2: esegui sudo apt install libfuse2 su Ubuntu 22.04, oppure sudo apt install libfuse2t64 da Ubuntu 24.04 in poi.
4. Aggiungi il tuo utente al gruppo dialout per accedere alle porte seriali: sudo usermod -a -G dialout $USER. Riavvia il computer perché la modifica abbia effetto, altrimenti il caricamento fallirà con Permission denied.
5. Se la porta di una scheda con chip CH340 o CP2102 compare per un attimo e poi sparisce, se ne sta impossessando il servizio brltty, preinstallato per i display braille. Se non usi un display braille, rimuovilo con sudo apt remove brltty, poi scollega e ricollega la scheda.
6. Se su Ubuntu 24.04 l'IDE non si apre affatto e il terminale mostra The SUID sandbox helper binary was found, but is not configured correctly, AppArmor sta bloccando la sandbox dell'applicazione. Come soluzione temporanea puoi avviare l'IDE dal terminale con l'opzione --no-sandbox.

Tour dell'interfaccia di Arduino IDE 2

Al primo avvio l'IDE ti accoglie con uno sketch vuoto: questo scheletro formato dalle funzioni setup() e loop() è la base di qualsiasi programma Arduino. Nel mondo Arduino i programmi si chiamano sketch, e ogni sketch è salvato come file .ino dentro una cartella con lo stesso nome. La finestra è divisa in quattro zone: in alto la barra degli strumenti con il selettore della scheda, a sinistra la barra laterale, al centro l'editor del codice e in basso il pannello Output, dove scorrono i messaggi del compilatore, insieme al Monitor seriale. La barra di stato, in fondo, mostra il numero di riga del cursore e la scheda e la porta selezionate.

Scegliere scheda e porta

La scelta della scheda dice all'IDE per quale processore compilare e con quale strumento caricare; la scelta della porta indica la scheda fisica collegata al computer. Senza entrambe corrette il caricamento non è possibile. Dopo aver collegato la scheda, apri il selettore in alto: una Uno originale compare con il suo nome e si sceglie con un clic. Con i cloni CH340, invece, l'IDE non riconosce la scheda e la porta compare come Sconosciuta (Unknown). In quel caso apri Scegli un'altra scheda e un'altra porta, scrivi "uno" nella casella di ricerca, scegli Arduino Uno a sinistra e la porta a destra, poi fai clic su OK. Se non sai quale porta appartiene alla tua scheda, scollegala, guarda l'elenco e ricollegala: la porta che compare è la tua.

Caricare il primo sketch: Blink passo passo

1. Vai su File > Esempi > 01.Basics > Blink. L'esempio si apre in una nuova finestra; è uno sketch incluso nell'IDE che fa lampeggiare il LED integrato.
2. Scegli la tua scheda e la porta nel selettore; nella barra di stato in basso ora dovresti vedere il nome della scheda e la porta.
3. Fai clic prima su Verifica (Ctrl+R). Se l'output (con l'interfaccia in inglese) mostra Sketch uses 924 bytes (2%) of program storage space. Maximum is 32256 bytes., la compilazione è riuscita.
4. Poi fai clic su Carica (Ctrl+U). I LED TX e RX della scheda lampeggiano velocemente per un attimo e in basso a destra compare la notifica Caricamento terminato (Done uploading).
5. Il LED contrassegnato con L ora dovrebbe restare acceso un secondo e spento un secondo. Per essere sicuro che sulla scheda ci sia davvero il nuovo codice, cambia entrambe le righe delay(1000) in delay(200) e ricarica; se il lampeggio accelera, tutto funziona.
6. Quando provi a salvare l'esempio modificato, l'IDE ti chiede un nuovo nome e una nuova posizione, perché gli esempi stanno nella cartella del programma. I tuoi sketch vengono salvati per impostazione predefinita nella cartella Documenti/Arduino, il tuo Sketchbook.

Queste righe dell'output ti informano sulla memoria della scheda. Il bootloader occupa 512 byte dei 32 KB di memoria flash dell'ATmega328P della Uno, per questo restano 32256 byte per il tuo codice, di cui Blink usa appena il 2%. La riga Global variables use 9 bytes, subito sotto, indica quanta parte dei 2048 byte di RAM è riservata alle variabili globali. Quando i tuoi progetti cresceranno, tenere d'occhio queste percentuali risponderà spesso alla domanda "perché la mia scheda si blocca?" prima ancora che te la ponga. Ora scrivi il tuo primo sketch: il codice qui sotto aggiunge a Blink alcune righe che inviano messaggi al Monitor seriale, così verifichi insieme il caricamento e lo scambio di dati via USB.

1// İlk test: dahili LED yanıp söner, Seri Port Ekranı'na yazı gelir
2// First test: blinks the onboard LED and prints to the Serial Monitor
3int sayac = 0;                        // kaç kez yanıp söndü / blink counter
4
5void setup() {
6  pinMode(LED_BUILTIN, OUTPUT);       // Uno'da pin 13 (L LED'i) / pin 13 (L LED) on the Uno
7  Serial.begin(9600);                 // Seri Port Ekranı hızı / Serial Monitor baud rate
8  Serial.println("Merhaba BlueGrays! / Hello BlueGrays!");
9}
10
11void loop() {
12  digitalWrite(LED_BUILTIN, HIGH);    // LED'i yak / turn the LED on
13  delay(1000);                        // 1 saniye bekle / wait 1 second
14  digitalWrite(LED_BUILTIN, LOW);     // LED'i söndür / turn the LED off
15  delay(1000);
16  sayac++;
17  Serial.print("Yanip sonme / Blink: ");
18  Serial.println(sayac);
19}

setup() viene eseguita una volta all'accensione o al reset della scheda: qui impostiamo il pin 13 come uscita e avviamo la comunicazione seriale a 9600 baud. loop() poi si ripete all'infinito finché la scheda è alimentata. LED_BUILTIN è il nome del pin a cui è collegato il LED integrato; su Uno, Nano e Mega corrisponde al 13, quindi lo stesso codice funziona su queste schede senza modifiche. Per una spiegazione dettagliata dei comandi, dai un'occhiata a Comandi Arduino.

Monitor seriale e Plotter seriale

Dopo il caricamento, fai clic sull'icona della lente in alto a destra o premi Ctrl+Maiusc+M. Il Monitor seriale si apre nel pannello in basso e scrive una nuova riga a ogni lampeggio. Il menu della velocità, in alto a destra nel pannello, deve corrispondere al valore di Serial.begin() nel codice, cioè 9600 baud; altrimenti lo schermo si riempie di caratteri senza senso. Scrivi nella casella del messaggio in alto e premi Invio per inviare testo alla scheda. Il menu di fine riga accanto offre Nessun fine riga, A capo, Ritorno carrello (CR) ed Entrambi NL & CR; scegli quello che si aspetta il tuo codice.

Il Plotter seriale mostra i numeri in un grafico: se invii righe con etichetta come Serial.print("luce:"); Serial.println(valore);, ogni etichetta diventa una linea di colore diverso. È perfetto per seguire dal vivo i valori di un potenziometro o di una fotoresistenza. Durante il caricamento assicurati che nessun altro programma (una seconda finestra dell'IDE, PuTTY, uno script Python) stia occupando la porta, perché una porta può essere aperta da un solo programma alla volta. Abbiamo raccolto tutti i dettagli di questi strumenti in Monitor seriale di Arduino.

Gestore librerie e Gestore schede

Gran parte della forza di Arduino viene dalle librerie già pronte. Apri il Gestore librerie con l'icona dei libri nella barra laterale sinistra (Ctrl+Maiusc+I), scrivi il nome della libreria nella casella di ricerca (per esempio "DHT sensor library") e fai clic su Installa. Se la libreria dipende da altre librerie, l'IDE te lo chiede; scegliere Installa tutto evita fin dall'inizio gli errori per file mancanti. Le librerie installate finiscono nella cartella libraries del tuo Sketchbook e i loro esempi si aggiungono al menu File > Esempi. I file ZIP scaricati da internet si installano con Sketch > Includi Libreria > Aggiungi libreria da file .ZIP; trovi i dettagli in Come aggiungere una libreria Arduino.

Il Gestore schede (Ctrl+Maiusc+B), invece, installa i compilatori e gli strumenti di caricamento per le diverse famiglie di processori. Il pacchetto di Uno, Nano e Mega arriva da solo al primo avvio; per schede come Uno R4, ESP32 o Pico installi il pacchetto relativo una sola volta. Le schede di Arduino compaiono direttamente nell'elenco, mentre per quelle di altri produttori devi prima aggiungere l'URL del loro pacchetto nelle Preferenze. I pacchetti delle schede non si installano nello Sketchbook, ma in una cartella separata chiamata Arduino15: C:\Users\utente\AppData\Local\Arduino15 su Windows, ~/Library/Arduino15 su macOS e ~/.arduino15 su Linux.

Aggiungere il pacchetto delle schede ESP32

1. Apri File > Preferenze (Ctrl+,) e incolla questo indirizzo nel campo URL aggiuntive per il Gestore schede: https://espressif.github.io/arduino-esp32/package_esp32_index.json. Per aggiungerne più di uno, fai clic sull'icona accanto al campo e scrivi ogni URL su una riga a sé.
2. Fai clic su OK, poi apri il Gestore schede e scrivi esp32 nella casella di ricerca.
3. Trova esp32 by Espressif Systems e fai clic su Installa. Il pacchetto pesa centinaia di megabyte, quindi con una connessione lenta il download può richiedere diversi minuti. Il pacchetto Arduino ESP32 Boards, che compare anch'esso, serve solo per l'Arduino Nano ESP32; per le schede ESP32 generiche installa quello di Espressif.
4. Scegli ESP32 Dev Module come scheda e la porta della tua scheda. Poiché la maggior parte degli ESP32 DevKit usa un chip CP2102 o CH340, l'IDE mostra la scheda come sconosciuta; è normale.
5. Carica lo sketch di prova qui sotto e imposta il Monitor seriale a 115200 baud. Se nell'output compare Connecting.... e non finisce più, tieni premuto il pulsante BOOT della scheda e rilascialo quando le percentuali di caricamento iniziano a scorrere.

1// ESP32 kurulum testi: yonga bilgisi + LED / ESP32 setup test: chip info + LED
2const int LED_PIN = 2;   // çoğu ESP32 DevKit'te dahili LED / onboard LED on most DevKits
3
4void setup() {
5  pinMode(LED_PIN, OUTPUT);
6  Serial.begin(115200);  // ESP32 için yaygın hız / common ESP32 baud rate
7  delay(1000);           // Seri Port Ekranı açılsın diye bekle / give the monitor time to open
8  Serial.print("Model: ");
9  Serial.println(ESP.getChipModel());                  // ör. ESP32-D0WD-V3 / e.g. ESP32-D0WD-V3
10  Serial.print("Cekirdek / Cores: ");
11  Serial.println(ESP.getChipCores());
12  Serial.print("CPU (MHz): ");
13  Serial.println(ESP.getCpuFreqMHz());
14  Serial.print("Flash (MB): ");
15  Serial.println(ESP.getFlashChipSize() / (1024 * 1024));
16  Serial.print("Bos RAM / Free heap (bayt / bytes): ");
17  Serial.println(ESP.getFreeHeap());
18}
19
20void loop() {
21  digitalWrite(LED_PIN, !digitalRead(LED_PIN));        // LED'i ters çevir / toggle the LED
22  delay(500);
23}

Se il Monitor seriale mostra il modello del chip, il numero di core, la frequenza di 240 MHz e la dimensione della flash, di solito 4 MB, il tuo ESP32 è pronto; se la scheda ha un LED integrato sul GPIO 2, lampeggerà anche ogni mezzo secondo. I pin dell'ESP32, la connessione al Wi-Fi e un primo progetto controllato dallo smartphone li vediamo in Che cos'è l'ESP32?

Aggiungere il pacchetto delle schede Raspberry Pi Pico

1. Nelle Preferenze aggiungi nell'elenco URL aggiuntive per il Gestore schede, su una riga separata sotto l'indirizzo dell'ESP32: https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json.
2. Cerca pico nel Gestore schede e installa il pacchetto Raspberry Pi Pico/RP2040/RP2350 di Earle F. Philhower. Questo pacchetto della community supporta Pico, Pico W, Pico 2 e Pico 2 W e funziona con la maggior parte delle librerie Arduino.
3. Scegli Raspberry Pi Pico come scheda, oppure il modello che hai (Pico W, Pico 2).
4. Per il primo caricamento, tieni premuto il pulsante BOOTSEL del Pico mentre colleghi il cavo USB, poi rilascialo. Il Pico compare sul computer come un'unità chiamata RPI-RP2 (RP2350 sul Pico 2) e nell'elenco delle porte appare UF2 Board; scegli quella porta e fai clic su Carica.
5. Quando il codice parte, il Pico apre una normale porta seriale. Scegli questa nuova porta nell'elenco; nei caricamenti successivi non serve più BOOTSEL, perché l'IDE riavvia la scheda da solo.

1// Pico kurulum testi: dahili LED + yonga sıcaklığı
2// Pico setup test: onboard LED + chip temperature
3void setup() {
4  pinMode(LED_BUILTIN, OUTPUT);   // Pico'da GP25; Pico W'de kablosuz yonga üzerinden / GP25 on Pico, via the wireless chip on Pico W
5  Serial.begin(115200);           // USB seri port / USB serial port
6}
7
8void loop() {
9  digitalWrite(LED_BUILTIN, HIGH);
10  delay(500);
11  digitalWrite(LED_BUILTIN, LOW);
12  delay(500);
13  Serial.print("Yonga sicakligi / Chip temperature (C): ");
14  Serial.println(analogReadTemp());   // dahili sensör, yaklaşık değer / internal sensor, approximate
15}

Se vuoi programmare il Pico in MicroPython, si usa Thonny al posto di Arduino IDE; trovi le differenze tra i due approcci e l'installazione di MicroPython in Che cos'è il Raspberry Pi Pico? Ricorda che caricando da Arduino IDE MicroPython viene cancellato dalla scheda. Per tornare indietro basta ricaricare il file UF2 di MicroPython con il metodo BOOTSEL.

Preferenze: lingua, dimensione del carattere e altre impostazioni

La finestra delle Preferenze si apre da File > Preferenze (su macOS dal menu dell'app Arduino IDE) o con Ctrl+,. Per avere l'interfaccia in italiano, scegli Italiano nell'elenco Language (Lingua) e fai clic su OK; dopo un breve ricaricamento l'IDE si apre con i menu tradotti. I messaggi di errore del compilatore restano in inglese. Queste sono le impostazioni più utili per chi inizia:

Arduino Cloud Editor: programmare nel browser senza installare nulla

Se non puoi installare programmi sul tuo computer (un computer della scuola, un Chromebook o un portatile senza permessi di amministratore), l'Arduino Cloud Editor è una buona alternativa. Accedi su app.arduino.cc con un account Arduino gratuito e crei un nuovo sketch nella sezione Sketches; il tuo codice viene salvato nel cloud e si apre uguale su qualsiasi computer. Su Windows, macOS e Linux devi installare una volta un piccolo programma in background, l'Arduino Cloud Agent, per caricare sulla scheda via USB. Su Chromebook si usa il browser o l'app Arduino Cloud for Chromebook al posto dell'agent, ma lì sono supportate solo la Uno R3, la Uno R4 e poche altre schede Arduino ufficiali. Puoi anche usare i due strumenti insieme: se accedi con il tuo account Arduino nell'IDE 2, il Cloud Sketchbook fa sì che l'IDE di casa e il Cloud Editor della scuola vedano gli stessi sketch.

Problemi comuni durante l'installazione e soluzioni

Installazione completata: e adesso?

• Consolida le basi: scopri come si combinano scheda, pin e programmazione in Che cos'è Arduino? e trova i comandi più usati nella guida Comandi Arduino.
• Monta il tuo primo circuito: al posto del LED integrato, fai Blink con un LED e una resistenza su una breadboard; trova la resistenza giusta con il calcolatore di resistenza per LED e guarda dove si trova ogni pin nello strumento Pinout.
• Prova senza scheda: se non hai ancora una scheda, simula nel browser con Tinkercad o Wokwi.
• Impara a risolvere gli errori: quando compaiono messaggi in rosso, consulta le guide sugli errori di caricamento e sugli errori di compilazione.
• Passa al wireless: se hai installato il pacchetto ESP32, realizza il tuo primo progetto Wi-Fi con Che cos'è l'ESP32?
• Scegli la scheda giusta: se non hai ancora comprato una scheda, dai un'occhiata a Quale Arduino comprare? e a Starter kit Arduino.

Una volta installato bene, Arduino IDE funziona senza problemi per anni; quando prendi una nuova scheda, ti basta installare il suo pacchetto nel Gestore schede e scegliere la scheda e la porta giuste. Se Blink funziona, sei pronto: nell'app BlueGrays trovi decine di progetti per Arduino, ESP32 e Raspberry Pi Pico, dai LED lampeggianti ai semafori, dai sensori di distanza ai progetti Wi-Fi, ognuno con schema elettrico, elenco dei componenti e codice spiegato passo passo, da provare subito nel tuo IDE appena installato.