Instituto de Cultura Técnica

DIEGO DE OLIVEIRA CARVALHO

MICHEL PAULA ALVES

VICTOR NÉLIO DIAS ELEUTÉRIO
VITOR MIGUEL LIMA
WEBER PAULO CEZÁRIO DOS SANTOS

ROBÔ SEGUIDOR DE TRILHA

VOLTA REDONDA/RJ
2016

1
 DIEGO DE OLIVEIRA CARVALHO
MICHEL PAULA ALVES
VICTOR NÉLIO DIAS ELEUTÉRIO
VITOR MIGUEL LIMA
WEBER PAULO CEZÁRIO DOS SANTOS

ROBÔ SEGUIDOR DE TRILHA

Projeto Final apresentado ao Instituto de

Cultura Técnica – ICT, como requesito
parcial para obtenção do título de Técnico
de Mecatrônica.

Coordenador: Paulo Fleming

Professor Orientador: Ricardo

2
 ERRATA

CARVALHO, Diego de Oliveira; ALVES, Michel Paula; ELEUTÉRIO, Victor

Nélio Dias; LIMA, Vitor Miguel; SANTOS, Weber Paulo Cezário dos; Projeto
Robô Seguidor de Trilha - Trabalho de Conclusão de Curso Técnico de
Mecatrônica - Instituto de Cultura Técnica, Volta Redonda, Rio de Janeiro -
2016

Folha Linha Onde se lê Leia-se

3
 DIEGO DE OLIVEIRA CARVALHO
MICHEL PAULA ALVES
VICTOR NÉLIO DIAS ELEUTÉRIO
VITOR MIGUEL LIMA
WEBER PAULO CEZÁRIO DOS SANTOS

ROBÔ SEGUIDOR DE TRILHA

Trabalho de Conclusão do Curso Técnico de Mecatrônica do Instituto de

Cultura Técnica como um dos pré-requesitos para obtenção de grau, sob orientação
do professor orientador. Como parte dos requesitos necessários a obtenção do grau
em Técnico de Mecatrônica.

Data de aprovação:__/__/____
Resultado:_______________

APROVADO POR:

____________________________________________
Nome do Professor Orientador/ Coordenador de Curso

______________________________
______________________________
______________________________
______________________________
Professores Banca Examinadora

4
 Dedicamos aos nossos pais que sempre
ficaram ao nosso lado nos apoiando.
Dedicamos também ao nosso coordenador,
aos professores e nosso Orientador pela
dedicação e comprometimento.

5
 AGRADECIMENTOS

Agradecemos, primeiramente, a Deus por ter nos permitido estar aqui hoje
e ter nos dado forças para não desistir. Agradecemos aos nossos pais por
terem nos apoiado, tanto financeiramente como moralmente.

Agradecemos aos nossos professores, por terem cedido aulas para

trabalharmos no projeto, e por ter nos auxiliado em vários momentos.

Um agradecimento em particular ao Professor Ricardo por ter nos

ajudado com nossas dificuldades, ter nos auxiliado com paciência e por ter nos
mostrado como vencer nossas dificuldades e seguir em frente.

6
 “A verdadeira motivação vem da realização,
desenvolvimento pessoal, satisfação no
trabalho e reconhecimento.”
Frederick Herzberg

SUMÁRIO

7
1 INTRODUÇÃO ...................................................................................... 09

1.1 OBJETIVOS ......................................................................................... 09

2 FUNDAMENTAÇÃO TEÓRICA ........................................................... 09

2.1 MICROCONTROLADOR ...................................................................... 10

2.2 MOTORES DE CORRENTE CONTÍNUA ............................................. 10

2.3 SENSORES INFRAVERMELHO .......................................................... 10

2.4 ULTRASSÔNICO .................................................................................. 11

2.5 ACELERÔMETRO................................................................................ 11

2.6 SHIELD................................................................................................ 11

3 FLUXOGRAMA........................................................................................ 12

4. DIAGRAMA......................................................................................... 13

5. CRONOGRAMA........................................................................................ 14

6. TABELA DE CUSTO ................................................................................. 15

