ESP8266 - Encoder Rotativo
Este tutorial mostra como usar o encoder rotativo incremental com o ESP8266. Veja o que vamos abordar:
- Como funciona o encoder rotativo
- A diferença entre um encoder rotativo e um potenciômetro (outro tipo de knob)
- Como conectar fisicamente o encoder rotativo a um ESP8266
- Como escrever o código para o ESP8266 ler a direção e a posição do encoder rotativo.
Hardware Necessário
Or you can buy the following kits:
| 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 tipo de knob que pode transformar o giro em um sinal elétrico. Ele informa quanto algo girou e qual é a sua posição. Existem dois tipos principais:
- Encoder incremental: Este usa sinais rápidos para medir quanto algo se moveu.
- Encoder absoluto: Este tipo fornece um código especial para cada posição, o que ajuda a saber exatamente onde algo está, mesmo se a energia for cortada.
Este tutorial é focado no 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 quanto de rotação ocorreu. Sempre que você gira o knob por um detent (clique) em qualquer direção, o pino CLK emite um sinal que completa um ciclo inteiro (LOW → HIGH → LOW).
- Pino DT (Saída B): age como o pino CLK, mas emite um sinal que fica atrasado 90 graus em relação ao sinal do CLK. Ele nos ajuda a descobrir a direção da rotação (horária ou anti-horária).
- 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á HIGH quando o knob não estiver pressionado e LOW quando estiver pressionado.
- Pino VCC (+): precisa ser conectado ao VCC (entre 3,3 e 5 volts)
- Pino GND: precisa 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 em um círculo completo sem parar, enquanto o potenciômetro só pode girar cerca de três quartos do círculo.
- O encoder rotativo emite pulsos, enquanto o potenciômetro emite 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 é como um terra compartilhado. Há mais dois pinos, A e B.
- Quando você gira o knob, os pinos A e B tocam o pino de terra compartilhado 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 são um pouco diferentes no tempo, porque um pino toca o terra antes do outro. Os dois sinais ficam defasados em 90 graus um do 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.
- Ao monitorar quando cada pino toca ou deixa o terra, podemos descobrir para qual 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 está LOW, o knob foi girado no sentido horário.
- Se B está 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 dos fabricantes, a ordem pode ser diferente. Os códigos fornecidos abaixo foram testados com o encoder rotativo da DIYables
Como Programar para 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
Para mais informações, veja Pinagem do ESP8266 e como alimentar o ESP8266 e outros componentes.
Código ESP8266 – Encoder Rotativo
O código ESP8266 abaixo faz o seguinte:
- Detecta a direção e a quantidade de rotação do encoder.
- Se detectar o knob girado por um detent (clique) no sentido horário, aumenta o contador em um.
- Se detectar o knob girado por um detent (clique) no sentido anti-horário, diminui o contador em um.
- Detecta se o botão foi pressionado.
Para simplificar o código de debouncing do botão, a biblioteca ezButton é usada.
/*
* Este código de ESP8266 NodeMCU foi desenvolvido por pt.newbiely.com
* Este código de ESP8266 NodeMCU é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/esp8266/esp8266-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN D7 // The ESP8266 pin D7 connected to the rotary encoder's CLK pin
#define DT_PIN D6 // The ESP8266 pin D6 connected to the rotary encoder's DT pin
#define SW_PIN D5 // The ESP8266 pin D5 connected to the rotary encoder's SW pin
#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 for pin 7;
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("Rotary Encoder:: direction: ");
if (direction == DIRECTION_CW)
Serial.print("CLOCKWISE");
else
Serial.print("ANTICLOCKWISE");
Serial.print(" - count: ");
Serial.println(counter);
}
// save last CLK state
prev_CLK_state = CLK_state;
if (button.isPressed()) {
Serial.println("The button is pressed");
}
}
Passos Rápidos
Para começar com o ESP8266 no Arduino IDE, siga estes passos:
- Veja o tutorial como configurar o ambiente para o ESP8266 no Arduino IDE se esta for a sua primeira vez usando o ESP8266.
- Ligue os componentes como mostrado no diagrama.
- Conecte a placa ESP8266 ao seu computador usando um cabo USB.
- Abra o Arduino IDE no seu computador.
- Escolha a placa ESP8266 correta, como (por exemplo, NodeMCU 1.0 (ESP-12E Module)), e a porta COM correspondente.
- Instale a biblioteca ezButton no Arduino IDE. Veja Como Fazer
- Copie o código acima e abra-o com o Arduino IDE
- Clique no botão Upload no Arduino IDE para enviar o código ao ESP8266
- Gire o knob no sentido horário e depois no sentido anti-horário
- Pressione o knob
- Confira o resultado no Serial Monitor.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Nodemcu 1.0 (ESP-12E Module)' on 'COM15')
New Line
9600 baud
Rotary Encoder:: direction: CLOCKWISE - count: 1
Rotary Encoder:: direction: CLOCKWISE - count: 2
Rotary Encoder:: direction: CLOCKWISE - count: 3
Rotary Encoder:: direction: CLOCKWISE - count: 4
Rotary Encoder:: direction: CLOCKWISE - count: 5
Rotary Encoder:: direction: ANTICLOCKWISE - count: 4
Rotary Encoder:: direction: ANTICLOCKWISE - count: 3
Rotary Encoder:: direction: ANTICLOCKWISE - count: 2
Rotary Encoder:: direction: ANTICLOCKWISE - count: 1
Rotary Encoder:: direction: ANTICLOCKWISE - count: 0
The button is pressed
Explicação do Código
Confira os comentários linha por linha no código
Código ESP8266 – Encoder Rotativo com Interrupção
No código anterior, verificar repetidamente o estado do pino por polling pode desperdiçar recursos e pode não contar corretamente se outras tarefas demorarem muito. As interrupções oferecem uma solução, evitando a verificação contínua e permitindo que o ESP8266 lide com diferentes tarefas sem perder nenhum evento.
Aqui está um exemplo de ESP8266 de como ler um encoder rotativo com interrupções.
/*
* Este código de ESP8266 NodeMCU foi desenvolvido por pt.newbiely.com
* Este código de ESP8266 NodeMCU é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/esp8266/esp8266-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN D7 // The ESP8266 pin D7 connected to the rotary encoder's CLK pin
#define DT_PIN D6 // The ESP8266 pin D6 connected to the rotary encoder's DT pin
#define SW_PIN D5 // The ESP8266 pin D5 connected to the rotary encoder's SW pin
#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 for pin 7;
void ICACHE_RAM_ATTR INTERRUPT_handler() {
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();
}
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 INTERRUPT_handler() when CLK pin changes from LOW to HIGH
attachInterrupt(digitalPinToInterrupt(CLK_PIN), INTERRUPT_handler, RISING);
}
void loop() {
button.loop(); // MUST call the loop() function first
if (prev_counter != counter) {
Serial.print("Rotary Encoder:: direction: ");
if (direction == DIRECTION_CW)
Serial.print("CLOCKWISE");
else
Serial.print("ANTICLOCKWISE");
Serial.print(" - count: ");
Serial.println(counter);
prev_counter = counter;
}
if (button.isPressed()) {
Serial.println("The button is pressed");
}
// TO DO: your other work here
}
Agora, ao girar o knob, você verá informações aparecendo no Serial Monitor, bem parecidas com as do código anterior.
※ Nota:
- 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. Ignorar 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ção do Encoder Rotativo com ESP8266
Com o Encoder Rotativo, podemos fazer as seguintes aplicações, mas sem se limitar a elas:
- ESP8266 - Encoder Rotativo controla a Posição do Servo Motor
- ESP8266 - Encoder Rotativo controla o Brilho do LED
- ESP8266 - Encoder Rotativo controla a Velocidade do Motor de Passo