Arduino IDE 2.x su Linux Mint e Fedora: installazione e funzionamento

Arduino IDE 2.x è l’ambiente di sviluppo ufficiale per la programmazione delle schede Arduino e di numerose piattaforme compatibili basate su microcontrollori AVR, SAMD, ESP32, ESP8266, RP2040 e altri. Rispetto alla storica versione 1.x, la 2.x rappresenta una riscrittura completa: l’interfaccia è basata sul framework Eclipse Theia, il motore di compilazione e gestione delle schede è affidato ad arduino-cli e sono stati integrati strumenti moderni come l’autocompletamento del codice, la navigazione tra le definizioni, il debugger hardware e un gestore di librerie e schede più rapido.

Su GNU/Linux l’installazione richiede alcune attenzioni in più rispetto a Windows o macOS: la scelta del formato di distribuzione più adatto, la configurazione dei permessi di accesso alla porta seriale e, in alcuni casi, la definizione di regole udev per il riconoscimento delle schede. Queste operazioni differiscono leggermente tra le distribuzioni derivate da Debian/Ubuntu, come Linux Mint, e quelle basate su RPM, come Fedora. In questa guida vengono analizzate entrambe le famiglie, con i comandi specifici per ciascun sistema.

Al termine della lettura sarà possibile installare Arduino IDE 2.x in modo pulito e aggiornabile, collegare correttamente una scheda, compilare e caricare uno sketch di prova e diagnosticare i problemi più comuni legati alle porte seriali su Linux.

Architettura di Arduino IDE 2.x

Arduino IDE 2.x non è un semplice aggiornamento grafico della versione precedente, ma un’applicazione con architettura completamente diversa. Il frontend è costruito su Eclipse Theia, un framework per IDE basato su tecnologie web, mentre tutte le operazioni di compilazione, caricamento, gestione dei core e delle librerie sono delegate ad arduino-cli, uno strumento a riga di comando che l’IDE avvia e controlla in background.

Questa separazione ha conseguenze pratiche importanti:

• Language server: l’autocompletamento e il controllo del codice in tempo reale sono forniti da un language server basato su clangd, che analizza lo sketch mentre viene scritto.
• arduino-cli: la stessa toolchain usata dall’IDE può essere richiamata da terminale o da script, con risultati identici a quelli ottenuti dall’interfaccia grafica.
• Debugger integrato: sulle schede che lo supportano è possibile eseguire il debug passo-passo con breakpoint, ispezione delle variabili e dei registri.
• Compatibilità degli sketch: gli sketch scritti con la versione 1.x restano pienamente compatibili, così come il formato delle librerie e dei core.

Requisiti di sistema

Arduino IDE 2.x è distribuito per Linux esclusivamente in versione a 64 bit per architettura x86_64. I requisiti sono modesti per gli standard attuali, ma è bene verificarli prima dell’installazione, soprattutto su macchine datate.

Requisiti minimi Arduino IDE 2.x su GNU/Linux
 
Architettura:          x86_64 (64 bit)
Memoria RAM:           2 GB minimo, 4 GB consigliati
Spazio su disco:       ~850 MB per l'IDE
                       + spazio aggiuntivo per core e toolchain
                       (un core ESP32 può superare 1,5 GB)
Distribuzione:         glibc recente; testato su Ubuntu LTS e derivate
Ambiente grafico:      X11 o Wayland (con XWayland)
Dipendenze runtime:    fuse2 / libfuse2 (solo per formato AppImage)
Connessione internet:  necessaria per scaricare core, librerie e indici

Linux Mint (dalla versione 21 in poi) e Fedora (versioni recenti) soddisfano ampiamente questi requisiti. L’unico punto critico è la libreria libfuse2, richiesta dal formato AppImage e non sempre presente nelle installazioni predefinite.

Formati di distribuzione disponibili

Per Linux, Arduino IDE 2.x è disponibile in più formati. La scelta influenza il metodo di aggiornamento, l’integrazione con il sistema e la gestione dei permessi.

Come regola generale: su Linux Mint le scelte più pratiche sono AppImage e Flatpak; su Fedora, Flatpak è particolarmente naturale perché il supporto è preinstallato, ma anche l’AppImage funziona correttamente. È sconsigliato affidarsi al pacchetto arduino presente nei repository tradizionali, che in molti casi corrisponde ancora alla vecchia serie 1.8.x.

Preparazione del sistema su Linux Mint

Linux Mint deriva da Ubuntu e utilizza il gestore pacchetti APT. Prima di installare l’IDE è opportuno aggiornare il sistema e installare la libreria FUSE necessaria al formato AppImage.

# Aggiornamento del sistema
sudo apt update
sudo apt upgrade
 
