Il modulo KY-040 Rotary encoder fa parte della serie “37 In 1 Sensor Module Board Set Kit For Arduino“. Questo modulo dotato di encoder rotativo fornisce in dati digitali, secondo il codice Gray a 2bit , la rivoluzione in gradi e quindi la posizione angolare dell’asse dello stesso.
Indice
Come funziona l’encoder rotativo del modulo KY-040
Il KY-040 Rotary Encoder è un modulo molto diffuso nei progetti di elettronica e Arduino, utilizzato per rilevare la rotazione di una manopola e, in molti casi, anche la pressione del pulsante integrato.
A differenza dei potenziometri, l’encoder rotativo non misura una posizione assoluta, ma fornisce informazioni sul movimento: direzione e numero di scatti.
Encoder incrementale a due canali
Il cuore del KY-040 è un encoder rotativo incrementale basato su due interruttori.
Una volta l’interruttore collega il pin A (CLK) al pin C e l’altro switch collega il pin B (DT) a C.
Questo sfasamento, detto quadratura, è fondamentale per determinare:
- Il verso di rotazione (orario o antiorario)
- Il numero di scatti effettuati
Quando la manopola viene ruotata, i contatti interni si chiudono e si aprono in una sequenza precisa. Analizzando quale canale cambia stato per primo, il microcontrollore può capire la direzione della rotazione.
Utilizzi dell’encoder
L’encoder è facile da usare per regolazioni incrementali come:
- controllo del volume
- navigazione nei menu
- impostazione di valori numerici
Pulsante integrato
Oltre alla rotazione, il modulo KY-040 Rotary encoder include anche un pulsante attivabile premendo la manopola.
Il pulsante è elettricamente indipendente dall’encoder e viene normalmente collegato a un ingresso digitale separato, spesso utilizzato per confermare una selezione o cambiare modalità di funzionamento.
Segnali di uscita e collegamenti
Il modulo KY-040 Rotary encoder presenta solitamente 5 pin:
I segnali in uscita sono di tipo digitale e possono essere letti direttamente da un microcontrollore. Tuttavia, trattandosi di contatti meccanici, è comune dover gestire il rimbalzo (debounce) via software o hardware per ottenere letture stabili.
Differenze rispetto a un potenziometro
A differenza di un potenziometro:
- l’encoder può ruotare infinite volte
- non ha un valore minimo o massimo assoluto
- è ideale per interfacce utente e controlli incrementali
Descrizione del circuito del modulo KY-040 Rotary Encoder
Sotto è visibile lo schema elettrico tipico del modulo KY-040 Rotary Encoder che integra un encoder rotativo incrementale e un pulsante su una singola scheda, pronto per il collegamento a un microcontrollore.
Alimentazione e connettore
Il modulo utilizza un connettore a 5 pin (H1) che semplifica l’uso del modulo evitando cablaggi complessi.
La parte centrale del circuito è l’encoder rotativo meccanico (datasheet), costituito da tre terminali principali:
- A (CLK)
- B (DT)
- C (Common)
Il terminale C è collegato a GND e rappresenta il riferimento comune.
Abbiamo poi i pin 1 e 2 che fanno capo al pulsante momentaneo, elettricamente separato dalla parte rotativa.
Un terminale del pulsante è collegato a GND mentre l’altro è collegato al segnale SW
Gli “X” mostrati sotto l’encoder indicano contatti meccanici non utilizzati elettricamente.
Resistenze di pull-up
Nello schema troviamo tre resistenze, le prime due collegano i segnali CLK e DT a VCC, mantenendoli normalmente a livello logico HIGH.
R1 (10 kΩ) → pull-up del segnale CLK
R2 (10 kΩ) → pull-up del segnale DT
Quando il contatto interno dell’encoder si chiude, il segnale viene portato a GND (LOW).
In questo modo, i segnali sono stabili quando l’encoder è fermo e si evitano stati flottanti sugli ingressi del microcontrollore.
La terza resistenza R3 (10 kΩ) di pull-up collega SW a VCC e garantisce un segnale stabile e facilmente leggibile da un ingresso digitale.
- pulsante rilasciato → SW = HIGH
- pulsante premuto → SW = LOW
NOTA: non sempre questa resistenza è saldata sul PCB, nel caso si ovviare, attivando la resistenza interna Arduino tramite il comando pinMode(SW, INPUT_PULLUP)
Funzionamento complessivo del circuito
- Le resistenze R1, R2 e R3 assicurano segnali digitali definiti
- L’encoder genera impulsi su CLK e DT durante la rotazione
- Il pulsante fornisce un ingresso aggiuntivo per selezioni o conferme
- Tutti i segnali sono compatibili con ingressi digitali standard di Arduino e microcontrollori simili
NOTA: Poiché i contatti sono meccanici, i segnali possono presentare rimbalzi (bounce); spesso è necessario gestire il debounce via software.
Dove trovare il KY-040 Rotary encoder
Il modulo potrà essere trovato all’interno del Kit 37 Sensori per Arduino (codice HMTKITS) in vendita presso il sito Homotix. Inserire il codice sconto “ADRIROBOT” per ottenere uno sconto del 3%.
Il kit è anche disponibile anche presso il sito Futura Elettronica (codice 1606-SENSORKIT37).
  | 
