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.

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.