Carrinho Seguidor de Linha Capaz de Realizar Ultrapassagens

Emanoeli Madalosso, Vanderlei Luiz Azzolini

Este artigo descreve a criao de um carrinho capaz de realizar ultrapassagens sem o risco de colises, utilizando a plataforma
de prototipagem Arduino Uno. O prottipo desenvolvido consiste em um carrinho seguidor de percurso equipado com dois
motores de corrente contnua, alimentados por meio de uma ponte H. Foi utilizado um sensor LDR (Light Dependent Resistor) para
delimitar o percurso a ser seguido pelo prottipo. Tambm foram utilizados sensores ultrassnicos alocados nas reas do prottipo
correspondentes aos pontos cegos de um veculo. Estes sensores verificam a presena de obstculos que estejam em rota de coliso,
para que o prottipo possa desvi-los ou aguardar que esses objetos sejam removidos.
Palavras-chave: seguidor de percurso, arduino, ultrassnico.

I.

INTRODUO

As ultrapassagens so um dos momentos mais crticos

do trnsito, podendo muitas vezes provocar colises,
colocando em risco a vida dos ocupantes do veculo. O
tipo mais comum de coliso a de tipo frontal, porm
existem tambm outros tipos de colises, que se devem
ao fato de o veculo possuir pontos cegos, ou seja, faixas
onde o motorista no tem visibilidade da pista, fazendo
assim com que ele no perceba algum veculo que pode
estar em rota de coliso. Estes pontos cegos podem ser
causados por diversos fatores, tais como, o mau
posicionamento
dos
espelhos
retrovisores,
e
principalmente pelo bloqueio causado pelas laterais ou
cantos do prprio veculo.
Pensando em uma soluo a este problema, este
trabalho mostra a construo de um carrinho capaz de
seguir uma pista e realizar ultrapassagens ao encontrar
outro carrinho a sua frente. Estas ultrapassagens devem
ser feitas em segurana, verificando tambm se existe
algum outro carrinho que esteja vindo pelo lado esquerdo
do veculo, nos chamados pontos cegos, utilizando para
isto a integrao de vrios sensores. No decorrer deste
trabalho sero mostrados os passos necessrios para o
desenvolvimento deste carrinho.
II. FUNDAMENTAO TERICA
Nesta seo sero apresentados conceitos importantes
sobre os componentes utilizados no projeto, bem como o
funcionamento dos mesmos, tais como o Arduino Uno,
PWM, ponte H, motores CC (Corrente Contnua), sensor
LDR e sensores ultrassnicos.

TABELA 1
CARACTERSTICAS DA PLATAFORMA ARDUINO
UNO
Microcontrolador
ATmega328
Tenso de operao
5V
Tenso de entrada
7-12V
(recomendada)
Tenso de entrada (limite)
6-20V
Pinos de entrada e sada
14 (dos quais 6
(E/S)
fornecem sada PWM)
Pinos de entrada analgica
6
Corrente CC por pino e E/S

40 mA

Corrente CC pelo pino de

3,3V

50 mA

Memria Flash

32 KB

SRAM

2 KB

EEPROM

1 KB

Velocidade de clock

16 MHz

A figura 1mostra a plataforma de prototipagem

Arduino Uno.

Arduino Uno
O Arduino Uno uma plataforma de prototipagem
eletrnica open-source baseada no mircrocontrolador
ATmega328. Suas principais caractersticas so
mostradas na tabela 1 [1].

Fig 1. Arduino Uno

O Arduino possui uma linguagem de programao
prpria, baseada em Wiring, que implementada em um
ambiente de desenvolvimento (IDE), tambm prprio.
Este ambiente escrito em Java e baseado em
Processing [2]. Suas bibliotecas so escritas em C e C++.

Esta IDE simples e pode ser utilizada em vrios

sistemas operacionais.
A linguagem de programao utilizada semelhante
ao C. Um programa bsico do Arduino constitudo de
uma funo void setup(), logo no incio do programa e
uma funo void loop(). Na funo void setup()
inicializa-se tudo o que for necessrio antes da execuo
do programa, como por exemplo, a definio de um pino
como entrada ou sada. A funo void loop() funciona
como um lao infinito, ou seja, ela executada
repetidamente dentro do microcontrolaldor. dentro da
funo void loop() que chamamos todas as funes
necessrias pra o funcionamento do carrinho, garantindo
assim que elas sejam executadas repetidamente enquanto
este estive em funcionamento.
PWM
Como o carrinho deve fazer curvas, necessrio
controlar a velocidade com que seus motores giram. Se o
carrinho precisar virar para esquerda, por exemplo, o
motor da direita deve possuir velocidade maior que o da
esquerda. Enviando simplesmente sinal alto ou sinal
baixo aos motores no seria possvel fazer este controle
de velocidade, j que s existiriam duas situaes
possveis: o motor parado ou o motor girando com sua
potncia mxima. Sendo assim, para fazer este controle
de velocidade foi utilizada modulao PWM (PulseWidth Modulation).
A tcnica de PWM constitui uma maneira fcil de
controlar motores, onde utilizada uma sada digital para
o controle e consiste em um padro de rpida alternncia
entre liga e desliga de um perodo T, na qual, parte do
tempo ela estar em estado ativo e parte do tempo em
estado desativado [3].
Em outras palavras, a modulao PWM consiste na
gerao de um trem de pulsos de onda quadrada variando
a largura de pulso, mas mantendo sempre a mesma
amplitude, como apresentado na Figura 2.

