Robô seguidor de linha

Autor: Isvaldo Fernandes de Souza
Site: www.robotizando.com
Email: Miojex360@hotmail.com
Robô seguidor de linha

Sumário
INTRODUÇÃO ........................................................................................................................................ 2

OBEJETIVO GERAL .................................................................................................................................. 3

OBJETIVOS ESPECÍFICO .......................................................................................................................... 4

APRESENTAÇÃO DO MATERIAL .............................................................................................................. 5

ARDUINO ............................................................................................................................................. 5

SENSOR SHIELD .................................................................................................................................... 7

SENSOR UTRASÔNICO .......................................................................................................................... 8

SENSOR DE LUZ .................................................................................................................................. 10

DRIVE MOTOR .................................................................................................................................... 11

MOTOR SERVO ................................................................................................................................... 15

ALIMENTAÇÃO ................................................................................................................................... 16

MONTAGEM DO ROBÔ ........................................................................................................................ 17
PROGRAMAÇÃO – ESTRUTURA LÓGICA .............................................................................................. 21
PROGRAMAÇÃO TEORIA ..................................................................................................................... 21
PROGRAMAÇÃO DO CARRO ................................................................................................................ 26

Conclusão.......................................................................................................................... 31
Bibliografia ........................................................................................................................ 32

1

Introdução
Com a revolução industrial e com o surgimento de um mercado competitivo a vida das
pessoas começou a ser facilitado por diversos utensílios que são produzidos o tempo
todo, com passar do tempo a demanda foi aumentando esse fato começou a estimular
os detentores do capital a investir em tecnologia, agora as indústrias eram equipadas
com robô que poderiam ser controlados pelo homem, hoje em dia existe algo muito
mais avançado, a inteligência artificial, método utilizado para que um dispositivo tenha
ações com embasamento no seu ambiente, um robô interage com ambiente através
de atuadores que no caso seria uma garra, por exemplo, ele consegue detectar o
ambiente atrás de sensores, por exemplo, um LDR 1, esse trabalho vai demonstrar
teoricamente a montagem de um carro capaz de seguir uma linha e de detectar um
objeto de dimensões específicas para depois desviar, o carro será montado com
diversos sensores e apenas um tipo de atuador, o conhecimento para montagem desse
carro foi obtido de forma fragmentada ao longo de um ano e meio, muitas técnicas
foram desenvolvidas pelo autor desse trabalho bibliográfico, outras foram conseguidas
ao longo do ano no laboratório de robótica da escola ferreira Viana 2 junto ao
orientador Cesar Bastos e colegas de equipe.

1
Light Dependent Resistor, Resistor que varia sua resistência na presença da luz, sua composição
química permite ter uma capacidade de diminuir sua resistência na presença da luz
2
O laboratório de robótica da escola ferreira Viana tem suas atividades as quintas feiras das 18h30min
ate 20h30min terça no mesmo horário para desenvolvimento de projetos dos veteranos

2

Objetivo geral
O robô deve seguir um algoritmo que harmonize todos os sensores, o robô e
estruturado da seguinte forma em cima temos um micro controlador da atmel ao lado
de um motor servo que orienta um sensor ultra-sônico no meio temos um drive que
controla os motores em baixo temos um motor ao ladeado por dois sensores de luz, o
carro vai identificar a intensidade luminosa que esta em baixo dele a partir desses
dados é feito um calculo para determinar as propriedades da superfície que ele se
encontra, a cor, textura, ate mesmo a altura que ele se encontra, a partir destes
princípios o carro pode seguir uma linha preta no chão desde que o chão seja
totalmente branco, ou pode seguir uma linha branca desde que o chão seja totalmente
preto, o carro possui um sensor que é capaz de detectar objetos de ate 6 metros de
distancia.

3

Objetivo específico
O robô deve de forma totalmente autônoma seguir uma linha preta em uma pista
especifica para esse tipo de projeto, nessa pista vai existir um obstáculo que deve ser
detectado e desviado depois disso o robô vai tentar localizar a linha para completar o
percurso, para execução dessas tarefas os sensores serão “orientados” pelo uso de um
micro controlador que fará os cálculos e fornecer pulsos para dar inicio aos atuadores,
o micro controlador é programável em linguagem C/C++, a técnica de programação
tem embasamento em inteligência artificial.

