Rotary encoder met Arduino: KY-040 aansluiten, interrupts en menucode
Een rotary encoder gebruiken met Arduino: KY-040 aansluiten, A/B-kwadratuurdecodering, interrupts zonder gemiste stappen, contactdender, LCD-menu, ESP32 PCNT en Pico.
Een rotary encoder is een digitale draaiknop voor Arduino-projecten die eindeloos doordraait, per klik één stap telt en als drukknop werkt wanneer je op de as drukt. Aangesloten op een Arduino gedraagt een rotary encoder zich als de menuknop van een 3D-printer, het afstelwieltje van een oscilloscoop of de volumeknop in een auto: hij weet hoeveel klikken je hebt gedraaid en in welke richting, en hij loopt nooit tegen een eindaanslag aan. Het model dat je in de meeste hobbysets vindt, is de vijfpins KY-040-module.
In deze gids leer je hoe de KY-040 verschilt van een potmeter, hoe de richting wordt gedecodeerd uit de A- en B-fasen (kwadratuur), hoe je contactdender filtert in hardware en software en hoe je elke klik telt met interrupts. Daarna bouwen we stap voor stap de snelle route met de Encoder-bibliotheek, menunavigatie op een LCD en een OLED, de hardwareteller PCNT van de ESP32 en MicroPython-code voor de Raspberry Pi Pico.
Wat is een rotary encoder en hoe werkt hij?
In een mechanische encoder zoals de KY-040 zit een getande contactschijf die met de as meedraait en twee kleine schakelaars die erover glijden. Terwijl de as draait, gaan de twee schakelaars na elkaar open en dicht, waardoor er blokgolfpulsen ontstaan op de pinnen CLK (A) en DT (B). De twee golven zijn een kwart periode verschoven, oftewel 90 graden; dit heet een kwadratuursignaal. De microcontroller bepaalt de richting door te kijken welke golf eerst verandert, en de hoeveelheid draaiing door de veranderingen te tellen. De encoder onthoudt zijn positie niet, hij meldt alleen beweging. Daarom is de KY-040 een incrementele encoder: de positie is nul bij het opstarten en het tellen is volledig aan jouw code.
| Eigenschap | Waarde KY-040 |
|---|---|
| Type | Mechanisch, incrementeel, A/B-uitgangen |
| Rastpunten | 20 klikken per omwenteling (30 bij sommige encoders) |
| Pulsen | 20 volledige A/B-cycli per omwenteling, dus 80 flanken |
| Hoekresolutie | 18 graden per klik |
| Pinnen | CLK (A), DT (B), SW (knop), + (voeding), GND |
| Voeding | 3,3–5 V (voedt alleen de pull-upweerstanden) |
| Ingebouwde weerstanden | 10 kΩ pull-ups op CLK en DT; de SW-weerstand zit niet op elke module |
| Knop | Normaal open; als je op de as drukt, wordt SW verbonden met GND (actief LAAG) |
| Draaiing | Onbeperkt, geen eindaanslag |
Rotary encoder versus potmeter: wat is het verschil?
Op het eerste gezicht lijkt een encoder veel op een potmeter: beide hebben een draaiende as en beide gebruik je om een waarde aan te passen. Maar ze werken totaal anders. Een potmeter is een spanningsdeler; hij geeft een analoge spanning tussen 0 en 5 V af, afhankelijk van de asstand, en je leest hem uit met analogRead. Een encoder geeft in plaats van een spanning pulsen; hij vertelt je over verandering, niet over positie.