# Libreria richiesta dagli AppImage (Mint 21/22 e derivate Ubuntu 22.04+)
sudo apt install libfuse2
 
# Strumenti utili per la diagnostica seriale
sudo apt install mokutil usbutils

Su Linux Mint, Flatpak e il negozio Flathub sono già configurati nel Gestore Applicazioni: se si sceglie questa strada non è necessaria alcuna preparazione aggiuntiva.

Preparazione del sistema su Fedora

Fedora utilizza il gestore pacchetti DNF e include Flatpak preinstallato. Per usare gli AppImage è necessario il pacchetto fuse (compatibilità FUSE 2), mentre per Flathub può servire abilitare il repository completo.

# Aggiornamento del sistema
sudo dnf upgrade --refresh
 
# Supporto AppImage (compatibilità FUSE 2)
sudo dnf install fuse fuse-libs
 
# Abilitazione del repository Flathub completo (se non già attivo)
flatpak remote-add --if-not-exists flathub \
  https://dl.flathub.org/repo/flathub.flatpakrepo
 
# Strumenti utili per la diagnostica seriale
sudo dnf install usbutils

Installazione tramite AppImage

L’AppImage è il metodo più diretto: si scarica un singolo file eseguibile dal sito ufficiale, lo si rende eseguibile e lo si avvia. La procedura è identica su Linux Mint e Fedora.

# Creazione di una cartella dedicata alle applicazioni
mkdir -p ~/Applicazioni
cd ~/Applicazioni
 
# Download dell'AppImage dal sito ufficiale
# (verificare sempre l'ultima versione su https://www.arduino.cc/en/software)
wget https://downloads.arduino.cc/arduino-ide/arduino-ide_2.3.6_Linux_64bit.AppImage
 
# Assegnazione del permesso di esecuzione
chmod +x arduino-ide_2.3.6_Linux_64bit.AppImage
 
# Avvio dell'IDE
./arduino-ide_2.3.6_Linux_64bit.AppImage

Se all’avvio compare un errore relativo a fuse o libfuse.so.2, significa che la libreria FUSE 2 non è installata: è sufficiente installarla con i comandi visti nei paragrafi precedenti. In alternativa, l’AppImage può essere estratto ed eseguito senza FUSE con l’opzione --appimage-extract-and-run.

Integrazione dell’AppImage nel menu delle applicazioni

L’AppImage non crea automaticamente una voce nel menu. Per integrarlo è sufficiente creare un file .desktop nella cartella delle applicazioni utente.

# File: ~/.local/share/applications/arduino-ide.desktop
 
[Desktop Entry]
Type=Application
Name=Arduino IDE 2
Comment=Ambiente di sviluppo Arduino
Exec=/home/utente/Applicazioni/arduino-ide_2.3.6_Linux_64bit.AppImage %U
Icon=arduino
Terminal=false
Categories=Development;IDE;Electronics;
StartupWMClass=Arduino IDE
MimeType=text/x-arduino;
 
# Aggiornamento del database delle applicazioni
update-desktop-database ~/.local/share/applications

Il percorso indicato in Exec deve corrispondere alla posizione reale dell’AppImage e va aggiornato a ogni cambio di versione, oppure si può rinominare il file scaricato con un nome fisso, ad esempio arduino-ide.AppImage, così da non dover modificare il collegamento.

Installazione tramite Flatpak

Il pacchetto Flatpak ufficiale è pubblicato su Flathub con identificativo cc.arduino.IDE2. Questo metodo garantisce aggiornamenti automatici e piena integrazione nel menu, sia su Linux Mint sia su Fedora.

# Installazione da Flathub
flatpak install flathub cc.arduino.IDE2
 
# Avvio da terminale (oppure dal menu delle applicazioni)
flatpak run cc.arduino.IDE2
 
# Aggiornamento
flatpak update cc.arduino.IDE2

Poiché il Flatpak è eseguito in sandbox, l’accesso ai dispositivi seriali è mediato dai permessi del pacchetto. Il pacchetto ufficiale include già l’accesso ai dispositivi, ma resta necessario che l’utente appartenga al gruppo corretto del sistema, come descritto più avanti. In caso di problemi è possibile verificare e ampliare i permessi con Flatseal o da terminale.

# Verifica dei permessi del Flatpak
flatpak info --show-permissions cc.arduino.IDE2
 
# Concessione esplicita dell'accesso ai dispositivi (se necessario)
sudo flatpak override cc.arduino.IDE2 --device=all

Installazione tramite archivio ZIP

L’archivio ZIP contiene l’applicazione già pronta: basta estrarlo in una cartella e avviare l’eseguibile. È il metodo preferibile quando si vogliono mantenere più versioni dell’IDE in parallelo.