4

Apresentação do material

Arduíno
3
Apresentação do Arduíno: È uma placa micro-controladora baseada no micro-
controlador ATmega 328. Ela tem 14 Pinos Input/output digitais, 6 entradas analógicas,
um botão de reset. Ele contém tudo que é necessário para o suporte do Micro-
controlador, Ligando-a simplesmente a um computador através de um cabo USB, ou
alimentando-o com um Adaptador AC/AD (ou baterias 9V) para dar a partida.

Especificações do hardware

Micro-controlador ATmega328
Tensão de funcionamento 5V
Tensão de entrada (recomendado) 7-12V
Tensão de entrada (limites) 6-20V
Pinos E/S Digitais 14 (dos quais 6 são saídas PWM)
Pinos de Entrada Analógicos 6
Corrente DC por pino E/S 40 mA
Corrente DC por pino 3.3V 50 mA
Memória Flash 32KB
SRAM 2Kb
EEPROM 1KB

O Arduíno vem com um bootloader que permite enviar novos programas sem o uso
de um programador de hardware externo. Ele se comunica utilizando o protocolo
original STK500 (referência, C Header file). Também poder-se-á programar o
ATmega328 através do ICSP (in-Circuit Serial Programming) header;4

Memória

O ATmega tem 32KB de memória flash para armazenar o código ( dos quais 2KB são
utilizados pelo bootloader), além de 2 KB de SRAM e 1 KB de EEPROM (electrically-
erasable programmable Read-Only memory), quepode ser lida e escrita através da
biblioteca EEPROM.

Comunicação

Com o Arduíno, a comunicação com um computador, com outro Arduíno ou com
outros micro-controladores é muito simplificada. O ATmega328 permite comunicação
série no padrão UART TTL (5V), que está disponível nos pinos digitais 0 (RX) e 1 (TX).

3
Texto extraído da revista ‘Saber eletrônica’; Ano 47; nº454-2011; Editora Saber LTDA páginas 12 a 15.
Autor Filipe pereira
4
Embasamento retirado da apostila da PET auto net autor: Micael bronzatti

5

Um chip FTDI FT232RL na placa encaminha esta comunicação série através do USB e os
drives FTDI (incluído no software do Arduíno) fornecem uma porta COM virtual para o
software no computador. O software Arduíno inclui um monitor série que permite que
dados simples de texto sejam enviados à placa Arduíno.

Veja a aparência física do Arduíno.

Programação

A programação é em C/C++ e estruturada em condicionais (if,else,for,while,do
while,swith) o Arduíno já vem com uma biblioteca com funções como DigitalWrite
DigitalRead (escrever e ler sinais digitais), A programação será mais detalhada no
tópico “programação Estrutura lógica”

6

Sensor Shield

Com a fama do Arduíno começou a produção de placas que mais tarde foram
chamadas de Shield, tais placas são encaixadas perfeitamente no Arduíno para
aumentar a capacidade e a funcionalidade o mesmo, o sensor facilita o acesso as
portas e fornece um pino de VCC (5v) e pino GND (terra) para as portas digitais, para
as portas analógicas temos uma entrada especifica para sensores (três pinos )
Sinal,vcc,gnd agora essa placa fornece terra e vcc para suprir grandes projetos como
esse que usa diversos sensores.

7

Sensor Ultrassônico
O ultra-som é um som, uma onda de pressão com uma freqüência maior do que o
limite superior audição humana, não Há muitos sons na faixa Ultra podemos
aproveitar uma propriedade da onde muito interessante. Quando emitimos uma onda
para um local caso haja um obstáculo ela pode sofrer uma reflexão e voltar, veja a
figura5

Então para simular calcular a distancia em que uma parede esta de você, é preciso
saber a “velocidade do som” tempo da emissão e o momento da captação a partir de
um calculo pode-se determinar a distancia de um objeto, para simular esse evento
com ultra-som usamos um emissor sônico junto com um receptor

