KY-040 Kodierter Drehschalter (Rotary Encoder)

Der kodierte Drehschalter (Rotary Encoder) gibt die Bewegungsrichtung und die aktuelle Position des Schalters über seine Ausgänge aus, wenn er gedreht wird.

Bei jedem Schritt ändert sich der Zustand der beiden Ausgänge, wodurch die Drehrichtung ermittelt werden kann. Die Drehrichtung wird durch die Reihenfolge der Zustandsänderungen der Ausgänge bestimmt: Je nachdem, welcher Ausgang zuerst seinen Zustand ändert, kann erkannt werden, ob der Schalter im Uhrzeigersinn oder gegen den Uhrzeigersinn gedreht wird.

Dieser Drehschalter ist ideal für Anwendungen, bei denen präzise Positions- und Bewegungsinformationen benötigt werden, wie z.B. in Benutzeroberflächen für elektronische Geräte, Maschinensteuerungen oder in Rotationsmesssystemen. Er ermöglicht eine genaue und zuverlässige Eingabe und ist eine vielseitige Komponente für viele Projekte.

Anschlussbelegung

Arduino	Sensor
5 V	+V
GND	GND
Pin 3	CLK
Pin 4	DT
Pin 5	Knopf

Code-Beispiel

Das Beispielprogramm prüft auf die Änderung der Pin-Zustände und ermittelt die Drehrichtung, sobald eine Drehung erkannt wurde. Nachdem die Richtung festgestellt wurde, werden die Schritte von der Startposition an gezählt und ausgegeben. Ein Drücken des Knopfes setzt dabei die Zählung zurück.

Um das folgende Codebeispiel auf Ihren Arduino zu laden, empfehlen wir die Verwendung der Arduino IDE. In der IDE können Sie den passenden Port und das richtige Board für Ihr Gerät auswählen.

Kopieren Sie den unten stehenden Code in Ihre IDE. Um den Code auf Ihren Arduino hochzuladen, klicken Sie einfach auf den Upload-Button.

// Initialisierung benötigter Variablen
int counter = 0; 
boolean direction;
int pin_clk_last;  
int pin_clk_current;
 
// Definition der Eingangs-Pins
int pin_clk = 3;  
int pin_dt = 4; 
int button_pin = 5;
  
  
void setup()  { 
  // Eingangs-Pins werden initialisiert...
  pinMode(pin_clk,INPUT);
  pinMode(pin_dt,INPUT);
  pinMode(button_pin,INPUT);
  
  // ...und deren Pull-Up Widerstände aktiviert
  digitalWrite(pin_clk, true);
  digitalWrite(pin_dt, true);
  digitalWrite(button_pin, true);
  
  // Initiales Auslesen des Pin_CLK
  pin_clk_last = digitalRead(pin_clk);   
  Serial.begin (9600);
  Serial.println("KY-040 Drehschaltertest");
 } 
 
// Das Programm überprüft, falls eine Änderung der Pin-Zustände sich ereignet hat, welcher der beiden
// Pins sich zuerst geändert hatte, was auf die Drehrichtung schließen lässt.
// Diese Information erhält man, in dem man einen der beiden Pin-Werte aus einem vorherigen
// Durchlauf mit dem Wert des aktuellen Durchlaufs vergleicht.
// Nachdem die Richtung festgestellt wurde, werden die Schritte von der Startposition an gezählt und ausgegeben.
// Ein Drücken auf den Knopf des Drehgebers resettet die aktuelle Position.
 
void loop() { 
  // Auslesen des aktuellen Statuses  
  pin_clk_current = digitalRead(pin_clk);

  // Überprüfung auf Änderung
  if (pin_clk_current != pin_clk_last) { 
    if (digitalRead(pin_dt) != pin_clk_current) {  
      // Pin_CLK hat sich zuerst verändert
      counter ++;
      direction = true;
    } 
    else {       
      // Andernfalls hat sich Pin_DT zuerst verändert
      direction = false;
      counter--;
    }
    delay(300);
    Serial.println("Drehung erkannt");
    Serial.print("Drehrichtung: "); 
    if (direction) Serial.println ("Im Uhrzeigersinn");
    else Serial.println("Gegen den Uhrzeigersinn");
      
    Serial.print("Aktuelle Position: ");
    Serial.println(counter);
    Serial.println("------------------------------");
  } 
  // Vorbereitung für den nächsten Druchlauf:
  // Der Wert des aktuellen Durchlaufs ist beim nächsten Druchlauf der vorherige Wert
  pin_clk_last = pin_clk_current;
  // Reset-Funktion um aktuelle Position zu speichern
  if (!digitalRead(button_pin) && counter!=0) {
    counter = 0;
    Serial.println("Position resettet");
  }
 }

# -*- coding: iso-8859-1 -*-
import time
from gpiozero import Button

# Initialisierung der Pins fuer den Drehencoder
clk = Button(16, pull_up=True)
dt = Button(15, pull_up=True)
reset_button = Button(14, pull_up=True)  # Knopf zum Zuruecksetzen des Zaehlers

last_clk_state = clk.is_pressed  # Speichert den letzten Zustand von CLK

