I2C roterande encoder

Placerad på 2019-10-01

I²C Rotary Encoder

Jag kommer att täcka två ämnen i den här artikeln.

Den första handlar om Rotary Encoders och (kortfattat) hur de fungerar. Den andra handlar om Inter-Integrated Circuit-protokollet (I²C) som utvecklats av Philips.

roterande pulsgivare

En Rotary Encoder är en anordning som (fysiskt) liknar en potentiometer, men som inte varierar motståndet mellan två/tre kontakter utan istället ger pulser när axeln vrids. En annan skillnad med potentiometern är att du kan rotera axeln 360° (det finns faktiskt ingen gräns för hur många grader du kan rotera axeln).

De flesta roterande kodare har en tryckknapp som aktiveras när du trycker på axeln. Och det finns Rotary Encoders som har en intern trefärgad LED (så kallad RGB Rotary Encoder) med vilken man kan ge feedback till en användare med en palett av färger.

RGB Rotary Encoder

Rotary Encoder genererar pulser när axeln vrids. De flesta roterande kodare genererar 24 pulser med varje 360° rotation, men det finns även roterande kodare som levererar fler eller färre pulser per varv. I ditt program kan du räkna dessa pulser och reagera på dem (till exempel: öka eller minska utspänningen från ett nätaggregat eller gå igenom en menylista).

Du kanske frågar: " varför använda en roterande kodare och inte bara en potentiometer? ". Naturligtvis finns det inget " det här är bättre än det" svar på detta. Det beror på projektet. Om du bygger en analog hi-fi-förstärkare är potentiometern förmodligen det bättre valet. Om du har ett projekt med en mikroprocessor så ger Rotary Encoder dig många alternativ för att skapa ett snyggt användargränssnitt (med kanske en fin/grov förändring beroende på kort eller lång tryckning på axeln och en färgad feedback för att visa vilket läge som är aktivt) .

Nedan finns en exempelskiss för att "läsa" en roterande kodare. För att det här programmet ska fungera korrekt och tillförlitligt behöver du maskinvarustudskontroll (RC-nätverk) på stift A och B på kodaren:

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
 }

Tyvärr har det också en nackdel att använda en Rotary Encoder i ett projekt: du behöver många GPIO-stift!

En RGB Rotary Encoder behöver två GPIO-stift för själva kodaren (plus GND), sedan behöver du ett GPIO-stift för tryckbrytaren och tre GPIO-stift för RGB LED. Det är totalt sex GPIO-stift! På en ESP8266, till exempel, har du bara tre GPIO-stift kvar för att styra resten av ditt projekt! På en Arduino UNO har du fler GPIO-stift så en Rotary Encoder kommer inte att vara ett problem. Men tänk om du vill ansluta två, tre eller till och med fler roterande kodare. Det är inte möjligt på en ESP8266, men på en Arduino UNO kommer du snart att få slut på GPIO-stift!

Lyckligtvis finns det en lösning!

Inter-Integrated Circuit-bussen (I²C)

Detta kallas en (data) "buss" eftersom du kan ansluta många enheter till den. "Bussen" består av två linjer. En klocklinje (SCL) och en datalinje (SDA). Det finns alltid (minst) enbemästra'-enhet och alla andra enheter är'slav' enheter. Varje enhet har en unik adress för att skilja sig från varandra. Jag går inte in på djupet av I²C-protokollet, men normalt kommer mastern att göra anspråk på kontroll över bussen och skicka en förfrågan till en slav med en specifik adress. Slaven kommer i sin tur att vidta åtgärder på begäran, antingen genom att utföra en specifik åtgärd i själva slaven, skicka data tillbaka till mastern eller helt enkelt skicka en bekräftelse tillbaka till mastern som låter den veta att han har tagit emot förfrågan. Här du kan läsa mer om I²C-protokollet.

I²C Rotary Encoder

Skulle det inte vara trevligt att kunna ansluta en roterande kodare med endast de två ledningarna på I²C-bussen!?

Och det är vad det här inlägget egentligen handlar om: en Rotary Encoder som du ansluter via I²C-bussen och styr med I²C-protokollet.

Jag designade firmware och ett litet kretskort med en ATtiny841 mikroprocessor. ATtiny841 har inbyggd trådhårdvara (lagret under I²C) vilket gör den extremt lämplig som en I²C-slav för denna design.

I2C Rotary Encoder v2.2 bottenvy

Den fasta programvaran säkerställer att ATtiny841 å ena sidan beter sig som en "normal" I²C-slav och å andra sidan förser gränssnittet med en RGB Rotary Encoder. För att enkelt styra I²C RotaryEncoder har jag en matchande och lättanvänd Arduino / ESP8266 bibliotek skriven.

Med denna inställning är det möjligt att ansluta så många (bokstavligen!) I²C RotaryEncoders till din mikroprocessor som du vill och fortfarande bara behöver använda två GPIO-stift. Du kan till och med ansluta andra I²C-enheter (skärmar, sensorer, etc.) till samma två GPIO-stift och lämna många GPIO-stift lediga för andra ändamål.

I2C BUS

Om du vill kan du använda avbrottsstiftet på I²C RotaryEncoder för att göra ditt program "avbrottsdrivet".

Avbrottsstiftet genererar ett avbrott vid varje förändring av den roterande axelns eller tryckknappens position. Alla I²C RotaryEncoders delar samma avbrottslinje.

Hur kan du använda I²C RotaryEncoder i ditt projekt?

Koden nedan är en exempelskiss för att kommunicera med I²C RotaryEncoder (med avbrottsstiftet):

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 är en användarvänlig digital RGB-rotationskodare som förenklar kabeldragning och kodning. Den har en inbyggd knapp, stöder upp till 16 miljoner färger och ansluts enkelt till Qwiic-systemet. Perfekt för Arduino projekt. I lager € 28,95

Nuvarande sida 1. Introduktion Nästa sida 2. I2C Rotary Encoder Library 1. Introduktion 2. I2C Rotary Encoder Library 3. Schematisk I2C Rotary Encoder Postat av Willem Aandewiel Hemsida Willem Aandewiel (1955) har en bakgrund inom elektronik och digital teknik. Men större delen av sitt yrkesverksamma liv har han arbetat inom automation där han har arbetat inom i stort sett alla discipliner från programmerare till projektledare och projektledare. Willem var en av de första holländarna med en mikrodator (KIM-1, 1976) vid en tidpunkt då datorn ännu inte hade uppfunnits. Numera sysslar han främst med design och produktion av små elektroniska kretsar med mikroprocessorer. Hans "uppdrag i livet" är att göra människor entusiastiska över att göra sina egna elektroniska kretsar, mikrodatorer och programmering.

I2C roterande encoder

I²C Rotary Encoder

roterande pulsgivare

Demo Sketch Rotary Encoder

Lyckligtvis finns det en lösning!

Inter-Integrated Circuit-bussen (I²C)

I²C Rotary Encoder

Hur kan du använda I²C RotaryEncoder i ditt projekt?

Basic I2C_RotaryEncoder Sketch

Kommentarer