I2C Rotary Encoder

Geplaatst op 2019-10-01

I²C Rotary Encoder

Ik zal in dit artikel twee onderwerpen behandelen.

De eerste gaat over Rotary Encoders en (summier) hoe ze werken. De tweede gaat over het door Philips ontwikkelde Inter-Integrated Circuit-protocol (I²C).

Rotary Encoders

Een Rotary Encoder is een apparaat dat (fysiek) op een potentiometer lijkt, maar niet de weerstand tussen twee / drie connectoren varieert maar in plaats daarvan pulsen geeft wanneer aan de as wordt gedraaid. Een ander verschil met de potentiometer is dat je de as 360° kunt draaien (er is in feite geen limiet in hoeveel graden je de as kunt draaien).

De meeste Rotary Encoders hebben een druk-schakelaar die wordt geactiveerd als je op de as drukt. En er zijn Rotary Encoders die intern een driekleuren LED hebben (zgn. RGB Rotary Encoder) waarmee je een gebruiker met een pallet aan kleuren feedback kunt geven.

RGB Rotary Encoder

De Rotary Encoder genereert pulsen als er aan de as wordt gedraaid. De meeste Rotary Encoders genereren 24 pulsen bij elke 360° rotatie maar er zijn ook Rotary Encoders die meer of minder pulsen per omwenteling afgeven. In je programma kunt je deze pulsen tellen en daarop reageren (bijvoorbeeld: de uitgangs spanning van een voeding verhogen of verlagen of een menulijst doorlopen).

Je kunt je afvragen: "waarom een Rotary Encoder gebruiken en niet gewoon een potentiometer?". Natuurlijk is hierop geen "dit is beter dan dat" antwoord. Het hangt van het project af. Als je een analoge hifi-versterker bouwt, is de potentiometer waarschijnlijk de betere keuze. Als je een project hebt met een microprocessor dan biedt de Rotary Encoder je veel opties om een mooie gebruikersinterface te maken (met misschien een fijne / grove verandering afhankelijk van de kort of lang indrukken van de as en een gekleurde feedback om weer te geven welke modus actief is).

Hieronder staat een voorbeeldschets om een Rotary Encoder te “lezen”. Om dit programma goed en betrouwbaar te laten werken hebt je hardware-bounce control (RC-netwerk) op pin A en B van de encoder nodig:

Demo Sketch Rotary Encoder

 #define outputA 6
 #define outputB 7

 int rotVal = 0; 
 int rotState;
 int rotLastState;  

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

 void loop() { 
   rotState = digitalRead(outputA);
   // If the previous and the current state of the outputA are different, 
   // that means a Pulse has occured
   if (rotState != rotLastState){     
     // If the outputB state is different to the outputA state, 
     // the encoder is rotating clockwise
     if (digitalRead(outputB) != rotState) { 
       rotVal ++;
     } else {
       rotVal --;
     }
     Serial.print(F("Position: "));
     Serial.println(rotVal);
   } 
   rotLastState = rotState; // Update the previous state to the current state
 }

Het gebruik van een Rotary Encoder in een project heeft helaas ook een nadeel: je hebt veel GPIO pinnen nodig!

Eén RGB Rotary Encoder heeft twee GPIO-pinnen nodig voor de Encoder zelf (plus GND), vervolgens heb je één GPIO-pin nodig voor de drukschakelaar en drie GPIO-pinnen voor de RGB-LED. Dat is een totaal van zes GPIO-pinnen! Op bijvoorbeeld een ESP8266 heb je dan nog slechts drie GPIO-pinnen over om de rest van je project te besturen! Op een Arduino UNO heb je meer GPIO-pinnen zodat één Rotary Encoder geen probleem zal zijn. Maar wat als je twee, drie of nog meer Rotary Encoders wilt aansluiten. Op een ESP8266 is dat niet mogelijk maar op een Arduino UNO zul je ook snel geen GPIO-pinnen meer hebben!

Gelukkig is er een oplossing!

De Inter-Integrated Circuit bus (I²C)

Dit wordt een (data) "bus" genoemd omdat je er veel devices op kunt aansluiten. De "bus" bestaat uit twee lijnen. Een kloklijn (SCL) en een datalijn (SDA). Er is altijd (ten minste) één 'master'-device en alle andere apparaten zijn 'slave'-devices. Elk device heeft een uniek adres om zich van elkaar te kunnen onderscheiden. Ik zal niet de diepte van het I²C-protocol ingaan, maar normaal zal de master de controle over de bus claimen en een verzoek verzenden naar een slave met een specifiek adres. De slave zal op zijn beurt actie ondernemen op het verzoek, hetzij door een specifieke actie in de slave zelf uit te voeren, door gegevens terug te sturen naar de master of eenvoudigweg door een bevestiging terug te sturen naar de master om hem te laten weten dat hij het verzoek heeft ontvangen. Hier kun je meer over het I²C-protocol lezen.

De I²C Rotary Encoder

Zou het niet leuk zijn om een Rotary Encoder aan te kunnen sluiten met alleen de twee draden van de I²C-bus !?

En daar gaat deze post echt over: een Rotary Encoder die je via de I²C-bus verbindt en bestuurt met het I²C-protocol.

Ik heb de firmware en een kleine printplaat met een ATtiny841 microprocessor ontworpen. De ATtiny841 heeft ingebouwde Wire-hardware (de laag die onder I²C zit) waardoor deze uitermate geschikt is als I²C Slave voor dit ontwerp.