|
Potrete trovare il Joystick anche presso il sito TechMaker codice SKU: CE482256.
Inserire nel carrello il codice sconto “ADRIROBOT” per ottenere uno sconto del 3%.
Sul sito Amazon tramite lo Store di AZDelivery link https://amzn.to/4q6nCmC
Sul sito Keyestudio con il codice KS0013
Alcuni esempi di utilizzo
Lettura dati su display
In questo primo esempio, l’Arduino Nano V3.0 con OLED integrato, gestisce la lettura dell’encoder e la visualizzazione delle informazioni sul display.
Il modulo KY-040 Rotary Encoder viene utilizzato per rilevare rotazioni e pressioni.
In alternativa si potrà utilizzare un normale Arduino Nano con un display OLED da 0,91″ con SSD1306 e risoluzione 128×32, il codice utilizzabile è lo stesso.
Componenti utilizzati
 Nano V3.0 con OLED integrato, |  Rotary encoder KY-040 (con pulsante integrato) |
|
Breadboard |  Cavetti di collegamento |
Collegamento del rotary encoder KY-040
| Pin KY-040 | Arduino | Descrizione |
|---|---|---|
| GND | GND | Massa comune |
| + | 5V Arduino | Alimentazione encoder |
| CLK | Pin D2 | Segnale di clock encoder |
| DT | Pin D3 | Segnale dati encoder |
| SW | Pin D4 | Pulsante integrato |
Codice utilizzato
Descrizione del programma, pensato per Nano con OLED integrato 0.91″
- legge un rotary encoder KY-040
- rileva direzione e conteggio delle rotazioni
- utilizza il pulsante SW per azzerare il contatore
- visualizza direzione e valore del contatore su un display OLED I2C
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | //==================================================== // KY-040 Rotary Encoder // Arduino Nano V3 con OLED integrato 0.91" 128x32 I2C //==================================================== #include <Wire.h> #include <Adafruit_SSD1306.h> // ---- Display OLED ---- #define SCREEN_WIDTH 128 #define SCREEN_HEIGHT 32 #define OLED_RESET 4 Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); // ---- Pin Encoder ---- #define CLK 2 #define DT 3 #define SW 4 // ---- Variabili Encoder ---- int counter = 0; int currentCLK; int previousCLK; const char* encdir = "----"; // ---- Debounce pulsante ---- unsigned long lastButtonTime = 0; const unsigned long debounceDelay = 200; //==================================================== void setup() { pinMode(CLK, INPUT); pinMode(DT, INPUT); pinMode(SW, INPUT_PULLUP); Serial.begin(9600); if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { for (;;) ; } display.clearDisplay(); display.display(); previousCLK = digitalRead(CLK); } //==================================================== void loop() { handleButton(); handleEncoder(); } //==================================================== void handleButton() { if (digitalRead(SW) == LOW) { if (millis() - lastButtonTime > debounceDelay) { counter = 0; encdir = "RESET"; showReset(); lastButtonTime = millis(); } } } //==================================================== void handleEncoder() { currentCLK = digitalRead(CLK); if (currentCLK != previousCLK) { if (digitalRead(DT) != currentCLK) { counter--; encdir = "Antiorario"; } else { counter++; encdir = "Orario"; } showData(); } previousCLK = currentCLK; } //==================================================== void showData() { display.clearDisplay(); display.setTextColor(SSD1306_WHITE); display.setTextSize(1); display.setCursor(0, 0); display.print("DIR: "); display.print(encdir); display.drawLine(0, 10, 127, 10, SSD1306_WHITE); display.setTextSize(2); display.setCursor(40, 14); display.print(counter); display.display(); } //==================================================== void showReset() { display.clearDisplay(); display.setTextColor(SSD1306_WHITE); display.setTextSize(2); display.setCursor(20, 0); display.print("RESET"); display.display(); } |
Gestione accensione led
In questo secondo esempio, il cui schema è visibile sotto , si utilizza un Arduino Nano per leggere il Rotary encoder KY-040 e comandare l’accensione progressiva di una barra LED a 8 segmenti.
Componenti utilizzati
 Arduino Nano | Rotary encoder KY-040 (con pulsante integrato) |
 Modulo LED Bar 8 bit – catodo comune |  Breadboard |
