SERVOMOTOR COM ARDUINO

Controlando um servo motor com Arduino

O grande barato de comprar as coisas pela internet, e no exterior, a quase completa

falta de manuais. Um exemplo disso o servo motor abaixo, que chegou essa semana :

Chegou inteiro, mas desse jeito : o servo, os acessrios num plstico, e s. Uma etiqueta
escrito "Micro Servo 9g" foi a maior pista que eu tive do modelo.

A comea a parte divertida da coisa, que descobrir como o servo funciona, suas
conexes, voltagens e tal. Vasculhando no Google, descobri um modelo muito parecido,
chamado HXT900, e que sua voltagem de operao vai de 3 a 6v. J um comeo. Mas
e as conexes ?

Bom, o cabo tem 3 vias : Preto, vermelho e branco. Fcil, no ? Preto no GND,
vermelho no 5V e branco para dados.

Testei o servo usando o exemplo que j vem na IDE do Arduino, que usa um
potencimetro para controlar a rotao do motor :

O programa abaixo voc pode encontrar no menu Arquivo -> Exemplos -> Servo ->
Knob :
 // Programa : Controlando a posicao de um servo usando
potenciometro
1 // Traducao e comentarios : Arduino e Cia
2 //
3 // Controlling a servo position using a potentiometer (variable
4 resistor)
5 // by Michal Rinott <http://people.interaction-ivrea.it/m.rinott>
6
7
8 #include <Servo.h>
9 Servo myservo; // create servo object to control a servo
10
11 // Pino analgico do potenciometro
12 int potpin = 0;
13
14 // Variavel que armazena o valor lido do potenciometro
15 int val;
16
17 void setup()
18 {
19 // Define que o servo esta ligado a porta 9
20 myservo.attach(9);
21 }
22
23 void loop()
24 {
25 // Le o valor do potenciometro (valores entre 0 e 1023)
26 val = analogRead(potpin);
27
28 // Converte o valor pra ser usado no servo (valores entre 0 e
29 180)
30 val = map(val, 0, 1023, 0, 179);
31
32 // Move o eixo do servo, de acordo com o angulo
33 myservo.write(val);
34
35 // Aguarda o servo atingir a posio
36 delay(15);
}

O programa l as informaes do potencimetro ligado entrada analgica (valores de

0 a 1023), converte esses valores para serem usados no servo (0 a 180), e move o servo
motor para a posio correspondente. Gire o potencimetro nos 2 sentidos, e o servo ir
acompanhar o movimento do potencimetro.

Tambm podemos controlar o servo usando posies pr-estabelecidas, o que muito

til quando precisamos usar o motor para movimentos repetitivos. Como no exemplo
abaixo, onde utilizei 3 chaves (push-button) :
e o seguinte programa :

1 // Programa : Controlando o servo com 3 chaves

2 // Autor: Arduino e Cia
3
4 #include <Servo.h>
5
6 Servo myservo;
7
8 int val;
9 int ChaveEsquerda=3; //Pino a ser ligado na chave esquerda
10 int ChaveCentral=4; //Pino a ser ligado na chave central
11 int ChaveDireita=5; //Pino a ser ligado na chave direita
12
13 void setup()
14 {
15 // Pino de dados do servo conectado ao pino 9 do Arduino
16 myservo.attach(9);
17 //Define o pino como entrada
18 pinMode(ChaveEsquerda, INPUT);
19 //Aciona o resistor pull-up interno
20 digitalWrite(ChaveEsquerda, HIGH);
21 pinMode(ChaveCentral, INPUT);
22 digitalWrite(ChaveCentral, HIGH);
23 pinMode(ChaveDireita, INPUT);
24 digitalWrite(ChaveDireita, HIGH);
25 }
26
27 void loop()
28 {
29 //Le o valor da Chave Esquerda (On/Off)
30 val=digitalRead(ChaveEsquerda);
31 //Caso a chave seja pressionada, movimenta o servo
32 if(val!=1)
33 {
34 myservo.write(60); //Move o servo para o angulo de 60
35 graus
36 delay(15); //Delay para o servo atingir a posiao
37 }
38
39 val=digitalRead(ChaveCentral);
40 if(val!=1)
41 {
42 myservo.write(90); //Move o servo para o angulo de 90
43 graus
44 delay(15);
45 }
46
47 val=digitalRead(ChaveDireita);
48 if(val!=1)
49 {
50 myservo.write(120); //Move o servo para o angulo de 120
51 graus
delay(15);
}
}