Agora a parte que de fato interessa, ou você monta um circuito para amplificar os
sinais e toda “parafernália” que esse circuito vai precisar ou simplesmente compra

5
Esse artigo foi retirado do site http://robotizando.com/blog/ultrasonic-sensor-sensor-de-distancia/
artigo que foi escrito pelo autor deste trabalho bibliográfico

8

Um módulo (quem souber eletrônica a fundo tente
montar). Ultrassônico no Arduíno ou ultra sônico tanto faz, com o Arduíno o ultra som
e muito fácil de usar, O sensor ultra-sônico e muito usado na robótica

Veja o modulo do sensor ultrassônico

Vcc: tensão 5V
TRIG: comunicação
ECHO: comunicação
GND : Terra

As especificações mais precisas do funcionamento serão explicadas em outro tópico
que fala sobre a programação.

9

Sensor de linha

Esse sensor tem um emissor infravermelho e um receptor quando é emitido um feche
de luz (infravermelho) o receptor recebe a luz que volta por reflexão dependendo da
cor da superfície o receptor varia sua resistência, então para nosso entendimento
vamos teorizar vamos dividir a variação em 1024 valores diferentes, para preto vamos
supor que seja 0 e para branco 1024, esse sensor faz exatamente isso ele possui um
regulador um” potenciômetro” que regula a precisão do sensor e um CI que modulo
as variações de forma a transforma essa variação toda em um sinal digital 0 ou 1 logo
esse sensor só detecta preto ou branco, Isso e bem vantajoso pois ler um sinal digital e
mais rápido do que ler um sinal tão variável como o analógico, quanto mais rápido a
freqüência de leitura do sinal digital mais rápido será a resposta do controlador, o
Arduíno demora cerca de 10 Microssegundos para ler uma porta.

10

Drive Motor
E bem difícil imaginar um robô que não tenha motor ou alguma forma de se
locomover, nesse projeto utilizamos 4 motores normais que funcionam um uma
tensão de 3V seu torque aumenta de acordo com a corrente ate certos limites
desconhecidos nesse projeto, nesse projeto e muito interessante o controle do motor
tanto para um sentido quanto para outro, esse problema pode ser controlado
utilizando um método de chaveamento de transistores, esse método e conhecido
como Ponte H 6

Esse simples circuito resolve nosso problema porem apenas para um motor, existem
outros fatores que complicam que incentiva a procura por uma nova saída de fato
existe duas alternativas uma e totalmente inviável seria a utilização de relés a outra
seria usar um CI para essa funcionalidade, hoje em dia existem muitos, vamos usar
nesse projeto L298N esse CI nos permite controlar dois motores, ou seja, cada Ci tem
duas pontes H internas, veja os pinos

6
Ponte H pois sua forma esquemática lembra a letra H

11


Vamos a uma breve explicação dos pinos
OUTPUT: são saídas que vão alimentar os motores
INPUT: São entradas que recebem sinais lógicos (5V) que alternam o sentido da
corrente das saídas output
LOGIC SUPPLY VSS: 5V (sinal para alimentar o CI )
SUPPLY VSS: tensão para alimentar os motores

12

Para um melhor funcionamento desse ci se deve fazer essa ligação

Pronto agora sim temos um drive que controle nossos motores, porem para o melhor
desempenho vamos usar um modulo que contem tudo Isso em SMD resistores de 1%
de precisão fusível e reguladores também contem um Dissipador de calor . Veja a
imagem

13


14

Motor Servo
Para mover o robô usamos um motor comum, porem para controlar o movimento do
sensor ultrassônico precisamos de um motor que mapeie o movimento seu
movimento, infelizmente o moto servo não faz isso porem ele possibilita o movimento
em graus em certos limites (180º) assim temos podemos mover o motor para ambos
os lados sem muito problema tanto para um sentido quanto para outro, o motor servo
contem uma ponte H interna, também existe um jogo de engrenagem denominada
Caixa de redução que fornece uma vantagem mecânica ao movimento final do motor,
ou seja, temos um motor com mais torque (força) veja um motor servo internamente