estar sendo suavemente variada conforme a taxa de pulso

alterada [4].
A durao de tempo em que em que o sinal est em
nvel alto (ON) conhecida como largura de pulso. Por
exemplo, ao enviar o valor 0 para o pino de PWM digital
11 utilizando analogWrite(), o perodo ON seria zero, ou
seja, ele teria um ciclo de trabalho de 0 por cento. Ao
enviar o valor 64 (25 por cento do mximo de 255) o pino
seria ON para 25 por cento do tempo e OFF de 75 por
cento do tempo. O valor de 191 ter um ciclo de
funcionamento de 75 por cento, j um valor de 255 teria
um ciclo de 100 por cento [5].
Ponte H
Para movimentao do carrinho foram utilizados
motores de corrente continua. Estes, porm, no podem
ser ligados diretamente na sada do microcontrolador,
pois ele no consegue fornecer corrente suficiente para o
pleno funcionamento dos mesmos, o que pode ser
verificado pela tabela 1. Em razo disso utilizou-se um
circuito eletrnico chamado de Ponte H.
Trata-se de um circuito utilizado para controlar um
motor CC a partir de sinais gerados por um
microcontrolador. Devido disposio dos seus
componentes, torna-se extremamente fcil selecionar o
sentido da rotao de um motor, apenas invertendo a
polaridade sobre seus terminais [6]. Esse circuito
construdo com quatro "chaves" (S1-S4) que so
acionadas de forma alternada (S1 e S4 ou S2 e S3).

Figura 3 - Esquema da ponte H quando todas as chaves

esto abertas.

Fig 2. Modulao PWM

No Arduino existe a funo analogWrite(), que
utiliza a tcnica de PWM para emular um sinal analgico
usando pulsos digitais. O Arduino envia para o pino de
PWM uma onda quadrada, alterando o estado do pino de
nvel baixo para nvel alto muito rapidamente. Quando os
pulsos so repetidos de forma suficientemente rpida
(cerca de 500 vezes por segundo no Arduino) a pulsao
no pode ser detectada pelos sentidos humanos, e a sada
de coisas tais como LEDs (Light Emitting Diodes) parece

Fig 4. Esquema quando os pares de chaves esto

fechadas.
Para cada configurao das chaves o motor gira em
um sentido, devido inverso da corrente que circula
sobre ele quando cada par de chaves esta ligado, como
mostrado a figura 4, onde a figura da esquerda encontrase com as chaves S1 e S4 ligadas, j a figura a direita
encontra-se com as chaves S2 e S3 fechadas. As chaves
S1 e S2, assim como as chaves S3 e S4, no podem ser
ligadas ao mesmo tempo, pois podem gerar um curto
circuito.
Em circuitos reais, essas chaves podem ser qualquer
componente que simule uma chave liga-desliga como, por

exemplo, transistores, rels, MOSFETs ou ainda portas

lgicas presentes em circuitos integrados.
Para esse projeto foi utilizado uma placa com um
circuito integrado LM293. Este possui duas pontes H
independentes, possibilitando assim o controle de cada
motor separadamente. Alm disso, a placa possui diodos
de proteo contra corrente reversa e sobre corrente,
ocasionada quando os motores partem ou sua rotao
invertida. Ela tambm j possui um dissipador de calor.
Outro ponto importante da placa est em seu
fornecimento de corrente, sendo que cada canal pode
fornecer at dois amperes de corrente. O circuito da placa
mostrado na figura 5.

permanente com uma bobina e com escovas, que pode ser

facilmente encontrado no mercado.
Os principais componentes deste tipo de motor so
descritos a seguir.
Estator: um im permanente que alimentado
diretamente por uma fonte de tenso contnua;
Rotor: um eletrom constitudo de um ncleo de
ferro com enrolamentos em sua superfcie que so
alimentados por um sistema mecnico de
comutao;
Comutador: sistema mecnico (tubo de cobre
axialmente segmentado) cuja funo inverter a
corrente na fase de rotao apropriada de forma que
o conjugado desenvolvido seja sempre na mesma
direo [7].

