Hoe Rotary Encoder werkt en hoe het te gebruiken met Arduino

In deze tutorial zullen we leren hoe roterende encoder werkt en hoe deze te gebruiken met Arduino. Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.

Overzicht

Een roterende encoder is een type positiesensor die wordt gebruikt voor het bepalen van de hoekpositie van een roterende as. Het genereert een elektrisch signaal, analoog of digitaal, afhankelijk van de draaibeweging.

Er zijn veel verschillende soorten roterende encoders die worden geclassificeerd op basis van uitgangssignaal of detectietechnologie. De specifieke roterende encoder die we in deze tutorial zullen gebruiken, is een incrementele roterende encoder en het is de eenvoudigste positiesensor om rotatie te meten.

Deze roterende encoder is ook bekend als kwadratuur-encoder of relatieve roterende encoder en de output is een reeks blokgolfpulsen.

Hoe Rotary Encoder werkt

Laten we de encoder eens nader bekijken en het werkingsprincipe ervan bekijken. Hier is hoe de blokgolfpulsen worden gegenereerd:De encoder heeft een schijf met gelijkmatig verdeelde contactzones die zijn verbonden met de gemeenschappelijke pin C en twee andere afzonderlijke contactpinnen A en B, zoals hieronder geïllustreerd.

Wanneer de schijf stap voor stap begint te draaien, zullen de pinnen A en B contact maken met de gemeenschappelijke pin en worden de twee blokgolfuitgangssignalen dienovereenkomstig gegenereerd.

Elk van de twee uitgangen kan worden gebruikt voor het bepalen van de gedraaide positie als we alleen de pulsen van het signaal tellen. Als we echter ook de draairichting willen bepalen, moeten we beide signalen tegelijkertijd in overweging nemen.

We kunnen zien dat de twee uitgangssignalen 90 graden uit fase ten opzichte van elkaar zijn verschoven. Als de encoder met de klok mee draait, ligt uitgang A voor uitgang B.

Dus als we de stappen tellen elke keer dat het signaal verandert, van Hoog naar Laag of van Laag naar Hoog, kunnen we op dat moment zien dat de twee uitgangssignalen tegengestelde waarden hebben. Omgekeerd, als de encoder tegen de klok in draait, hebben de uitgangssignalen gelijke waarden. Dus als we dit overwegen, kunnen we onze controller eenvoudig programmeren om de encoderpositie en de rotatierichting te lezen.

Arduino-voorbeeld met roterende encoder

Laten we er een praktisch voorbeeld van maken met behulp van de Arduino. De specifieke module die ik voor dit voorbeeld zal gebruiken, komt op een breakout-bord en heeft vijf pinnen. De eerste pin is de output A, de tweede pin is de output B, de derde pin is de Button-pin en natuurlijk zijn de andere twee pinnen de VCC en de GND-pin.

We kunnen de uitgangspinnen verbinden met elke digitale pin van het Arduino-bord.

U kunt de benodigde componenten voor deze Arduino-zelfstudie verkrijgen via de onderstaande links:

• Roterende encodermodule……………….
• Arduino-bord …………………………
• Broodplank en springdraden ……… 

Broncode

Hier is de Arduino-code:

/*     Arduino Rotary Encoder Tutorial
 *      
 *  by Dejan Nedelkovski, www.HowToMechatronics.com
 *  
 */
 
 #define outputA 6
 #define outputB 7

 int counter = 0; 
 int aState;
 int aLastState;  

 void setup() { 
   pinMode (outputA,INPUT);
   pinMode (outputB,INPUT);
   
   Serial.begin (9600);
   // Reads the initial state of the outputA
   aLastState = digitalRead(outputA);   
 } 

 void loop() { 
   aState = digitalRead(outputA); // Reads the "current" state of the outputA
   // If the previous and the current state of the outputA are different, that means a Pulse has occured
   if (aState != aLastState){     
     // If the outputB state is different to the outputA state, that means the encoder is rotating clockwise
     if (digitalRead(outputB) != aState) { 
       counter ++;
     } else {
       counter --;
     }
     Serial.print("Position: ");
     Serial.println(counter);
   } 
   aLastState = aState; // Updates the previous state of the outputA with the current state
 }Code language: Arduino (arduino)

