Codificador rotatorio I2C

Colocado en 2019-10-01

Codificador rotatorio I²C

Cubriré dos temas en este artículo.

El primero es sobre codificadores rotatorios y (brevemente) cómo funcionan. El segundo es sobre el protocolo de Circuito Inter-Integrado (I²C) desarrollado por Philips.

codificadores rotatorios

Un codificador rotatorio es un dispositivo que (físicamente) se parece a un potenciómetro, pero no varía la resistencia entre dos o tres conectores, sino que emite pulsos cuando se gira el eje. Otra diferencia con el potenciómetro es que puede girar el eje 360° (de hecho, no hay límite en cuanto a la cantidad de grados que puede girar el eje).

La mayoría de los codificadores rotatorios tienen un interruptor de presión que se activa cuando presiona el eje. Y hay codificadores rotatorios que tienen un LED interno de tres colores (el llamado codificador rotatorio RGB) con el que puede dar retroalimentación a un usuario con una paleta de colores.

Codificador rotatorio RGB

El codificador rotatorio genera pulsos cuando se gira el eje. La mayoría de los codificadores rotatorios generan 24 pulsos con cada rotación de 360°, pero también hay codificadores rotatorios que entregan más o menos pulsos por revolución. En su programa puede contar estos pulsos y reaccionar ante ellos (por ejemplo: aumentar o disminuir el voltaje de salida de una fuente de alimentación o recorrer una lista de menú).

Puede preguntarse: "¿ por qué usar un codificador rotatorio y no solo un potenciómetro? ". Por supuesto, no hay una respuesta de " esto es mejor que aquello ". Depende del proyecto. Si está construyendo un amplificador de alta fidelidad analógico, el potenciómetro es probablemente la mejor opción. Si tiene un proyecto con un microprocesador, el codificador rotatorio le brinda muchas opciones para crear una interfaz de usuario agradable (tal vez con un cambio fino/grueso dependiendo de la presión corta o larga en el eje y una retroalimentación de color para mostrar qué modo activo) .

A continuación se muestra un boceto de ejemplo para "leer" un codificador rotatorio. Para que este programa funcione correctamente y de manera confiable, necesita un control de rebote de hardware (red RC) en los pines A y B del codificador:

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
 }

Desafortunadamente, usar un codificador rotatorio en un proyecto también tiene una desventaja: ¡necesita muchos pines GPIO!

Un codificador rotatorio RGB necesita dos pines GPIO para el propio codificador (más GND), luego necesita un pin GPIO para el interruptor pulsador y tres pines GPIO para el LED RGB. ¡Eso es un total de seis pines GPIO! En un ESP8266, por ejemplo, ¡solo le quedan tres pines GPIO para controlar el resto de su proyecto! En un Arduino UNO, tiene más pines GPIO, por lo que un codificador rotatorio no será un problema. Pero, ¿qué sucede si desea conectar dos, tres o incluso más codificadores rotatorios? Eso no es posible en un ESP8266, pero en un Arduino UNO pronto se quedará sin pines GPIO.

¡Afortunadamente, hay una solución!

El bus de circuito interintegrado (I²C)

Esto se llama un "bus" (de datos) porque puede conectar muchos dispositivos a él. El "autobús" consta de dos líneas. Una línea de reloj (SCL) y una línea de datos (SDA). Siempre hay (al menos) uno'maestro'-dispositivo y todos los demás dispositivos son 'esclavo' dispositivos. Cada dispositivo tiene una dirección única para distinguirse entre sí. No profundizaré en el protocolo I²C, pero normalmente el maestro reclamará el control del bus y enviará una solicitud a un esclavo con una dirección específica. El esclavo, a su vez, tomará medidas sobre la solicitud, ya sea realizando una acción específica en el mismo esclavo, enviando datos de vuelta al maestro, o simplemente enviando un acuse de recibo al maestro haciéndole saber que ha recibido la solicitud. Aquí puede leer más sobre el protocolo I²C.

El codificador rotatorio I²C

¿No sería bueno poder conectar un codificador rotatorio usando solo los dos cables del bus I²C?

Y de eso se trata realmente esta publicación: un codificador rotatorio que se conecta a través del bus I²C y se controla mediante el protocolo I²C.

Diseñé el firmware y una pequeña placa de circuito con un microprocesador ATtiny841. El ATtiny841 tiene incorporado cablehardware (la capa debajo de I²C) lo que lo hace extremadamente adecuado como esclavo I²C para este diseño.

Vista inferior del codificador rotatorio I2C v2.2

El firmware asegura que el ATtiny841 se comporte, por un lado, como un esclavo I²C 'normal' y, por otro lado, proporciona la interfaz con un codificador rotatorio RGB. Para controlar fácilmente el codificador rotatorio I²C, tengo uno a juego y fácil de usar Biblioteca Arduino / ESP8266 escrito.

Con esta configuración, es posible conectar tantos (¡literalmente!) codificadores rotatorios I²C a su microprocesador como desee y solo necesita usar dos pines GPIO. Incluso puede conectar otros dispositivos I²C (pantallas, sensores, etc.) a los mismos dos pines GPIO, dejando muchos pines GPIO libres para otros fines.

AUTOBÚS I2C

Si lo desea, puede usar el pin de interrupción del codificador rotatorio I²C para hacer que su programa sea "impulsado por interrupciones".

El pin de interrupción genera una interrupción con cada cambio en la posición del eje giratorio o del botón pulsador. Todos los codificadores rotatorios I²C comparten la misma línea de interrupción.

¿Cómo puede utilizar el codificador rotatorio I²C en su proyecto?

El siguiente código es un boceto de ejemplo para comunicarse con el codificador rotatorio I²C (usando el pin de interrupción):

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 - Desglose del codificador rotatorio RGBEl Sparkfun Qwiic Twist es un codificador rotatorio RGB digital fácil de usar que simplifica el cableado y la codificación. Cuenta con un botón incorporado, admite hasta 16 millones de colores y se conecta fácilmente con el sistema Qwiic. Ideal para proyectos Arduino . En stock € 28,00

Página actual 1. Introducción Siguiente página 2. Biblioteca de codificadores rotatorios I2C 1. Introducción 2. Biblioteca de codificadores rotatorios I2C 3. Codificador rotatorio esquemático I2C Publicado por Willem Aandewiel Sitio web Willem Aandewiel (1955) tiene experiencia en electrónica y técnicas digitales. Sin embargo, la mayor parte de su vida laboral ha trabajado en automatización, donde ha trabajado en casi todas las disciplinas, desde programador hasta líder de proyecto y gerente de proyecto. Willem fue uno de los primeros holandeses con una microcomputadora (KIM-1, 1976) en un momento en que aún no se había inventado la PC. Actualmente se dedica principalmente al diseño y producción de pequeños circuitos electrónicos con microprocesadores. Su 'misión en la vida' es hacer que la gente se entusiasme con la fabricación de sus propios circuitos electrónicos, microcomputadoras y programación.