Hai un Arduino collegato via USB e vuoi leggere un sensore da Python o accendere un LED con un comando sul computer. Di solito basta comunicare sulla porta seriale con pySerial, ma la scheda può riavviarsi quando la apri e ignorare i primi dati.

Python gestisce i dati, Arduino legge sensori e controlla i pin
- Per iniziare: usa la porta seriale USB e la libreria pySerial.
- Stesso baud rate: il valore impostato in Python deve coincidere con quello passato a
Serial.begin(). - Messaggi completi: definisci un terminatore, per esempio
\n, e leggilo con un timeout. - Avvio affidabile: dopo l’apertura della porta, aspetta il messaggio di pronto della scheda prima di inviare comandi.
- Alternativa: Firmata permette il controllo dei pin da Python senza scrivere da zero un protocollo seriale.
Per un primo progetto, fai dialogare i due programmi via USB
Python gira sul computer; lo sketch Arduino resta responsabile dei pin e dei tempi precisi. La porta seriale USB fa da ponte: Arduino invia righe di dati e Python le legge, oppure il programma sul computer manda comandi alla scheda. È una divisione semplice da provare e da correggere.
Installa pySerial nell’ambiente Python che userai per lanciare lo script con python -m pip install pyserial. Poi individua la porta assegnata alla scheda: su Windows può apparire come COM4, mentre macOS e Linux mostrano nomi come /dev/cu.usbmodem… o /dev/ttyACM0. La numerazione cambia da computer a computer; il comando python -m serial.tools.list_ports aiuta a elencare le porte disponibili, come descritto nella documentazione di pySerial.
Per un test leggibile, Arduino può inviare una riga ogni volta che legge un sensore:
const int sensorePin = A0;
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println(analogRead(sensorePin));
delay(100);
}
Serial.println() stampa il valore come testo e termina la riga con i caratteri di ritorno a capo e nuova riga. Questo dettaglio permette a Python di separare una lettura dalla successiva, invece di ricevere un flusso di caratteri senza confini evidenti, come spiega la referenza Arduino per Serial.println().
Un messaggio per riga evita dati incollati o letture bloccate
Quando il monitor seriale mostra valori corretti ma Python sembra fermo, spesso il programma sta aspettando il terminatore di riga, oppure la porta è aperta da un’altra applicazione. Chiudi il monitor seriale dell’IDE prima di avviare lo script: normalmente una sola applicazione alla volta può usare quella porta.
import serial
porta = "COM4" # Su macOS o Linux sostituisci con il nome rilevato
with serial.Serial(porta, 9600, timeout=1) as arduino:
while True:
riga = arduino.readline()
if riga:
print(riga.decode("utf-8").strip())
Il timeout impedisce a readline() di restare in attesa per sempre se non arriva il carattere di nuova riga. Se compare un errore di decodifica, prima verifica che Arduino invii testo semplice e che il messaggio finisca con println(); per pacchetti binari la decodifica UTF-8 non è la scelta giusta. Per un prototipo, il testo delimitato da righe è più facile da ispezionare; per dati binari o messaggi complessi, serve un protocollo definito con più cura.
Un handshake risolve il riavvio che fa perdere il primo comando
Aprire la connessione seriale può riavviare alcune schede Arduino. Se Python invia subito un comando, la scheda potrebbe essere ancora nella fase di avvio e non riceverlo. Invece di affidarti a una pausa arbitraria, fai inviare allo sketch una riga di stato quando è pronto e aspetta quella riga da Python.
// Arduino
void setup() {
Serial.begin(9600);
Serial.println("READY");
}
void loop() {
if (Serial.available() > 0) {
String comando = Serial.readStringUntil('\n');
comando.trim();
if (comando == "LED_ON") {
digitalWrite(LED_BUILTIN, HIGH);
Serial.println("OK");
}
}
}
# Python
import serial
with serial.Serial("COM4", 9600, timeout=2) as arduino:
while True:
messaggio = arduino.readline().decode("utf-8").strip()
if messaggio == "READY":
break
arduino.write(b"LED_ON\n")
risposta = arduino.readline().decode("utf-8").strip()
print(risposta)
Per usare l’esempio LED, aggiungi pinMode(LED_BUILTIN, OUTPUT); nel setup(). READY funziona da handshake, cioè da conferma che entrambe le parti sono pronte a scambiarsi dati. Credo che sia una soluzione più affidabile del semplice sleep(2), perché Python aspetta un evento effettivo anziché presumere quanto duri l’avvio.
Se invece Python riceve righe complete ma i valori sembrano vecchi o arrivano a scatti, controlla la frequenza di invio. Con una seriale impostata a 9600 baud e la configurazione comune 8N1, il limite teorico è circa 960 byte al secondo, perché ogni byte occupa 10 bit sul filo. Una riga di 20 byte inviata 10 volte al secondo richiede circa 200 byte al secondo: resta entro quel limite, ma etichette verbose, pause e ritrasmissioni riducono il margine disponibile.
La scelta tra pySerial e Firmata dipende da chi deve comandare i pin
Se vuoi che Arduino esegua una logica propria e invii dati a un’app Python, scegli pySerial e definisci comandi brevi, per esempio LED_ON e LED_OFF. Se preferisci impostare pin e leggere ingressi direttamente dal programma sul computer, Firmata è un protocollo già pronto: carichi sulla scheda uno sketch compatibile, come StandardFirmata, e usi un client Python supportato.
La differenza pratica è nel luogo in cui vive il comportamento. Con uno sketch personalizzato, Arduino può continuare a reagire anche se Python si chiude; con Firmata, molte decisioni restano sul computer e dipendono dalla connessione. La specifica Firmata descrive lo scambio tra microcontrollore e software host, mentre il repository Firmata per Arduino documenta gli sketch da caricare. Per un progetto con sensori e una logica autonoma, sceglierei pySerial; per prove rapide sui pin da PC, partirei da Firmata.
Considera anche la scheda: sulla documentazione di Arduino UNO R4 WiFi sono distinti la seriale USB e la UART sui pin RX/TX, che usano oggetti diversi nello sketch. Quindi, se il computer comunica via USB, usa Serial; se colleghi un dispositivo esterno ai pin UART, verifica quale porta seriale usare e non confondere i due collegamenti.
Quando la comunicazione fallisce, segui il sintomo invece di cambiare tutto
La porta seriale mette insieme nome del dispositivo, velocità e formato dei messaggi: modificare più parametri contemporaneamente rende difficile capire quale fosse il problema. Parti dal sintomo più visibile e cambia una sola cosa alla volta.
| Situazione | Probabile causa | Cosa fare |
|---|---|---|
| Errore di accesso alla porta | La porta è già occupata dal monitor seriale o da un altro script | Chiudi l’altra applicazione e riavvia il programma Python |
| Python resta in attesa | readline() aspetta il terminatore o non ha un timeout |
Imposta un timeout e controlla che Arduino invii println() |
| Il primo comando viene ignorato | La scheda si riavvia quando si apre la porta | Attendi il messaggio READY prima di inviare il comando |
| Arrivano caratteri senza senso | Baud rate diversi oppure bytes interpretati come testo con la codifica sbagliata | Allinea Serial.begin() e pySerial; verifica se il payload è testuale o binario |
| La porta indicata non esiste | Il nome è cambiato o la scheda non è stata rilevata | Riesegui l’elenco delle porte dopo aver collegato Arduino e scegli quella nuova |
Su Arduino UNO R4 WiFi, l’USB e i pin UART sono percorsi distinti: se la porta è aperta ma non passa il dato atteso, controlla anche che lo sketch utilizzi Serial per USB oppure Serial1 per RX/TX. È un controllo più utile che aumentare subito la velocità, soprattutto quando il codice funziona su un modello di scheda ma non su un altro.
Per un progetto stabile, rendi esplicite le regole del messaggio
Un LED acceso è un buon test; un’applicazione robusta richiede che i messaggi siano riconoscibili anche quando i dati arrivano in ritardo o in più parti. Definisci un terminatore, un formato prevedibile e una risposta di conferma. Per esempio, una lettura può essere inviata come TEMP,23.4\n, così Python distingue il tipo di dato dal valore.
All’inizio, mantieni la comunicazione leggibile e prova separatamente invio e ricezione. Quando il protocollo cresce, aggiungi controlli di validità e gestisci comandi sconosciuti senza bloccare il ciclo di Arduino. Se la scheda deve continuare a controllare sensori o attuatori anche senza computer, lascia a bordo la logica essenziale e usa Python per registrare dati, visualizzarli o impartire richieste di alto livello.