7. PROGRAMAÇÃO...................................................................................... 16

7. PROGRAMAÇÃO..................................................................................... 17

7. PROGRAMAÇÃO..................................................................................... 18

7. PROGRAMAÇÃO..................................................................................... 19

7. PROGRAMAÇÃO..................................................................................... 20

7. PROGRAMAÇÃO..................................................................................... 21

7. PROGRAMAÇÃO..................................................................................... 22

8. DIFICULDADES......................................................................................... 23

9. APLICAÇÕES INDUSTRIAIS.................................................................... 23

10. COMO SE MOVIMENTAM ?................................................................... 24

11. CONCLUSÃO..............................................................................................25

8
1. INTRODUÇÃO:

O projeto irá suprir a necessidade de viabilização em relação à

produção, organização e segurança. A monografa começa com uma visão
geral dos objetivos do trabalho e em seguida apresenta detalhes do
planejamento, montagem do hardware e da implementação do software que
serão usados no robô. Serão usados para locomover o robô dois motores de
corrente contínua em conjunto com o ponte H alimentados por uma bateria de
7,5V. Para medir a distancia e auxiliar no desvio utilizamos o sensor de
distância Ultrassônico HC-SR04. Para detectar a trilha utilizamos quatro
sensores infravermelhos, sendo que cada um possui um emissor e um
receptor. Para acelerar na rampa utilizamos um Acelerômetro 7455. Tudo será
controlado pela placa Arduino ATMEGA 2560.

1.1 OBJETIVOS:

Desenvolver um robô que se move sobre a trilha branca em uma

superfície preta, guiado por sensores infravermelhos compostos por um
emissor TIL 78 e um receptor TIL 32, que realiza o desvio de objetos através
da medição de distância realizada pelo sensor Ultrassônico HC-SR04 e
acelerar na rampa utilizando o Acelerômetro 7455.

2. FUNDAMENTAÇÃO TEÓRICA:

Para entender o Robô é necessário entender alguns conceitos e o

funcionamento dos componentese peças envolvidos pelo trabalho, a
fundamentação teórica explica esse ponto do projeto.

9
2.1 MICROCONTROLADOR:
Utilizamos no nosso projeto o microcontrolador Arduino, que é responsavel
pela comunicação entre os sensores e os motores. No caso dos motores, os
sensores infravermelhos enviam um comando para os motores através do
ponte H para executar o movimento corretamente e se manter na trilha. No
caso do desvio, o Arduino se comunica com o Ultrassônico, verificando a
distancia medida, e através de uma função especificada programção, ele
realiza o desvio caso a distância seja menor que 11cm.
Arduino é uma placa de protoatipagem eletrônica, baseado em um
microcontrolador ATMega 2560 que se conecta ao computador pessoal através
de uma porta serial USB. Ele possui uma linguagem de programação própria,
que é a linguagem tipo C, baseada em Wiring, que é implementada em um
ambiente de desenvolvimento (IDE), que pode ser utilizada em varios sitemas
operacionais.
O modelo do Arduino que estamos utilizando no projeto é o
ATMega2560 que possui entrada USB e também conector de alimentação
externa.

2.2 MOTORES DE CORRENTE CONTÍNUA:

Motores eléticos convertem energia elética em mecânica. No nosso

projeto utilizamos dois Motores de Corrente Contínua. Os dois motores
precisam ser acionados nos dois sentidos, portanto há necessidade de
controlar o sentido da corrente fornecida para que o motor inverta o sentido de
rotação. Esse controle é feito pela ponte H, que controla o sentido da corrente
para o motor através da disposição de quatro chaves eletrônicas em que o
motor é posicionado entre elas, de forma que formem um “H”, daí o seu nome.
2.3 SENSORES INFRAVERMELHO:
Os sensores utilizados são sensores infravermelhos, que são compostos
por um emissor de luz infravermelho, que é o TIL 78, e um receptor, o TIL 32.
O led emissor envia um sinal de luz infravermelho, que reflete na trilha e é
captado pelo receptor. Quando esse sinal é captado pelo receptor gera uma
variação de intensidade, que é diferente para cada cor. Através dessa variação
que é enviada pelo sensor, o Arduino consegue diferenciar as cores, então,