# Initialisiere den Zaehler
counter = 0

def read_encoder():
    global last_clk_state, counter
    while True:
        current_clk_state = clk.is_pressed
        if current_clk_state != last_clk_state:  # Erkenne eine Zustands�nderung
            if current_clk_state:
                if dt.is_pressed != current_clk_state:
                    counter += 1  # Drehung im Uhrzeigersinn
                    direction = "Uhrzeigersinn"
                else:
                    counter -= 1  # Drehung gegen den Uhrzeigersinn
                    direction = "Gegen den Uhrzeigersinn"
                print(f"Drehrichtung: {direction}")
                print(f"Aktuelle Position: {counter}")
                print("------------------------------")
            last_clk_state = current_clk_state
        time.sleep(0.001)  # kurze Pause, um CPU-Zeit zu sparen

def reset_counter():
    global counter
    counter = 0
    print("Zaehler zurueckgesetzt!")
    print("------------------------------")

# Fuege einen Ereignishandler fuer den Reset-Knopf hinzu
reset_button.when_pressed = reset_counter

print("Sensor-Test [druecken Sie STRG+C, um den Test zu beenden]")

try:
    read_encoder()  # Start der Funktion zum Lesen des Encoders
except KeyboardInterrupt:
    print("Programm wurde durch Benutzer unterbrochen")

	
		function RotaryEncoder () {
		    CLKAKTUELL = pins.digitalReadPin(DigitalPin.P1)
		    if (CLKAKTUELL != CLKLETZTE) {
		        if (pins.digitalReadPin(DigitalPin.P2) != CLKAKTUELL) {
		            Richtung = 1
		        } else {
		            Richtung = 0
		        }
		        serial.writeLine("Drehung Erkannt: ")
		        if (Richtung == 1) {
		            POS += -1
		            POSLETZTE = POS
		            serial.writeLine("Drehrichtung: Gegen den Uhrzeigersinn")
		        } else {
		            POS += 1
		            POSLETZTE = POS
		            serial.writeLine("Drehrichtung: Im Uhrzeigersinn")
		        }
		        serial.writeLine("Aktuelle Position: ")
		        serial.writeLine("" + (POS))
		    }
		    if (POS != VORHERIGEPOS) {
		        serial.writeLine("" + (POS))
		        VORHERIGEPOS = POS
		    }
		}
		pins.onPulsed(DigitalPin.P2, PulseValue.High, function () {
		    RotaryEncoder()
		})
		pins.onPulsed(DigitalPin.P2, PulseValue.Low, function () {
		    RotaryEncoder()
		})
		pins.onPulsed(DigitalPin.P0, PulseValue.Low, function () {
		    Reset()
		})
		function Reset () {
		    basic.pause(100)
		    CLKLETZTE = CLKAKTUELL
		    POS = 0
		}
		let VORHERIGEPOS = 0
		let POSLETZTE = 0
		let POS = 0
		let Richtung = 0
		let CLKAKTUELL = 0
		let CLKLETZTE = 0
		CLKLETZTE = 0
		CLKAKTUELL = 0
		Richtung = 1
		CLKLETZTE = pins.digitalReadPin(DigitalPin.P1)
		POS = 0
		POSLETZTE = 0
		pins.setPull(DigitalPin.P0, PinPullMode.PullUp)
		pins.setPull(DigitalPin.P1, PinPullMode.PullUp)
		pins.setPull(DigitalPin.P2, PinPullMode.PullUp)
	

# Bibliotheken laden
from machine import Pin
from time import sleep

# Initialisierung von GPIO16, GPIO17 und GPIO18 als Input
CLK = Pin(16,Pin.IN, Pin.PULL_DOWN)
DT = Pin(17,Pin.IN, Pin.PULL_DOWN)
SW = Pin(18,Pin.IN, Pin.PULL_UP)

# Variablen Definierung
counter = 0
clk_last = CLK.value()
clk_current = 0
direction = True

print("KY-040 Drehencodertest")
print("-------------------------------------------")

def output():
    global clk_current, counter, direction

    # Auslesen des aktuellen Statuses 
    clk_current = CLK.value()

    # Überprüfung auf Änderung
    if clk_current != clk_last:

        # Pin_CLK hat sich zuerst verändert
        if DT.value() != clk_current:
            counter = counter + 1
            direction = True

        # Andernfalls hat sich Pin_DT zuerst verändert
        else:
            direction = False
            counter = counter - 1
        print("Drehung erkannt: ")

        if direction:
            print("Drehrichtung: Im Uhrzeigersinn")
        else:
            print("Drehrichtung: Gegen den Uhrzeigersinn")
        print("Aktuelle Position: " + str(counter))
        print("-------------------------------------------")

# Funktion: Counter Variable wird zurück gesetzt wenn der Knopf gedrückt wird
def counterReset():
    global counter
    if SW.value() == 0:
        print("Position zurückgesetzt!")
        print("-----------------------")
        counter = 0
        sleep(0.5)

# Endlosschleife zum konstanten Auslesen des Sensors
while True:
    output()
    clk_last = clk_current
    counterReset()