| Eigenschap | Potmeter | Rotary encoder (KY-040) |
|---|---|---|
| Draaiing | Ongeveer 270–300 graden, beperkt | Onbeperkt, continu 360 graden |
| Uitgang | Analoge spanning (0–5 V) | Digitale pulsen (A en B) |
| Uitlezen | analogRead (ADC) | digitalRead of tellen met interrupts |
| Positie | Absoluut; de asstand geeft de waarde, ook na een stroomonderbreking | Relatief; de positie is onbekend bij het opstarten |
| Klikgevoel | Geen, draait soepel | Ja, meestal 20 klikken per omwenteling |
| Knop | Nee | Ja (druk op de as) |
| Typisch probleem | Gekraak en waarden die na verloop van tijd wegdrijven | Contactdender (opgelost in software) |
| Typisch gebruik | Volume, servohoek, analoge afstelling | Menunavigatie, numerieke instellingen in stappen, apparaatpanelen |
Kortom: als de waarde één op één moet overeenkomen met de fysieke asstand (een servoarm met de hand sturen of een eenvoudige volumeregeling), is een potmeter simpeler. Wil je door een menu navigeren, een getal in precieze stappen verhogen en verlagen, meerdere instellingen met één knop wijzigen of de waarde ook vanuit software aanpassen, dan is een encoder veel flexibeler. Als bijvoorbeeld een waarde van 50 vanaf je telefoon op 80 wordt gezet, draai je met de encoder gewoon verder vanaf 80; bij een potmeter komen de knopstand en de waarde op het scherm niet meer overeen.
A- en B-fasen: hoe kwadratuurdecodering werkt
Wanneer de KY-040 in een rastpunt rust, zijn beide schakelaars open en lezen CLK en DT dankzij de pull-upweerstanden allebei HIGH (1). Als je de knop één klik draait, gaan de twee lijnen na elkaar naar LOW en daarna na elkaar terug naar HIGH. Met de klok mee daalt CLK eerst; tegen de klok in daalt DT eerst. Deze reeks van vier toestanden is een Gray-code: bij elke stap verandert maar één bit. In de tabel hieronder zie je wat de twee pinnen lezen tijdens één klik beweging:
| Stap | Met de klok mee (CLK, DT) | Tegen de klok in (CLK, DT) |
|---|---|---|
| Rustend in een rastpunt | 1, 1 | 1, 1 |
| 1e overgang | 0, 1 | 1, 0 |
| 2e overgang | 0, 0 | 0, 0 |
| 3e overgang | 1, 0 | 0, 1 |
| 4e overgang (volgende klik) | 1, 1 | 1, 1 |
Uit de tabel volgen twee simpele regels. Eén: als DT nog HIGH is wanneer CLK daalt, draait de knop met de klok mee; als DT al LOW is, draait hij tegen de klok in. Twee: één klik heeft vier overgangen, dus 20 klikken per omwenteling betekent 80 overgangen. Simpele code gebruikt alleen de eerste regel en telt één keer per klik. Robuuste code volgt alle vier de overgangen, zodat hij dender of half afgemaakte bewegingen kan wegfilteren. Welke richting als met de klok mee geldt, kan verschillen per module en bedrading; loopt je teller de verkeerde kant op, verwissel dan gewoon de CLK- en DT-pinnen in de code.
KY-040-pinout en bedrading
| KY-040-pin | Functie | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| CLK | Fase A | D2 | GPIO 25 | GP16 |
| DT | Fase B | D3 | GPIO 26 | GP17 |
| SW | Knop (LOW als ingedrukt) | D4 | GPIO 27 | GP18 |
| + | Voeding | 5V | 3V3 | 3V3(OUT) |
| GND | Massa | GND | GND | GND |
Op de Arduino Uno en Nano zijn hardware-interrupts alleen beschikbaar op de pinnen D2 en D3, dus CLK en DT sluit je het best op die twee pinnen aan. Op de Mega zijn de interruptpinnen 2, 3, 18, 19, 20 en 21; op de Leonardo 0, 1, 2, 3 en 7. Op de ESP32 en Pico kan bijna elke GPIO een interrupt activeren. De pinindeling van je board kun je bekijken in de tool Pinout. Gebruik in je code INPUT_PULLUP voor de SW-pin: sommige modules hebben geen weerstand op deze lijn, en een zwevende pin leest alsof hij willekeurig wordt ingedrukt. Op de ESP32 zijn GPIO 34–39 alleen ingang en hebben ze geen interne pull-up, dus gebruik ze niet voor SW.
Eerste test stap voor stap: uitlezen met polling
- Sluit de CLK-pin van de KY-040 aan op D2, DT op D3 en SW op D4.
- Sluit de +-pin aan op 5V en GND op de GND van de Arduino.
- Plak de onderstaande code in de Arduino IDE en upload hem naar het board.
- Open de Serial Monitor en stel de snelheid in op 115200 baud.
- Draai de knop een paar klikken in beide richtingen en druk dan op de as om de teller te resetten.
1// KY-040: CLK -> D2, DT -> D3, SW -> D4, + -> 5V, GND -> GND
2const byte PIN_CLK = 2;
3const byte PIN_DT = 3;
4const byte PIN_SW = 4;
5
6int counter = 0;
7int lastClk;
8
9void setup() {
10 pinMode(PIN_CLK, INPUT_PULLUP); // modülde 10k pull-up zaten var / the module already has 10k pull-ups
11 pinMode(PIN_DT, INPUT_PULLUP);
12 pinMode(PIN_SW, INPUT_PULLUP); // basınca LOW okunur / reads LOW when pressed
13 Serial.begin(115200);
14 lastClk = digitalRead(PIN_CLK);
15}
16
17void loop() {
18 int clk = digitalRead(PIN_CLK);
19 if (clk != lastClk && clk == LOW) { // CLK düşen kenar / CLK falling edge
20 if (digitalRead(PIN_DT) == HIGH) { // DT hâlâ HIGH: saat yönü / DT still HIGH: clockwise
21 counter++;
22 Serial.print("CW ");
23 } else { // DT zaten LOW: ters yön / DT already LOW: counter-clockwise
24 counter--;
25 Serial.print("CCW ");
26 }
27 Serial.println(counter);
28 }
29 lastClk = clk;
30
31 if (digitalRead(PIN_SW) == LOW) { // mile basıldı / shaft pressed
32 delay(20); // buton sıçramasını bekle / wait out the button bounce
33 if (digitalRead(PIN_SW) == LOW) {
34 counter = 0;
35 Serial.println("Sifirlandi / reset");
36 while (digitalRead(PIN_SW) == LOW) {} // bırakılmasını bekle / wait for release
37 }
38 }
39}Bij elke ronde door loop leest de code CLK en vangt alleen het moment waarop CLK van HIGH naar LOW valt. Is DT op dat moment nog HIGH, dan is de knop met de klok mee gedraaid; is DT LOW, dan tegen de klok in. Dit is de makkelijkst te begrijpen methode, maar hij heeft twee zwakke punten. Ten eerste worden pulsen die binnenkomen terwijl loop met ander werk bezig is (een display bijwerken, delay, sensoren uitlezen) gemist, en de teller loopt achter als je snel draait. Ten tweede dendert het mechanische contact: CLK kan meerdere keren LOW-HIGH gaan terwijl hij één keer daalt, en de code kan één klik als twee of drie tellen. De volgende twee paragrafen lossen beide problemen op.
Contactdender (debounce): oplossingen in hardware en software
De metalen veertjes in de encoder stuiteren een paar keer als ze het contact raken voordat ze tot rust komen. In datasheets van fabrikanten staat deze tijd meestal als enkele milliseconden (bijvoorbeeld maximaal 2 ms). Bij drukknoppen los je dender op met "wacht 20–50 ms na de laatste verandering", maar dat werkt niet voor een encoder: bij snel draaien zitten er maar enkele milliseconden tussen twee flanken, en een lange wachttijd slokt ook echte stappen op. In plaats daarvan gebruik je deze methoden:
- Hardwarefilter: Plaats een condensator van 10–100 nF tussen CLK en GND en nog een tussen DT en GND. Samen met de pull-ups van 10 kΩ van de module vormen ze een RC-filter; de tijdconstante ligt tussen 10 kΩ × 10 nF = 0,1 ms en 10 kΩ × 100 nF = 1 ms, wat korte dender wegfiltert. Je kunt dit berekenen met de tool RC-tijdconstante en een condensator met opdruk 103 of 104 ontcijferen met de tool condensatorcode.
- Toestandstabel: Bij elke flank van beide lijnen worden de oude en nieuwe AB-toestand vergeleken. Dender betekent heen en weer springen tussen dezelfde twee toestanden, wat afwisselend +1 en −1 oplevert, en die heffen elkaar op. Overgangen waarbij beide bits tegelijk veranderen worden als ongeldig beschouwd en overgeslagen.
- Alleen beslissen bij een rastpunt: Kwartstappen worden opgeteld en de teller wordt pas verhoogd of verlaagd wanneer de encoder in een rastpunt tot rust komt (beide lijnen HIGH). Zo laat een contact dat op een klik trilt de menucursor niet springen.
- Blokkeertijd voor de knop: De SW-pin gedraagt zich als een gewone drukknop; een blokkeertijd van 30 ms met millis() is genoeg.
Uitlezen met interrupts zodat je nooit een stap mist
Een interrupt laat de processor ophouden met waar hij mee bezig is zodra een pin verandert, en een korte functie (ISR) uitvoeren. Als de encoderlijnen aan interrupts hangen, gaat er geen flank verloren, ook niet als loop een delay van 50 ms bevat of het display traag bijwerkt. De onderstaande code draait op beide flanken van CLK en DT, gebruikt de hierboven beschreven toestandstabel en telt alleen als de knop in een rastpunt tot rust komt. Voor de basis kun je ook het artikel Arduino-interrupt lezen.
1// KY-040: CLK -> D2 (INT0), DT -> D3 (INT1), SW -> D4, + -> 5V
2const byte PIN_CLK = 2;
3const byte PIN_DT = 3;
4const byte PIN_SW = 4;
5
6// İndeks: (eski AB << 2) | yeni AB / Index: (old AB << 2) | new AB
7const int8_t QEM[16] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};
8
9volatile long position = 0; // tık sayısı, ISR ile loop paylaşır / detent count shared by ISR and loop
10uint8_t lastAB = 3; // son durum, 3 = ikisi de HIGH / last state, 3 = both HIGH
11int8_t quarter = 0; // iki tık arası çeyrek adımlar / quarter steps between detents
12
13void readEncoder() {
14 uint8_t ab = (digitalRead(PIN_CLK) << 1) | digitalRead(PIN_DT);
15 quarter += QEM[(lastAB << 2) | ab];
16 lastAB = ab;
17 if (ab == 3) { // tıka oturdu / settled in a detent
18 if (quarter > 1) position++; // saat yönü / clockwise
19 else if (quarter < -1) position--; // ters yön / counter-clockwise
20 quarter = 0;
21 }
22}
23
24bool buttonPressed() {
25 static bool lastState = HIGH;
26 static unsigned long lastChange = 0;
27 bool state = digitalRead(PIN_SW);
28 if (state != lastState && millis() - lastChange > 30) { // 30 ms kilit / 30 ms lockout
29 lastChange = millis();
30 lastState = state;
31 return state == LOW; // yalnızca basış anı / only the moment of pressing
32 }
33 return false;
34}
35
36void setup() {
37 pinMode(PIN_CLK, INPUT_PULLUP);
38 pinMode(PIN_DT, INPUT_PULLUP);
39 pinMode(PIN_SW, INPUT_PULLUP);
40 Serial.begin(115200);
41 lastAB = (digitalRead(PIN_CLK) << 1) | digitalRead(PIN_DT);
42 attachInterrupt(digitalPinToInterrupt(PIN_CLK), readEncoder, CHANGE); // her iki kenar / both edges
43 attachInterrupt(digitalPinToInterrupt(PIN_DT), readEncoder, CHANGE);
44}
45
46long lastPosition = 0;
47
48void loop() {
49 noInterrupts(); // 4 baytı güvenle kopyala / copy the 4 bytes safely
50 long pos = position;
51 interrupts();
52
53 if (pos != lastPosition) {
54 Serial.print(pos > lastPosition ? "CW " : "CCW ");
55 Serial.println(pos);
56 lastPosition = pos;
57 }
58
59 if (buttonPressed()) {
60 noInterrupts();
61 position = 0;
62 interrupts();
63 Serial.println("Sifirlandi / reset");
64 }
65
66 delay(50); // loop yavaş olsa da tık kaçmaz / no detent is lost even with a slow loop
67}| Codedeel | Wat doet het? |
|---|---|
| QEM[16]-tabel | Zet de oude en nieuwe AB-toestand om in +1, −1 of 0; ongeldige overgangen waarbij beide lijnen tegelijk veranderen tellen als 0 |
| attachInterrupt(..., CHANGE) | Voert readEncoder() uit op zowel de stijgende als de dalende flanken van CLK en DT |
| quarter | Telt de kwartstappen tussen twee klikken op; paren +1 en −1 door dender heffen elkaar op |
| if (ab == 3) | De beslissing wordt alleen genomen wanneer de encoder in een rastpunt tot rust komt (beide lijnen HIGH); een opgetelde waarde van +2 of meer telt als één klik |
| volatile long position | De variabele die ISR en loop delen; volatile voorkomt dat de compiler een verouderde kopie gebruikt |
| noInterrupts() / interrupts() | Voorkomt dat de ISR ertussen komt terwijl de 4-byte long wordt gekopieerd |
| buttonPressed() | Filtert SW met een blokkeertijd van 30 ms en geeft slechts één keer true terug, op het moment van indrukken |
De snelle route: de Encoder-bibliotheek
Als je geen eigen ISR wilt schrijven, doet de Encoder-bibliotheek van Paul Stoffregen hetzelfde werk met geoptimaliseerde code. Open de Library Manager in de Arduino IDE, zoek naar "Encoder" en installeer de bibliotheek van Paul Stoffregen; voor de installatiestappen kijk je in de gids een Arduino-bibliotheek toevoegen. De bibliotheek presteert het best als beide pinnen interruptpinnen zijn, goed als alleen de eerste pin die je aan de constructor meegeeft dat is, en slecht als geen van beide dat is. Omdat hij elke flank telt, verandert de waarde met 4 per klik; deel door 4 om het aantal klikken te krijgen.
1#include <Encoder.h>
2
3// Önce DT (3), sonra CLK (2): saat yönü artı sayılır / DT (3) first, then CLK (2): clockwise counts up
4Encoder knob(3, 2);
5const byte PIN_SW = 4;
6long lastDetent = 0;
7
8void setup() {
9 pinMode(PIN_SW, INPUT_PULLUP);
10 Serial.begin(115200);
11}
12
13void loop() {
14 long detent = knob.read() / 4; // 4 kenar = 1 tık / 4 edges = 1 detent
15 if (detent != lastDetent) {
16 lastDetent = detent;
17 Serial.println(detent);
18 }
19 if (digitalRead(PIN_SW) == LOW) { // basınca sıfırla / reset on press
20 knob.write(0);
21 }
22}read() geeft het totale aantal flanken tot nu toe terug, write(0) reset de teller en readAndReset() leest en reset in één keer. We geven DT eerst en CLK als tweede aan de constructor mee vanwege het teken van de richting: in deze volgorde telt met de klok mee als positief. Is het bij jou omgekeerd, verwissel dan 2 en 3. De bibliotheek schakelt de interne pull-upweerstanden van de pinnen ook zelf in.
Menunavigatie met een rotary encoder op een LCD