Fig 7(a). Motor CC elementar

Fig 5. Circuito da Ponte H
Como neste projeto no h a necessidade de inverter a
rotao dos motores, utilizamos apenas um sinal de
controle (PWM) para cada motor, como representado na
figura 6, sendo que PWM 1 representa o controle do
motor esquerdo feito pela porta 10 do microcontrolador
Arduino e PWM 2, representa o controle do motor
direito feito pela porta 5. Para alimentar a ponte H,
utilizou-se quatro pilhas de 1.2V, totalizando
aproximadamente 5V, a tenso apropriada para o
funcionamento desta ponte.

Fig 7(b). FA-130

O funcionamento de um motor CC est baseado no

princpio do eletromagnetismo. Segundo este princpio,
um condutor carregando uma corrente e mergulhado em
um fluxo magntico fica submetido a uma fora
eletromagntica, como mostrado na Figura 7(a). O
sentido desta fora pode mudar se o sentido do fluxo ou o
sentido da corrente tambm mudar. O fluxo magntico
pode ser produzido por um im permanente ou um
eletrom.
Para este projeto utilizamos dois motores CC modelo
FA-130 como mostra a Figura 7(b), pois este mostrou-se
adequado s necessidade de locomoo do carrinho.
Este motor possui tenso nominal de 4.5V e suporta
uma corrente de at 1.31 amperes. Ele pode chegar a
12000rpm sem carga e 60gcm de torque.
Sensor LDR
Para a montagem do circuito seguidor de linha fez-se
uso de um LDR. O LDR um tipo de resistor, cuja
resistncia inversamente proporcional quantidade de
luz
incidente
sobre
ele. Verifica-se que quando o LDR submetido a um
feixe de luz mais intenso, o valor da resistncia diminui.
J quando este submetido a um feixe de luz mais fraco,
esta resistncia aumenta. A figura 8 representa variao
da resistncia do LDR em relao luminosidade.

Fig 6. Esquema de ligao da Ponte H

Motores CC
O motor CC tem como objetivo converter a energia
eltrica em energia mecnica, necessria para a
movimentao do carrinho. H vrios tipos de motores
CC, mas nesse projeto utilizou-se um motor CC de im
Fig 8. Variao da resistncia em relao luminosidade

Esta sensibilidade luz se deve ao fato de o LDR ser

constitudo de um material fotossensvel, como por
exemplo, sulfeto de cdmio ou sulfeto de chumbo. O
processo de construo de um LDR consiste na conexo
do material fotossensvel com os terminais, sendo que
uma fina camada simplesmente exposta incidncia
luminosa externa [8].
O LDR
no
possui
pinagem,
seus
terminais podem ser ligados de qualquer forma. A figura
9 mostra um LDR.

Fig 9. Sensor LDR

Sensores Ultrassnicos
Optou-se pelo sensor ultrassnico HC-SR04 para
fazer a deteco de obstculos ao redor do carrinho.
O princpio de funcionamento dos sensores ultrasnicos est baseado na emisso de uma onda sonora de
alta freqncia, e na medio do tempo levado para a
recepo do eco produzido quando esta onda se choca
com um objeto capaz de refletir o som. Eles emitem
pulsos ultra-snicos ciclicamente. Quando um objeto
reflete estes pulsos, o eco resultante recebido e
convertido em um sinal eltrico [9].
A principal vantagem dos sensores ultrassnicos a
capacidade de detectar objetos sem a necessidade de tocar
esses objetos. Alm disso, como este sensor possibilita
fazer leituras rpidas, a distncia de um objeto em
movimento (como neste caso, outro carrinho frente na
pista) pode ser atualizada rapidamente. Outra vantagem
que estes sensores so indiferentes as condies do
ambiente
como
luminosidade,
interferncia
eletromagntica ou radiao infravermelha.
O sensor HC-SR04 tem como caracterstica a
capacidade de medir distncias que variam de 2
centmetros at 5 metros, com uma preciso de 0,3
centmetros, o que atende perfeitamente as necessidades
deste projeto. Este sensor proporciona uma melhor
eficincia com um angulo de 30, como mostra a figura
10.

Fig 11. Sensor ultrassnico HC-SR0

