🎛 Arduino • PWM • Ingressi analogici

LED e potenziometro con Arduino: regolare la luminosità con PWM

Impariamo a leggere un potenziometro con Arduino e a trasformare il suo valore in un comando PWM per controllare in modo graduale la luminosità di un LED.

Difficoltà Principiante
Ingresso Potenziometro su A0
Uscita LED PWM su pin 9
In poche parole: Arduino legge la posizione del potenziometro con analogRead(), converte il valore da 0–1023 a 0–255 con map() e usa analogWrite() per regolare la luminosità del LED.

Cosa imparerai

Questo progetto è molto utile perché mette insieme tre concetti fondamentali della programmazione e dell’elettronica con Arduino:

  • come funziona un ingresso analogico;
  • come leggere un potenziometro con analogRead();
  • come convertire un intervallo di valori con map();
  • come controllare la luminosità di un LED tramite PWM;
  • la differenza tra un valore analogico letto e un’uscita PWM generata.

Come funziona il potenziometro

Un potenziometro è una resistenza variabile dotata normalmente di tre terminali. I due terminali esterni vengono collegati ai riferimenti di alimentazione, mentre il terminale centrale, chiamato cursore, restituisce una tensione che cambia mentre ruotiamo la manopola.

Collegando un estremo a 5 V, l’altro a GND e il cursore al pin A0, Arduino può misurare una tensione compresa indicativamente tra 0 e 5 V.

Concetto chiave: il potenziometro si comporta come un partitore di tensione regolabile. Arduino non legge direttamente “quanto è ruotata” la manopola: misura la tensione presente sul cursore e la converte in un numero.

Materiale necessario

🔌 Arduino Uno o compatibile
💡 1 LED
〰️ 1 resistenza da 220 Ω
🎛 1 potenziometro da 10 kΩ
🧩 Breadboard
🔗 Cavetti jumper

Kit Arduino consigliato

Se non possiedi ancora i componenti puoi utilizzare un kit Arduino completo con LED, resistenze, potenziometri, breadboard e altri moduli utili per realizzare molti progetti.

🛒 Guarda un kit Arduino su Amazon

Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.

Collegamenti del circuito

Componente Terminale Arduino
Potenziometro Estremo 1 5V
Potenziometro Cursore centrale A0
Potenziometro Estremo 2 GND
LED Anodo, tramite 220 Ω Pin 9
LED Catodo GND
Attenzione al LED: il terminale più lungo è normalmente l’anodo (+), mentre quello più corto è il catodo (−). La resistenza da 220 Ω limita la corrente che attraversa il LED.
Schema Arduino con LED e potenziometro per regolare la luminosità tramite PWM

Schema di collegamento di Arduino, potenziometro e LED.

Da 0–1023 a 0–255: perché servono due scale?

Quando Arduino Uno legge il potenziometro con analogRead(A0), ottiene un valore compreso tra 0 e 1023. Il comando analogWrite(), utilizzato nel progetto per il PWM, lavora invece con valori compresi tra 0 e 255.

Per questo utilizziamo la funzione map():

Conversione del valore
int brightness = map(potValue, 0, 1023, 0, 255);

In questo modo, alla posizione minima del potenziometro corrisponde circa un valore PWM pari a 0, mentre alla posizione massima corrisponde 255.

Lettura A0 Valore PWM circa LED
00Spento
25664Poco luminoso
512128Luminosità media
768191Molto luminoso
1023255Massima luminosità

Cos’è il PWM

PWM significa Pulse Width Modulation. Il pin digitale non genera una vera tensione analogica continua: viene acceso e spento molto rapidamente. Modificando la percentuale di tempo in cui il segnale rimane acceso, Arduino può controllare la potenza media fornita al carico.

Questa percentuale viene chiamata duty cycle. Con un duty cycle basso il LED appare poco luminoso; aumentando il duty cycle aumenta anche la luminosità percepita.

Perché non vediamo il LED lampeggiare? Il segnale PWM cambia stato abbastanza rapidamente da far percepire all’occhio una luminosità apparentemente continua.

Codice Arduino

LED e potenziometro
// Control LED brightness with a potentiometer

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

void setup() {

  // Set LED pin as output
  pinMode(ledPin, OUTPUT);

}