Ao pressionar o boto da esquerda, o servo se movimenta para a posio "60 graus", o

boto central leva posio 90 graus, e o boto da direita, posio 120 graus.

http://www.arduinoecia.com.br/2013/06/controlando-um-servo.html

________________________________________________________________

Arduino e servos: como controlar servomotores

Controlar servos com o Arduino para fazer esses motores apontarem

precisamente para os ngulos desejados envolve uma conexo fsica simples, e
poucas funes de uma biblioteca padronizada.

Um servomotor, tipicamente chamado de servo, geralmente um motor que vem

acompanhado de circuito especial para permitir que ele aponte com preciso o seu eixo
para o ngulo que o usurio definir. Os servos usados em conjunto com o Arduino
frequentemente so aqueles desenvolvidos para uso em modelismo radiocontrolado, em
aplicaes como o controle da direo de carrinhos ou da inclinao dos ailerons de
aeromodelos.

Para ter um primeiro contato com os servos, recorri a uma aplicao familiar, embora eu
a tenha implementado de forma bem diferente (e bem menos eficiente) que o elegante
mecanismo tradicional: um ventilador oscilante.
Os ventiladores tradicionais capazes de movimentar lateralmente seu corpo para dirigir
o vento a diferentes partes do ambiente usam um mecanismo que aproveita o mesmo
movimento do motor que gira a hlice para tambm fazer a oscilao lateral. Para o meu
objetivo, entretanto, bastava imitar o efeito produzido, e assim usei um motor parte
(justamente o servo, com o qual eu queria me familiarizar) para se encarregar da
oscilao, enquanto a hlice era operada pelo nosso velho amigo mdulo Keyes 14c04,
o mesmo que eu usei para soprar e apagar as chamas de um isqueiro no artigo Arduino,
sensor de chamas e hlice: detectando e apagando um isqueiro.

Como em vrios outros aspectos deste meu aprendizado sobre o Arduino, acabei
descobrindo que a operao bsica dos servos mais simples do que eu imaginava:
basta inicializ-los e depois "escrever" neles os ngulos para os quais queremos que eles
apontem. Isso ocorre devido existncia da biblioteca Servo, que acompanha o Arduino
e cuja documentao, incluindo a lista de funes que ela disponibiliza, foi suficiente
para realizar o experimento de hoje.

O circuito

O experimento de hoje exigiu de minha parte apenas um circuito muito simples,

interconectando pinos dos componentes envolvidos. no interior desses
componentesque reside a complexidade que eu no preciso1 conhecer para usar ;-)
O esquema de interconexo do Arduino, do servo TowerPro SG90, do mdulo do hlice
e do suporte para 4 pilhas AA foi este:

O diagrama acima mostra, em blocos, os pinos de cada um dos 4 componentes

envolvidos. Sobre o servo SG90 que eu usei, vale mencionar que ele no identifica em
seu corpo a funo de cada pino, mas verifiquei que seus cabos marrom, vermelho e
laranja correspondem, respectivamente, a terra, alimentao e sinal.

Sobre o mdulo da hlice, os detalhes j constam no artigo anterior, mas vale resumir:
alm do pino de alimentao e do terra, temos 2 pinos de controle: INA e INB. Se
ambos estiverem com o mesmo valor (HIGH e HIGH ou LOW e LOW), a hlice para.
Se estiverem com valores diferentes, ela gira no sentido horrio ou anti-horrio,
conforme o caso.

Note que a simplicidade do circuito que eu montei talvez pudesse ser ainda maior:
segundo a documentao, como eu estou usando apenas 1 servo, eu poderia aliment-lo
diretamente do pino 5V do prprio Arduino, sem recorrer a uma fonte externa.

Mas eu fiz algumas contas por alto sobre a possibilidade de consumo no pior caso com
relao ao conjunto servo + ventilador, e preferi separar a alimentao do Arduino e a
dos 2 motores, recorrendo assim a um suporte para 4 pilhas AA. Tambm testei com a
obteno de alimentao de uma porta USB do computador, e funcionou igualmente
bem. Poderia ter usado transistores para chavear os pinos de comando, para separar
ainda mais o Arduino dos demais componentes, e talvez faa isso em futuras aplicaes.
Programao do Arduino para controlar o servo

