Potenziometro con Arduino - collegamenti, lettura e usi pratici

Un potenziometro collegato ad Arduino è uno dei modi più rapidi per trasformare una rotazione manuale in un valore leggibile dal microcontrollore. Io lo considero il punto di partenza ideale per capire gli ingressi analogici, perché in poche prove vedi subito il passaggio dal movimento al numero, e poi dal numero a un effetto concreto come la luminosità di un LED o la posizione di un servo. In questo articolo trovi il collegamento corretto, lo sketch minimo, i passaggi per usare quel valore in modo utile e gli errori che fanno perdere tempo anche nei montaggi più semplici.

Cosa fa davvero un potenziometro con Arduino

Un potenziometro è, in pratica, una resistenza variabile con tre piedini. Ruotando l’alberino sposti il contatto centrale lungo una pista resistiva e cambi la tensione che arriva al pin di lettura. Arduino non “legge la resistenza” in senso stretto: legge una tensione e la converte in un numero tramite il convertitore analogico-digitale, cioè l’ADC.

Sulle schede classiche, come Uno e Nano tradizionali, quella conversione produce valori compresi tra 0 e 1023. Lo zero corrisponde a una tensione vicina a massa, il valore massimo alla tensione di riferimento della scheda. In altre parole, il potenziometro non è solo un componente da test: è un ingresso manuale molto preciso per regolare parametri, selezionare opzioni e simulare un sensore di controllo.

Questa scala è il motivo per cui il potenziometro è perfetto nei primi progetti: il comportamento è intuitivo, e il passaggio dal mondo fisico al dato numerico è immediato. Da qui il passo successivo è collegarlo bene, perché un montaggio sbagliato fa sembrare “rotto” anche un circuito corretto.

Come collegarlo in modo corretto sulla breadboard

Il collegamento base è semplice, ma va fatto con ordine. Io parto sempre da questa regola: due pin esterni del potenziometro agli estremi dell’alimentazione, pin centrale all’ingresso analogico. Su una scheda a 5 V colleghi un terminale a 5V e l’altro a GND; su una scheda a 3,3 V usi la tensione corretta della scheda, non 5 V per abitudine. Il pin centrale va a A0 o a un altro ingresso analogico disponibile.

Se il verso di rotazione ti sembra “invertito”, non hai un errore serio: basta scambiare i due terminali esterni. Questa piccola inversione cambia solo la direzione della scala, non il funzionamento. Il problema vero nasce quando il pin centrale non è collegato bene, perché in quel caso la lettura può saltare, restare fissa o oscillare senza senso.

• Usa una breadboard solo come supporto: i contatti devono essere davvero ben inseriti.
• Controlla che il corpo del potenziometro sia del tipo giusto per la basetta, altrimenti i piedini fanno falso contatto.
• Se alimenti la scheda via USB, resta coerente con la tensione di riferimento della board.
• Non lasciare mai il pin centrale scollegato, perché un ingresso “flottante” produce letture instabili.

Quando il cablaggio è pulito, il comportamento diventa prevedibile e il debug si riduce molto. A quel punto conviene passare subito allo sketch minimo, che è il modo più veloce per verificare se il segnale arriva davvero ad Arduino.

Lo sketch minimo per leggere il valore

Prima di controllare un LED o un motore, io faccio sempre una prova in seriale. È il test più onesto: se il valore cambia in modo fluido sul monitor seriale, il circuito è a posto. Se invece vedi numeri fermi, salti improvvisi o zone morte, il problema è quasi sempre nel cablaggio o nel componente.

const int potPin = A0;
int valore = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  valore = analogRead(potPin);
  Serial.println(valore);
  delay(50);
}

Con questo sketch apri il Monitor Seriale dell’IDE e ruoti la manopola: i valori devono scorrere da vicino a 0 fino a vicino a 1023. Io uso un ritardo breve, come delay(50), solo per rendere la lettura più leggibile. Se vuoi una risposta più rapida, puoi ridurlo ancora; se il rumore è evidente, puoi alzarlo oppure mediare più campioni.

Una precisazione utile: su alcune schede la risoluzione dell’ADC può essere diversa, quindi non dare per scontato che ogni Arduino lavori sempre sulla stessa scala. Se il progetto deve essere portabile, conviene verificare la risoluzione della scheda prima di fissare numeri in modo rigido. Da qui il passo naturale è usare quel valore per comandare qualcosa di visibile.

Come trasformare il valore in un comando utile

Il valore grezzo letto dal potenziometro serve poco se resta fermo nel Monitor Seriale. Il vero vantaggio arriva quando lo converti in un comportamento: intensità luminosa, velocità di un motore, angolo di un servo, soglia di attivazione o selezione di menu. In questo passaggio entrano in gioco due funzioni fondamentali: map(), che rimappa un intervallo su un altro, e analogWrite(), che genera un segnale PWM sui pin compatibili.

