Encoder rotativo I2C

Posto su 2019-10-01

Encoder rotativo I²C

Tratterò due argomenti in questo articolo.

Il primo riguarda i codificatori rotativi e (brevemente) il loro funzionamento. Il secondo riguarda il protocollo Inter-Integrated Circuit (I²C) sviluppato da Philips.

encoder rotativi

Un codificatore rotativo è un dispositivo che (fisicamente) assomiglia a un potenziometro, ma non varia la resistenza tra due/tre connettori ma dà invece impulsi quando l'albero viene ruotato. Un'altra differenza con il potenziometro è che puoi ruotare l'albero di 360° (non c'è infatti limite a quanti gradi puoi ruotare l'albero).

La maggior parte degli encoder rotativi dispone di un interruttore a pressione che si attiva quando si preme l'albero. E ci sono Rotary Encoder che hanno un LED interno a tre colori (il cosiddetto RGB Rotary Encoder) con cui puoi dare un feedback a un utente con una tavolozza di colori.

Codificatore rotativo RGB

L'encoder rotativo genera impulsi quando l'albero viene ruotato. La maggior parte degli encoder rotativi genera 24 impulsi per ogni rotazione di 360°, ma esistono anche encoder rotativi che forniscono più o meno impulsi per giro. Nel tuo programma puoi contare questi impulsi e reagire ad essi (ad esempio: aumentare o diminuire la tensione di uscita di un alimentatore o scorrere un elenco di menu).

Potreste chiedervi: " perché usare un Rotary Encoder e non solo un potenziometro? ". Ovviamente non esiste una risposta " questo è meglio di quello ". Dipende dal progetto. Se stai costruendo un amplificatore hi-fi analogico, il potenziometro è probabilmente la scelta migliore. Se hai un progetto con un microprocessore, il Rotary Encoder ti offre molte opzioni per creare una bella interfaccia utente (con forse un cambiamento fine/grossolano a seconda della pressione breve o lunga sull'asse e un feedback colorato per mostrare quale modalità è attiva) .

Di seguito è riportato uno schizzo di esempio per "leggere" un codificatore rotativo. Affinché questo programma funzioni correttamente e in modo affidabile, è necessario il controllo del rimbalzo dell'hardware (rete RC) sui pin A e B dell'encoder:

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
 }

Sfortunatamente, l'utilizzo di un codificatore rotativo in un progetto presenta anche uno svantaggio: sono necessari molti pin GPIO!

Un codificatore rotativo RGB necessita di due pin GPIO per l'encoder stesso (più GND), quindi è necessario un pin GPIO per l'interruttore a pressione e tre pin GPIO per il LED RGB. Questo è un totale di sei pin GPIO! Su un ESP8266, ad esempio, ti rimangono solo tre pin GPIO per controllare il resto del tuo progetto! Su un Arduino UNO hai più pin GPIO, quindi un encoder rotativo non sarà un problema. Ma cosa succede se si desidera collegare due, tre o anche più encoder rotativi. Ciò non è possibile su un ESP8266, ma su un Arduino UNO finirai presto i pin GPIO!

Fortunatamente, c'è una soluzione!

Il bus a circuito integrato (I²C)

Questo è chiamato "bus" (dati) perché è possibile collegare molti dispositivi ad esso. Il "bus" è composto da due linee. Una linea orologio (SCL) e una linea dati (SDA). C'è sempre (almeno) uno'maestro'-dispositivo e tutti gli altri dispositivi sono 'schiavo' dispositivi. Ogni dispositivo ha un indirizzo univoco per distinguersi l'uno dall'altro. Non entrerò nei dettagli del protocollo I²C, ma normalmente il master rivendicherà il controllo del bus e invierà una richiesta a uno slave con un indirizzo specifico. Lo slave, a sua volta, agirà sulla richiesta, eseguendo un'azione specifica nello slave stesso, inviando i dati al master, o semplicemente inviando un messaggio di conferma al master per informarlo che ha ricevuto la richiesta. Qui puoi leggere di più sul protocollo I²C.

Il codificatore rotativo I²C

Non sarebbe bello poter collegare un Rotary Encoder utilizzando solo i due fili del bus I²C!?

Ed è proprio di questo che tratta questo post: un encoder rotativo che colleghi tramite il bus I²C e controlli utilizzando il protocollo I²C.

Ho progettato il firmware e un piccolo circuito stampato con un microprocessore ATtiny841. ATtiny841 ha integrato filohardware (lo strato sotto I²C) che lo rende estremamente adatto come slave I²C per questo progetto.

Encoder rotativo I2C v2.2 vista dal basso

Il firmware garantisce che l'ATtiny841 si comporti, da un lato, come un "normale" I²C Slave e, dall'altro, fornisca l'interfaccia con un codificatore rotativo RGB. Per controllare facilmente l'I²C RotaryEncoder ne ho uno corrispondente e facile da usare Libreria Arduino /ESP8266 scritto.

Con questa configurazione è possibile collegare tutti i (letteralmente!) I²C RotaryEncoder al microprocessore che si desidera e comunque è necessario utilizzare solo due pin GPIO. Puoi persino collegare altri dispositivi I²C (display, sensori, ecc.) agli stessi due pin GPIO, lasciando molti pin GPIO liberi per altri scopi.

AUTOBUS I2C

Se lo desideri, puoi utilizzare il pin di interruzione dell'I²C RotaryEncoder per rendere il tuo programma "guidato da interruzioni".

Il pin di interruzione genera un'interruzione a ogni modifica della posizione dell'albero rotante o del pulsante. Tutti i RotaryEncoder I²C condividono la stessa linea di interrupt.

Come puoi utilizzare l'I²C RotaryEncoder nel tuo progetto?

Il codice seguente è uno schizzo di esempio per comunicare con l'I²C RotaryEncoder (utilizzando il pin di interruzione):

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 dell'encoder rotativo RGBSparkfun Qwiic Twist è un codificatore rotativo RGB digitale facile da usare che semplifica il cablaggio e la codifica. È dotato di un pulsante integrato, supporta fino a 16 milioni di colori e si collega facilmente al sistema Qwiic. Ideale per progetti Arduino . disponibile € 28,25

Pagina corrente 1. introduzione Pagina successiva 2. Libreria codificatore rotativo I2C 1. introduzione 2. Libreria codificatore rotativo I2C 3. Encoder rotativo I2C schematico Pubblicato da Willem Aandewiel Sito web Willem Aandewiel (1955) ha un background in elettronica e tecniche digitali. Tuttavia, la maggior parte della sua vita lavorativa ha lavorato nell'automazione, dove ha lavorato in quasi tutte le discipline, dal programmatore al project leader e al project manager. Willem è stato uno dei primi olandesi con un microcomputer (KIM-1, 1976) in un'epoca in cui il PC doveva ancora essere inventato. Attualmente si occupa principalmente della progettazione e produzione di piccoli circuiti elettronici a microprocessore. La sua "missione nella vita" è rendere le persone entusiaste di creare i propri circuiti elettronici, microcomputer e programmazione.