💡 Arduino • LED • Pulsanti

Selezionare quale LED accendere con Arduino e due pulsanti

Usiamo due pulsanti per scorrere avanti e indietro tra tre LED, sfruttando le resistenze di pull-up interne di Arduino Uno.

DifficoltàFacile
Tempo15–20 minuti
Cosa impariINPUT_PULLUP e selezione LED
In poche parole: il pulsante SU seleziona il LED successivo, mentre il pulsante GIÙ torna al precedente. Quando si supera LED 3 si riparte da LED 1, e viceversa.

Perché usare le resistenze di pull-up interne

Un ingresso digitale lasciato scollegato può assumere valori casuali a causa dei disturbi elettrici presenti nell’ambiente. Per evitarlo serve una resistenza di pull-up o pull-down che mantenga il pin in uno stato definito.

Arduino Uno permette di attivare direttamente una resistenza di pull-up interna usando INPUT_PULLUP, evitando di aggiungere una resistenza esterna per ogni pulsante.

Logica invertita: con INPUT_PULLUP il pulsante rilasciato viene letto HIGH, mentre quando viene premuto e collega il pin a GND viene letto LOW.

Materiale necessario

🔌 Arduino Uno
💡 3 LED
Ω 3 resistenze da 220 Ω
🔘 2 pulsanti
🔗 Cavetti di collegamento
🧩 Breadboard

🧰 Kit Arduino consigliato

Un kit completo è utile per avere breadboard, cavetti, resistenze, LED, pulsanti e molti componenti di base per sperimentare con Arduino.

👉 Guarda il kit Arduino consigliato

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

📘 Vuoi imparare Arduino passo dopo passo?

Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino. All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.

👉 Scopri i miei libri su Arduino

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

Schema di collegamento

Schema Arduino tre LED due pulsanti

Schema con tre LED e due pulsanti collegati agli ingressi digitali.

Pin utilizzati

ElementoPin Arduino
Pulsante SUD2
Pulsante GIÙD3
LED 1D11
LED 2D12
LED 3D13

Codice Arduino commentato

Tre LED selezionabili con due pulsanti
/*
  SELEZIONE DI 3 LED CON DUE PULSANTI

  Pulsante SU   -> D2
  Pulsante GIÙ  -> D3

  LED 1 -> D11
  LED 2 -> D12
  LED 3 -> D13

  I pulsanti usano INPUT_PULLUP:
  - rilasciato = HIGH
  - premuto    = LOW

  Funzionamento:
  - SU scorre LED 1 -> LED 2 -> LED 3 -> LED 1
  - GIÙ scorre nella direzione opposta
  - resta acceso un solo LED alla volta
*/

const byte LED_1 = 11;
const byte LED_2 = 12;
const byte LED_3 = 13;

const byte BUTTON_UP   = 2;
const byte BUTTON_DOWN = 3;

// LED selezionato: valori da 1 a 3
byte ledSelezionato = 1;

// Stati precedenti per rilevare una sola pressione
bool ultimoUp = HIGH;
bool ultimoDown = HIGH;

// Debounce semplice
const unsigned long DEBOUNCE_MS = 40;
unsigned long ultimoCambioUp = 0;
unsigned long ultimoCambioDown = 0;

void setup() {

  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
  pinMode(LED_3, OUTPUT);

  // Attiva le resistenze di pull-up interne
  pinMode(BUTTON_UP, INPUT_PULLUP);
  pinMode(BUTTON_DOWN, INPUT_PULLUP);

  aggiornaLed();
}

void loop() {

  bool statoUp = digitalRead(BUTTON_UP);
  bool statoDown = digitalRead(BUTTON_DOWN);

  // ------------------------------------------------------
  // PULSANTE SU
  // ------------------------------------------------------
  if (statoUp != ultimoUp) {
    ultimoCambioUp = millis();
  }

  if ((millis() - ultimoCambioUp) > DEBOUNCE_MS) {

    // Rileva il fronte di pressione: HIGH -> LOW
    if (ultimoUp == HIGH && statoUp == LOW) {

      ledSelezionato++;

      if (ledSelezionato > 3) {
        ledSelezionato = 1;
      }

      aggiornaLed();
    }
  }

  // ------------------------------------------------------
  // PULSANTE GIÙ
  // ------------------------------------------------------
  if (statoDown != ultimoDown) {
    ultimoCambioDown = millis();
  }

  if ((millis() - ultimoCambioDown) > DEBOUNCE_MS) {

    if (ultimoDown == HIGH && statoDown == LOW) {

      if (ledSelezionato <= 1) {
        ledSelezionato = 3;
      } else {
        ledSelezionato--;
      }

      aggiornaLed();
    }
  }

  ultimoUp = statoUp;
  ultimoDown = statoDown;
}

