Encoder rotativo con Arduino, come evitare click persi

8 novembre 2026

Collegamento di un encoder rotativo Arduino a una breadboard con cavi colorati.

Indice

Stai montando una manopola per regolare un menu o il volume e Arduino conta i click al contrario, oppure ne salta qualcuno? Un encoder rotativo incrementale di solito si collega con tre fili di segnale, ma la lettura corretta dipende da come il programma interpreta i due canali A e B.

Schema di collegamento per un encoder rotativo Arduino con motore passo-passo e driver ULN2003A.

Una lettura affidabile parte dai due canali, non dal numero di fili

  • CLK e DT indicano direzione e movimento tramite segnali in quadratura.
  • SW è il pulsante integrato: spesso si collega con INPUT_PULLUP.
  • Il conteggio per scatto cambia secondo l’encoder e il metodo di decodifica.
  • Polling basta per una manopola usata a mano; gli interrupt aiutano quando il loop è occupato o la rotazione è rapida.

Collega CLK, DT e SW senza confondere i segnali

Su un modulo comune come il KY-040 trovi cinque pin: GND, VCC, CLK, DT e SW. Per una prova con una scheda Arduino compatibile con logica a 5 V, collega GND a GND, VCC all’alimentazione prevista dal modulo, CLK e DT a due pin digitali e SW a un terzo pin.

CLK e DT sono i due canali dell’encoder. I loro livelli cambiano in sequenza: leggendo quale canale anticipa l’altro, il programma ricava il verso di rotazione. SW è invece l’interruttore premuto dall’albero; con INPUT_PULLUP risulta normalmente HIGH e diventa LOW quando premi.

Attenzione alla tensione: non dare per scontato che ogni scheda tolleri 5 V sugli ingressi. Con una scheda a 3,3 V, verifica le specifiche dei pin e del modulo prima di collegare VCC: se l’uscita può superare la tensione ammessa, serve un adattamento di livello.

Un conteggio per scatto non è garantito da ogni encoder

La manopola può fare uno scatto percepibile senza che il programma debba necessariamente contare una sola transizione elettrica. Scatto meccanico, impulso e conteggio software sono grandezze diverse: confonderle è una causa frequente di valori che avanzano a passi doppi o quadrupli.

Per esempio, la serie Bourns PEC11R include varianti con 12, 18 o 24 impulsi per giro; il numero di scatti dipende anche dalla variante scelta. La scheda tecnica distingue queste opzioni, quindi non conviene copiare un divisore trovato per il KY-040 senza controllare il modello effettivo.

Nel codice d’esempio qui sotto, ogni passaggio tra stati validi aggiunge o sottrae una transizione, mentre il valore visualizzato cambia dopo quattro transizioni coerenti. È una scelta adatta a molti encoder meccanici per manopole, ma il numero di transizioni per scatto va verificato sul componente: se la tua variante produce uno scatto ogni due passaggi, cambia la soglia.

Il polling è la scelta semplice per una manopola manuale

Se il programma si limita a leggere una manopola durante l’esecuzione di un menu, partirei dal polling: il ciclo principale controlla spesso CLK e DT senza aggiungere la gestione degli interrupt. È più facile da capire e da modificare, a patto che il loop non resti bloccato a lungo in attese o operazioni lente.

Questo esempio usa una tabella di transizioni per ignorare i cambi di stato non validi e accumulare quattro passaggi concordi prima di modificare il contatore. Se il verso appare invertito, scambia i fili CLK e DT oppure inverti il segno di position.

const byte pinCLK = 4;
const byte pinDT  = 5;

int lastState;
int transitions = 0;
long position = 0;

// Transizione da stato precedente a stato corrente.
// Gli stati sono codificati come CLK * 2 + DT.
const int8_t directionTable[16] = {
   0, -1,  1,  0,
   1,  0,  0, -1,
  -1,  0,  0,  1,
   0,  1, -1,  0
};

void setup() {
  pinMode(pinCLK, INPUT_PULLUP);
  pinMode(pinDT, INPUT_PULLUP);
  Serial.begin(9600);

  lastState = (digitalRead(pinCLK) << 1) | digitalRead(pinDT);
}

void loop() {
  int currentState = (digitalRead(pinCLK) << 1) | digitalRead(pinDT);

  if (currentState != lastState) {
    int index = (lastState << 2) | currentState;
    transitions += directionTable[index];
    lastState = currentState;

    if (transitions >= 4) {
      position++;
      transitions = 0;
      Serial.println(position);
    } else if (transitions <= -4) {
      position--;
      transitions = 0;
      Serial.println(position);
    }
  }
}

Il programma legge solo la posizione, non il pulsante SW: per aggiungerlo, configura il relativo pin con INPUT_PULLUP e controlla quando passa a LOW. Un pulsante meccanico può rimbalzare, quindi per rilevare una sola pressione serve un debounce, cioè un filtro temporale o logico che scarti le variazioni ravvicinate.