Existe um protocolo de comunicação que desconheço para esse tipo de motor, porem
existe uma biblioteca que facilita essa comunicação o motor servo utilizado é esse

15

Alimentação
O Arduíno precisa de uma alimentação própria, o drive motor também assim como
todos os sensores e como qual quer componente eletrônico nesse projeto vamos ter 2
alimentações e talvez uma terceira em caso de necessidade de potencia

Suporte para bateria (alimentação do Arduíno)

Suporte para pilhas (alimentação do Motor drive)

16

7

Montagem do robô
Alimentação:

Pino Vin. alimentação do Arduíno 9V (bateria)
Drive motor 9V (6 pilhas)
Sensor de Cor A 5V (pino sensor shield)
Sensor de Cor B 5V (pino sensor shield)
Ultrassônico 5V (pino sensor shield)
Ligações digitais

Ligação Pino correspondente Arduíno
~~ sem ligação ~~ 13
Controle do motor para frente “A” 10
Controle do motor para trás “A” 9
Controle do Motor Servo 8
TRIG Pino do sonar 7
Controle do motor para frente “B” 6
Controle do motor para trás “B” 5
ECHO pino do sonar 4
Sensor óptico da Esquerda 3
Terra do drive motor GND (terra)
Suplemento de energia lógica (5v) 5V (alimentação)
Bateria 9V Vin (voltagem de entrada )
~~ sem ligação ~~ Todas as portas Analógicas
Motor 1 E 2 São ligados em paralelo
Motor 3 E 4 São ligados em paralelo

Observações:

7
Essa imagem foi retirada do site dealextreme, um site de venda de equipamentos importados, foi
nesse site que fiz a compra de todos os equipamentos para esse projeto

17

Todas as ligações foram feitas utilizando cabos Jump, o cabo tem uma entrada que
entra perfeitamente nos sensores no drive e no Arduíno, ou seja, esse cabo é padrão

Estrutura:

O robô tem dois andares são conectados por parafusos (espaçadores) cerca de 5 cm de
distancia entre um e outro no meio fica o drive do motor os mores são presos por um
suporte de alumínio que e preso por dois parafuso com porcas, são 4 motores.

18


19

Veja a imagem ilustrando os 4 motores o primeiro e o segundo andar com o drive
motor no meio, o robô precisa se mover então faz se necessário rodas.

Observação: as rodas são emborrachadas o material gera um atrito muito grande ate
em superfícies totalmente lisas, isso gera um problema na locomoção do carro então
para driblar esse problema a borracha da roda foi retirada, com o diminuição do atrito
o robô passou a fazer curvas mais perfeitas e a sua precisão aumentou muito.

Montagem do sonar com servo:

O sonar esta ligado ao servo por um suporte improvisado colado a um conjunto de
cabos com cola quente com objetivo de mover o sonar para melhor utilizá-lo.

20

Programação estrutura lógica
Teoria
Introdução:

Cada movimento do robô será orientado por um algoritmo escrito em uma linguagem
de programação a usada nesse projeto foi C/C++, esse tópico vai detalhar como
funciona a linguagem, sua estrutura lógica e alguns exemplos aplicados ao projeto, não
vou poder prolongar muito o funcionamento, pois não e o foco principal.

Plataforma IDE:

O Arduíno possui um programa8 para desenvolvimento do programa que vai dar “vida”
ao robô, o programa tem um Debug9 a fim de detectar erros e possui uma ferramenta
para visualizar os dados da porta serial, veja a aparência do programa.

8
Esse programa pode ser adquirido no site www.arduino.cc
9
Debug e um Script que fica na IDE para detectar erros na programação

21

Funcionamento da IDE

Cada parte da ide tem uma função veja a ilustração abaixo

Estrutura da linguagem
Variável:

Antes de falar de variáveis é costume meu antes de explicar uma linguagem de
programação por trabalho escrito é dar um “HELLO WORD” bom como o Arduíno não
tem propriamente um lugar para Exibir essa mensagem temos que usar um artifício
então vamos ficar com ‘Serial.print(“HELLO WORD”);’