Regolare la luminosità di un LED

Per un LED la catena è quasi sempre questa: leggi il potenziometro, trasformi il valore da 0-1023 a 0-255 e invii il risultato a un pin PWM. Su molte schede classiche Arduino i pin PWM sono quelli marcati con il simbolo ~; sull’Uno, per esempio, i più usati sono 3, 5, 6, 9, 10 e 11.

const int potPin = A0;
const int ledPin = 9;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int valore = analogRead(potPin);
  int luminosita = map(valore, 0, 1023, 0, 255);
  analogWrite(ledPin, luminosita);
}

Questo è il classico progetto che chiarisce due concetti in una volta sola: il valore analogico in ingresso e il PWM in uscita. Io lo consiglio anche a chi vuole capire perché analogWrite() non sia una vera uscita analogica, ma una modulazione che simula il controllo della potenza media.

Leggi anche: Progetti Arduino facili e utili per partire bene

Usarlo per soglie, menu o servo

Lo stesso ingresso può diventare un selettore. Per esempio, puoi dividere la corsa in tre fasce e usarle come modalità, oppure convertire la scala in gradi per un servo. In questi casi il potenziometro è utile non solo come regolatore continuo, ma anche come interfaccia manuale semplice e robusta. Se il movimento deve essere davvero preciso, io preferisco evitare mapping troppo aggressivi e verificare sempre il limite alto e basso con constrain() quando serve.

In pratica, il punto non è “leggere un potenziometro”, ma decidere che ruolo avrà nel progetto: controllo continuo, soglia, selezione o calibrazione. Una volta capito questo, restano solo gli errori tipici da evitare, e qui si perde spesso più tempo del necessario.

Gli errori che falsano la lettura

Le letture instabili non dipendono quasi mai da un unico motivo. Nella maggior parte dei casi il problema è banale, ma un po’ nascosto. Io parto sempre da questi controlli, perché eliminano subito le cause più frequenti senza complicare il progetto.

• Pin sbagliato: il terminale centrale deve andare su un ingresso analogico, non su un pin digitale qualsiasi.
• Terminali esterni invertiti o scollegati: se manca uno dei due estremi, la scala non è più affidabile.
• Falso contatto sulla breadboard: basta una fila inserita male per introdurre rumore o letture ferme.
• Pin PWM sbagliato: se usi analogWrite() su un pin non PWM, l’effetto non sarà quello atteso.
• Valori troppo rumorosi: cavi lunghi, alimentazione instabile o potenziometro economico possono introdurre jitter.
• Aspettarsi un’uscita analogica vera: il PWM non è una tensione continua liscia, e questo cambia il comportamento di alcuni carichi.

Quando la lettura “balla”, io faccio sempre una prova semplice: leggo il valore nel monitor seriale e muovo il cursore molto lentamente. Se i salti compaiono solo in alcuni punti della corsa, il problema è spesso meccanico, non software. Se invece il valore resta irregolare ovunque, conviene controllare alimentazione, massa comune e contatti.

Una soluzione pratica, quando serve più stabilità, è prendere 5 o 10 letture consecutive e farne una media. Non è magia, ma spesso basta per rendere il controllo più fluido senza cambiare hardware. Da qui nasce un’altra domanda utile: quale potenziometro conviene comprare davvero?

Quando un potenziometro basta e quando conviene un’alternativa

Per i progetti con Arduino, il modello che consiglio più spesso è un lineare da 10 kΩ. È economico, facile da trovare e si comporta in modo prevedibile sulla breadboard. Un logaritmico può avere senso in applicazioni audio o dove vuoi una risposta percepita più naturale, ma per imparare e per i controlli generici il lineare è quasi sempre la scelta giusta.

Se il tuo obiettivo è solo leggere un ingresso e controllare qualcosa di semplice, non serve complicarsi la vita: un potenziometro lineare standard fa il suo lavoro molto bene. Se invece vuoi un comando senza fine corsa, per esempio per navigare menu o cambiare parametri in modo incrementale, allora un encoder rotativo diventa spesso più adatto. Io lo vedo così: il potenziometro è eccellente quando ti serve un valore assoluto, l’encoder quando ti serve un controllo relativo.

Per un progetto serio, la scelta migliore resta quasi sempre questa: potenziometro lineare da 10 kΩ, collegamento pulito, lettura in seriale prima di tutto e poi conversione del valore in una funzione utile. Se tieni fermi questi quattro passaggi, il resto diventa una questione di creatività e di logica applicata al microcontrollore.