Os encoders são botões giratórios, similares aos potenciômetros, e que podem ser girados indefinidamente. Eles estão presentes em rádios, mouses, impressoras 3D, equipamentos de bancada, entre vários outros dispositivos eletrônicos. Assim, entender o seu funcionamento e aprender a usa-lo é algo muito interessante e útil, por isso vamos te ensinar mais sobre eles!

Podemos classificar os encoders em dois tipos, os absolutos e os incrementais. Aqui não iremos nos aprofundar muito nos encoders absolutos, mas vale apena uma breve explicação sobre eles. De modo simplificado, os encoders absolutos são construídos com um disco com diversas trilhas, cada uma com um sensor e uma marcação específica de modo que, ao se combinar as informações captadas pelos sensores de todas as trilhas é possível se formar um código, que é único para a posição em que o encoder se encontra, ou seja, em um encoder absoluto podemos determinar exatamente sua posição através de um código.

O segundo tipo de encoder, o incremental é um pouco mais simples. Ele é formado por uma unica trilha com marcações igualmente espaçadas e dois sensores postos lado a lado, assim, quando o seu disco é girado, com o auxilio do seu eixo, temos a ordem com a qual os sensores são ativados e que dependem do sentido de rotação.

Conhecendo o encoder incremental

Um exemplo de encoder incremental é o EC11, que é o modelo que usaremos neste artigo. Ele possui cinco terminais, sendo dois deles usados por uma chave, que pode ser ativada pressionando o seu eixo. Enquanto isso os demais terminais são usados para controlar o encoder. A imagem abaixo representa o simbolo esquemático de um encorder desse tipo.

Aqui temos os terminais S1 e S2 para a chave, enquanto os terminais A e B permitem acesso a saída dos sensores. O terminal C é o comum aos dois sensores e geralmente é aterrado. O acionamento desse encoder ocorre de forma mecânica, sendo que, quando giramos o seu eixo, o contato entre um dos terminais das extremidades (A ou B) é fechado com o terminal comum (C). Como já foi dito, a ordem com a qual os sensores são acionados dependem do sentido de rotação do encoder, assim, se ele é rotacionado no sentido horário, sabemos que o contato entre A e C é fechado e em seguida entre B e C. Mas o inverso ocorre se girado no sentido anti-horário, quando fecha-se primeiro o contato entre B e C, e depois entre A e C.

Isso pode nos descrever duas ondas quadradas em quadratura, como abaixo.

Por quadratura nos referimos a diferença de fase entre os sinais, isto é, temos que um sinal esta adiantado em relação ao outro por 90° (aqui vale ressaltar que esse ângulo não se refere ao ângulo físico do encoder, mas sim a defasagem dos sinais).

Mapeando as transições do encoder

As ondas apresentadas mostram os sinais nos canais A e B de acordo com a posição do encoder. Se percorrermos as ondas da esquerda para a direita vemos que o sinal A está adiantado em relação ao sinal B. Isso ocorre quando giramos o encoder no sentido horário. Entretanto, se percorrermos as ondas da direita para a esquerda, veremos que o sinal B fica adiantado em relação ao A, o que acontece quando giramos o encoder no sentido anti-horário. Assim, para saber o sentido de rotação, precisamos apenas encontrar o sinal adiantado.

Agora que conhecemos seu funcionamento, pensamos em como identificar o sinal adiantado. Com as formas de onda em mãos, podemos mapear as transições realizadas, ou seja, encontrar todas as transições possíveis e determinar em quais condições ela ocorre.

Vamos usar como exemplo o caso em que A e B estão em nível alto, ou seja, AB=11, os próximos estados possíveis são AB=01, quando girado no sentido horário e AB=10, quando girado no sentido anti-horário. Isso fica mais claro na imagem abaixo.

Além disso, se AB permaneceu em 11 ele ficou parado, e para AB=00 temos um erro de leitura. Assim, para cada posição temos 4 estados futuros, sendo 1 deles impossível (ou um erro de leitura). Isso está sintetizado na tabela abaixo.

