I2C roterende encoder

Placeret på 2019-10-01

I²C Rotary Encoder

Jeg vil dække to emner i denne artikel.

Den første handler om Rotary Encodere og (kort) hvordan de fungerer. Den anden handler om Inter-Integrated Circuit-protokollen (I²C) udviklet af Philips.

roterende encodere

En Rotary Encoder er en enhed, der (fysisk) minder om et potentiometer, men som ikke varierer modstanden mellem to/tre stik men i stedet giver impulser, når akslen drejes. En anden forskel med potentiometret er, at man kan dreje akslen 360° (der er faktisk ingen grænse for, hvor mange grader man kan dreje akslen).

De fleste roterende encodere har en trykkontakt, der aktiveres, når du trykker på akslen. Og der er Rotary Encodere, der har en intern tre-farvet LED (såkaldt RGB Rotary Encoder), hvormed man kan give feedback til en bruger med en palet af farver.

RGB Rotary Encoder

Rotary Encoder genererer impulser, når akslen drejes. De fleste Rotary Encodere genererer 24 impulser for hver 360° rotation, men der er også Rotary Encodere, der leverer flere eller færre impulser pr. omdrejning. I dit program kan du tælle disse impulser og reagere på dem (for eksempel: øge eller mindske udgangsspændingen på en strømforsyning eller gå gennem en menuliste).

Du kan spørge: " hvorfor bruge en roterende encoder og ikke bare et potentiometer? ". Selvfølgelig er der ikke noget " dette er bedre end det " svar på dette. Det afhænger af projektet. Hvis du bygger en analog hi-fi-forstærker, er potentiometeret sandsynligvis det bedre valg. Hvis du har et projekt med en mikroprocessor, giver Rotary Encoder dig mange muligheder for at skabe en god brugergrænseflade (med måske en fin/grov ændring afhængigt af det korte eller lange tryk på aksen og en farvet feedback for at vise, hvilken tilstand der er aktiv) .

Nedenfor er en eksempelskitse til at "læse" en roterende encoder. For at dette program skal fungere korrekt og pålideligt, har du brug for hardware-bounce-kontrol (RC-netværk) på ben A og B på encoderen:

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
 }

Desværre har det også en ulempe at bruge en Rotary Encoder i et projekt: du har brug for mange GPIO-ben!

En RGB Rotary Encoder har brug for to GPIO-ben til selve Encoderen (plus GND), så skal du bruge en GPIO-pin til trykkontakten og tre GPIO-ben til RGB LED. Det er i alt seks GPIO-ben! På en ESP8266 har du for eksempel kun tre GPIO-ben tilbage til at styre resten af dit projekt! På en Arduino UNO har du flere GPIO-ben, så en Rotary Encoder vil ikke være et problem. Men hvad nu hvis du vil forbinde to, tre eller endda flere roterende encodere. Det er ikke muligt på en ESP8266, men på en Arduino UNO vil du snart løbe tør for GPIO-pins!

Heldigvis er der en løsning!

Inter-Integrated Circuit bus (I²C)

Dette kaldes en (data) "bus", fordi du kan tilslutte mange enheder til den. "Bussen" består af to linjer. En kloklinje (SCL) og en datalinje (SDA). Der er altid (mindst) én'mestre'-enhed og alle andre enheder er'slave' enheder. Hver enhed har en unik adresse for at adskille sig fra hinanden. Jeg vil ikke gå i dybden med I²C-protokollen, men normalt vil masteren kræve kontrol over bussen og sende en anmodning til en slave med en specifik adresse. Slaven vil til gengæld tage handling på anmodningen, enten ved at udføre en specifik handling i selve slaven, sende data tilbage til masteren, eller blot sende en bekræftelse tilbage til masteren, der fortæller den, at han har modtaget anmodningen. Her du kan læse mere om I²C-protokollen.

I²C Rotary Encoder

Ville det ikke være rart at kunne tilslutte en Rotary Encoder kun ved hjælp af de to ledninger i I²C-bussen!?

Og det er, hvad dette indlæg i virkeligheden handler om: en Rotary Encoder, som du forbinder via I²C-bussen og styrer ved hjælp af I²C-protokollen.

Jeg designede firmwaren og et lille printkort med en ATtiny841 mikroprocessor. ATtiny841 har indbygget trådhardware (laget under I²C), hvilket gør den yderst velegnet som I²C-slave til dette design.

I2C Rotary Encoder v2.2 set nedefra

Firmwaren sikrer, at ATtiny841 på den ene side opfører sig som en 'normal' I²C Slave og på den anden side forsyner interfacet med en RGB Rotary Encoder. For nemt at styre I²C RotaryEncoder har jeg en matchende og nem at bruge Arduino / ESP8266 bibliotek skrevet.

Med denne opsætning er det muligt at forbinde så mange (bogstaveligt talt!) I²C RotaryEncoders til din mikroprocessor, som du vil, og stadig kun behøver at bruge to GPIO-ben. Du kan endda forbinde andre I²C-enheder (skærme, sensorer osv.) til de samme to GPIO-ben, hvilket efterlader mange GPIO-ben fri til andre formål.

I2C BUS

Hvis du vil, kan du bruge Interrupt-stiften på I²C RotaryEncoder til at gøre dit program "Interrupt-drevet".

Afbrydelsesstiften genererer en afbrydelse ved hver ændring i positionen af den roterende aksel eller trykknap. Alle I²C RotaryEncoders deler den samme afbrydelseslinje.

Hvordan kan du bruge I²C RotaryEncoder i dit projekt?

Koden nedenfor er en eksempelskitse til at kommunikere med I²C RotaryEncoder (ved hjælp af Interrupt-stiften):

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 - RGB Rotary Encoder BreakoutSparkfun Qwiic Twist er en brugervenlig digital RGB roterende encoder, der forenkler ledninger og kodning. Den har en indbygget knap, understøtter op til 16M farver og forbindes nemt med Qwiic-systemet. Ideel til Arduino projekter. På lager € 28,95

Nuværende side 1. Introduktion Næste side 2. I2C Rotary Encoder Library 1. Introduktion 2. I2C Rotary Encoder Library 3. Skematisk I2C Rotary Encoder Sendt af Willem Aandewiel Internet side Willem Aandewiel (1955) har en baggrund i elektronik og digitale teknikker. Det meste af sit arbejdsliv har han dog arbejdet med automation, hvor han har arbejdet i stort set alle discipliner fra programmør til projektleder og projektleder. Willem var en af de første hollændere med en mikrocomputer (KIM-1, 1976) på et tidspunkt, hvor pc'en endnu ikke var opfundet. I dag beskæftiger han sig hovedsageligt med design og produktion af små elektroniske kredsløb med mikroprocessorer. Hans 'mission i livet' er at gøre folk begejstrede for at lave deres egne elektroniske kredsløb, mikrocomputere og programmering.

I2C roterende encoder

I²C Rotary Encoder

roterende encodere

Demo Sketch Rotary Encoder

Heldigvis er der en løsning!

Inter-Integrated Circuit bus (I²C)

I²C Rotary Encoder

Hvordan kan du bruge I²C RotaryEncoder i dit projekt?

Basic I2C_RotaryEncoder Sketch

Kommentarer