O programa que eu tinha em mente era bem simples: considerando que o mdulo
ventilador foi fixado ao eixo do servo, bastava ligar a hlice e a instruir o servo para
apontar para diferentes ngulos, indo e voltando.

Veja como ficou:

#include <Servo.h>
Servo servo90g;

const byte vent_INA=10;

const byte vent_INB=11;

void setup() {
servo90g.attach(A0);
pinMode(vent_INA,OUTPUT);
pinMode(vent_INB,OUTPUT);
digitalWrite(vent_INA,LOW);
digitalWrite(vent_INB,HIGH);
}

int angulo=0;
const int pausa=350;
const byte angbase=14;
const byte angmax=28;

void loop() {
for(angulo = angbase; angulo < angmax; angulo++)
{
servo90g.write(angulo);
delay(pausa);
}
for(angulo = angmax; angulo>=angbase; angulo--)
{
servo90g.write(angulo);
delay(pausa);
}
}

No h nenhuma grande complexidade no programa, mas destaquei com cores os

trechos que merecem ateno.

Em vermelho temos as 3 linhas que inicializam os servos, e estaro presentes em todo

programa que faz uso deles: a que comea com #include faz a referncia biblioteca, a
que inicia com Servo instancia o objeto (a segunda palavra dessa linha ser o nome do
objeto criado, voc pode escolher livremente, desde que repita o mesmo nome nas
demais referncias), e a terceira, que vem pouco abaixo, na funo setup(), registra2
em qual dos pinos do Arduino o servo est conectado.

Apenas como informao, destaquei em verde as 2 linhas que fazem o ventilador

comear a girar. Os detalhes sobre elas voc encontra no artigo anterior.

Para completar, em cor salmo, esto as 2 linhas que mandam o servo apontar para um
determinado ngulo. A primeira delas est em um loop crescente, e a segunda est em
um loop decrescente. Esses loops so os responsveis pelo efeito de ida e volta graduais
tpico da oscilao lateral de um ventilador domstico.

Um detalhe curioso: o protocolo de comando dos servos

No necessrio saber ou entender isso para usar a biblioteca Servo mas, graas ao
captulo 5 do livro Arduino em Ao (publicado pela Novatec, patrocinadora do BR-
Arduino.org), eu satisfiz minha curiosidade sobre como o protocolo que a biblioteca
Servo usa para transmitir ngulos para um servomotor.

A biblioteca envia os comandos pelo pino de sinal, por meio de uma forma de PWM na
qual os parmetros importantes so a frequncia com que o pulso se repete (geralmente
a cada 20ms), e a durao de cada pulso, que indica o ngulo para o qual o servo deve
apontar.

A imagem abaixo mostra 3 variaes de durao de pulso, e seu efeito sobre um modelo
de servo em particular:

Observe: se o pulso dura 1ms, o servo apontar para o seu ngulo mnimo. Com um
pulso de 1,5ms, ele apontar para a posio central, e se o pulso for de 2ms, apontar
para seu ngulo mximo. Assim, o ngulo ser proporcional a qualquer valor entre 1ms
e 2ms.

Esses valores so tpicos e esperados, mas podem variar: cada modelo de servo tem seu
ngulo mnimo e mximo, bem como pode alterar os limites mnimos e mximos de
durao do pulso. Para verificar se o seu motor pode ir abaixo de 1ms (que podem
corresponder a ngulos inferiores a 0) ou acima de 2ms (ngulos superiores a 180),
voc pode usar a funo writeMicroseconds(), mas leia bem a documentao dela antes,
pois ela contm um alerta sobre uma situao a ser evitada.

Mais detalhes sobre servos no Arduino

O exemplo acima bsico mas explora o essencial da interao entre Arduino e servos:
inicializ-los e faz-los apontar para ngulos.
Na maior parte dos modelos de Arduino, at 12 servos podem ser controlados pela
biblioteca Servo. Vale observar que, nesses mesmos modelos, o uso de PWM (comando
analogWrite()) nos pinos 9 e 10 fica desativado quando a biblioteca Servo estiver em
uso.

Existem mais algumas funcionalidades a explorar, como a possibilidade de ler o ngulo

atual do servo, a funo writeMicroseconds() (cuja documentao aponta uma situao
de alta corrente que deve ser evitada), e mais alguns detalhes que a documentao cobre
bem.

