KY-040 Module encodeur rotatif

Le commutateur rotatif codé (Rotary Encoder) émet le sens du mouvement et la position actuelle du commutateur via ses sorties lorsqu'il est tourné.

À chaque étape, l'état des deux sorties change, ce qui permet de déterminer le sens de rotation. Le sens de rotation est déterminé par l'ordre des changements d'état des sorties : Selon la sortie qui change d'état en premier, il est possible de savoir si le commutateur est tourné dans le sens des aiguilles d'une montre ou dans le sens inverse.

Ce commutateur rotatif est idéal pour les applications qui nécessitent des informations précises sur la position et le mouvement, comme les interfaces utilisateur pour les appareils électroniques, les commandes de machines ou les systèmes de mesure de rotation. Il permet une saisie précise et fiable et constitue un composant polyvalent pour de nombreux projets.

Affectation des broches

Arduino	Capteur
5V	+V
GND	GND
Pin 3	CLK
Pin 4	DT
Pin 5	SW

Exemple de code

Si un changement d'état de la broche s'est produit, le programme vérifie laquelle des deux broches a changé en premier, ce qui indique le sens de rotation. Cette information est obtenue en comparant l'une des deux valeurs de la broche d'une manche précédente avec la valeur de la manche actuelle.

Une fois la direction déterminée, les pas depuis la position de départ sont comptés et édités. Appuyer sur le bouton de l'encodeur réinitialise la position actuelle.

Pour charger l'exemple de code suivant sur votre Arduino, nous vous recommandons d'utiliser l'IDE Arduino. Dans l'IDE, vous pouvez choisir le port et la carte qui conviennent à votre appareil.

Copiez le code ci-dessous dans votre IDE. Pour télécharger le code sur votre Arduino, il vous suffit de cliquer sur le bouton " Upload ".

// Initialisation des variables nécessaires
int counter = 0; 
boolean direction;
int pin_clk_last;  
int pin_clk_current;
 
// Définition des broches d'entrée
int pin_clk = 3;  
int pin_dt = 4; 
int button_pin = 5;
  
  
void setup()  { 
  // Les broches d'entrée sont initialisées
  pinMode(pin_clk,INPUT);
  pinMode(pin_dt,INPUT);
  pinMode(button_pin,INPUT);
  
  // ...et leurs résistances Pull-Up activées
  digitalWrite(pin_clk, true);
  digitalWrite(pin_dt, true);
  digitalWrite(button_pin, true);
  
  // Lecture initiale du Pin_CLK
  pin_clk_last = digitalRead(pin_clk);   
  Serial.begin (9600);
  Serial.println("KY-040 Test du commutateur rotatif");
 } 
 
// Le programme vérifie, si un changement d'état des broches s'est produit, laquelle des deux broches a été la première.
// la première broche à avoir changé, ce qui permet de déduire le sens de rotation.
// On obtient cette information en comparant l'une des deux valeurs de broche d'un passage précédent.
// avec la valeur du passage actuel.
// Une fois le sens déterminé, les pas sont comptés et édités à partir de la position de départ.
// Une pression sur le bouton de l'encodeur réinitialise la position actuelle.
 
void loop() { 
  // Lecture de l'état actuel  
  pin_clk_current = digitalRead(pin_clk);

  // Vérification de la modification
  if (pin_clk_current != pin_clk_last) { 
    if (digitalRead(pin_dt) != pin_clk_current) {  
      // Pin_CLK a changé en premier
      counter ++;
      direction = true;
    } 
    else {       
      // Sinon, Pin_DT a changé en premier
      direction = false;
      counter--;
    }
    delay(300);
    Serial.println("Rotation détectée");
    Serial.print("Sens de rotation: "); 
    if (direction) Serial.println ("Dans le sens des aiguilles d'une montre");
    else Serial.println("Dans le sens inverse des aiguilles d'une montre");
      
    Serial.print("Position actuelle: ");
    Serial.println(counter);
    Serial.println("------------------------------");
  } 
  // Préparation pour le passage suivant :
  // La valeur du passage actuel est la valeur précédente lors du passage suivant
  pin_clk_last = pin_clk_current;
  // Fonction de réinitialisation pour enregistrer la position actuelle
  if (!digitalRead(button_pin) && counter!=0) {
    counter = 0;
    Serial.println("Position réinitialisée");
  }
 }

import time
from gpiozero import Button

# Initialisation des broches du codeur rotatif
clk = Button(16, pull_up=True)
dt = Button(15, pull_up=True)
reset_button = Button(14, pull_up=True)  # Bouton de remise à zéro du compteur

last_clk_state = clk.is_pressed  # Sauvegarde le dernier état de CLK

# Initialiser le compteur
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:  # Reconnaître un changement d'état
            if current_clk_state:
                if dt.is_pressed != current_clk_state:
                    counter += 1  # Rotation dans le sens des aiguilles d'une montre
                    direction = "Dans le sens des aiguilles d'une montre"
                else:
                    counter -= 1  # Rotation dans le sens inverse des aiguilles d'une montre
                    direction = "Dans le sens inverse des aiguilles d'une montre"
                print(f"Sens de rotation: {direction}")
                print(f"Position actuelle: {counter}")
                print("------------------------------")
            last_clk_state = current_clk_state
        time.sleep(0.001)  # courte pause pour économiser le temps de l'unité centrale

def reset_counter():
    global counter
    counter = 0
    print("Contre-réinitialisation !")
    print("------------------------------")

# Ajouter un gestionnaire d'événement pour le bouton de réinitialisation
reset_button.when_pressed = reset_counter

print("Test du capteur [appuyez sur CTRL+C pour terminer le test]")

try:
    read_encoder()  # Lancer la fonction de lecture du codeur
except KeyboardInterrupt:
    print("Le programme a été interrompu par l'utilisateur")

	
		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)
	

# Charger des bibliothèques
from machine import Pin
from time import sleep

# Initialisation de GPIO16, GPIO17 et GPIO18 comme entrée
CLK = Pin(16,Pin.IN, Pin.PULL_DOWN)
DT = Pin(17,Pin.IN, Pin.PULL_DOWN)
SW = Pin(18,Pin.IN, Pin.PULL_UP)

# Définition des variables
counter = 0
clk_last = CLK.value()
clk_current = 0
direction = True

print("KY-040 Test du codeur rotatif")
print("-------------------------------------------")

def output():
    global clk_current, counter, direction

    # Lecture de l'état actuel 
    clk_current = CLK.value()

    # Vérification de la modification
    if clk_current != clk_last:

        # Pin_CLK a changé en premier
        if DT.value() != clk_current:
            counter = counter + 1
            direction = True

        # Sinon, Pin_DT a changé en premier
        else:
            direction = False
            counter = counter - 1
        print("rotation détectée : ")

        if direction:
            print("Sens de rotation : dans le sens des aiguilles d'une montre")
        else:
            print("Sens de rotation : sens inverse des aiguilles d'une montre")
        print("Position actuelle : " + str(counter))
        print("-------------------------------------------")

# Fonction : La variable compteur est remise à zéro lorsque le bouton est pressé.
def counterReset():
    global counter
    if SW.value() == 0:
        print("Position réinitialisée !")
        print("-----------------------")
        counter = 0
        sleep(0.5)

# Boucle sans fin pour une lecture constante du capteur
while True:
    output()
    clk_last = clk_current
    counterReset()