Menu's zijn de plek waar encoders het meest worden gebruikt: je draait aan de knop om tussen regels te bewegen, drukt erop om de gekozen instelling in bewerkmodus te zetten, draait om de waarde te wijzigen en drukt nog eens om terug te keren naar het menu. Het onderstaande voorbeeld stelt de rode, groene en blauwe kanalen van een RGB-led in tussen 0 en 255 en toont de waarden op een I2C LCD-display. Sluit de LCD aan op A4 (SDA) en A5 (SCL), en de kleurpootjes van een RGB-led met gemeenschappelijke kathode via weerstanden van 220 Ω op D9, D10 en D11.
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2); // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
5
6const byte PIN_CLK = 2, PIN_DT = 3, PIN_SW = 4;
7const byte COUNT = 3;
8const byte LED_PINS[COUNT] = {9, 10, 11}; // RGB LED, PWM pinleri / PWM pins
9const char* NAMES[COUNT] = {"Kirmizi/Red", "Yesil/Green", "Mavi/Blue"};
10int values[COUNT] = {0, 0, 0}; // 0-255 parlaklık / brightness
11
12const int8_t QEM[16] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};
13volatile int steps = 0; // loop'un işlemediği tıklar / detents not yet handled by loop
14uint8_t lastAB = 3;
15int8_t quarter = 0;
16
17int selected = 0; // seçili satır / selected item
18bool editing = false; // değer düzenleme modu / value edit mode
19
20void readEncoder() {
21 uint8_t ab = (digitalRead(PIN_CLK) << 1) | digitalRead(PIN_DT);
22 quarter += QEM[(lastAB << 2) | ab];
23 lastAB = ab;
24 if (ab == 3) {
25 if (quarter > 1) steps++;
26 else if (quarter < -1) steps--;
27 quarter = 0;
28 }
29}
30
31bool buttonPressed() {
32 static bool lastState = HIGH;
33 static unsigned long lastChange = 0;
34 bool state = digitalRead(PIN_SW);
35 if (state != lastState && millis() - lastChange > 30) {
36 lastChange = millis();
37 lastState = state;
38 return state == LOW;
39 }
40 return false;
41}
42
43void drawMenu() {
44 int top = selected > COUNT - 2 ? COUNT - 2 : selected; // görünen ilk satır / first visible row
45 for (byte row = 0; row < 2; row++) {
46 int i = top + row;
47 char mark = ' ';
48 if (i == selected) mark = editing ? '*' : '>';
49 char line[17];
50 snprintf(line, sizeof(line), "%c%-11s%4d", mark, NAMES[i], values[i]);
51 lcd.setCursor(0, row);
52 lcd.print(line);
53 }
54}
55
56void setup() {
57 pinMode(PIN_CLK, INPUT_PULLUP);
58 pinMode(PIN_DT, INPUT_PULLUP);
59 pinMode(PIN_SW, INPUT_PULLUP);
60 for (byte i = 0; i < COUNT; i++) pinMode(LED_PINS[i], OUTPUT);
61 lcd.init();
62 lcd.backlight();
63 lastAB = (digitalRead(PIN_CLK) << 1) | digitalRead(PIN_DT);
64 attachInterrupt(digitalPinToInterrupt(PIN_CLK), readEncoder, CHANGE);
65 attachInterrupt(digitalPinToInterrupt(PIN_DT), readEncoder, CHANGE);
66 drawMenu();
67}
68
69void loop() {
70 noInterrupts();
71 int s = steps; // biriken tıkları al / take the pending detents
72 steps = 0;
73 interrupts();
74
75 if (s != 0) {
76 if (editing) {
77 values[selected] = constrain(values[selected] + s * 5, 0, 255); // tık başına 5 / 5 per detent
78 analogWrite(LED_PINS[selected], values[selected]);
79 } else {
80 selected = constrain(selected + s, 0, COUNT - 1);
81 }
82 drawMenu();
83 }
84
85 if (buttonPressed()) { // bas: düzenle ya da bitir / press: edit or finish
86 editing = !editing;
87 drawMenu();
88 }
89}Aan het begin van de geselecteerde regel verschijnt een >-teken, en in bewerkmodus een *-teken. De encodercode is dezelfde als in het vorige voorbeeld; het enige verschil is dat de ISR het aantal onverwerkte klikken (steps) optelt in plaats van een positie, en loop het uitleest en wist. Ook als loop een tijdje bezig blijft, gaat er dus geen klik verloren; de opgetelde klikken worden samen verwerkt in de volgende ronde. In bewerkmodus verandert elke klik de waarde met 5; voor fijnere regeling kun je de stap verkleinen naar 1 of versnelling toevoegen die de stap vergroot als je snel draait.
Om hetzelfde menu op een OLED-display te tonen, hoef je alleen de functie drawMenu() te wijzigen. De onderstaande versie tekent de geselecteerde regel in omgekeerde kleuren op een witte balk. Voeg de bibliotheken Adafruit SSD1306 en Adafruit GFX toe in plaats van de LCD-bibliotheek, verwijder het lcd-object en roep in setup() display.begin() aan in plaats van lcd.init().
1// LCD menü kodunda değişecek kısımlar / parts to change in the LCD menu sketch
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4
5Adafruit_SSD1306 display(128, 64, &Wire, -1);
6// setup() içinde lcd.init() ve lcd.backlight() yerine / in setup() instead of lcd.init() and lcd.backlight():
7// display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
8
9void drawMenu() {
10 display.clearDisplay();
11 display.setTextSize(1);
12 for (byte i = 0; i < COUNT; i++) {
13 int y = i * 16;
14 if (i == selected) {
15 display.fillRect(0, y, 128, 14, SSD1306_WHITE); // seçili satır çubuğu / highlight bar
16 display.setTextColor(SSD1306_BLACK);
17 } else {
18 display.setTextColor(SSD1306_WHITE);
19 }
20 display.setCursor(4, y + 3);
21 display.print(NAMES[i]);
22 display.setCursor(98, y + 3);
23 display.print(values[i]);
24 if (i == selected && editing) display.print('*'); // düzenleme işareti / edit marker
25 }
26 display.display();
27}Rotary encoder met de ESP32: de hardwareteller PCNT
De ESP32 heeft een hardwareblok genaamd PCNT (Pulse Counter) dat pulsen telt zonder de processor bezig te houden. Elke eenheid heeft twee kanalen, zodat hij het A/B-signaal direct kan decoderen; de klassieke ESP32 heeft 8 PCNT-eenheden, de ESP32-S2 en S3 hebben er 4. De teller is 16 bits breed en bevat een glitchfilter dat korte ruis verwijdert. Dit filter kan worden ingesteld op maximaal ongeveer 12,8 microseconden, dus het slokt alleen zeer korte pieken op, niet de hele contactdender. Tellen op vier flanken vangt de rest van de dender zelf op: heen-en-weer-dender heft elkaar op als +1 en −1. De onderstaande code gebruikt de ESP-IDF-driver die bij versie 3.x van de Arduino ESP32-core hoort.
1#include "driver/pulse_cnt.h"
2#include "driver/gpio.h"
3
4// KY-040: CLK -> GPIO 25, DT -> GPIO 26, SW -> GPIO 27, + -> 3V3
5const int PIN_CLK = 25;
6const int PIN_DT = 26;
7const int PIN_SW = 27;
8
9pcnt_unit_handle_t unit = NULL;
10
11void setup() {
12 Serial.begin(115200);
13 pinMode(PIN_SW, INPUT_PULLUP);
14
15 pcnt_unit_config_t unitCfg = {};
16 unitCfg.low_limit = -10000; // sınıra varınca sayaç 0'a döner / the counter returns to 0 at a limit
17 unitCfg.high_limit = 10000;
18 ESP_ERROR_CHECK(pcnt_new_unit(&unitCfg, &unit));
19
20 pcnt_glitch_filter_config_t filterCfg = {};
21 filterCfg.max_glitch_ns = 1000; // 1 µs'den kısa iğneleri yok say / ignore spikes shorter than 1 µs
22 ESP_ERROR_CHECK(pcnt_unit_set_glitch_filter(unit, &filterCfg));
23
24 pcnt_chan_config_t aCfg = {};
25 aCfg.edge_gpio_num = PIN_CLK; // A kanalı: CLK kenarları, DT seviyesi / channel A: CLK edges, DT level
26 aCfg.level_gpio_num = PIN_DT;
27 pcnt_channel_handle_t chA = NULL;
28 ESP_ERROR_CHECK(pcnt_new_channel(unit, &aCfg, &chA));
29
30 pcnt_chan_config_t bCfg = {};
31 bCfg.edge_gpio_num = PIN_DT; // B kanalı: DT kenarları, CLK seviyesi / channel B: DT edges, CLK level
32 bCfg.level_gpio_num = PIN_CLK;
33 pcnt_channel_handle_t chB = NULL;
34 ESP_ERROR_CHECK(pcnt_new_channel(unit, &bCfg, &chB));
35
36 // 4x çözme: iki hattın tüm kenarları sayılır / 4x decoding: every edge of both lines is counted
37 ESP_ERROR_CHECK(pcnt_channel_set_edge_action(chA, PCNT_CHANNEL_EDGE_ACTION_DECREASE, PCNT_CHANNEL_EDGE_ACTION_INCREASE));
38 ESP_ERROR_CHECK(pcnt_channel_set_level_action(chA, PCNT_CHANNEL_LEVEL_ACTION_KEEP, PCNT_CHANNEL_LEVEL_ACTION_INVERSE));
39 ESP_ERROR_CHECK(pcnt_channel_set_edge_action(chB, PCNT_CHANNEL_EDGE_ACTION_INCREASE, PCNT_CHANNEL_EDGE_ACTION_DECREASE));
40 ESP_ERROR_CHECK(pcnt_channel_set_level_action(chB, PCNT_CHANNEL_LEVEL_ACTION_KEEP, PCNT_CHANNEL_LEVEL_ACTION_INVERSE));
41
42 gpio_pullup_en((gpio_num_t)PIN_CLK); // çıplak encoder için iç pull-up / internal pull-up for a bare encoder
43 gpio_pullup_en((gpio_num_t)PIN_DT);
44
45 ESP_ERROR_CHECK(pcnt_unit_enable(unit));
46 ESP_ERROR_CHECK(pcnt_unit_clear_count(unit));
47 ESP_ERROR_CHECK(pcnt_unit_start(unit));
48}
49
50int lastDetent = 0;
51
52void loop() {
53 int count = 0;
54 pcnt_unit_get_count(unit, &count);
55 int detent = count / 4; // 4 kenar = 1 tık / 4 edges = 1 detent
56 if (detent != lastDetent) {
57 lastDetent = detent;
58 Serial.printf("Tik / detent: %d (ham / raw: %d)\n", detent, count);
59 }
60 if (digitalRead(PIN_SW) == LOW) { // basınca sıfırla / reset on press
61 pcnt_unit_clear_count(unit);
62 }
63 delay(20);
64}De twee kanalen zijn als spiegelbeeld van elkaar ingesteld: kanaal A telt de flanken van CLK en keert de richting om op basis van het niveau van DT, terwijl kanaal B de flanken van DT telt ten opzichte van CLK. Daardoor verandert de teller met 4 per klik. Bij de limiet van ±10000 gaat hij terug naar nul; heb je een groter bereik nodig, dan kun je overflows optellen met de optie flags.accum_count en watch points. De ESP32-C3 heeft geen PCNT-eenheid; gebruik op dat board de Arduino-code op basis van interrupts. Werk je met versie 2.x van de Arduino ESP32-core of wil je kortere code, dan gebruikt de bibliotheek ESP32Encoder dezelfde hardware en doet hij het werk met zijn functies attachFullQuad() en getCount(). Gebruik je MicroPython op de ESP32, dan gebruikt de klasse machine.Encoder in recente versies (bijv. 1.27) achter de schermen ook PCNT. Ben je nieuw met de ESP32, lees dan eerst Wat is de ESP32.
Rotary encoder met de Raspberry Pi Pico en MicroPython
Elke GPIO-pin van de Pico kan een interrupt activeren, dus een encoder uitlezen in MicroPython met Pin.irq() is eenvoudig. De onderstaande code gebruikt exact dezelfde toestandstabel als het Arduino-voorbeeld en maakt van de encoder een ledlichtregelaar: elke klik verandert de helderheid met 5 procent en een druk op de as schakelt de led aan en uit. Sluit CLK aan op GP16, DT op GP17, SW op GP18 en een led via een weerstand van 220 Ω op GP15. Voor het instellen van MicroPython zie je het artikel Wat is de Raspberry Pi Pico.
1from machine import Pin, PWM
2import time
3
4clk = Pin(16, Pin.IN, Pin.PULL_UP) # A fazı / phase A
5dt = Pin(17, Pin.IN, Pin.PULL_UP) # B fazı / phase B
6sw = Pin(18, Pin.IN, Pin.PULL_UP) # buton, basınca 0 / button, 0 when pressed
7led = PWM(Pin(15)) # LED + 220 ohm
8led.freq(1000)
9
10# İndeks: (eski AB << 2) | yeni AB / Index: (old AB << 2) | new AB
11QEM = (0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0)
12last_ab = (clk.value() << 1) | dt.value()
13quarter = 0
14position = 10 # 0-20 tık, başlangıç %50 / 0-20 detents, start at 50 %
15
16def on_edge(pin):
17 global last_ab, quarter, position
18 ab = (clk.value() << 1) | dt.value()
19 quarter += QEM[(last_ab << 2) | ab]
20 last_ab = ab
21 if ab == 3: # tıka oturdu / settled in a detent
22 if quarter > 1 and position < 20:
23 position += 1
24 elif quarter < -1 and position > 0:
25 position -= 1
26 quarter = 0
27
28clk.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=on_edge)
29dt.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=on_edge)
30
31on = True
32shown = -1
33while True:
34 if sw.value() == 0: # mile basıldı / shaft pressed
35 time.sleep_ms(20) # sıçramayı bekle / wait out the bounce
36 if sw.value() == 0:
37 on = not on
38 shown = -1 # yeniden yaz / force an update
39 while sw.value() == 0: # bırakılmasını bekle / wait for release
40 time.sleep_ms(10)
41 if position != shown:
42 shown = position
43 led.duty_u16(shown * 65535 // 20 if on else 0)
44 print("Parlaklik / brightness: %d%%" % (shown * 5), "acik / on" if on else "kapali / off")
45 time.sleep_ms(10)We controleren de grenzen van de waarde (0–20 klikken) binnen de interruptfunctie, zodat de hoofdlus de variabele alleen leest en er geen race condition ontstaat waarbij beide kanten tegelijk schrijven. Hoe de helderheid van een led wordt geregeld, vind je in het artikel Wat is PWM. Heb je liever een kant-en-klare oplossing, dan komt de module rotary_irq_rp2 uit het project micropython-rotary met grenzen, wrap-around en richtingsomkering. Voor zeer snelle motorencoders kan het PIO-blok van de Pico tellen zonder de processor te belasten. Ben je nieuw met MicroPython, dan is het artikel MicroPython-basis een goed beginpunt.
Soorten rotary encoders: mechanisch, optisch en magnetisch
| Type | Hoe werkt het? | Typische resolutie | Waar wordt het gebruikt? |
|---|---|---|---|
| Mechanisch (KY-040, EC11) | Contactschijf en twee schakelaars | 12–30 klikken per omwenteling | Menuknoppen, volumeregelaars, voorpanelen van apparaten |
| Optisch | Schijf met sleuven, led en fototransistor | Honderden tot duizenden pulsen per omwenteling | CNC-machines, robotgewrichten, industriële motoren |
| Magnetisch (halleffect) | Magneetschijf en hallsensoren | Een paar pulsen per omwenteling van de motoras (bijv. 7 of 11) | N20- en DC-motoren met reductie en encoder |
| Absoluut | Geeft voor elke positie een unieke code af | Bijvoorbeeld 12 bits (4.096 posities) bij de AS5600 | Robotarmen, hoekmeting; kent zijn positie bij het opstarten |
De code in dit artikel werkt ook met andere incrementele encoders met A/B-uitgangen. Bij een DC-motor met reductie en encoder levert bijvoorbeeld een hallencoder met 11 pulsen per omwenteling van de motoras, tellen op vier flanken en een overbrengingsverhouding van 1:30 samen 11 × 4 × 30 = 1.320 tellingen per omwenteling van de uitgaande as. Als de pulsfrequentie oploopt tot duizenden per seconde, neemt code op basis van interrupts een merkbaar deel van de processortijd in, terwijl de PCNT-eenheid van de ESP32 dit tellen moeiteloos doet. Industriële optische encoders werken meestal op 5–24 V en hebben open-collector- of differentiële uitgangen; controleer altijd het uitgangstype en de spanning in de datasheet voordat je er een aansluit.
Projectideeën met een rotary encoder
- Digitale volumeknop: Stel met de encoder het volume in van muziek die speelt via een DFPlayer Mini en druk op de as om naar het volgende nummer te gaan.
- Kleurkiezerlamp: Draai met de encoder de tint van een ring met WS2812B-leds en druk om naar de helderheidsmodus te schakelen.
- Nauwkeurige positionering: Laat elke klik een stappenmotor een vast aantal stappen verplaatsen; bouw een camerarail of een draaitafel.
- Keukentimer: Stel de tijd in met de encoder, druk om het aftellen te starten en laat een buzzer klinken als de tijd om is.
- Gamecontroller: Gebruik de encoder als peddel in Pong; in Arduino-gameprojecten geeft hij fijnere besturing dan een joystick.
- Klok en wekker instellen: Stel met één knop de tijd en de wekker van een RTC-klokmodule in.
- Paneel voor meetapparatuur: Wijzig in fijne stappen een PWM-frequentie, de waarde van een signaalgenerator of de doeltemperatuur van een soldeerstation.
Veelgemaakte fouten en hoe je ze oplost
| Probleem | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Telt 2 of 4 per klik | Elke flank wordt apart geteld of de contacten denderen | Deel het aantal flanken door 4, gebruik een toestandstabel, voeg condensatoren van 10–100 nF toe aan CLK en DT |
| Telt alleen elke tweede klik | Encoder met 30 klikken / 15 pulsen; elke klik is een halve cyclus | Deel de waarde van de bibliotheek door 2 in plaats van 4; verander in de tabelcode if (ab == 3) in if (ab == 3 || ab == 0) |
| Richting is omgekeerd | CLK en DT zijn verwisseld of de module is anders | Verwissel de pinnummers van CLK en DT in de code |
| Stappen gemist bij snel draaien | Er wordt polling gebruikt, er zit een delay in loop | Gebruik interrupts of de ESP32 PCNT, houd de ISR kort |
| De knop drukt zichzelf in | SW-pin zweeft, geen pull-up | Gebruik pinMode(SW, INPUT_PULLUP) |
| De teller springt willekeurig | Geen gemeenschappelijke GND, lange of losse draden | Deel de GND, kort de draden in, controleer de contacten van de breadboard |
| fatal error: driver/pulse_cnt.h: No such file or directory / undefined reference to 'pcnt_new_unit' | Arduino ESP32-core 2.x (eerste fout) of een ESP32-C3, die geen PCNT-eenheid heeft (tweede fout) | Werk de core bij naar 3.x in de Boards Manager of gebruik de bibliotheek ESP32Encoder; gebruik op de C3 de interruptcode |
| De LCD toont alleen blokjes | Verkeerde contrastinstelling of I2C-adres | Draai aan de trimmer op de achterkant, probeer adres 0x3F in plaats van 0x27 |
Een rotary encoder is een van de goedkoopste manieren om een project een professionele gebruikersinterface te geven: één knop en een display kunnen tientallen instellingen aan. Begin met de pollingcode om de logica te begrijpen, stap dan over op de versie met interrupts of PCNT en pas het menuvoorbeeld aan op je eigen project. In de BlueGrays-app vind je projecten met potmeter-servobesturing, I2C LCD, drukknop en 7-segmentteller met schakelschema's en code stap voor stap, en je kunt ze eenvoudig upgraden door de potmeter of knop te vervangen door een encoder.
Veelgestelde vragen
Wat is het verschil tussen een rotary encoder en een potmeter?
Een potmeter geeft een analoge spanning af die afhangt van de asstand, zijn draaiing is beperkt tot ongeveer 270–300 graden en je leest hem uit met analogRead. Een rotary encoder draait eindeloos en geeft bij elke klik digitale pulsen; hij meldt de richting en de hoeveelheid beweging, niet de positie. Een encoder is beter voor menunavigatie en instellingen in stappen, een potmeter voor eenvoudige afstellingen op basis van positie.
Waarom telt mijn rotary encoder twee stappen per klik of slaat hij stappen over?
Te veel tellen komt meestal door contactdender of doordat elke flank apart wordt geteld; de 4 flanken per klik door 4 delen en een toestandstabel gebruiken lost dat op. Overgeslagen stappen ontstaan wanneer pulsen binnenkomen terwijl loop bezig is. Sluit CLK en DT aan op interruptpinnen en lees ze uit met interrupts, voeg zo nodig condensatoren van 10–100 nF toe, en het probleem verdwijnt.
Werkt de KY-040 rotary encoder op 3,3 V?
Ja. De KY-040 bestaat alleen uit mechanische schakelaars en pull-upweerstanden, dus hij werkt ook prima op 3,3 V. Sluit op de ESP32 en Raspberry Pi Pico de +-pin altijd aan op 3V3; voed je hem met 5 V, dan trekken de pull-upweerstanden CLK en DT omhoog naar 5 V en wordt de limiet van de 3,3 V-ingangen overschreden.
Hoeveel pulsen per omwenteling geeft de KY-040?
Gangbare KY-040-modules hebben 20 klikken per omwenteling, en de lijnen A en B doorlopen per klik één volledige cyclus. Elke cyclus heeft vier flanken, dus je telt 80 flanken per omwenteling, en elke klik is 18 graden. Sommige encoders hebben 30 klikken en 15 pulsen; bij die komt elke klik overeen met een halve cyclus.
Kan een rotary encoder zonder interrupts worden uitgelezen?
Ja, hij kan worden uitgelezen met polling, waarbij je de CLK-pin voortdurend in loop controleert, en dat is vaak genoeg voor een menuknop die langzaam wordt gedraaid. Maar als loop een delay, displayupdates of lange berekeningen bevat, worden snel gedraaide klikken gemist. Voor betrouwbare resultaten worden interrupts aanbevolen, en op de ESP32 de hardwareteller PCNT.
Kan ik meer dan één rotary encoder op een Arduino aansluiten?
Ja. Omdat alleen D2 en D3 op de Uno hardware-interrupts bieden, kun je met de Encoder-bibliotheek van elke encoder de eerste pin (degene die als eerste aan de constructor wordt meegegeven) op een interruptpin aansluiten en de andere op een gewone pin, of pin change-interrupts gebruiken. De Mega heeft zes interruptpinnen, de klassieke ESP32 kan met zijn 8 PCNT-eenheden 8 encoders in hardware tellen, en op de Pico kan elke GPIO een interrupt activeren.
Projecten om hierna te bouwen
Alle projecten bekijken
LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

ESP32-ledbesturing met drukknop (Toggle)
Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling
Als één druk op een knop je code 3-4 keer liet tellen, is contactdender de boosdoener: de metalen contacten van de knop gaan binnen microseconden vele malen open en dicht als ze elkaar raken! In dit project tellen we dezelfde knop op 2 manieren en vergelijken we ze naast elkaar in Serial: RAW-polling (vangt de dender op en telt fout) en IRQ + software-ontdendering (telt goed).

Servomotor aansturen met een potentiometer
Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

Teller met 7-segmentdisplay en knoppen
Een eenvoudige teller met drie knoppen: met de ene knop gaat het cijfer op het display er één omhoog, met de andere één omlaag en de derde zet het terug op nul.

Een lcd-scherm gebruiken met I2C
Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

Paddleballspel - SSD1306
Een bal, twee batjes en jij: op een klein OLED-scherm speel je tafeltennis, een van de allereerste videogames.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