O sensor composto por 4 pinos, sendo eles:
VCC : alimentao de 5V;
TRIG : pino de gatilho;
ECHO : pino de eco;
GND : terra.
Obs.: a mxima corrente suportada de 2mA.
O sensor emite um pulso ultrassnico (atravs do pino
trigger) que reflete em um objeto. O sinal que retorna
captado (atravs do pino echo) e convertido em um sinal
eltrico, a partir do qual se pode estimar a distncia entre
o objeto e o sensor. O prximo pulso pode ser transmitido
quando o eco estiver desaparecendo [10].
A velocidade do sinal ultrassnico de
aproximadamente 240 m/s, assim, se o sensor estiver a
uma distncia d do objeto, o sinal percorrer uma
distncia equivalente a 2d para sair e retornar ao sensor
[11]. Sabendo esses conceitos possvel calcular a
distncia de um objeto pela frmula:

III. DESENVOLVIMENTO
Nesta seo sero apresentados os passos para a
montagem do prottipo, tais como a montagem da
estrutura do carrinho, o sistema para deteco de objetos,
o circuito seguidor de linha e o procedimento usado para
o desenvolvimento do software.
Estrutura do carrinho

Fig 10. ngulo de melhor funcionamento do sensor

A figura 11 mostra o sensor HC-SR04.

O carrinho foi montado utilizando o Tamiya 70108

Tracked Vehicle Chassis Kit. Este kit vem com todas as
peas necessrias para a montagem de um carrinho do
tipo tanque, como mostrado na figura 12(a). Como este
modelo vem com apenas um motor e necessitava-se dois,
para controlar a direo dos carrinhos, foi utilizado
tambm o Tamiya Twin Motor Gearbox Model Kit, que
inclui dois motores, como mostrado na figura 12(b). Este
kit foi utilizado no lugar do motor original que
acompanhava o chassi. Uma vantagem deste kit que os
motores j vm com caixas redutoras de velocidade.

O pino GND do sensor ultrassnico foi ligado ao

pino GND do Arduino;
O pino ECHO do sensor foi ligado a porta de 10
de E/S digital do Arduino;
O pino TRIGGER do sensor foi ligado a porta 9
de E/S digital do Arduino;
O pino de 5V do sensor foi ligado ao pino de 5V
do Arduino.

Seguidor de linha
Fig 12(a).

Este circuito foi feito utilizando um pequeno pedao

de placa perfurada que foi colocada na parte da frente do
carrinho, de modo que ficasse bem prxima ao cho. O
circuito foi montado da forma mostrada na Figura 14. O
resistor utilizado foi de 390. Ele tem como funo
evitar que passe corrente demais pelo LED, evitando que
este queime, j que o mesmo suporta at 5mA. A funo
do LED por sua vez, emitir um feixe de luz sobre a
pista. O feixe de luz ser refletido no LDR com maior ou
menor intensidade, de acordo com a cor das faixas
pintadas na pista.

Fig 12(b). Tamiya Twin Motor Gearbox Model Kit

Sistema de deteco de objetos
Foram utilizados quatro sensores ultrassnicos,
dispostos da forma da figura 13, sendo que o sensor 4 o
sensor da frente do carrinho.

Fig 14. Circuito seguidor de linha

Se o carrinho estiver sobre uma superfcie de cor mais
clara, a luz emitida pelo LED refletir mais no LDR,
fazendo com que sua resistncia diminua. Se o carrinho
estiver sobre uma superfcie mais escura a luz refletir
menos sobre o LDR, fazendo com que este apresente
resistncia maior (figura 15).

Fig 13. Disposio dos sensores ultrassnicos no carrinho

Este sensor ir verificar se existe algum objeto
frente dele na pista. Em caso positivo, os sensores 2 e 3
verificaro a existncia de outros objetos ao lado do
carrinho, na segunda pista. Caso no exista nenhum
obstculo o carrinho estar apto para realizar a
ultrapassagem. Caso um dos sensores detecte um
obstculo, o carrinho no pode ultrapassar, tendo assim
que parar para no bater no carro da frente. O sensor 1
serve para verificar se existe algum obstculo direita,
aps o carrinho iniciar a ultrapassagem, verificando
assim, se ele j pode voltar para sua pista. Este processo
pode ser verificado pelo diagrama da figura 17.
A ligao de cada um dos sensores ultrassnicos ao
Arduino foi feita da seguinte forma:

Fig 15. Reflexo da luz emitida no LDR pelo LED

Em uma cartolina foi montado o circuito do carrinho.
Foram montadas duas pistas, cada uma delas composta de
uma faixa preta e uma vermelha, como pode ser mais bem
visualizado na Figura 16.

Fig 16. Circuito

O carrinho iniciar sua trajetria na pista 1, seguindo a