void loop() {

  // Read the potentiometer value
  int potValue = analogRead(potPin);

  // Convert the value (0-1023) to PWM range (0-255)
  int brightness = map(potValue, 0, 1023, 0, 255);

  // Set LED brightness
  analogWrite(ledPin, brightness);

}

Il codice spiegato passo passo

1

Definiamo i pin

ledPin identifica il pin PWM 9, mentre potPin identifica l’ingresso analogico A0.

2

Configuriamo il LED come uscita

Nel setup() impostiamo il pin 9 come uscita tramite pinMode(ledPin, OUTPUT).

3

Leggiamo il potenziometro

analogRead(potPin) restituisce la lettura dell’ingresso analogico, memorizzata nella variabile potValue.

4

Convertiamo il valore

map() trasforma l’intervallo 0–1023 nell’intervallo 0–255, più adatto al comando PWM utilizzato dal progetto.

5

Regoliamo la luminosità

analogWrite(ledPin, brightness) applica il valore PWM al pin 9 e modifica quindi la luminosità del LED.

Perché utilizziamo il pin 9?

Nel progetto il LED è collegato al pin 9 perché questo pin supporta il PWM sulla classica Arduino Uno. Se sposti il LED su un altro pin, assicurati che anche quel pin supporti il PWM.

Errore comune: collegare il LED a un normale pin digitale e aspettarsi una regolazione graduale della luminosità. In quel caso il LED potrà soltanto essere acceso o spento con il normale controllo digitale.

Come controllare i valori con il Monitor Seriale

Durante le prove può essere utile visualizzare il valore letto dal potenziometro. Puoi aggiungere temporaneamente il Monitor Seriale al progetto per capire se A0 varia correttamente.

Esempio di debug con Monitor Seriale
void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int potValue = analogRead(potPin);
  int brightness = map(potValue, 0, 1023, 0, 255);

  analogWrite(ledPin, brightness);

  Serial.print("Potenziometro: ");
  Serial.print(potValue);
  Serial.print("  PWM: ");
  Serial.println(brightness);

  delay(50);
}

Simulazione online

Puoi provare il circuito prima di montarlo realmente utilizzando la simulazione Tinkercad associata al progetto.

▶️ Apri la simulazione Tinkercad

Scarica lo sketch

Puoi anche scaricare direttamente il file Arduino originale del progetto.

⬇️ Scarica led_e_potenziometro.ino

Debug rapido

  • controlla che il cursore centrale del potenziometro sia collegato ad A0;
  • verifica che gli altri due terminali siano collegati a 5V e GND;
  • controlla la polarità del LED;
  • verifica la resistenza da 220 Ω;
  • assicurati che il LED sia collegato al pin PWM 9;
  • usa il Monitor Seriale per verificare che potValue cambi ruotando la manopola.

Varianti del progetto

Una volta capito il principio puoi riutilizzarlo per molte altre applicazioni:

  • controllare la luminosità di più LED;
  • regolare i canali di un LED RGB;
  • impostare la velocità di un motore DC tramite un circuito di pilotaggio adatto;
  • utilizzare il potenziometro come comando per un servomotore;
  • visualizzare il valore su un display LCD o OLED;
  • creare un semplice pannello di controllo analogico per altri progetti.

Cosa devi ricordare

  • Il potenziometro produce una tensione variabile sul cursore centrale.
  • Arduino legge il valore sul pin A0 tramite analogRead().
  • La lettura analogica viene convertita nell’intervallo PWM con map().
  • analogWrite() controlla il duty cycle del segnale PWM.
  • Per regolare la luminosità il LED deve essere collegato a un pin PWM.

Domande frequenti

Perché il LED non cambia luminosità?

Controlla che il LED sia collegato al pin PWM 9 e verifica che il terminale centrale del potenziometro sia collegato ad A0.

Posso usare un potenziometro con un valore diverso da 10 kΩ?

Per questo tutorial il progetto originale utilizza un potenziometro da 10 kΩ. Se vuoi mantenere esattamente lo schema proposto, usa quel valore.

analogWrite() genera una vera tensione analogica?

Nel progetto con Arduino Uno viene utilizzato un segnale PWM: il pin cambia rapidamente tra stato alto e basso e la luminosità percepita dipende dal duty cycle.

Perché il valore massimo letto è 1023?

Nel progetto la lettura analogica viene rappresentata nell’intervallo 0–1023; questo valore viene poi convertito in 0–255 per il comando PWM.