Usa gli interrupt quando il ciclo principale può perdere passaggi

Se il loop aggiorna uno schermo, comunica via seriale o esegue operazioni che lo tengono occupato, il polling può non leggere tutti i cambiamenti. In quel caso gli interrupt possono acquisire le transizioni mentre il programma svolge altro, ma la funzione associata deve restare molto breve.

Su Arduino UNO R3, gli interrupt esterni sono disponibili sui pin digitali 2 e 3. La documentazione di Arduino consiglia di convertire il pin con digitalPinToInterrupt(pin) e segnala che i pin disponibili cambiano tra schede; la variabile condivisa tra funzione di interrupt e programma principale va dichiarata volatile. Evita delay() e operazioni lunghe dentro la routine. La regola pratica è semplice: per una manopola lenta e un loop leggero, prova prima il polling; se perdi passi perché il programma è impegnato, passa agli interrupt o a una libreria di decodifica. Aggiungere interrupt a un sketch già leggero spesso complica il debug senza risolvere un problema reale.

Un conteggio instabile spesso segnala cablaggio o decodifica

Quando il valore salta, torna indietro o cresce troppo in fretta, sostituire subito l’encoder non è la prima mossa che consiglierei. Controlla prima i livelli logici, l’ordine dei fili e il modo in cui il codice conta le transizioni.

Situazione Possibile causa Cosa fare
Il valore diminuisce ruotando in senso orario Ordine di CLK e DT opposto a quello atteso Scambia CLK e DT oppure inverti il segno del conteggio.
Uno scatto aggiunge più unità Il programma conta ogni fronte come scatto completo Verifica la sequenza degli stati e calibra la soglia sul modello.
La rotazione produce salti casuali Rimbalzo dei contatti, cavi lunghi o letture perse Accorcia i collegamenti, controlla GND e prova una decodifica a stati.
Premendo SW il valore cambia più volte Rimbalzo del pulsante o ingresso lasciato flottante Usa INPUT_PULLUP e applica un debounce al pulsante.
La lettura si blocca durante altre operazioni Il loop trascorre troppo tempo senza controllare CLK e DT Riduci le attese oppure adotta interrupt o una libreria adatta.

La documentazione ufficiale di Arduino su attachInterrupt() chiarisce sia i limiti delle routine sia la differenza tra schede nella disponibilità dei pin. Prawdę mówiąc, credo che per la prima prova la tabella di transizioni sia più istruttiva di un semplice conteggio dei fronti: rende visibile quando il segnale segue una sequenza impossibile.

Fai una prova breve prima di collegare display e menu

Apri il monitor seriale, ruota lentamente la manopola in entrambi i sensi e verifica che il valore cambi di un passo per scatto. Poi prova una rotazione più rapida: se il conteggio diverge solo quando acceleri, il problema può dipendere dalla frequenza di lettura o dal debounce, non dal verso.

Se il contatore è coerente ma il menu avanza a passi inattesi, modifica la soglia delle transizioni prima di riscrivere tutta la logica. Per una manopola KY-040 destinata a un menu, sceglierei una lettura a stati e una soglia calibrata sul modulo; per un encoder di altro modello, partirei invece dalla scheda tecnica e misurerei gli scatti prima di fissare il conteggio.

Domande frequenti

Collega GND a GND, VCC all’alimentazione prevista dal modulo e CLK e DT a due pin digitali. SW va a un terzo pin e, configurato con INPUT_PULLUP, normalmente legge HIGH e passa a LOW quando premi. Con schede a 3,3 V verifica che le uscite non superino la tensione ammessa dagli ingressi.

Uno scatto meccanico non corrisponde necessariamente a una sola transizione elettrica: impulsi e conteggi software dipendono dal modello e dalla decodifica. L’esempio dell’articolo aggiorna la posizione ogni quattro transizioni coerenti, ma la soglia va verificata sul componente. Anche le varianti Bourns PEC11R possono avere 12, 18 o 24 impulsi per giro.

Per una manopola ruotata a mano e un loop leggero, il polling è semplice e spesso sufficiente. Se il programma resta occupato con aggiornamenti dello schermo, comunicazioni seriali o altre operazioni e perde passaggi, gli interrupt possono acquisire le transizioni mentre il loop svolge altro. La routine di interrupt deve essere breve e i pin disponibili dipendono dalla scheda; su Arduino UNO R3 gli interrupt esterni sono sui pin 2 e 3.

Se il conteggio aumenta nel verso sbagliato, scambia CLK e DT oppure inverti il segno della posizione nel codice. Per salti casuali, controlla GND e i collegamenti, accorciali se sono lunghi e usa una decodifica a stati che ignori le transizioni non valide. Se i problemi compaiono solo ruotando rapidamente, verifica anche che il programma legga abbastanza spesso i canali.

Valuta l'articolo

Valutazione: 0.00 Numero di voti: 0

Tag:

polling interrupt debounce encoder rotativi quadratura

Condividi post

Scrivi un commento