faixa de cor vermelha. Isto significa que os valores
captados devem estar entre 90 e 200, que so os valores
correspondentes esta cor.
Se os valores lidos forem menores do que esta faixa
sabe-se que o carrinho esta sobre a linha preta. O Arduino
ento deve diminuir o valor do PWM enviado para o
motor esquerdo do carrinho, fazendo com que este vire
para a esquerda. Caso o seguidor esteja lendo valores
maiores do que a faixa entre 90 e 200, significa que o
carrinho est sobre a regio branca, devendo ento virar
para a direita. Para isso o Arduino enviara um valor
menor de PWM ao motor direito.
Caso as condies para que o carrinho possa
ultrapassar sejam satisfeitas (condies verificadas pelos
sensores ultrassnicos), o carrinho deve virar para a
esquerda at encontrar a cor preta da pista 2. Feito isto, o
carrinho deve voltar a seguir a linha vermelha da pista 2
at que detecte que pode voltar para a pista 1, virando
assim para a direita at que encontre a cor preta desta e
ento siga a linha vermelha novamente.
Vale lembrar que como na segunda pista as cores
esto de forma invertida em relao a primeira, quando o
carrinho estiver sobre a faixa preta deve girar para a
direita, e quando estiver sobre a rea branca deve girar
para a esquerda, diferente da primeira pista. Optou-se por
fazer as pistas com as cores de forma invertida, pois de
outro modo, o carrinho teria que sair da cor vermelha da
pista 1 e teria que passar pela cor branca para em seguida
localizar a cor preta da pista 2. Sendo assim, ocorreu de
algumas vezes o circuito seguidor ficar exatamente sobre
a cor branca e a cor preta, fazendo com que o seguidor de
linha capturasse um valor que no correspondia a
nenhuma dessas duas cores, mas sim um valor que se
aproximava do valor da cor vermelha. Desta forma o
carrinho acabava por no detectar a cor preta, no
conseguindo, desta forma, encontra a pista 2 e se
perdendo.
Integrao dos sistemas
Aps a montagem do kit do chassi do carrinho foram
adicionados ao mesmo a ponte H, a placa do Arduino, os
sensores de distncia e o circuito seguidor de linha. A
Figura 17 mostra um diagrama de blocos de como ficou o
sistema completo.

Fig 17. Diagrama de blocos do carrinho

Programao
Como todas as funes para o funcionamento do
carrinho, como pro exemplo a funo de virar para a
esquerda, deveriam ser chamadas dentro da funo
void_loop() (que executada repetidamente dentro do
microcontrolador), estas acabavam por ser executadas
repetidamente, mesmo quando no houvesse necessidade
que isto acontecesse. Por exemplo, aps o carrinho estar
na pista 2, ou seja, ter detectado um obstculo na pista 1 e
nenhum obstculo vindo na pista 2, o mesmo no deveria
mais ficar verificando a existncia de objetos a sua
esquerda por meio dos sensores 2 e 3. Esta verificao s
deveria ser feita novamente quando o carrinho tivesse
retornado para a pista 1.
Para solucionar este problema o software foi
desenvolvido utilizando variveis de alerta, ou flags. No
caso citado acima, por exemplo, uma flag era setada
informando que o carrinho encontrava-se na pista 2. Se
esta flag estivesse setada, a funo de verificao dos
sensores 2 e 3 no chamada.

ser setada uma flag que indicar que o motor esquerdo

deve parar durante alguns milissegundos para que o
carrinho se endireite e possa novamente seguir a pista 1.
Finalmente, todas as flags so zeradas reiniciando todo o
processo.
A figura 19 representa o diagrama de sequncia das
instrues do programa do microcontrolador, nele
tambm encontra-se as flags que sero modificadas a
cada nova ao do carrinho.

Fig 18. Diagrama de blocos seguidor de linha

Inicialmente, o carrinho encontra-se seguindo a pista
1, como representa o diagrama de blocos da Figura 18,
sendo esta sua pista preferencial. Foi utilizada uma flag
em nvel baixo para indicar que o carrinho est na
preferencial. Se nessa pista for encontrada alguma
obstruo a menos de dez centmetros de distncia do
carrinho (detectada pelo sensor ultrassnico 4), uma outra
flag setada indicando que h um objeto frente.
Em seguida so lidos os dados dos sensores
ultrassnicos 2 e 3, responsveis pela deteco de objetos
esquerda do carrinho. Se as distncias detectadas forem
menores que 30 centmetros, a velocidade reduzida at
o carrinho parar. Este s entrar novamente em
movimento se os obstculos forem removidos. Neste caso
duas novas flags so colocadas em nvel alto, a primeira
indicando que os objetos que estavam obstruindo os
sensores ultrassnicos 2 e 3 foram removidos e a segunda
indicando que o caminho j pode virar a esquerda.
O carrinho ir virar at que o sensor de luminosidade
encontre o valor corresponde cor preta. Quando isso
ocorrer, a flag da preferencial que estava em nvel baixo
ser colocada em nvel alto, indicando que o carrinho j
est na pista 2. Ento, o motor da direita parado por
alguns milissegundos para que o carrinho se alinhe com a
linha vermelha da segunda pista. Depois do alinhamento,
todas as flags so colocadas em nvel baixo, exceto a flag
da preferencial. Feito isso, so lidos os dados do sensor 1,
que verificar se existe algum objeto direita do carrinho.
Se a distncia lida por ele for menor que 30 centmetros o
carrinho continuara seguindo a pista 2, caso contrrio,
uma nova flag setada indicando que no possui
obstrues e j seguro voltar para a pista 1.
O carrinho ento dever virar para a direita at
encontrar a faixa preta da pista 1. Quando isto acontecer

