Robô seguidor de linha com sensor

infravermelho e PWM
Neste tutorial vamos aprender a fazer um robô seguidor de linha utilizando o sensor de obstaculo
infravermelho (Você poderá usar o Módulo Segue Faixa – TCRT5000) em conjunto com um Arduino. O
seguidor de linha é um projeto bem famoso entre os apaixonados por robótica. Quase sempre é o primeiro
projeto de robótica móvel de todos nós. Em todo o mundo, competições de robótica possuem modalidades
únicas para o seguidor de linha, o que faz deste projeto algo que nunca irá deixar de ser melhorado.

Para melhor entendimento deste tutorial é necessário que você já tenha um conhecimento prévio sobre Arduino
e ponte H. Mas não se preocupe pois nossa equipe já produziu outros tutoriais sobre esse assuntos e você pode
conferir alguns destes nos seguintes links: Arduino e Ponte H.

Como o carrinho de um robô móvel funciona ?

O nosso seguidor de linha funciona de maneira bem simples. Ele deve seguir andando por cima de uma linha de
cor preta (fita isolante) ou branca. Os circuitos podem alternar entre as cores do campo e da faixa, no nosso caso
iremos assumir que a pista é branca e a faixa é preta. Usaremos 2 sensores infravermelho que detectam a
presença ou não desta faixa. De acordo com a combinação dos sensores, o carrinho irá para frente ou virar para
um dos lados.
Funcionamento do modulo infravermelho
O módulo sensor de obstáculo infravermelho IR é bem simples. Ele emite uma luz infravermelha por um LED
negro e capta o reflexo com um LED receptor (LED claro). Como sabemos, a luz reflete em superfícies claras e
é absorvida em superfícies negras, como a fita isolante. Sendo assim o LED receptor irá detectar a luz
infravermelha no branco e não detectar no preto. Para uma melhor eficácia do sensor, a superfície em contraste
com a faixa preta deve ser branca. Para ajustar a sensibilidade ao contraste, o modulo possui um potenciômetro
de calibração.

Funcionamento do sensor infravermelho

PWM
PWM (Pulse Width Modulation – Modulação por Largura de Pulso) é uma técnica para obter resultados
analógicos por meios digitais (Leia mais sobre Grandezas digitais e analógicas e PWM). Essa técnica consiste
na geração de uma onda quadrada em uma frequência muito alta em que pode ser controlada a porcentagem do
tempo em que a onda permanece em nível lógico alto. Essa variável será a responsável pelo controle de
velocidade do nosso carrinho. Os valores de PWM variam de 0 (parado) até 255 (velocidade máxima ou 5 V).
 Mais informações especificas sobre o assunto podem ser vistas no nosso tutorial sobre PWM.

Modulando a ponte H
No módulo Ponte H com CI L298N cada ponte H possui um pino que ativa ou não a ponte H. Caso tenha um
sinal de 5V aplicado nele, a ponte estará ligada, caso seja 0V a ponte estará desligada. Como temos 2 pontes H,
temos o Enable A(Ativa A) e o Enable B (Ativa B).

Normalmente os Enables A e B ficam em curto com um sinal de 5V da placa através de um jumper.

Jumpers Enable A e B

Se retiramos esse jumper e inserimos um sinal PWM nessas entradas, modularemos a tensão que é enviada para
o motor. Isso ocorre porque a ponte H só ira “funcionar” enquanto o sinal de Enable estiver com 5V.

A descrição completa do funcionamento da ponte H pode ser visto no nosso tutorial sobre Ponte H.

Componentes Necessários
Para este projeto iremos utilizar:
 1 x Placa Arduino UNO
 2 x Modulo sensor de obstaculo infravermelho IR (Você pode usar o módulo TCRT5000)
 1 x Chassi Robô móvel 2WD ( Ou 2 x Motores DC 5 v com roda + um suporte para o carrinho)
 1 x Ponte H L298N
 1 x Bateria 9 V + conector (ou fonte semelhante)
 Protoboard e Jumpers