Nessa tabela, temos um número binário de quatro bits para cada movimento do encoder. Além disso podemos escrever horário como sendo 1, anti-horário como -1 e parado ou impossível como 0, assim conseguimos escrever um vetor de 16 posições com as transições possíveis. Esse vetor é {0,-1,1,0,1,0,0,-1,-1,0,0,1,0,1,-1,0} e ele é muito útil, uma vez que podemos usa-lo para incrementar ou decrementar uma variável, como veremos logo mais.

Montando um teste

Para entender como usar um encoder preparamos um exemplo prático, mas, antes de mais nada precisamos de alguns materiais básicos, são eles:

Display LCD 16X2;
Arduíno;
Resistores de 330Ω e de 3,3kΩ (1 de cada);
Encoder rotativo EC11;
LED;

O que faremos é controlar o brilho de um LED, para isso, ajustaremos a razão cíclica de um PWM gerado com um Arduino. O valor da razão cíclica será determinado pelo encoder e exibido no display LCD, assim, precisamos montar o circuito como abaixo.

Aqui temos os pinos 0 e 1 (PD0 e PD1 para o ATmega328p) para a entrada dos sinais A e B do encoder, enquanto os pinos de 4 a 7 (PD4 ao PD7) são conectados nos pinos de mesmo valor do LCD, para o envio de dados. Já os pinos A0, A1 e A2 (PC0 ao PC2) são conectados nos pinos En, R/W e RS respectivamente, para configurar o display. Por fim temos o pino 11 (PB3), que é por onde saíra o PWM gerado.

Lendo o encoder

Com o hardware montado, podemos programar o Arduino. O programa completo com as bibliotecas utilizadas estão disponíveis em nosso github. Para o programa criamos uma função denominada “le_encoder()”, que como o nome já diz, é responsável pela leitura do encoder. Essa função ficou como mostrado abaixo:


int le_encoder(void){

    static int8_t A_B = 3;                                                                                     // A_B |==> Armazena os estados anterior e atual do encoder.
    static int8_t incremento;                                                                                // incremeto|==> Variavel retornada pela função, indica o sentido de rotação do encoder.
    static int8_t entradas[]= {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};          // entradas[] |==> Vetor com as mudanças de estados possíveis.

// Cria um binario de 4 bits com os 2 MSDs indicando o estado passado e os 2 LSDs indicando o estado atual do encoder.
    A_B<<=2;
    A_B |= (PIND & 0x03);
    incremento += entradas[A_B & 0x0f];

// Evita incrementos e decrementos descontrolados.
    if(incremento>1){
        incremento=0;
    }
    if(incremento<-1){
        incremento=0;
    }
    return incremento;
}

Primeiro temos a declaração das variáveis locais, sendo todas estáticas para não serem reiniciadas a cada chamada da função. Em seguida, o valor antigo da variável A_B, responsável por armazenar o estado dos pinos PD0 e PD1, sofre um deslocamento de dois bits para a esquerda (A_B<<=2) e o valor dos pinos PD0 e PD1 são lidos com o auxilio de uma mascara e colocados nos 2 bits menos significativos (A_B |= (PIND & 0x03)). Isso forma um binário que representa a mudança de estado do encoder.

Logo após, soma-se na variável incremento 1, -1 ou 0, de acordo com o valor dos quatro bits menos significativos de A_B. Para isso lê-se a posição A_B & 0X0f do vetor entradas[], que é o vetor com as transições possíveis, que já discutimos aqui. Aplica-se a mascará 0x0f para se descartar os bits mais significativos de A_B, e ler apenas os 4 menos significativos, que são formados pelo valor de A_B anterior e atual.
Finalmente temos um “if”, que verifica se o valor do incremento é maior que 1 ou menor que -1, e se sim zera esse valor. Isso evita incrementos sucessivos de forma descontrolada.

Controlando o PWM

Agora que já conseguimos identificar o sentido de rotação do nosso encoder, vamos realizar o controle do PWM. Para isso, usaremos um inteiro de 8 bits e sem sinal, assim, temos uma variável que ira de 0 a 255. Fazemos isso porque o registrador OCR2A, responsável pelo PWM no pino PB3, é de 8 bits. O código fica como segue abaixo.