10
através de funções especificadas na programação, ele controla os motores
para seguir a trilha.

2.4 ULTRASSÔNICO:

No nosso projeto utilizamos o Ultassônico HC-SR04. O Ultrassônico HC-

SR04 é utilizado para medir distância, e possui um alcance máximo de 4
metros. No nosso projeto utilizamos para desviar de objetos a 10cm de
distância. O HC-SR04 possui um Trig e um Echo. A função do Trig é enviar um
pulso sonoro de 20.000Hz, esse pulso é refletido quando há algo no caminho, e
é recebido de volta pelo Echo. Através de funções especificadas na
programação, o Arduino compara a distância medida pelo Ultrassônico, e caso
seja menor que 11cm, o Arduino envia para os motores o comando de desvio.

2.5 ACELERÔMETRO:

Utilizamos também um acelerômetro do modelo 7455. Utilizamos esse

sensor para identificar a inclinação da rampa. Quando o acelerômetro detecta a
rampa, acelera os motores através de funções especificadas na programação
para o robô ter a força necessária para subir a rampa.

2.6 SHIELD:
Usamos nesse projeto um Motor Shield L293D Driver Ponte H, este Arduino
Motor Shield é baseado no chip L293D e com ele é possível controlar até 4
Motores DC, 2 Servos ou 2 Motores de Passo. O chip L293D possui
internamente 2 Ponte H e suporta uma corrente de saída de 600mA por canal,
ou seja, será possível controlar até 2 motores com 600mA cada, visto que
neste Shield temos 2 chips. Tensão suportada de 4,5-36V. 

11
3. FLUXOGRAMA:

12
4. DIAGRAMA:

13
5. CRONOGRAMA :

14
6. TABELA DE CUSTO

15
7. PROGRAMAÇÃO:

#include <AFMotor.h>
#include <MMA_7455.h>
#include <Wire.h>
MMA_7455 mySensor = MMA_7455();
char xVal, yVal, zVal;
AF_DCMotor motor1(2); //Seleciona o motor 1
AF_DCMotor motor2(3); //Seleciona o motor 2
const int SENSOR1 = A11;
const int SENSOR2 = A10;
const int SENSOR3 = A9;
const int SENSOR4 = A8;
#include <Ultrasonic.h>
#define eco 15
#define trig 14
Ultrasonic ultrasonic(trig,eco);
int cm = 0 ;
int Valor1 = 0;
int Valor2 = 0;
int Valor3 = 0;
int Valor4 = 0;
int Corte = 700;
float distancia = 0;
long leitura = 0;

void setup() {

pinMode (SENSOR1, INPUT);

pinMode (SENSOR2, INPUT);
pinMode (SENSOR3, INPUT);
pinMode (SENSOR4, INPUT);
Serial.begin(9600);
pinMode(eco,INPUT);
pinMode(trig,OUTPUT);
mySensor.initSensitivity(2);
}