Montando o Projeto
Abaixo segue um esquema de ligações e montagem ELETRÔNICA do projeto:

Este projeto possui um procedimento de montagem complexo devido ao fato da necessidade de termos
que passar vários fios por um espaço limitado ao tamanho do chassi do seu carrinho.

Calibração do Sensor infravermelho:

Programando
A programação do projeto é bem simples. O carrinho precisa fazer a leitura dos sensores e definir pra qual lado
ele deve ir, somente isso, até por que um programa muito extenso pode prejudicar o rendimento.
 /*DECLARAÇÃO DE VARIAVEIS*/
#define MotorA_sentido1 2
1 #define MotorA_sentido2 4
2 #define MotorB_sentido1 8
3 #define MotorB_sentido2 9
4 #define MotorA_PWM 3
5 #define MotorB_PWM 10
6
7
#define veloc0 0
8
#define veloc1 80
9
10 #define veloc2 180
11 #define veloc3 255
12
13 #define Sensor_direita 6
14 #define Sensor_esquerda 7
15
16 bool direita, esquerda;
17
18 void setup() {
19 Serial.begin(9600);
20 pinMode(MotorA_sentido1, OUTPUT);
21 pinMode(MotorA_sentido2, OUTPUT);
22 pinMode(MotorB_sentido1, OUTPUT);
23 pinMode(MotorB_sentido2, OUTPUT);
24
pinMode(MotorA_PWM, OUTPUT);
25
pinMode(MotorB_PWM, OUTPUT);
26
27 pinMode(Sensor_direita, INPUT);
28 pinMode(Sensor_esquerda, INPUT);
29
30 }
31
32 void loop() {
33 //Define o sentido de rotação dos motores
34 digitalWrite(MotorA_sentido1, LOW);
35 digitalWrite(MotorA_sentido2, HIGH);
36 digitalWrite(MotorB_sentido1, HIGH);
37 digitalWrite(MotorB_sentido2, LOW);
38
39 //Leituras dos Sensores
40 direita = digitalRead(Sensor_direita);
41
esquerda = digitalRead(Sensor_esquerda);
42
Serial.print(direita);
43
44 Serial.print(" || ");
45 Serial.println(esquerda);
46
47 //Rodando os motores dependendo das leituras
48 if(direita == false && esquerda == false){
49 analogWrite(MotorA_PWM, veloc2);
50 analogWrite(MotorB_PWM, veloc2);
51 } else if(direita == false && esquerda == true){
52 delay(400);
53 analogWrite(MotorA_PWM, veloc2);
54 analogWrite(MotorB_PWM, veloc1);
55 delay(400);
56 }else if(direita == true && esquerda == false){
57 delay(400);
58
analogWrite(MotorA_PWM, veloc1);
59
analogWrite(MotorB_PWM, veloc2);
60
61 delay(400);
62
63 }else if(direita == true && esquerda == true){
64 analogWrite(MotorA_PWM, veloc0);
65 analogWrite(MotorB_PWM, veloc0);
}
}
 Colocando para funcionar
Agora é só por o carrinho pra rodar na pista !

Robô seguidor de linha montado

Vale notar que ele pode não fazer o percurso de primeira, o que significa que ajustes devem ser feitos no
código ou ate mesmo no hardware. Alguns problemas comuns de acontecer:
 Bateria fraca – Os testes podem ter consumido a bateria e talvez seja necessário o uso de uma nova. Baterias
abaixo de 6,5 Volts já começam a diminuir a eficiência do carrinho.
 Carrinho saindo da pista – Isso pode acontecer por ele estar rápido de mais ou por falha do infravermelho. Em