Fig 19. Diagrama com as flags.

IV. RESULTADOS
Utilizando sensores em conjunto com Arduino foi
possvel desenvolver um carrinho capaz de realizar
ultrapassagens automaticamente, quando detectava que
havia uma obstruo sua frente uma distncia prestabelecida. O carrinho tambm foi capaz de verificar as
condies para poder realizar essa ultrapassagem, como a
existncia objetos sua esquerda, tanto na hora de fazer a
ultrapassagem, quanto na hora de voltar para sua pista,
aps ter concludo a ultrapassagem.
Foram realizados vrios testes para calibrao dos
sensores de luminosidade e ultrassnicos, para assim se
ter uma melhor eficincia nas ultrapassagens. Com tudo,
ainda h possibilidade do carrinho, algumas vezes, se
perder da linha devido imperfeies na pista, que pode ter
algumas dobras ou lombadas. Outro fator que pode
resultar na leitura errada de valores est na impreciso
dos prprios sensores ultrassnicos, que no so cem por
cento precisos. Alm disso, como foram utilizados muitos
cabos para fazer a ligao de todos os sensores, se algum
dos cabos acidentalmente entrar no campo de viso do
sensor, este poder detect-lo, lendo um valor de
distncia indesejado.
O carrinho, mesmo sendo em modelo reduzido, teve
como objetivo simular um sistema real, que propenso a
acidentes devido a m visibilidade na hora das
ultrapassagens, mostrando que o uso sensores de distncia
pode ser uma soluo a este problema, ajudando a
prevenir acidentes.

V. DIFICULDADES
Uma das dificuldades encontradas foi em relao aos
motores e a caixa de reduo. Como cada motor
independente, o motor da esquerda estava com uma
rotao maior que o da direita mesmo aplicando um
mesmo potencial nos dois motores, ocasionado assim um
desvio do carrinho para a direita, quando o objetivo era
que ele seguisse em linha reta. Para reduzir os efeitos
desse desvio foi utilizada uma compensao no sinal
PWM enviado pelo microcontrolador a cada motor, ou
seja, o sinal enviado ao motor da direita 10% maior que
o da esquerda, possibilitando assim que eles tenham
rotaes muito prximas e conseqentemente seguindo a
linha com mais exatido.
Outro fator de dificuldade foi o sensor ultrassnico.
Muitas vezes, devido ao mau posicionamento dos
mesmos (se estes ficassem um pouco mais inclinados) por
causa do constante manuseio do prottipo, as distncias
lidas eram muito menos precisas, pois o objeto acaba
ficando fora da faixa do ngulo de eficincia do sensor
(30).

Fig 20. Diagrama de erro na leitura.

Uma ltima dificuldade encontrada foi quanto
prpria programao, pois as funes a serem realizadas
pelo carrinho so chamadas dentro da funo
void_loop(), que executada repetidamente dentro do
microcontrolador. Porm, nem todas as funes criadas
necessitam serem executadas repetidamente, algumas s
devem ser executadas uma nica vez. O Arduino possui
apenas duas portas para gerar interrupes, mas essas
portas so utilizadas na transmisso e recebimento de
dados pela USB. Para resolver este problema foram
utilizadas variveis de alerta, as flags. Antes de chamar
uma funo, estas flags eram verificadas e de acordo com
seu estado, uma funo era ou no chamada.
VI. CONCLUSO
O presente trabalho teve como objetivo o
desenvolvimento de um carrinho capaz de realizar
ultrapassagens, utilizando para isto um circuito seguidor
de linha, baseado em um sensor LDR e um sistema de
deteco de objetos formado por 4 sensores ultrassnicos,
posicionados nos pontos cegos do carrinho.
Este mostrou eficcia no desvio de outro carrinho a
sua frente, sempre que detectasse que no havia outro
obstculo vindo pela esquerda. Como era esperado, o
carrinho tambm foi capaz de voltar eficientemente para
sua pista aps verificar que j tinha de fato ultrapassado o
carro que antes estava sua frente.
Com este prottipo foi possvel mostrar uma soluo
ao risco de colises na hora das ultrapassagens. Este
ainda pode ser melhorado, pois o microcontrolador possui
entradas e sadas de dados que no foram utilizadas
permitindo a expanso do nmero de sensores ou mesmo