void calcula_PWM(int incremento){

static uint8_t D;                    // D = duty cicle em percentual
static uint8_t duty = 0;             // duty = duty cicle valor passado para o OCR2A para dutyrole do PWM
char s_duty[20];                     // s_duty = string com o duty cicle em percentual para exibir no LCD.

if (incremento){
            if(duty>10){
                if(duty<245){
                    duty += 3*incremento;
                }
                else if(duty<253){
                    duty += incremento;
                }
                else if(incremento>0){
                    duty = 255;
                }
                else{
                    duty += incremento;
                }
            }
            else if(duty>2){
                duty += incremento;
            }
            else if(incremento<0){
                duty = 0;
            }
            else{
                duty += incremento;
            }
            D=100*duty/255;
            if(duty > 254){
            sprintf(s_duty, "Duty: %d%%  Max    ", D);
            }
            else if(duty < 1){
                sprintf(s_duty, "Duty: %d%%  Min    ", D);
            }
            else{
                sprintf(s_duty, "Duty: %d%%         ", D);
            }
            OCR2A = duty;
            LCD_move_cursor(0,0);
            LCD_write(s_duty);
             _delay_ms(20);
        }
}

Nessa função primeiro se verifica se existe algum incremento (ou decremento) e se sim, verifica se a variável duty (que será passada para o OCR2A) está entre 10 e 245. Em caso afirmativo será somado 3 vezes o incremento em duty, mas caso essa variável esteja entre 2 e 10 ou 245 e 253, esse incremento será de apenas uma unidade. No caso dessa variável ser menor que dois ou maior que 253 então a saída será 0 ou 255 respectivamente.

O incremento de 3 quando duty está entre 10 e 245 permite um controle veloz da razão cíclica, mas mantem o controle do brilho do led suave, já que uma mudança dessa grandeza no PWM não é perceptível. Além disso, quando o valor está próximo de 255 o controle do PWM não permite um novo incremento, já que isso acarretaria em uma transição abrupta de nível máximo para mínimo. O mesmo ocorre nas proximidades de 0.

Em seguida calculamos o valor percentual da razão cíclica na variável D, exibindo esse valor no display LCD na forma “Duty: XXX”. Além disso, imprimimos na tela Máx quando a razão cíclica é 100% e Min quando essa é 0%. Por fim enviamos o valor de duty para o registrador OCR2A.

Main

Finalmente temos a função main, que realiza a configuração das entradas e saídas, além de configurar o PWM. Ela ficou como abaixo:


int main(void){
// Configura os pinos de entrada. 
    DDRD &= ~((1<<PD0)+(1<<PD1));
    PORTD |= ((1<<PD0)+(1<<PD1));

// Configura PWM.
    DDRB |= (1<<PB3);
    TCCR2A |= ((1<<COM2A1)+(1<<WGM21)+(1<<WGM20));
    TCCR2B |= (1<<CS20);
    OCR2A = 0;

// Inicia o LCD.
    LCD_init();
    LCD_move_cursor(0,0);

// Loop de execução.
    while(1){
        calcula_PWM(le_encoder());
    }
return 0;
}

O que fazemos aqui é configurar os pinos PD0 e PD1 como entradas (no registrador DDRD) e habilitar o resistor de pull up interno (no PORTD). Em seguida, habilitamos PB3 como saída (com DDRB), e configuramos o timer 2 no modo fast PWM, sem prescale. Aqui também iniciamos o LCD, configurando as entradas e saídas pertinentes com a função LCD_init(), e posicionamos o cursor na primeira casa e na primeira coluna. Finalmente, temos um loop infinito que realiza a constante chamada da função calcula_PWM().

Nós montamos este circuito para testarmos na prática e ele ficou funcionando como no vídeo deste link. O que você achou desse artigo? Pretende usar o encoder em algum projeto? Nos conte aqui nos comentários.

Conhecimento

Usando um Encoder Rotativo