Variáveis são como gavetas que tem a função de guardar dados, as variáveis guardam
dados na memória do micro-processador, para declarar uma variável você precisa
dizer o tipo dela se e um numero ou caráter ou um dado booleano depois dar um
nome a ela desde que o primeiro caráter seja uma letra e não tenha espaços, depois

22

atribuir um valor da seguinte forma

Estruturas de controle

Estrutura de controle e responsável por “guiar” o código para com alguma orientação

IF () { }

If é uma condicional dentro dos () fica um teste lógico feito a partir de operadores é
um assunto que não vou poder detalhar nesse trabalho. Veja a imagem

23

o if faz uma pergunta a condição se ela for verdadeira executa o que esta dentro das
chaves caso não for essa estrutura e “pulada”

If (condição) {
corpo
}

Para complementar essa condição existe ELSE que executa caso a condição não seja
verdadeira
If (condição) {
executa aqui se a condição
for verdadeira
} ELSE {
executa aqui caso a condição
for falsa
}

Estrutura de repetição:
o for e uma estrutura com que gera uma repetição controlada veja a sintaxe

For (iniciação;Condição;incremento)
{
comandos a serem repetidos
}

Incremento é a técnica de adicionar +1 a uma variável a sintaxe e (variavel++)

Funções Nativas

Não vai da para detalhar todas as estruturas de programação por isso só descrevi as
mais básicas. O Arduíno possui funções nativas, ou seja, funções que tem uma atuação
que esta difícil para descrever veja na lista a baixo algumas funções do que vem com o
Arduíno.

24

Delay(tempo); // pausa o programa por um tempo X
Email: Miojex360@hotmail.com comando obrigatório para informa tipo de porta
pinMode(pino,tipo); //
digitalWrite(pino,estado); // envia um estado para uma porta
digitalRead(pino); // faz a leitura de uma entrada
analogWrite(pino,força); escreve de 0 a 5 V no pino sendo dividido em 0
a 255 valores que representam 0-5v

Bibliotecas:

Biblioteca no mundo da programação representa uma Class, e class é uma estrutura
que agrupa funções nesse trabalho usamos a biblioteca para controlar o Sonar e o
moto servo, o Arduíno possui milhares de class preparadas para da suporte a todo tipo
de equipamento, alem de facilitar o uso de class também simplifica o código, hoje em
dia o uso de class e tão importante que recebeu ate um nome, Programação orientada
a objeto, esse nome é bem impactante no mercado, muita gente fica boba quando
ouve falar de POO.

Conexão:

É muito importante mencionar que o Arduíno pode fazer uma comunicação serial o
código para fazer essa tarefa e através de uma biblioteca chamada Serial com esse
recurso se torna possível analisar os dados que são obtidos pelo dispositivo pelo
computador, dessa forma facilitando a analise o projeto fica mais fácil de ser
construído e elaborado.

Interação ambiente X programação:

Essa interação se baseia na seguinte teoria, através de sensores no ambiente o robô
toma executa ações através de atuadores, esse é o principio da inteligência artificial
nosso robô usa a programação para comparar situações e tomar uma atitude, por
exemplo, “caso houver um obstáculo desvie se não tiver seguir reto” a partir de
diversas deduções lógicas o algoritmo chega a possuiu uma espécie de inteligência
artificial, inteligência artificial é algo muito mais complicado do que parece, eu já fiz
alguns projetos voltados à inteligência artificial porem não tive muito sucesso, esse
projeto, por exemplo, é seqüencial, pois segue uma regra e caso essa regra não exista
ele se desorienta e não procura resolver o problema, um exemplo, um robô seguidor
de linha segue uma linha preta e o chão e branco, se eu pudesse inverter isso o chão
preto e a linha branca, o robô se perderia na mesma hora entre tanto um robô com
inteligência artificial poderia bolar um meio através de seu próprio algoritmo para
tentar entender a situação e talvez compreender que pode inverta a ordem seguir a
linha branca ao invés da preta.

25

Programação do carro

Para compor o algoritmo do robô desenvolvi funções para facilitar a visualização e
futuras modificações no programa, para entender a programação vou dividir ela em 6
partes.