void loop() {
Valor1 = analogRead(SENSOR1);
Valor2 = analogRead(SENSOR2);
Valor3 = analogRead(SENSOR3);
Valor4 = analogRead(SENSOR4);
xVal = mySensor.readAxis('x'); //Read out the 'x' Axis
yVal = mySensor.readAxis('y'); //Read out the 'y'a Axis
zVal = mySensor.readAxis('z'); //Read out the 'z'

16
long t=ultrasonic.timing();
cm=ultrasonic.convert(t,Ultrasonic::CM);
if ((cm) > (10) && (cm) < (13))

{ motor1.run(RELEASE);
motor2.run(RELEASE);
delay(500);
motor1.setSpeed(182);
motor2.setSpeed(170);
motor1.run(FORWARD);
motor2.run(BACKWARD);
delay(450);
motor1.run(RELEASE);
motor2.run(RELEASE);
delay(500);
motor1.setSpeed(182);
motor2.setSpeed(170);
motor1.run(FORWARD);
motor2.run(FORWARD);
delay(600);
motor1.run(RELEASE);
motor2.run(RELEASE);
delay(500);
motor2.setSpeed(170);
motor1.run(RELEASE);
motor2.run(FORWARD);
delay(950);
motor1.run(RELEASE);
motor2.run(RELEASE);
delay(500);
motor1.setSpeed(182);
motor2.setSpeed(170);
motor1.run(FORWARD);
motor2.run(FORWARD);
delay(900);
motor1.run(RELEASE);
motor2.run(RELEASE);
delay(500);
motor2.setSpeed(170);
motor1.run(RELEASE);
motor2.run(FORWARD);
delay(900);
motor1.run(RELEASE);
motor2.run(RELEASE);
delay(500);
motor1.setSpeed(182);
motor2.setSpeed(170);
motor1.run(FORWARD);
motor2.run(FORWARD);

17
 delay(700);

motor1.run(RELEASE);
motor2.run(RELEASE);
delay(500);
motor1.setSpeed(182);
motor2.setSpeed(170);
motor1.run(FORWARD);
motor2.run(BACKWARD);
delay(400);
motor1.run(RELEASE);
motor2.run(RELEASE);
delay(500);
motor1.setSpeed(140);
motor2.setSpeed(140);
}

Serial.print("ACELEROMETRO");
if (xVal > -2)
{Serial.println("NORMAL");

// curva 90 direita

if((Valor4) < (Corte) && (Valor3) > (Corte) && (Valor2) > (Corte)&& (Valor1) > (Corte))
{
motor1.setSpeed(140);
motor2.setSpeed(140);
motor1.run(FORWARD);
motor2.run(BACKWARD);
}
// curva normal direita
if((Valor4) > (Corte) && (Valor3) < (Corte) && (Valor2) > (Corte)&& (Valor1) > (Corte))
{
motor1.setSpeed(160);
motor1.run(FORWARD);
motor2.run(RELEASE);
}
//curva 90 direita
if((Valor4) < (Corte) && (Valor3) < (Corte) && (Valor2) > (Corte)&& (Valor1) > (Corte))
{
motor1.setSpeed(140);
motor2.setSpeed(140);
motor1.run(FORWARD);
motor2.run(BACKWARD);
}
//curva normal esquerda
if((Valor4) > (Corte) && (Valor3) > (Corte) && (Valor2) < (Corte)&& (Valor1) > (Corte))

18
motor2.setSpeed(140);
motor1.run(RELEASE);
motor2.run(FORWARD);
}

//linha reta
if((Valor2) < (Corte) && (Valor3) < (Corte) && (Valor4) > (Corte) && (Valor1) > (Corte))
{
motor1.setSpeed(140);
motor2.setSpeed(140);
motor1.run(FORWARD);
motor2.run(FORWARD);
}

// curva 90 direita

if((Valor4) < (Corte) && (Valor3) < (Corte) && (Valor2) < (Corte)&& (Valor1) > (Corte))
{
motor1.setSpeed(140);
motor2.setSpeed(140);
motor1.run(FORWARD);
motor2.run(BACKWARD);
}
//curva 90 esquerda

if((Valor4) > (Corte) && (Valor3) > (Corte) && (Valor2) > (Corte)&& (Valor1) < (Corte))
{
motor1.setSpeed(150);
motor2.setSpeed(150);
motor1.run(BACKWARD);
motor2.run(FORWARD);
}

// curva 90 esquerda
if((Valor1) < (Corte) && (Valor2) > (Corte) && (Valor3) > (Corte)&& (Valor4) > (Corte))
{
motor1.setSpeed(140);
motor2.setSpeed(140);
motor1.run(BACKWARD);
motor2.run(FORWARD);
}
// curva 90 esquerda
if((Valor4) > (Corte) && (Valor3) < (Corte) && (Valor2) < (Corte)&& (Valor1) < (Corte))
{
motor1.setSpeed(140);
motor2.setSpeed(140);

19
 motor1.run(BACKWARD);
motor2.run(FORWARD);
}

// cruzamento

if((Valor1) < (Corte) && (Valor2) < (Corte) && (Valor3) < (Corte) && (Valor4) < (Corte))
{
motor1.setSpeed(140);
motor2.setSpeed(140);
motor1.run(FORWARD);
motor2.run(FORWARD);
}

// falha

if((Valor1) > (Corte) && (Valor2) > (Corte) && (Valor3) > (Corte) && (Valor4) >
(Corte))
{
motor1.setSpeed(140);
motor2.setSpeed(140);
motor1.run(FORWARD);
motor2.run(FORWARD);
}}
if (xVal < -1)
{Serial.println("SUBINDO");
// curva 90 direita

if((Valor4) < (Corte) && (Valor3) > (Corte) && (Valor2) > (Corte)&& (Valor1) > (Corte))
{
motor1.setSpeed(255);
motor2.setSpeed(255);
motor1.run(FORWARD);
motor2.run(BACKWARD);
}

// curva normal direita

if((Valor4) > (Corte) && (Valor3) < (Corte) && (Valor2) > (Corte)&& (Valor1) > (Corte))
{
motor1.setSpeed(255);
motor1.run(FORWARD);
motor2.run(RELEASE);
}
//curva 90 direita
if((Valor4) < (Corte) && (Valor3) < (Corte) && (Valor2) > (Corte)&& (Valor1) > (Corte))

20
motor1.setSpeed(255);
motor2.setSpeed(255);
motor1.run(FORWARD);
motor2.run(BACKWARD);
}
//curva normal esquerda
if((Valor4) > (Corte) && (Valor3) > (Corte) && (Valor2) < (Corte)&& (Valor1) > (Corte))
{
motor2.setSpeed(255);
motor1.run(RELEASE);
motor2.run(FORWARD);
}