caso de ele estar muito rápido basta trocar a velocidade dos motores em cada situação, o nosso código já possui
outras velocidades definidas no cabeçalho. Se o problema for com o contraste da pista (talvez parte dela esteja
mais escura) use 2 LEDs de alto brilho na frente do carrinho para iluminar a pista próximo aos sensores. Os
LEDs podem ir conectados diretos no 5 V do arduino (lembrando de por um resistor de 300Ohms).
 Carrinho não roda – Este é um problema complexo, pois podem ser infinitas possibilidades. Tente isolar os
componentes e testar 1 por 1, principalmente os motores e a ponte H. Em alguns casos pode ser problemas de
aterramento da bateria também.

Entendendo a fundo
Software
Declaração de Variáveis
Na primeira parte do código é feita a declaração das variáveis a serem utilizadas. Nota-se que a existe um
grande numero de variáveis utilizando #define, isto é por conta de serem apenas nomes associados a números,
não precisamos fazer contas com essas variáveis, portanto elas não precisam ser do tipo INT, FLOAT, entre
outras. O fato de declarar algo por meio de #define ocupa menos espaço de memória, o que dá um ganho na
velocidade de execução do programa. As únicas variáveis a serem definidas por um tipo são as que armazenarão
os valores lidos dos sensores (direita e esquerda), essas variáveis são do tipo bool e portanto só assumem dois
estados (FALSE e TRUE).

1 /*DECLARAÇÃO DE VARIAVEIS*/
2 #define MotorA_sentido1 2
3 #define MotorA_sentido2 4
4 #define MotorB_sentido1 8
5 #define MotorB_sentido2 9
6 #define MotorA_PWM 3
7 #define MotorB_PWM 10
8
9 #define veloc0 0
10 #define veloc1 80
11 #define veloc2 180
12 #define veloc3 255
13
14 #define Sensor_direita 6
15 #define Sensor_esquerda 7
16
17 bool direita, esquerda;

Cada motor possui 3 pinos: 2 para definir o sentido de rotação da roda (IN1 e IN2 / IN3 e IN4) e 1 pra definir a
velocidade de rotação (Enable A / Enable B)por meio de valores PWM. Lembre-se de que os pinos de
velocidade devem conter o “~” desenhado ao lado da porta na placa Arduino, caracterizando o pino como
PWM. Declaramos também 4 velocidades de PWM que podem ser interpretadas como PARADO, DEVAGAR,
NORMAL e RÁPIDO, respectivamente. Os sensores foram definidos em suas respectivas portas digitais(6 e 7)
e por fim, foram declaradas 2 variáveis do tipo BOOL para armazenar os valores dos sensores.

Void Setup()
A função void setup, que roda apenas uma vez, defini todas as configurações necessárias para funcionamento do
sistema.

1 void setup() {
2 Serial.begin(9600);
3 pinMode(MotorA_sentido1, OUTPUT);
4 pinMode(MotorA_sentido2, OUTPUT);
5 pinMode(MotorB_sentido1, OUTPUT);
6 pinMode(MotorB_sentido2, OUTPUT);
7 pinMode(MotorA_PWM, OUTPUT);
8 pinMode(MotorB_PWM, OUTPUT);
9 pinMode(Sensor_direita, INPUT);
10 pinMode(Sensor_esquerda, INPUT);
11
12 }

Nesta função declaramos as variáveis que definem os pinos utilizados no Arduino como sendo Entrada(INPUT)
ou Saída(OUTPUT). Além disso colocamos a função Serial.begin() que inicializa a comunicação serial entre o
Arduino e o computador. MAS O CARRINHO NÃO RODA LIGADO NA BATERIA ?!?!?! Sim, porém
precisamos fazer testes antes de executar a versão final, para isso utilizamos alguns comandos via serial para
poder calibrar sensores, averiguar execução do programa, entre outros.

Void Loop ()
Em seguida temos o loop do nosso programa onde o carrinho ira fazer suas principais funções. Primeiro é
necessário definir o sentido de rotação das rodas.

1 //Define o sentido de rotação dos motores