1)Declaração de variáveis e objetos

Nessa parte declaro todo tipo de variável, referencia ou objeto, variável como já
explicado e um endereço de memória que pode ser escrita ou lida a qual quer
momento, Referencia é uma técnica para evitar usar um nome ou numero muitas
vezes ou mesmo para organizar usamos uma referencia que na hora de Copilar “passar
para placa” a referencia é alterada pelo valor, dessa forma facilitando, e evitando o
uso de espaço na memória.

#include "Ultrasonic.h" // incluir o arquivo da lib
#include "Servo.h" // incluir arquivo da lib
#define TRIG_PIN 7
#define ECHO_PIN 4
#define SEE 3
#define SED 0
#define DMF 10
#define DMT 9
#define EMF 5
#define EMT 6
Servo motor; // Lib Servor
Ultrasonic OurModule(TRIG_PIN, ECHO_PIN); // Lib Ultrasonic
int vel=255; // velocidade curva
int tempo1=350; // tempo de curva

A variável vel e responsável pelo controle da velocidade com que o carro faz uma curva
e tempo1 é o intervalo de tempo em mile segundos que ele vai fazer a curva na
velocidade “vel”, Servo motor e utrasonic são bibliotecas usadas no programa.

26

2)Função Move

o robô se locomove através de 4 motores que são ligados em em pares (em paralelo)
para que funcione bolei o seguinte função move(); essa função tem 4 argumentos que
simbolizam o chaveamento do drive por exemplo Move(255,0,255,0); moveria o meu
motor a velocidade máxima para frente, veja dessa maneira Move(velocidade A para
frente, Velocidade A para trás,Velocidade B para frente,velocidade B para trás); essa
função foi montada com a estrutura abaixo.

void move(int DmF, int DmT, int EmF, int EmT)
{
analogWrite(DMF, DmF);
analogWrite(DMT, DmT);
analogWrite(EMF, EmF);
analogWrite(EMT, EmT);
}

3) Função Seguir linha

Essa função é bem mais complexa do que a anterior, então vamos detalhar bem ela,
primeiro é importante explicar que essa função usa a função anterior para mover o
robô, primeiramente vamos jogar no “ar” o objetivo da função, Seguir linha para
conseguir essa façanha bolei uma técnica a partir de um método cientifico vou colocar
uma verdade absoluta e a partir dela fazer deduções, essa verdade será “o robô vai ser
ligado De baixo de uma linha” isso não precisa ser verdade porem a partir desse
postulado posso fazer com que ele não saia de baixo dela, colocando os sensores na
frente afastado por certa distancia para depois fazer uma leitura digital, retorna 1 para
perto e 0 , o algoritmo funcionara da seguinte forma caso o sensor da esquerda ver
preto (a linha é preta) o carro vira um pouco para direita caso o sensor da direita ver
preto o carro vai um pouco para esquerda,logo o carro vai fazer o movimento inverso
do sensor que responder com 1 (preto), para melhor analise na hora da construção do
robô usei a comunicação serial para ver no display o estado no qual o robô estava,
existe um pequeno tempo nomeado tempo1 que é o tempo de curva já explicada na
primeira divisão da programação.

27

Script da função

void linha () {
if (digitalRead(SED)==1){ //esquerda
move(vel,0,0,vel);
delay(tempo1);
Serial.print("esquerda");
Serial.println("n");
Serial.println(digitalRead(SED));
}
else if (digitalRead(SEE)==1){ //direita
move(0,vel,vel,0);
delay(tempo1);
Serial.print("direita");
Serial.println(digitalRead(SEE));
}
Serial.print("seguindo para frente");
move(150,0,150,0);
delay(10);
}

4) Detector de Obstáculos