//linha reta
if((Valor2) < (Corte) && (Valor3) < (Corte) && (Valor4) > (Corte) && (Valor1) > (Corte))
{
motor1.setSpeed(255);
motor2.setSpeed(255);
motor1.run(FORWARD);
motor2.run(FORWARD);
}

// curva 90 direita

if((Valor4) < (Corte) && (Valor3) < (Corte) && (Valor2) < (Corte)&& (Valor1) > (Corte))
{
motor1.setSpeed(255);
motor2.setSpeed(255);
motor1.run(FORWARD);
motor2.run(BACKWARD);
}

//curva 90 esquerda

if((Valor4) > (Corte) && (Valor3) > (Corte) && (Valor2) > (Corte)&& (Valor1) < (Corte))
{
motor1.setSpeed(255);
motor2.setSpeed(255);
motor1.run(BACKWARD);
motor2.run(FORWARD);
}

// curva 90 esquerda

if((Valor1) < (Corte) && (Valor2) > (Corte) && (Valor3) > (Corte)&& (Valor4) > (Corte))
{
motor1.setSpeed(255);
motor2.setSpeed(255);

21
 motor1.run(BACKWARD);
motor2.run(FORWARD);
}

// curva 90 esquerda

if((Valor4) > (Corte) && (Valor3) < (Corte) && (Valor2) < (Corte)&& (Valor1) < (Corte))
{
motor1.setSpeed(255);
motor2.setSpeed(255);
motor1.run(BACKWARD);
motor2.run(FORWARD);
}

// cruzamento

if((Valor1) < (Corte) && (Valor2) < (Corte) && (Valor3) < (Corte) && (Valor4) < (Corte))
{
motor1.setSpeed(255);
motor2.setSpeed(255);
motor1.run(FORWARD);
motor2.run(FORWARD);
}

// falha

if((Valor1) > (Corte) && (Valor2) > (Corte) && (Valor3) > (Corte) && (Valor4) >
(Corte))
{
motor1.setSpeed(255);
motor2.setSpeed(255);
motor1.run(FORWARD);
motor2.run(FORWARD);
}}}

22
8. DIFICULDADES:

Nosso grupo teve algumas dificuldades na junção das programações ,pois

quando inserimos as tais juntas na placa arduino o nosso robô acaba que não
fazendo a programação correta.Acreditamos que seja pelo motivo que
trabalhamos com um Arduino que processa as suas informações em GigaHertz
entrando em conflito com o sensor ultrassônico que processa em
KiloHertz.Nesse caso concluímos que devemos fazer a conversão do
ultrassônico para GigaHertz.