# Estrazione in /opt (installazione a livello di sistema)
sudo mkdir -p /opt/arduino-ide
sudo unzip arduino-ide_2.3.6_Linux_64bit.zip -d /opt/arduino-ide
 
# Avvio
/opt/arduino-ide/arduino-ide_2.3.6_Linux_64bit/arduino-ide
 
# Collegamento simbolico per l'avvio rapido da terminale
sudo ln -s /opt/arduino-ide/arduino-ide_2.3.6_Linux_64bit/arduino-ide \
  /usr/local/bin/arduino-ide

Permessi della porta seriale: dialout e dialout/uucp

Su GNU/Linux le schede Arduino vengono esposte come dispositivi seriali, tipicamente /dev/ttyACM0 (schede con USB nativa o convertitore integrato, come UNO e Leonardo) oppure /dev/ttyUSB0 (schede con convertitori esterni CH340, CP2102, FT232). L’accesso a questi dispositivi è riservato a un gruppo di sistema: se l’utente non ne fa parte, l’IDE mostra errori di permesso durante il caricamento dello sketch.

Il nome del gruppo differisce tra le due famiglie di distribuzioni:

# Identificazione della scheda collegata
lsusb
dmesg | grep -i tty
 
# Verifica del gruppo proprietario del dispositivo
ls -l /dev/ttyACM0
# esempio di output:
# crw-rw---- 1 root dialout 166, 0 ago 14 10:32 /dev/ttyACM0
 
# Verifica dei gruppi dell'utente corrente
groups
 
# Aggiunta dell'utente al gruppo corretto
sudo usermod -aG dialout $USER

La modifica dei gruppi diventa effettiva solo dopo il logout e il successivo login (o il riavvio del sistema). È l’errore più frequente in assoluto: molti utenti aggiungono il gruppo ma non ricaricano la sessione, e continuano a ricevere l’errore Permission denied sulla porta.

Il caso di brltty su Fedora e sui convertitori CH340

Su alcune installazioni recenti il demone brltty, dedicato ai display braille, può prendere possesso dei convertitori seriali USB (in particolare i CH340 delle schede compatibili), facendo sparire il dispositivo /dev/ttyUSB0 pochi istanti dopo il collegamento. Se non si utilizzano display braille, il servizio può essere disattivato senza conseguenze.

# Verifica della presenza di brltty nei log
dmesg | grep -i brltty
 
# Disattivazione del servizio (Fedora e Mint)
sudo systemctl stop brltty.service brltty-udev.service
sudo systemctl mask brltty.service brltty-udev.service

Regole udev per schede non riconosciute

Alcune schede, in particolare quelle programmate tramite bootloader con reset automatico (Leonardo, Micro, molte schede SAMD e RP2040), richiedono regole udev specifiche per essere riconosciute correttamente in fase di caricamento. Arduino pubblica un pacchetto di regole ufficiali che è consigliabile installare una sola volta.

# Esempio di regola udev per schede Arduino
# File: /etc/udev/rules.d/60-arduino.rules
 
SUBSYSTEMS=="usb", ATTRS{idVendor}=="2341", GROUP="dialout", MODE="0664"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="1a86", GROUP="dialout", MODE="0664"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="10c4", GROUP="dialout", MODE="0664"
 
# idVendor 2341 = Arduino SA
# idVendor 1a86 = convertitori CH340/CH341
# idVendor 10c4 = convertitori Silicon Labs CP210x
 
# Ricaricamento delle regole senza riavvio
sudo udevadm control --reload-rules
sudo udevadm trigger

Primo avvio e struttura dell’interfaccia

Al primo avvio l’IDE scarica gli indici dei core e delle librerie, quindi propone l’installazione del core AVR se viene rilevata una scheda collegata. L’interfaccia è organizzata in aree ben distinte:

• Barra superiore: pulsanti di verifica (compilazione), caricamento, debug, selettore rapido di scheda e porta.
• Barra laterale sinistra: gestore degli sketch, gestore delle schede (Boards Manager), gestore delle librerie, debugger e ricerca.
• Editor centrale: editor con evidenziazione della sintassi, autocompletamento e navigazione del codice.
• Pannello inferiore: output di compilazione e caricamento, monitor seriale integrato.

Dal menu File → Preferences (File → Impostazioni) è possibile attivare l’output dettagliato di compilazione e caricamento, opzione preziosa in fase di diagnosi, oltre a impostare la posizione dello sketchbook, il tema scuro e la lingua dell’interfaccia.

Gestione delle schede: il Boards Manager

Il Boards Manager gestisce i “core”, ovvero i pacchetti che contengono toolchain, definizioni e strumenti di caricamento per ciascuna famiglia di schede. Il core Arduino AVR Boards copre UNO, Nano, Mega e Leonardo; le piattaforme di terze parti come ESP32 ed ESP8266 richiedono l’aggiunta di un URL aggiuntivo nelle impostazioni.