outros dispositivos. O software tambm pode receber

melhorias, incluindo algoritmos para outros casos, como
por exemplo, o de uma pista mais complexa.
REFERNCIAS
[1] Arduino ArduinoBoardUno. Disponvel em:
http://arduino.cc/en/Main/ArduinoBoardUno. Acessado
em 22 de maro de 2012.
[2] Gioppo, L., L.; Higaskino, M., M., K.; Costa, R., F. e
Meira, W., H., T. Rob Seguidor de Linha, Curitiba
PR, 2009.
[3] Guimares, C., S., S. e Maurer, H., P. EduBot:
Prottipo de umaplataforma para educao atravs da
Metareciclagem, Santo Angelo RS, 2011.
[4] Margolis, M. Arduino CookBook, Editora OReilly,
2 Edio pg 242.
[5] Roberts, M. Beggining Arduino, Editora
TECHNOLOGY IN ACTION, 1 Edio, 2010 pg 60.
[6] Patsko, L., F. Tutorial Montagem da Ponte H,
Maxwell Bohr Instrumentao Eletrnica, 2005.
[7] Siemens, MOTORES DE CORRENTE CONTNUA
Guia rpido para uma especificao precisa, 1 Edio,
2006.
[8]
GTA/UFRJ
LDR.
Disponvel
em:
http://www.gta.ufrj.br/grad/01_1/contador555/ldr.
Acessado em 10 de Junho de 2012.
[9] Automatize Soluo em Sensores Sensores Ultrasncos
Siemens.
Disponvel
em:
http://www.automatizesensores.com.br/ultrasonicos.html.
Acessado em 06 de Outubro de 2012.
[10] Diarioelectronicohoy Datasheet HC-SR04.
Disponvel
em:
http://www.diarioelectronicohoy.com/arduino/imagenes/2
012/08/HC-SR04.pdf. Acessado em 3 de Julho de 2012.
[11] Compartilhar preciso Sensor ultrassnico.
Disponvel
em
http://ferpinheiro.wordpress.com/2011/04/29/meuprimeiro-projeto-arduino-sensor-ultrasonico-hc-sr04/,
Acessado em 15 de Maro de 2012.