Além de seguir linha nosso robô e será capaz de detectar um obstáculo e desviar para
isso ele usei um motor servo para mover o sonar que faz a leitura em centímetros dos
objetos ao redor, existe uma rotina chamada “loop” que vamos detalhar em outro
tópico que faz a verificação constante da possibilidade de existir um obstáculo, a
função que detecta obstáculo tem o nome de pedra, depois que o algoritmo já estiver
certo que há um obstáculo a função pedra vai virar o servo para esquerda e para
direita para verificar qual lado e disponível para passar depois disso ele escolhe o lado
que estiver livre, caso os dois estejam livre ele vai para direita por padrão, para o
funcionamento adequado do sensor existe um tempo de espera para executar o
movimento do motor, o motor servo gira em graus, 90 -> mirado para frente, 0,
esquerda ,180 Direita , veja o script na próxima pagina.

28

Script para desviar de obstáculo

void pedra () {
int Sensor_teste = 0;
motor.write(90);
delay(500);
motor.write(0); // realocar para esquerda
delay(500);
if (OurModule.Ranging(CM) > 10) {
motor.write(90);
delay(500);
Sensor_teste = 1;
}
motor.write(180); // realocar para direita
delay(500);
if (OurModule.Ranging(CM) > 10) {
motor.write(90);
delay(500);
Sensor_teste = 2;
} // parte responsavel pelo movimento do carro apos detectar os objetos
if (Sensor_teste==2) { // se encontrar uma pedra na direita virar para esquerda
move(vel,0,0,vel);
delay(tempo1);
}if else (Sensor_teste==1) { // se encontra uma pedra na esquerda vira para
direita
move(0,vel,vel,0);
delay(tempo1);
else { // caso não houver nenhuma pedra virar para direita por padrão
move(0,vel,vel,0);
delay(tempo1);
}
}
}
5)preparação

Antes de fato de executar o script é preciso fazer uma preparação, para por exemplo
posicionar o sonar declarar entradas e algumas portas

void setup () {
pinMode(SED,INPUT);
pinMode(SEE,INPUT);
Serial.begin(9600);
motor.attach(8);
motor.write(90);
delay(500); 29
}

6)rotina de repetição

Finalmente a parte final, ate então só declarei e preparei o programa de fato, agora o
programa vai entra em uma rotina infinita, nessa parte o programa vai organizar a
cadeia de eventos

void loop () {
linha();
if (OurModule.Ranging(CM) < 15) {
delay(200);
if (OurModule.Ranging(CM) < 15) {
pedra();
}
}
}

Nessa ultima parte há um teste para ver se existe obstáculo, para ter certeza que não
haja uma interferência momentânea (caso o sonar detectar um obstáculo sem de fato
existir) o algoritmo fará um segundo teste e só assim executara a função pedra.

30

Conclusão
Esse trabalho possibilitou a analise de dados de diversas áreas que a robótica atua.

Eletrônica:

Houve diversos problemas com uso de baterias o Arduíno consome muito em poucos
minutos uma bateria normal de 9V não consegue mais da suporte ao robô, isso se
deve pelo fato de ter N sensores drives entre outras coisas alimentadas pelo Arduíno.

Física:

As rodas de borracha causam muito atrito com o chão, isso se torna um problema na
hora de fazer curvas, outra analise interessante é com os sensores, a distancia dos
sensores com o chão e determinante para a precisão do sensor.

Programação:

É preciso muita organização no código, pois o código e constantemente alterado por
isso e importante desenvolver funções em forma de diagrama, pois caso uma parte
não funcionar, assim podemos ir direto ao erro e conserta sem a necessidade de
analisar todo o código, estruturar com base em objetos e referencias aumentou
bastante a velocidade de processamento do programa.

31

Bibliografia
Bronzatti,AutoNet,Aprendendo a programar em Arduíno,realização PET

Marshall Brain. "HowStuffWorks - Como funciona a programação em C". Publicado
em 01 de abril de 2000 (atualizado em 14 de maio de 2008)
http://informatica.hsw.uol.com.br/programacao-em-c.htm (26 de julho de 2012)

SOAREZ, R. Curso de robots m´oviles. Universidad Carlos III de Madrid, Nov. 1999.

WALLNER, F., AND DILLMANN, R. Real-time map refinement by use of sonar and
active stereo-vision. Robotics and Autonomous Systems, 16 (1995), 47–56.

32

Robô seguidor de linha

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Robô seguidor de linha

Mais de Isvaldo Souza

Robô seguidor de linha