9. APLICAÇÕES INDUSTRIAIS :

As diferentes gamas de AGVs vêm cobrir um espaço dentro do campo da

logística até agora não resolvido devido a que se trata de veículos leves, com
máxima manobrabilidade (podem girar sobre seu próprio eixo), mínima
manutenção, máxima robustez, programáveis facilmente e que podem ser
controlados automaticamente ou manualmente.

Tradicionalmente, os AGVs foram usados para levar cargas pesadas de

um local a outro. Num armazém, por exemplo, o AGV realiza de forma
automática tarefas como a recepção de um container diretamente de uma
correia transportadora, seu traslado a seu emprazamento final, e o
empilhamento de containers a diversas alturas predeterminadas.

Os AGVs foram criados com o objetivo de facilitar ao ser humano um

conjunto de tarefas difíceis de realizar, monótonas ou aquelas que acarretam
um risco humano. São inumeráveis os projetos desenvolvidos neste campo e
também o é o aprofundamento com que tem sido abordado.

Este veículo foi desenvolvido com o objetivo de minimizar custos e ter uma
alta flexibilidade no momento de incorporar novos componentes.

O grau de operacionalidade e complexidade pode ser tão grande quanto

for desejado e, além do mais, podem ser utilizados sensores de alto
desempenho e processadores de grande potência para reconhecer objetos.

23
10. COMO SE MOVIMENTAM ?

Um AGV precisa de uma realimentação sensorial para se movimentar, que

lhe informe se vai por bom caminho, se vai bater com alguma coisa, ou o que é
o que tem na frente. Embora existam diversos modelos de guiado padrão,
atualmente cada fabricante tem adotado um ou dois desses modelos e tem
desenvolvido novos sistemas baseados neles, com potentes dispositivos
SW+HW registrados, que guardam com zelo seus segredos.

Numa fábrica industrial, um AGV usualmente segue uma trajetória

prefixada, de forma que só tem que garantir não sair do caminho e não bater
com nada. Normalmente lhe é ordenado que vá do ponto A ao ponto B e isso
lhe é permitido. Quando há mais de um AGV, a gestão do tráfico é realizada ou
com sinais (fototransistores) ou então, uma unidade encarrega-se de ter
localizados todos os AGVs e de lhes mandar ordens no momento oportuno.

Quando não existe um guia ou trajetória prefixada, a sensorização é mais

complexa. Mediante câmeras ou ferramentas de software, um operador
humano fala para o robô onde tem que ir e que é o que tem que fazer. Também
pode lhe deixar fazer, em cujo caso o AGV terá que se virar para explorar e
reconhecer o entorno e conseguir sua missão sem sofrer nenhum percalço.
Os métodos principais de guiado são os que seguem:

Wire Guidance (guiado por cabo): A trajetória é fixada por um fio que vai
sob do solo.

Laser Guidance (guiado por laser): Um scanner de laser vai montado no

ponto mais alto do AGV. Este scanner realiza um varrido da área circundante
procurando uns targets (para se movimentar, o AGV necessita detectar um
mínimo de três refletores).

Inertial Guidance and encoder system (guiado por inércia e encoders):

Através de sensores de posição, velocidade e ângulo de giro é obtida
informação sobre a distância percorrida, a posição atual e o ângulo de giro.

Magnet-Gyro Guidance (guiado por imãs + giroscópio): Aplica a mesma

filosofia que o guiado por fio, substituindo este por uns pequenos imãs no solo
que indicam a trajetória a seguir. O sistema é completado com sensores de
ângulo de giro e um giroscópio que mantém sempre a direção e a estabilidade
do AGV.

24
11. CONCLUSÃO :

Concluímos que o robô seguidor de trilha, ‘’ Robo AGV (Automatic Guided

Vehicle) ’’ ou ‘’veículo auto-guiado’’ é um robô capacitado para se movimentar
de forma autônoma num entorno determinado, realizando tarefas como o
transporte de objetos pesados ou a manipulação e colheita de amostras,
evitando a colisão com os demais elementos que o rodeiam.

25
.

26