2 digitalWrite(MotorA_sentido1, LOW);
3 digitalWrite(MotorA_sentido2, HIGH);
4 digitalWrite(MotorB_sentido1, HIGH);
5 digitalWrite(MotorB_sentido2, LOW);

Nesta parte do código precisamos mandar um sinal alto e um sinal baixo entre os pares de portas IN1/IN2 e
IN3/IN4. Como nosso carrinho não anda pra trás nós vamos setar essas configurações para que as rodas girem
no mesmo sentido(pra frente no caso). Note que os pares no nosso código estão invertidos, isso acontece por
que a montagem de hardware foi invertida entre os motores. É como se os polos fossem trocados de lugar entre
os motores, porém lembre-se que motores DC não possuem polaridade definida, logo podemos inverter a
ligação + e – sem problemas. Isso altera apenas o sentido para o qual o motor gira. Essa é uma das partes que
devem ser testadas antes da montagem final do carrinho.

Em seguida temos as leituras dos sensores infravermelhos e, note também que, temos a impressão na serial dos
valores lidos. Isso é apenas para verificar se os sensores estão funcionando corretamente, não interferindo no
funcionamento final do projeto.

1 //Leituras dos Sensores

2 direita = digitalRead(Sensor_direita);
3 esquerda = digitalRead(Sensor_esquerda);
4 Serial.print(direita);
5 Serial.print(" || ");
6 Serial.println(esquerda);

As variáveis do tipo BOOL são utilizadas para armazenar os valores digitais lidos pelos sensores.

Por fim, temos as condições de giro do motor com base no sensores infravermelhos.

1 //Rodando os motores dependendo das leituras

2 if(direita == false && esquerda == false){
3 analogWrite(MotorA_PWM, veloc2);
4 analogWrite(MotorB_PWM, veloc2);
5 } else if(direita == false && esquerda == true){
6 delay(400);
7 analogWrite(MotorA_PWM, veloc2);
8 analogWrite(MotorB_PWM, veloc1);
9 delay(400);
10 }else if(direita == true && esquerda == false){
11 delay(400);
12 analogWrite(MotorA_PWM, veloc1);
13 analogWrite(MotorB_PWM, veloc2);
14 delay(400);
15
16 }else if(direita == true && esquerda == true){
17 analogWrite(MotorA_PWM, veloc0);
18 analogWrite(MotorB_PWM, veloc0);
19 }

Para isso utilizamos as condições IF Else, que são mais comum. São 2 variáveis combinatórias que geram 4
possibilidades, porém a ultima condição é quase “impossível” (true e true), pois seria a leitura dos sensores
detectando a faixa preta ao mesmo tempo (como é um erro estranho, o carrinho deve parar).

Os motores estão ligados em portas DIGITAIS mas lembre-se que estamos utilizando valores PWM, logo as
funções de comando são do tipo analogWrite(porta, PWM). Para que o carrinho possa ter tempo de verificar o
estado dos sensores novamente, alguns delays de curto período são utilizados, mas isso pode variar de projeto
para projeto.

Hardware
O carrinho funciona com uma comunicação entre os sensores, o Arduino e a ponte H controlando os motores.
Através das leituras do sensores enviadas para o Arduino por meio das portas digitais, o controlador irá acionar
um motor mais rápido ou mais devagar do que o outro. Os sensores emitem 5 V (faixa preta) ou 0 V(pista
branca) para as portas digitais. O Arduino modula os valores de velocidade pelos valores PWM que variam de 0
volts (0) até 5 volts (255), fazendo isso ao longo de todo trajeto.

Note que utilizamos apenas 1 bateria para todo o sistema. A bateria que alimenta o Arduino pelo pino P4
energiza não somente o controlador como também a ponte H dos motores por meio do pino Vin do Arduino.
Esta porta é capaz de emitir valores maiores do que os 5 volts que o regulador de tensão da placa utiliza. Sendo
assim a tensão de entrada no pino P4 é a mesma do pino Vin.