Codificador rotativo I2C

Colocado sobre 2019-10-01

Codificador Rotativo I²C

Vou cobrir dois tópicos neste artigo.

A primeira é sobre Rotary Encoders e (brevemente) como eles funcionam. A segunda trata do protocolo Inter-Integrated Circuit (I²C) desenvolvido pela Philips.

codificadores rotativos

Um Rotary Encoder é um dispositivo que (fisicamente) se assemelha a um potenciômetro, mas não varia a resistência entre dois/três conectores, mas em vez disso dá pulsos quando o eixo é girado. Outra diferença com o potenciômetro é que você pode girar o eixo em 360° (na verdade, não há limite para quantos graus você pode girar o eixo).

A maioria dos codificadores rotativos possui um botão de pressão que é ativado quando você pressiona o eixo. E existem codificadores rotativos que possuem um LED interno de três cores (o chamado codificador rotativo RGB) com o qual você pode fornecer feedback a um usuário com uma paleta de cores.

Codificador Rotativo RGB

O Rotary Encoder gera pulsos quando o eixo é girado. A maioria dos Rotary Encoders gera 24 pulsos a cada rotação de 360°, mas também existem Rotary Encoders que fornecem mais ou menos pulsos por revolução. Em seu programa, você pode contar esses pulsos e reagir a eles (por exemplo: aumentar ou diminuir a tensão de saída de uma fonte de alimentação ou percorrer uma lista de menu).

Você pode perguntar: " por que usar um Rotary Encoder e não apenas um potenciômetro? ". Claro que não existe uma resposta " isto é melhor do que aquilo". Depende do projeto. Se você estiver construindo um amplificador hi-fi analógico, o potenciômetro é provavelmente a melhor escolha. Se você tem um projeto com um microprocessador, o Rotary Encoder oferece muitas opções para criar uma interface de usuário agradável (talvez com uma mudança fina/grossa, dependendo do toque curto ou longo no eixo e um feedback colorido para mostrar qual modo ativo) .

Abaixo está um esboço de exemplo para “ler” um Rotary Encoder. Para que este programa funcione corretamente e de forma confiável, você precisa de controle de rejeição de hardware (rede RC) nos pinos A e B do 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
 }

Infelizmente, usar um Rotary Encoder em um projeto também tem uma desvantagem: você precisa de muitos pinos GPIO!

Um RGB Rotary Encoder precisa de dois pinos GPIO para o próprio codificador (mais GND), então você precisa de um pino GPIO para o interruptor de pressão e três pinos GPIO para o LED RGB. Isso é um total de seis pinos GPIO! Em um ESP8266, por exemplo, você tem apenas três pinos GPIO sobrando para controlar o resto do seu projeto! Em um Arduino UNO você tem mais pinos GPIO, então um Rotary Encoder não será um problema. Mas e se você quiser conectar dois, três ou até mais codificadores rotativos? Isso não é possível em um ESP8266, mas em um Arduino UNO você logo ficará sem pinos GPIO!

Felizmente, há uma solução!

O barramento de circuito integrado (I²C)

Isso é chamado de "barramento" (dados) porque você pode conectar muitos dispositivos a ele. O "ônibus" consiste em duas linhas. Uma linha de relógio (SCL) e uma linha de dados (SDA). Há sempre (pelo menos) um'mestre'-dispositivo e todos os outros dispositivos são 'escravo' dispositivos. Cada dispositivo tem um endereço único para se distinguir um do outro. Não vou me aprofundar no protocolo I²C, mas normalmente o mestre reivindicará o controle do barramento e enviará uma solicitação a um escravo com um endereço específico. O escravo, por sua vez, realizará uma ação sobre a solicitação, seja executando uma ação específica no próprio escravo, enviando dados de volta ao mestre, ou simplesmente enviando uma confirmação de volta ao mestre informando que recebeu a solicitação. Aqui você pode ler mais sobre o protocolo I²C.

O Codificador Rotativo I²C

Não seria legal poder conectar um Rotary Encoder usando apenas os dois fios do barramento I²C!?

E é disso que trata este post: um Rotary Encoder que você conecta via barramento I²C e controla usando o protocolo I²C.

Desenhei o firmware e uma pequena placa de circuito com um microprocessador ATtiny841. O ATtiny841 possui aramehardware (a camada abaixo do I²C), tornando-o extremamente adequado como I²C Slave para este projeto.

Visão inferior do codificador rotativo I2C v2.2

O firmware garante que o ATtiny841 se comporte, por um lado, como um I²C Slave 'normal' e, por outro lado, fornece a interface com um RGB Rotary Encoder. Para controlar facilmente o I²C RotaryEncoder, tenho um correspondente e fácil de usar Biblioteca Arduino /ESP8266 escrito.

Com esta configuração é possível conectar quantos (literalmente!) I²C RotaryEncoders você quiser ao seu microprocessador e ainda precisar usar apenas dois pinos GPIO. Você pode até mesmo conectar outros dispositivos I²C (displays, sensores, etc.) aos mesmos dois pinos GPIO, deixando muitos pinos GPIO livres para outras finalidades.

ÔNIBUS I2C

Se desejar, você pode usar o pino de interrupção do I²C RotaryEncoder para tornar seu programa "orientado por interrupção".

O pino de interrupção gera uma interrupção a cada mudança na posição do eixo rotativo ou botão de pressão. Todos os I²C RotaryEncoders compartilham a mesma linha de interrupção.

Como você pode usar o I²C RotaryEncoder em seu projeto?

O código abaixo é um esboço de exemplo para se comunicar com o I²C RotaryEncoder (usando o pino de interrupção):

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 - Descoberta do Codificador Rotativo RGBO Sparkfun Qwiic Twist é um codificador rotativo RGB digital fácil de usar que simplifica a fiação e a codificação. Possui um botão integrado, suporta até 16 milhões de cores e conecta-se facilmente ao sistema Qwiic. Ideal para projetos Arduino . Em estoque € 28,45

Pagina atual 1. Introdução Próxima página 2. Biblioteca do codificador rotativo I2C 1. Introdução 2. Biblioteca do codificador rotativo I2C 3. Codificador Rotativo I2C Esquemático postado por Willem Aandewiel Local na rede Internet Willem Aandewiel (1955) tem formação em eletrônica e técnicas digitais. No entanto, na maior parte de sua vida profissional, ele trabalhou em automação, onde trabalhou em praticamente todas as disciplinas, de programador a líder de projeto e gerente de projeto. Willem foi um dos primeiros holandeses com um microcomputador (KIM-1, 1976) numa época em que o PC ainda não havia sido inventado. Actualmente dedica-se principalmente à concepção e produção de pequenos circuitos electrónicos com microprocessadores. Sua 'missão na vida' é fazer as pessoas se entusiasmarem em fazer seus próprios circuitos eletrônicos, microcomputadores e programação.