Beschrijving van de code: Dus eerst moeten we de pinnen definiëren waarmee onze encoder is verbonden en enkele variabelen definiëren die nodig zijn voor het programma. In het setup-gedeelte moeten we de twee pinnen als input definiëren, de seriële communicatie starten om de resultaten op de seriële monitor af te drukken, en de initiële waarde van output A lezen en de waarde in de variabele aLastState invoeren.

Vervolgens lezen we in de lussectie de uitvoer A opnieuw, maar nu plaatsen we de waarde in de aState-variabele. Dus als we de encoder draaien en een puls wordt gegenereerd, zullen deze twee waarden verschillen en wordt de eerste "if" -verklaring waar. Meteen daarna bepalen we met behulp van de tweede "if"-instructie de rotatierichting. Als de toestand van uitgang B verschilt van de toestand van uitgang A, wordt de teller met één verhoogd, anders wordt deze verlaagd. Aan het einde, na het afdrukken van de resultaten op de seriële monitor, moeten we de aLastState-variabele bijwerken met aState-variabele.

Dat is alles wat we nodig hebben voor dit voorbeeld. Als u de code uploadt, start u de seriële monitor en begint u de encoder te draaien. We krijgen de waarden in de seriële monitor. De specifieke module die ik heb maakt 30 tellingen per volledige cyclus.

Meer informatie:Ultrasone sensor HC-SR04 en Arduino – complete gids

Voorbeeld 2 – Een stappenmotor besturen met behulp van een roterende encoder

Naast dit basisvoorbeeld heb ik nog een voorbeeld gemaakt van het besturen van een stappenmotorpositie met behulp van de roterende encoder.

Hier is de broncode van dit voorbeeld:

/*     Stepper Motor using a Rotary Encoder
 *      
 *  by Dejan Nedelkovski, www.HowToMechatronics.com
 *  
 */

 #include <LiquidCrystal.h> // includes the LiquidCrystal Library 
 LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // Creates an LC object. Parameters: (rs, enable, d4, d5, d6, d7) 

// defines pins numbers
 #define stepPin 8 
 #define dirPin  9
 #define outputA 10
 #define outputB 11

 int counter = 0;
 int angle = 0; 
 int aState;
 int aLastState;  
 
void setup() {
  // Sets the two pins as Outputs
  pinMode(stepPin,OUTPUT); 
  pinMode(dirPin,OUTPUT);
  pinMode (outputA,INPUT);
  pinMode (outputB,INPUT);
  
  aLastState = digitalRead(outputA);
  lcd.begin(16,2); // Initializes the interface to the LCD screen, and specifies the dimensions (width and height) of the display } 

}
void loop() {

  aState = digitalRead(outputA);
  
  if (aState != aLastState){     
     if (digitalRead(outputB) != aState) { 
       counter ++;
       angle ++;
       rotateCW();  
     }
     else {
       counter--;
       angle --;
       rotateCCW(); 
     }
     if (counter >=30 ) {
      counter =0;
     }
     
     lcd.clear();
     lcd.print("Position: ");
     lcd.print(int(angle*(-1.8)));
     lcd.print("deg"); 
     lcd.setCursor(0,0);
     
   }
  aLastState = aState;
}

void rotateCW() {
  digitalWrite(dirPin,LOW);
    digitalWrite(stepPin,HIGH);
    delayMicroseconds(2000);
    digitalWrite(stepPin,LOW);
    delayMicroseconds(2000); 
}
void rotateCCW() {
  digitalWrite(dirPin,HIGH);
    digitalWrite(stepPin,HIGH);
    delayMicroseconds(2000);
    digitalWrite(stepPin,LOW);
    delayMicroseconds(2000);   
}
Code language: Arduino (arduino)

Stel gerust een vraag in de opmerkingen hieronder.