Arduino - Encoder Rotativo
Neste tutorial, vamos aprender a usar o encoder incremental com o Arduino. Em detalhes, vamos aprender:
- Como um encoder rotativo funciona
- Encoder rotativo vs potenciômetro
- Como conectar o encoder rotativo ao Arduino
- Como programar o Arduino para ler a direção e a posição do encoder rotativo SEM interrupção
- Como programar o Arduino para ler a direção e a posição do encoder rotativo COM interrupção
Hardware Necessário
Or you can buy the following kits:
| 1 | × | DIYables STEM V3 Starter Kit (Arduino included) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Divulgação: Alguns dos links desta seção são links de afiliado da Amazon. Podemos receber uma comissão pelas compras feitas por meio desses links, sem custo adicional para você. Agradecemos o seu apoio.
Sobre o Encoder Rotativo
Um encoder rotativo é um dispositivo eletromecânico que converte o movimento de rotação em um sinal elétrico. Ele mede a rotação e a posição de um eixo ou knob. Existem dois tipos principais:
- Encoder incremental: gera pulsos para medir a mudança relativa
- Encoder absoluto: fornece um código digital único para cada posição, o que o torna ideal para posicionamento preciso mesmo após uma perda de energia.
Este guia é sobre o encoder incremental.
Pinagem do Módulo Encoder Rotativo
Um módulo encoder rotativo tem 4 pinos:
- Pino CLK (Saída A): é o pulso principal que nos diz quanta rotação ocorreu. Sempre que você gira o knob em um detent (clique) em qualquer direção, o pino CLK gera um sinal que completa um ciclo inteiro (LOW → HIGH → LOW).
- Pino DT (Saída B): funciona como o pino CLK, mas gera um sinal atrasado 90 graus em relação ao sinal CLK. Ele nos ajuda a descobrir a direção da rotação (sentido horário ou anti-horário).
- Pino SW: é a saída do botão de pressão dentro do encoder. Ele é normalmente aberto. Se usarmos um resistor de pull-up neste pino, o pino SW ficará em HIGH quando o knob não estiver pressionado e em LOW quando estiver pressionado.
- Pino VCC (+): deve ser conectado ao VCC (entre 3,3 e 5 volts)
- Pino GND: deve ser conectado ao GND (0V)
Encoder Rotativo vs Potenciômetro
Você pode confundir o encoder rotativo com o potenciômetro, mas eles são componentes diferentes. Veja uma comparação entre eles:
- O encoder rotativo é como a versão moderna do potenciômetro, mas pode fazer mais coisas.
- O encoder rotativo pode girar uma volta completa sem parar, enquanto o potenciômetro só gira cerca de três quartos da volta.
- O encoder rotativo gera pulsos, enquanto o potenciômetro gera uma tensão analógica.
- O encoder rotativo é útil quando você só precisa saber quanto o knob se moveu, e não exatamente onde ele está. O potenciômetro é útil quando você realmente precisa saber exatamente onde o knob está.
Como o Encoder Rotativo Funciona
Dentro do encoder, há um disco com ranhuras conectado a um pino chamado C, que funciona como um terra comum. Há mais dois pinos, A e B.
- Quando você gira o knob, os pinos A e B tocam o pino terra comum C, mas em uma certa ordem, dependendo do sentido em que você gira o knob (horário ou anti-horário).
- Esses toques criam dois sinais. Eles têm uma pequena diferença de tempo porque um pino toca o terra antes do outro. Os dois sinais ficam 90 graus fora de sincronia um com o outro. Isso se chama codificação em quadratura.
- Quando você gira o knob no sentido horário, o pino A toca o terra antes do pino B. Quando você gira o knob no sentido anti-horário, o pino B toca o terra antes do pino A.
- Monitorando quando cada pino toca ou deixa o terra, podemos descobrir para que lado o knob está girando. Fazemos isso verificando o que acontece com o pino B quando o pino A muda.
Quando A muda de estado de LOW para HIGH:
- Se B estiver em LOW, o knob foi girado no sentido horário.
- Se B estiver em HIGH, o knob foi girado no sentido anti-horário.
※ Nota:
Os pinos A e B estão conectados aos pinos CLK e DT. No entanto, dependendo do fabricante, a ordem pode ser diferente. Os códigos fornecidos abaixo foram testados com o encoder rotativo da DIYables
Como Programar o Encoder Rotativo
- Verifique o sinal do pino CLK
- Se o estado mudar de LOW para HIGH, verifique o estado do pino DT.
- Se o estado do pino DT for HIGH, o knob foi girado no sentido anti-horário; aumente o contador em 1
- Se o estado do pino DT for LOW, o knob foi girado no sentido horário; diminua o contador em 1
Diagrama de Ligação
This image is created using Fritzing. Click to enlarge image
Código Arduino – Encoder Rotativo sem Interrupção
O código Arduino abaixo faz o seguinte:
- Detecta a direção e a quantidade de rotação do encoder.
- Se detectar que o knob foi girado um detent (clique) no sentido horário, aumenta o contador em um.
- Se detectar que o knob foi girado um detent (clique) no sentido anti-horário, diminui o contador em um.
- Detecta se o botão foi pressionado.
/*
* Este código de Arduino foi desenvolvido por pt.newbiely.com
* Este código de Arduino é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/arduino/arduino-rotary-encoder
*/
#include <ezButton.h> // the library to use for SW pin
#define CLK_PIN 2
#define DT_PIN 3
#define SW_PIN 4
#define DIRECTION_CW 0 // clockwise direction
#define DIRECTION_CCW 1 // counter-clockwise direction
int counter = 0;
int direction = DIRECTION_CW;
int CLK_state;
int prev_CLK_state;
ezButton button(SW_PIN); // create ezButton object that attach to pin 4
void setup() {
Serial.begin(9600);
// configure encoder pins as inputs
pinMode(CLK_PIN, INPUT);
pinMode(DT_PIN, INPUT);
button.setDebounceTime(50); // set debounce time to 50 milliseconds
// read the initial state of the rotary encoder's CLK pin
prev_CLK_state = digitalRead(CLK_PIN);
}
void loop() {
button.loop(); // MUST call the loop() function first
// read the current state of the rotary encoder's CLK pin
CLK_state = digitalRead(CLK_PIN);
// If the state of CLK is changed, then pulse occurred
// React to only the rising edge (from LOW to HIGH) to avoid double count
if (CLK_state != prev_CLK_state && CLK_state == HIGH) {
// if the DT state is HIGH
// the encoder is rotating in counter-clockwise direction => decrease the counter
if (digitalRead(DT_PIN) == HIGH) {
counter--;
direction = DIRECTION_CCW;
} else {
// the encoder is rotating in clockwise direction => increase the counter
counter++;
direction = DIRECTION_CW;
}
Serial.print("DIRECTION: ");
if (direction == DIRECTION_CW)
Serial.print("Clockwise");
else
Serial.print("Counter-clockwise");
Serial.print(" | COUNTER: ");
Serial.println(counter);
}
// save last CLK state
prev_CLK_state = CLK_state;
if (button.isPressed()) {
Serial.println("The button is pressed");
}
}
Para simplificar o código de debounce do botão, usamos a biblioteca ezButton.
Passos Rápidos
- Instale a biblioteca ezButton no Arduino IDE. Veja Como Fazer
- Copie o código acima e abra-o no Arduino IDE
- Clique no botão Upload no Arduino IDE para carregar o código no Arduino
- Gire o knob no sentido horário e depois no sentido anti-horário
- Pressione o knob
- Veja o resultado no Serial Monitor.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Arduino Uno' on 'COM15')
New Line
9600 baud
DIRECTION: Clockwise | COUNTER: 1
DIRECTION: Clockwise | COUNTER: 2
DIRECTION: Clockwise | COUNTER: 3
DIRECTION: Clockwise | COUNTER: 4
DIRECTION: Clockwise | COUNTER: 5
DIRECTION: Counter-clockwise | COUNTER: 4
DIRECTION: Counter-clockwise | COUNTER: 3
DIRECTION: Counter-clockwise | COUNTER: 2
DIRECTION: Counter-clockwise | COUNTER: 1
DIRECTION: Counter-clockwise | COUNTER: 0
The button is pressed
Explicação do Código
Confira os comentários linha por linha no código
Código Arduino – Encoder Rotativo com Interrupção
No código de exemplo anterior, usamos o método de polling, que verifica continuamente o estado do pino. Isso tem duas desvantagens:
- Desperdiça recursos do Arduino
- Alguns pulsos do contador podem ser perdidos se outro trecho de código demorar muito para executar.
Uma forma de resolver isso é usar interrupções. As interrupções eliminam a necessidade de verificar constantemente um determinado evento. Isso permite que o Arduino realize outras tarefas sem deixar passar nenhum evento.
Veja um exemplo de como ler um encoder rotativo com interrupções.
/*
* Este código de Arduino foi desenvolvido por pt.newbiely.com
* Este código de Arduino é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/arduino/arduino-rotary-encoder
*/
#include <ezButton.h> // the library to use for SW pin
#define CLK_PIN 2
#define DT_PIN 3
#define SW_PIN 4
#define DIRECTION_CW 0 // clockwise direction
#define DIRECTION_CCW 1 // counter-clockwise direction
volatile int counter = 0;
volatile int direction = DIRECTION_CW;
volatile unsigned long last_time; // for debouncing
int prev_counter;
ezButton button(SW_PIN); // create ezButton object that attach to pin 4
void setup() {
Serial.begin(9600);
// configure encoder pins as inputs
pinMode(CLK_PIN, INPUT);
pinMode(DT_PIN, INPUT);
button.setDebounceTime(50); // set debounce time to 50 milliseconds
// use interrupt for CLK pin is enough
// call ISR_encoderChange() when CLK pin changes from LOW to HIGH
attachInterrupt(digitalPinToInterrupt(CLK_PIN), ISR_encoderChange, RISING);
}
void loop() {
button.loop(); // MUST call the loop() function first
if (prev_counter != counter) {
Serial.print("DIRECTION: ");
if (direction == DIRECTION_CW)
Serial.print("Clockwise");
else
Serial.print("Counter-clockwise");
Serial.print(" | COUNTER: ");
Serial.println(counter);
prev_counter = counter;
}
if (button.isPressed()) {
Serial.println("The button is pressed");
}
// TO DO: your other work here
}
void ISR_encoderChange() {
if ((millis() - last_time) < 50) // debounce time is 50ms
return;
if (digitalRead(DT_PIN) == HIGH) {
// the encoder is rotating in counter-clockwise direction => decrease the counter
counter--;
direction = DIRECTION_CCW;
} else {
// the encoder is rotating in clockwise direction => increase the counter
counter++;
direction = DIRECTION_CW;
}
last_time = millis();
}
Agora, ao girar o knob, você verá informações aparecendo no Serial Monitor, muito parecidas com as que você viu no código anterior.
※ Nota:
- Se você usar a interrupção, precisa conectar o pino CLK do encoder a um pino do Arduino que suporte interrupções. Mas lembre-se: nem todos os pinos do Arduino fazem isso. Por exemplo, no Arduino Uno, apenas os pinos 2 e 3 funcionam com interrupções.
- Você pode encontrar tutoriais em outros sites que usam duas interrupções para um único encoder, mas isso é desnecessário e um desperdício. Apenas uma interrupção é suficiente.
- É importante usar a palavra-chave volatile nas variáveis globais usadas na interrupção. Não fazer isso pode causar problemas inesperados.
- Mantenha o código dentro da interrupção o mais simples possível. Evite usar Serial.print() ou Serial.println() dentro da interrupção.
Aplicações do Encoder Rotativo com Arduino
Com o Encoder Rotativo, podemos fazer as seguintes aplicações, entre outras:
- Arduino - Encoder Rotativo controla a Posição do Servo Motor
- Arduino - Encoder Rotativo controla o Brilho do LED
- Arduino - Encoder Rotativo controla a Velocidade do Motor de Passo