URL aggiuntivi per il Boards Manager
(File → Preferences → Additional boards manager URLs)
 
ESP32 (Espressif):
https://espressif.github.io/arduino-esp32/package_esp32_index.json
 
ESP8266:
https://arduino.esp8266.com/stable/package_esp8266com_index.json

I core installati vengono salvati nella cartella dati dell’utente e possono occupare spazio significativo: un’installazione con AVR, ESP32 e RP2040 supera facilmente i 3 GB tra toolchain e strumenti.

Gestione delle librerie

Il Library Manager, accessibile dalla barra laterale, consente di cercare, installare e aggiornare le librerie pubblicate nel registro ufficiale. Le librerie installate manualmente vanno invece copiate nella sottocartella libraries dello sketchbook, oppure importate come archivio ZIP dal menu Sketch → Include Library → Add .ZIP Library.

Compilazione e caricamento di uno sketch di prova

Il modo più rapido per verificare l’intera catena (IDE, toolchain, porta seriale, permessi) è il classico sketch Blink, disponibile anche tra gli esempi integrati in File → Examples → 01.Basics → Blink.

// Sketch di prova: lampeggio del LED integrato
 
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}
 
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

La procedura operativa è la seguente:

• Selezione della scheda: dal selettore rapido nella barra superiore o da Tools → Board, scegliere il modello esatto, ad esempio “Arduino UNO”.
• Selezione della porta: scegliere la porta rilevata, tipicamente /dev/ttyACM0 o /dev/ttyUSB0. L’IDE 2.x mostra accanto alla porta il nome della scheda riconosciuta.
• Verifica: il pulsante con il segno di spunta compila lo sketch senza caricarlo, utile per controllare la sintassi.
• Caricamento: il pulsante con la freccia compila e trasferisce il firmware sulla scheda. Al termine compare il messaggio di conferma nel pannello di output.

Se il LED integrato lampeggia con periodo di un secondo, l’installazione è completa e funzionante.

Monitor seriale e plotter seriale

Il monitor seriale della versione 2.x è integrato nel pannello inferiore e non apre più una finestra separata. Permette di impostare la velocità di comunicazione (baud rate), che deve coincidere con quella dichiarata nello sketch tramite Serial.begin(), e di inviare dati verso la scheda. Il plotter seriale, accessibile da Tools → Serial Plotter, rappresenta graficamente in tempo reale i valori numerici stampati sulla seriale, con supporto a più tracce contemporanee.

Va ricordato che la porta seriale è una risorsa esclusiva: se il monitor è aperto in un altro programma (screen, minicom, un secondo IDE), il caricamento fallisce con errori di porta occupata.

Debug integrato

Una delle novità più rilevanti della serie 2.x è il debugger hardware integrato, che consente breakpoint, esecuzione passo-passo, ispezione di variabili, registri e memoria. Il debug richiede una scheda con supporto adeguato (ad esempio le famiglie SAMD, Renesas UNO R4, ESP32 con interfaccia JTAG/USB) ed eventualmente una sonda esterna come Atmel-ICE o J-Link per le piattaforme che non espongono il debug sulla USB nativa. Le classiche schede AVR come UNO R3 e Nano non supportano il debug integrato.

Cartelle di configurazione e sketchbook

Conoscere la posizione dei file di configurazione è utile per i backup, per la migrazione tra macchine e per la pulizia in caso di installazioni corrotte. I percorsi seguenti valgono sia su Linux Mint sia su Fedora; nel caso del Flatpak sono replicati all’interno della cartella sandbox.

Percorsi principali di Arduino IDE 2.x su GNU/Linux
 
Sketchbook (sketch e librerie utente):
  ~/Arduino
 
Configurazione dell'IDE:
  ~/.arduinoIDE
 
Core, toolchain, indici e cache di arduino-cli:
  ~/.arduino15
 
Dati dell'interfaccia (Theia):
  ~/.config/arduino-ide
 
Percorsi equivalenti per l'installazione Flatpak:
  ~/.var/app/cc.arduino.IDE2/config/arduino-ide
  ~/.var/app/cc.arduino.IDE2/data/Arduino15

Aggiornamento dell’IDE

Il metodo di aggiornamento dipende dal formato scelto. L’AppImage e lo ZIP non si aggiornano da soli: alla pubblicazione di una nuova release viene mostrata una notifica, ma il download e la sostituzione del file sono manuali. Il Flatpak si aggiorna con il resto del sistema tramite flatpak update o dal Gestore Applicazioni. In tutti i casi, core e librerie si aggiornano dall’interno dell’IDE, indipendentemente dal formato dell’applicazione.

Problemi comuni e soluzioni