// Accende soltanto il LED selezionato
void aggiornaLed() {

  digitalWrite(LED_1, ledSelezionato == 1 ? HIGH : LOW);
  digitalWrite(LED_2, ledSelezionato == 2 ? HIGH : LOW);
  digitalWrite(LED_3, ledSelezionato == 3 ? HIGH : LOW);
}

Come funziona lo sketch

1. La variabile di selezione

ledSelezionato contiene un valore da 1 a 3. Il valore indica quale LED deve essere acceso.

2. Pulsante SU

Ogni nuova pressione incrementa la selezione. Se il valore supera 3, viene riportato a 1.

3. Pulsante GIÙ

Il secondo pulsante decrementa la selezione. Se si scende sotto 1, il programma passa direttamente a 3.

4. Un solo LED alla volta

La funzione aggiornaLed() accende soltanto l’uscita corrispondente alla selezione e spegne le altre due.

Debounce dei pulsanti

Nel codice è presente anche un semplice filtro software da 40 ms. Serve a evitare che il rimbalzo meccanico di un pulsante venga interpretato come più pressioni consecutive.

Tempo di debounce
const unsigned long DEBOUNCE_MS = 40;

Perché INPUT_PULLUP è comodo

Con le resistenze interne attive il collegamento dei pulsanti si semplifica: ogni pulsante deve semplicemente mettere a massa il relativo ingresso quando viene premuto.

Questa tecnica è molto utile anche in progetti con menu, selettori, pulsanti di navigazione e pannelli di controllo.

Simulazione Tinkercad

▶️ Apri la simulazione Tinkercad

Scarica lo sketch

⬇️ Scarica arduino_3_led_2_pulsanti.ino

Usare dei relè al posto dei LED

La stessa logica può essere applicata a uscite differenti. Per esempio puoi sostituire i LED con ingressi di moduli relè e usare i due pulsanti per scegliere quale dispositivo attivare.

Attenzione: un relè non deve essere collegato direttamente al pin Arduino se non è montato su un modulo con transistor, diodo di protezione e circuito di pilotaggio adatto.

Debug rapido

  • se i pulsanti sembrano funzionare al contrario, ricorda che INPUT_PULLUP usa LOW quando sono premuti;
  • se un LED non si accende, verifica polarità e resistenza da 220 Ω;
  • se saltano più posizioni con una sola pressione, aumenta leggermente il debounce;
  • se l’ingresso cambia da solo, controlla che sia realmente configurato come INPUT_PULLUP;
  • se LED 3 resta acceso in modo inatteso, ricorda che D13 è anche collegato al LED integrato di Arduino Uno.

Varianti del progetto

  • aumentare il numero di LED;
  • usare un display per mostrare la selezione;
  • controllare relè invece dei LED;
  • aggiungere un terzo pulsante di conferma;
  • realizzare un semplice menu;
  • usare un encoder rotativo al posto dei due pulsanti;
  • memorizzare l’ultima selezione in EEPROM.

Cosa devi ricordare

  • I pulsanti sono collegati a D2 e D3.
  • I tre LED usano D11, D12 e D13.
  • INPUT_PULLUP elimina la necessità delle resistenze esterne sui pulsanti.
  • Con INPUT_PULLUP il pulsante premuto viene letto LOW.
  • La selezione scorre ciclicamente da 1 a 3.
  • Il debounce evita più cambi con una sola pressione.

Domande frequenti

Perché non servono resistenze da 10 kΩ sui pulsanti?

Perché Arduino attiva internamente la resistenza di pull-up tramite INPUT_PULLUP.

Posso aggiungere un quarto LED?

Sì. Devi aggiungere una nuova uscita, estendere il valore massimo della selezione a 4 e aggiornare la funzione che gestisce i LED.

Perché il pulsante premuto vale LOW?

Con INPUT_PULLUP il pin viene mantenuto internamente a HIGH; premendo il pulsante lo colleghi a GND e quindi viene letto LOW.

Posso usare questa logica per scegliere un relè?

Sì. La selezione funziona allo stesso modo, purché i relè vengano pilotati tramite moduli adeguati.