http://br-arduino.org/2015/01/arduino-e-servos-como-controlar-servomotores.html

http://automacaoerobotica.blogspot.com.br/2012/07/controlando-servomotores-com-
arduino.html

Controlando dois (ou mais) servo motores com Arduino.

Publicado em 26 de julho de 2011

J recebi varios e-mails perguntando se possvel controlar dois ou mais servo motores
com o Arduino, fiquei de postar o cdigo aqui mas sempre acabava esquecendo.

Como voc j deve ter visto, no projeto que desenvolvi com o Emotiv Epoc + Arduino
utilizo dois servo motores para representar o prottipo.

Se a primeira vez que voc vai se aventurar com Arduino e servo motores, aconselho
dar uma lida neste post (Controlando Servo Motor utilizando o teclado com Arduino e
C#), e claro, para isso, necessrio que voc j tenha um mnimo de conhecimento no
assunto. Caso queira pesquisar mais, sugiro que de uma olhada no site oficial do
Arduino (arduino.cc).

O conceito o mesmo do post em que mostro como controlar um servo a partir do

teclado com C#. Ento, se voc entendeu e deu tudo certo l, no ter problemas com
essa modificao.

O que eu fiz foi colocar um bloco if e fazendo a verificao da string de entrada via
serial para identificar para qual servo motor queremos enviar o comando.
 simples, no projeto com apenas um servo, enviamos uma string, por exemplo: 180,
e o servo movimenta 180 graus. Com dois, acrescentamos um caracter ao final, por
exemplo: 180a, movimentamos o servo A 180 graus.

Abaixo segue o cdigo na ntegra do programa.

1 //Biblioteca do Arduino para

2 //controlar Servo Motores
3 #include <Servo.h>
4
5 Servo servo1;
6 Servo servo2;
7
8 char buffer[4];
9 int received;
10
11void setup(){
12
13 //Inicia a porta serial
14 Serial.begin(9600);
15
16 //Atribui as entradas do Arduino
17 //as variaveis
servo1.attach(8);
18
servo2.attach(9);
19
20
//Movimentamos ambos os motores para 90 graus
21
servo1.write(90);
22
servo2.write(90);
23
24 received = 0;
25}
26
27void loop(){
28
29 //Verifica se possui alguma entrada de dados
30 //na entrada Serial
31 if(Serial.available()){
32
33 char c = Serial.read();
34
35 // Se o "c" for igual ao caracter "A" (97 na tabela ASCII)
36 if(c == 97){
37 Serial.println(buffer);
38 int numero = atoi(buffer);
39 servo1.write(numero);
40 received = 0;
41 }
42
43 // Se o "c" for igual ao caracter "B" (98 na tabela ASCII)
44 if(c == 98){
45 Serial.println(buffer);
46 int numero = atoi(buffer);
47 if(numero >= 60){
48 servo2.write(numero);
49 received = 0;
50 }
51 received = 0;
52 }
53
54 if(c != 97 && c != 98){
55 buffer[received++] = c;
}
56
57
Serial.flush();
58
}
59
60
}
61
62

No cdigo acima os servos foram conectados as entradas 8 e 9 no Arduino.

Como voc deve j ter observado, a comparao feita utilizando o cdigo do caracter
de acordo com a tabela ASCII.

Se voc precisar controlar mais de dois servo motores, s implementar mais condies
(seria mais elegante usar o bloco switch) e utilizar outros caracteres (da tabela ASCII)
para se identificar os motores.

No sei se essa a forma mais elegante de se implementar isto, mas foi uma soluo
que encontrei quando me deparei com este problema, se algum possui alguma outra
forma, por favor contribua.

Acho que isso ai pessoal.

Como eu disse anteriormente, se voc j seguiu este tutorial no ter problema algum
em entender o funcionamento e vai lhe servir muito bem.

http://www.renatopeterman.com.br/blog/2011/07/26/controlando-dois-ou-mais-servo-
motores-com-arduino/

Como utilizar um encoder rotativo com Arduino

Conhece o encoder rotativo ? Por fora, ele um componente muito parecido com um
potencimetro, mas internamente funciona de uma forma bem diferente, sendo um
componente interessante para voc utilizar com seus projetos para Arduino. Eu utilizei um
mdulo encoder KY-040 para criar um pequeno sistema de seleo com display LCD 20x4.

O encoder um componente utilizado para converso de movimentos rotativos (ou lineares)

em impulsos eltricos de onda quadrada. Esse impulsos podem ser lidos por um
microcontrolador (no nosso caso, vamos utilizar o Arduino), e geram uma quantidade exata de
impulsos por volta.

O encoder que utilizamos tem rotao contnua, e tambm um boto (basta empurrar o eixo)
que vamos usar para selecionar uma das opes do "menu" no display.
Ligando o encoder no Arduino
O primeiro circuito de testes utiliza somente o encoder. Vamos utilizar 3 pinos do Arduino para
ligar o componente, sendo que os pinos analgicos A2 e A3 sero ligados nos pinos de medio,
e o pino digital 7 no pino do boto, junto com um resistor pull-up.

Caso voc esteja utilizando somente o encoder (sem o mdulo, siga o esquema ligao abaixo:
Teste esse circuito carregando o programa abaixo, que utiliza a biblioteca RotaryEncoder
(download). Baixe a biblioteca e coloque-a na pasta LIBRARIES da IDE do Arduino.

//Programa : Teste basico encoder Arduino

1 //Autor : Arduino e Cia
2
3 //Carrega a biblioteca do encoder
4 #include <RotaryEncoder.h>
5
6 //Pinos de ligacao do encoder
7 RotaryEncoder encoder(A2, A3);
8
9 //Variavel para o botao do encoder
10 int valor = 0;
11 int newPos = 0;
12
13 void setup()
14 {
15 pinMode(7, INPUT);
16 Serial.begin(9600);
17 Serial.println("Gire o encoder....");
18 }
19
20 void loop()
21 {
22 //Verifica se o botao do encoder foi pressionado
23 valor = digitalRead(7);
24 if (valor != 1)
25 {
26 Serial.println("Botao pressionado");
27 while (digitalRead(7) == 0)
28 delay(10);
29 }
30
31 //Le as informacoes do encoder
32 static int pos = 0;
33 encoder.tick();
34 int newPos = encoder.getPosition();
35 //Se a posicao foi alterada, mostra o valor
36 //no Serial Monitor
37 if (pos != newPos) {
38 Serial.print(newPos);
39 Serial.println();
40 pos = newPos;
41 }
42 }
43
O programa aguarda que o usurio gire o encoder para a direita ou para a esquerda, atualizando
o valor de um contador. Girando para a direita, o contador aumenta, e para a esqueda, o
contador diminui. Caso o boto seja pressionado, uma mensagem tambm aparece no serial
monitor:

Esse um circuito bem simples que voc pode usar para testar se o seu encoder est
funcionando corretamente.

Sistema de menu com display LCD 20x4 e encoder

Neste segundo circuito, vamos manter as ligaes do encoder que utilizamos anteriormente, e
adicionar um display LCD 20x4 ao circuito. O potencimetro de 10K e serve para ajustar o
contraste do display. O resistor utilizado como pull-up do boto do encoder de 330 ohms.
No programa deste circuito, vamos primeiramente criar caracteres customizados para os
nmeros de 1 a 6 que forem selecionados (so os nmeros "invertidos"). Conforme giramos o
encoder, os nmeros no display vo sendo substitudos por esses nmero invertidos.

No loop, testamos se o boto foi pressionado, e tambm limitamos as opes de seleo entre
1 e 6, atravs do comando encoder.setPosition(). O programa checa se o valor do encoder foi
alterado e, em caso positivo, chama a rotina destaque_selecionado(), que atualiza os dados da
tela.

1 //Programa : Menu com encoder e LCD 20x4

2 //Autor : Arduino e Cia
3
4 //Carrega biblioteca LCD e encoder
5 #include <LiquidCrystal.h>
6 #include <RotaryEncoder.h>
7
8 //Inicializa o LCD
9 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
10
11 //Pinos de ligacao do encoder
12 RotaryEncoder encoder(A2, A3);
13
14 int contador = 1;
15 int contador_anterior = 1;
16 int valor = 0;
17
18
19 byte Bloco_Cheio[8] = {0b11111, 0b11111, 0b11111, 0b11111,
20 0b11111, 0b11111, 0b11111, 0b11111
21 };
22 byte Um_invertido[8] = {0b11011, 0b10011, 0b11011, 0b11011,
23 0b11011, 0b11011, 0b10001, 0b11111
24 };
25 byte Dois_invertido[8] = {0b10001, 0b01110, 0b11110, 0b11101,
26 0b11011, 0b10111, 0b00000, 0b11111
27 };
28 byte Tres_invertido[8] = {0b00000, 0b11101, 0b11011, 0b11101,
29 0b11110, 0b01110, 0b10001, 0b11111
30 };
31 byte Quatro_invertido[8] = {0b11101, 0b11001, 0b10101, 0b01101,
32 0b00000, 0b11101, 0b11101, 0b11111
33 };
34 byte Cinco_invertido[8] = {0b00000, 0b01111, 0b00001, 0b11110,
35 0b11110, 0b01110, 0b10001, 0b11111
36 };
37 byte Seis_invertido[8] = {0b11001, 0b10111, 0b01111, 0b00001,
38 0b01110, 0b01110, 0b10001, 0b11111
39 };
40
41 static int pos = 1;
42 int newPos = 0;
43 int selecionado = 0;
44
45 void setup()
46 {
47 Serial.begin(9600);
48 //Inicializa o botao do encoder no pino 7
49 pinMode(7, INPUT);
50 //Define o LCD com 20 colunas e 4 linhas
51 lcd.begin(20, 4);
52 //Cria os caracteres customizados
53 lcd.createChar(0, Bloco_Cheio);
54 lcd.createChar(1, Um_invertido);
55 lcd.createChar(2, Dois_invertido);
56 lcd.createChar(3, Tres_invertido);
57 lcd.createChar(4, Quatro_invertido);
58 lcd.createChar(5, Cinco_invertido);
59 lcd.createChar(6, Seis_invertido);
60
61 //Informacoes iniciais
62 lcd.setCursor(0, 0);
63 lcd.print(" 1 2 3 4 5 6");
64 lcd.setCursor(1, 2);
65 lcd.print("Valor atual: 0");
66 lcd.setCursor(1, 3);
67 lcd.print("Selecionado: -");
68 }
69
70 void loop()
 71 {
72 //Verifica se o botao do encoder foi pressionado
73 valor = digitalRead(7);
74 Serial.println(valor);
75 if (valor != 1)
76 {
77 Serial.println("Botao pressionado");
78 lcd.setCursor(14, 3);
79 selecionado = newPos;
80 lcd.print(selecionado);
81 //while (digitalRead(7) == 1)
82 // delay(10);
83 }
84
85 //Le as informacoes do encoder
86 encoder.tick();
87 newPos = encoder.getPosition();
88 if (pos != newPos)
89 {
90 //Limite maximo menu
91 if (newPos > 6)
92 {
93 encoder.setPosition(6);
94 newPos = 6;
95 }
96 //Limite minimo menu
97 if (newPos < 1)
98 {
99 encoder.setPosition(1);
100 newPos = 1;
101 }
102 Serial.print("Posicao: ");
103 Serial.println(newPos);
104 //Atualiza o menu no display
105 destaque_selecionado(newPos);
106 pos = newPos;
107 }
108 }
109
110 void destaque_selecionado(int conta)
111 {
112 //Define posicao inicial
113 int posicao = (conta * 3) - 1;
114 //Apaga selecao anterior
115 if (conta > pos)
116 {
117 lcd.setCursor(posicao - 4, 0);
118 lcd.print(" ");
119 lcd.print(conta - 1);
120 lcd.print(" ");
121 }
122 //Apaga selecao posterior
123 if (conta < pos)
124 {
125 lcd.setCursor(posicao + 2, 0);
126 lcd.print(" ");
127 lcd.print(conta + 1);
128 lcd.print(" ");
129 }
130
131 //Imprime blocos cheios
132 lcd.setCursor(posicao - 1, 0);
133 lcd.write((uint8_t)0);
134 lcd.write((uint8_t)0);
135 lcd.write((uint8_t)0);
136
137 //imprime valor
138 lcd.setCursor(posicao, 0);
139 lcd.write((uint8_t)(conta));
140
141 //Imprime Opcao atual
142 lcd.setCursor(14, 2);
143 lcd.print(conta);
144 }

Achou a explicao muito complicada ? D uma olhada no vdeo abaixo, que mostra esse circuito
em funcionamento:

O programa atualiza os valores somente na tela, mas voc pode modificar facilmente este
programa para que ele acione portas do Arduino ou envie e receba dados de algum sensor

http://www.arduinoecia.com.br/2015/08/como-usar-encoder-rotativo-ky-040-arduino.html