Arduino e Python via seriale con pySerial

21 ottobre 2026

Arduino e Python uniti creano un nuovo logo Python, simbolo di potenti progetti maker.

Indice

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.

Schema di collegamento tra un laptop con Windows 11 e un Arduino UNO. Il laptop esegue codice Python per comunicare via USB con l'ATmega32u4, che converte il segnale USB in seriale per l'ATmega328P.

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.

Domande frequenti

Alcune schede si riavviano all’apertura della connessione e potrebbero non essere pronte a ricevere subito. Fai inviare allo sketch il messaggio READY dopo l’avvio e attendilo da Python prima di spedire il comando, per esempio LED_ON seguito da una nuova riga.

Imposta un timeout in pySerial e controlla che Arduino termini ogni messaggio con una nuova riga, per esempio usando Serial.println(). readline() aspetta quel terminatore; inoltre, chiudi il monitor seriale dell’IDE, perché un’altra applicazione potrebbe occupare la porta.

Usa pySerial se vuoi che Arduino esegua una logica autonoma, legga sensori o continui a controllare i pin anche se Python si chiude. Firmata è utile per prove rapide in cui il programma sul computer imposta i pin e legge gli ingressi tramite un protocollo già pronto, dopo aver caricato sulla scheda uno sketch compatibile come StandardFirmata.

Il baud rate deve coincidere nei due programmi, per esempio 9600 in Serial.begin(9600) e in pySerial. Per un prototipo, invia testo con un messaggio per riga e usa un timeout; a 9600 baud con configurazione 8N1 il limite teorico è circa 960 byte al secondo. Se invii dati binari, non interpretarli come testo UTF-8.

Valuta l'articolo

Valutazione: 4.50 Numero di voti: 4

Tag:

porte seriali pyserial firmata protocolli seriali

Condividi post

Scrivi un commento