| Cavetti di collegamento |
Collegamento del rotary encoder KY-040
| Pin KY-040 | Arduino | Descrizione |
|---|---|---|
| GND | GND | Massa comune |
| + | 5V Arduino | Alimentazione encoder |
| CLK | Pin D2 | Segnale di clock encoder |
| DT | Pin D3 | Segnale dati encoder |
| SW | Pin D4 | Pulsante integrato |
Collegamento del modulo LED Bar 8 bit (catodo comune)
Il modulo LED Bar è composto da 8 LED con un catodo comune (COM). Ogni LED è pilotato singolarmente da un pin digitale di Arduino. Portando il pin digitale a livello HIGH, il LED corrispondente si accende grazie al catodo comune collegato a massa.
| LED Bar | Arduino Nano |
|---|---|
| LED D1 | Pin D12 |
| LED D2 | Pin D11 |
| LED D3 | Pin D10 |
| LED D4 | Pin D9 |
| LED D5 | Pin D8 |
| LED D6 | Pin D7 |
| LED D7 | Pin D6 |
| LED D8 | Pin D5 |
| COM | GND |
Codice utilizzato
Ruotando il rotary encoder, Arduino legge i segnali CLK e DT e in base al verso di rotazione:
- orario → aumenta il numero di LED accesi
- antiorario → diminuisce il numero di LED accesi
La barra LED fornisce quindi un feedback visivo immediato della posizione del rotary encoder.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 | // ---------------------------- // Pin Rotary Encoder // barra led con Arduino Nano // ---------------------------- #define CLK 2 #define DT 3 #define SW 4 // ---------------------------- // Pin LED Bar (8 LED) // ---------------------------- const byte ledPins[8] = {5, 6, 7, 8, 9, 10, 11, 12}; // Variabili int counter = 0; // Valore da 0 a 8 int lastStateCLK; unsigned long lastButtonTime = 0; void setup() { Serial.begin(9600); pinMode(CLK, INPUT_PULLUP); pinMode(DT, INPUT_PULLUP); pinMode(SW, INPUT_PULLUP); for (byte i = 0; i < 8; i++) { pinMode(ledPins[i], OUTPUT); digitalWrite(ledPins[i], LOW); } lastStateCLK = digitalRead(CLK); Serial.println("Rotary Encoder LED Bar Ready"); } void loop() { // ---- Lettura encoder ---- int currentStateCLK = digitalRead(CLK); if (currentStateCLK != lastStateCLK) { if (digitalRead(DT) != currentStateCLK) { counter++; } else { counter--; } if (counter < 0) counter = 0; if (counter > 8) counter = 8; updateLEDs(counter); Serial.print("Valore: "); Serial.println(counter); } lastStateCLK = currentStateCLK; // ---- Lettura pulsante ---- if (!digitalRead(SW)) { if (millis() - lastButtonTime > 250) { counter = 0; updateLEDs(counter); Serial.println("Reset tramite pulsante"); lastButtonTime = millis(); } } } // ---------------------------- // Accende i primi N led // ---------------------------- void updateLEDs(int value) { for (byte i = 0; i < 8; i++) { digitalWrite(ledPins[i], (i < value) ? HIGH : LOW); } } |
Conclusione
Il KY-040 Rotary encoder è un componente semplice ma molto potente, che consente di trasformare una rotazione meccanica in segnali digitali interpretabili da un microcontrollore. Grazie alla rilevazione della direzione, agli scatti meccanici e al pulsante integrato, è una soluzione economica e versatile per creare interfacce di controllo intuitive.