ANEXO
//Carrinho seguidor de linha capaz de realizar ultrapassagens
//Acadmicos: Emanoeli Madalosso, Vanderlei Luiz Azzolini
#include "Ultrasonic.h"
Ultrasonic sensor1(12, 13);
Ultrasonic sensor2(9, 11);
Ultrasonic sensor3(6, 7);
Ultrasonic sensor4(3, 4);
int dist1, dist2, dist3, dist4;
int motorPin1 = 5;//esquerda
int motorPin2 = 10;
int ldr = 5;
int valor, cor = 0, cor1 = 0, cont = 0;
int z= 0, h = 0, y = 0;
int esta = 0, a =0, c = 0, tempo = 0;
int obstaculo = 0, sen23 = 0, achaB0 = 0, achaP0 = 0, segue1 = 0;
int achaB1 = 0, achaP1 = 0, segue2 = 0, VirarEsquerda = 0, global = 0;
int flagVira = 0;
int vira2 = 0, achaB02 = 0;
void SegueLinhaP1(int valor);
void SegueLinhaP2(int valor);
void FuncaoViraEsquerda(void);
void FuncaoViraDireita(void);
void diminui(void);
void para(void);
void setup() {
Serial.begin(9600);
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(4, INPUT);
pinMode(3, OUTPUT);
pinMode(7, INPUT);
pinMode(6, OUTPUT);
pinMode(11, INPUT);
pinMode(9, OUTPUT);
pinMode(13, INPUT);
pinMode(12, OUTPUT);
}
void loop() {
valor = analogRead(ldr);
//Serial.println(valor);
if (global == 0){ //Linha 1
if(obstaculo == 0){
dist4 = (sensor4.Ranging(CM));
delay(10);
}
//Serial.println(dist4);
if(dist4 < 20){
obstaculo = 1;
if(esta == 0){
//dist2 = (sensor2.Ranging(CM));
//delayMicroseconds(5000);
dist3 = (sensor3.Ranging(CM));
Serial.println(dist3);

delayMicroseconds(20);
if(dist3 > 2000){
dist3 = 5;
}
if(dist3 < 30){
sen23 = 1;
}
else{
sen23 = 0;
esta = 1;
//Serial.println("--------------Esta no else--------------");
Serial.println(dist3);
}
}
}
if(obstaculo == 0){
SegueLinhaP1(valor);
//Serial.println("--------------Seguindo a linha---------------");
}
if((obstaculo == 1)&& (sen23 == 1) &&(flagVira == 0)){
para();
//Serial.println("--------------Esta no Para---------------");
}
else if((obstaculo == 1)&& (sen23 == 0)&&(flagVira == 0)&&(esta == 1)){
VirarEsquerda = 1;
flagVira = 1;
//Serial.println("--------------Esta virando--------------");
}
if((obstaculo == 1)&& (sen23 == 0) && (VirarEsquerda == 1) &&(flagVira == 1)&& (achaB0 == 0)&& (achaP0 == 0)){
FuncaoViraDireita();
delay(100);
Serial.println(valor);
if(valor < 90){ //Acha o Preto
//Serial.println("-----------------Achou linha preta----------------");
achaB0 = 1;
achaP0 = 1;
}
}
if((obstaculo == 1)&& (sen23 == 0) && (VirarEsquerda == 1) &&(flagVira == 1)&& (achaB0 == 1)&& (segue1 == 0)){
while(z != 150){
z++;
delay(5);
analogWrite(motorPin1, 0);
analogWrite(motorPin2, 200);
Serial.println(z);
}
//Serial.println("-----------------Achou, esta aqui----------------");
obstaculo = 0;
esta = 0;
VirarEsquerda = 0;
flagVira = 0;
achaB0 = 0;
achaP0 = 0;
z = 0;
global = 1;
Serial.println(global);
}
}
if(global == 1){ //Linha 2
if (h == 0){

SegueLinhaP2(valor);
//Serial.println("--------------Seguindo a linha 2---------------");
}
Serial.println(tempo);
if(tempo < 50){
tempo++;
}
if((vira2 == 0)&& (tempo == 50)){
dist1 = (sensor1.Ranging(CM));
Serial.println(dist1);
delayMicroseconds(5000);
if(dist1 < 30){
SegueLinhaP2(valor);
}else{
vira2 = 1;
h = 1;
}
}
if((vira2 == 1)&&(a == 0)){
FuncaoViraEsquerda();
delay(30);
Serial.println(valor);
if(valor < 90){ //Acha o Preto
//Serial.println("-----------------Achou linha preta----------------");
achaB02 = 1;
a = 1;
}
}
if((vira2 == 1)&&(achaB02 == 1)){
while(y != 300){
y++;
delay(3);
analogWrite(motorPin1, 200);
analogWrite(motorPin2, 0);
//Serial.println(y);
}
/*while(c != 300){
SegueLinhaP1(valor);
c++;
}*/
//Serial.println("-----------------Achou, esta aqui 2--------------");
vira2 = 0;
achaB02 = 0;
y = 0;
h = 0;
a = 0;
c = 0;
cor = 0;
tempo = 0;
global = 0;
cont = 0;
}
}
}
void SegueLinhaP1(int valor){
if(valor < 90){
analogWrite(motorPin1, 150);
analogWrite(motorPin2, 75);
cor1 = 1;

//Serial.println("esta no if ");
}
else if((valor > 90) && (valor < 200)){
analogWrite(motorPin1, 130);
analogWrite(motorPin2, 130);
cor1 = 0;
//Serial.println("esta no else if");
}
else{
analogWrite(motorPin1, 75);
analogWrite(motorPin2, 150);
//Serial.println("esta no else");
}
}
void SegueLinhaP2(int valor){
if(valor < 170){
//dir
analogWrite(motorPin1, 75);
analogWrite(motorPin2, 150);
cor = 1;
//Serial.println("esta no if1 ");
}
else if((valor > 170) && (valor < 240)){
analogWrite(motorPin1, 130);
analogWrite(motorPin2, 130);
cor = 0;
//Serial.println("esta no else if1");
}
else{
analogWrite(motorPin1, 150);
analogWrite(motorPin2, 75);
cor = 0;
//Serial.println("esta no else1");
}
}
void para(void){
analogWrite(motorPin1, 0);
analogWrite(motorPin2, 0);
}
void diminui(void){
for(int i = 200; i > 70; i--){
analogWrite(motorPin1, i);
analogWrite(motorPin2, i);
//delay(10);
}
analogWrite(motorPin1, 0);
analogWrite(motorPin2, 0);
}
void FuncaoViraEsquerda(){
analogWrite(motorPin1, 90);
analogWrite(motorPin2, 200);
}
void FuncaoViraDireita(){
analogWrite(motorPin1, 130);
analogWrite(motorPin2, 80);
}