I2C Rotary Encoder v 2.2 bottom view

De firmware zorgt ervoor dat de ATtiny841 zich, aan de ene kant, als een ‘normale’ I²C Slave gedraagt en aan de andere kant de interface met een RGB Rotary Encoder verzorgt. Om de I²C RotaryEncoder eenvoudig aan te kunnen sturen heb ik een bijpassende en eenvoudig te gebruiken Arduino / ESP8266-bibliotheek geschreven.

Met deze opzet is het mogelijk om zoveel (letterlijk!) I²C RotaryEncoders op je microprocessor aan te sluiten als je wilt en je toch nog steeds slechts twee GPIO-pinnen hoeft te gebruiken. Je kunt zelfs andere I²C-devices (displays, sensoren, enz.) aansluiten op dezelfde twee GPIO-pinnen, waardoor er veel GPIO-pinnen vrij blijven voor andere doeleinden.

I2C BUS

Als je wilt, kun je de Interrupt-pin van de I²C RotaryEncoder gebruiken om je programma "Interrupt-driven" te laten werken.

De Interrupt-pin genereert een Interrupt bij elke verandering in de positie van de Rotary as of drukknop. Alle I²C RotaryEncoders delen dezelfde Interrupt-lijn.

Hoe kun je de I²C RotaryEncoder in je project gebruiken?

De onderstaande code is een voorbeeldschets om te communiceren met de I²C RotaryEncoder (met gebruik van de Interrupt pin):

Basic I2C_RotaryEncoder Sketch

/* Sketch to show the use of the I2C_RotaryEncoder */

#define I2C_DEFAULT_ADDRESS  0x28    // the 7-bit address 

#include <I2C_RotaryEncoder.h>

I2CRE Encoder; // Create instance of the I2CRE object

int16_t       rotVal;

volatile bool interruptPending  = false;

//====================================================================
ISR_PREFIX void handleInterrupt()
{
  interruptPending = true;
}


//====================================================================
void handleRotaryEncoder()
{
  byte statusReg = Encoder.getStatus();
  if (statusReg == 0) return;

  if (Encoder.isRotValChanged() ) {
    Serial.print(F("Request Value of ROTARY .......... "));
    rotVal = Encoder.getRotVal();
    Serial.print(F("["));
    Serial.print(rotVal);
    Serial.println(F("]"));
  }

  if (Encoder.isButtonPressed() ) {
    Serial.println(F("-------> Button Pressed"));
  }
  if (Encoder.isButtonQuickReleased() ) {
    Serial.println(F("-------> Quick Release"));
    Encoder.setRotVal(0);	        // or do something usefull
    Encoder.setRGBcolor(200, 0, 0); // Light the Red LED
  }
  if (Encoder.isButtonMidReleased() ) {
    Serial.println(F("-------> Mid Release"));
    Encoder.setRotVal(255);	        // or do something usefull
    Encoder.setRGBcolor(0, 200, 0); // Light the Green LED
  }
  if (Encoder.isButtonLongReleased() ) {
    Serial.println(F("-------> Long Release"));
    Encoder.setRotVal(128);	         // or do something usefull
    Encoder.setRGBcolor(0, 0, 200);  // Light the Blue LED
  }

} // handleRotaryEncoder();

//====================================================================
void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start I2C-Rotary-Encoder Basic ....\n"));
  Serial.print(F("Setup Wire .."));
  Wire.begin();
  Serial.println(F(".. done"));

  pinMode(_INTERRUPTPIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(_INTERRUPTPIN)
                         , handleInterrupt
                         , FALLING);

  if (!Encoder.begin(Wire, I2C_DEFAULT_ADDRESS)) {
    Serial.println(F(".. Error connecting to I2C slave .."));
    delay(1000);
    return;	// restart the micro processor
  }

  Encoder.setLedGreen(128);      // turn green led on half intensity

  interruptPending  = false;

  Serial.println(F("setup() done .. \n"));

} // setup()

//====================================================================
void loop()
{
  if (interruptPending) {
    interruptPending = false;
    handleRotaryEncoder();
  } // handle interrupt ..

  // do other important stuff ..

} // loop()

SparkFun Qwiic Twist - Breakout voor RGB rotary encoderDe SparkFun Qwiic Twist is een digitale RGB-roterende encoder-breakout die ook kan worden aangesloten op ons Qwiic Connect-systeem. De Twist zorgt voor alle verschillende interrupts, schakelaars, PWM'ing van LED's en presenteert al die functies via een gebruiksvriendelijke I2C-interface. Direct leverbaar € 28,00

Huidige pagina 1. Introductie Volgende pagina 2. I2C Rotary Encoder Library 1. Introductie 2. I2C Rotary Encoder Library 3. Schema I2C Rotary Encoder Geschreven door Willem Aandewiel Website Willem Aandewiel (1955) heeft als achtergrond een opleiding in elektronica en digitale technieken. Het grootste deel van zijn werkbare leven heeft hij echter in de automatisering gewerkt waar hij zo'n beetje in alle disciplines van programmeur tot projectleider en projectmanager heeft gewerkt. Willem was één van de eerste Nederlanders met een micro-computer (KIM-1, 1976) in een tijd dat de PC nog moest worden uitgevonden. Tegenwoordig houdt hij zich vooral bezig met het ontwerpen en maken van kleine elektronische schakelingen met microprocessoren. Zijn ‘mission in life’ is om mensen enthousiast te maken voor het zelf maken van elektronische schakelingen, microcomputers en programmeren.