robô seguidor de linha

Autor: Isvaldo Fernandes de Souza Site: www.robotizando.com Email: [email protected]

1

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


2

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


3

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.


4

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.


5

Apresentação do material

Arduíno

Apresentação do Arduíno:3 È 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


6

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”


7

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.


8

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

http://robotizando.com/blog/ultrasonic-sensor-sensor-de-distancia/


9

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.


10

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.


11

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


12

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


13

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


14


15

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


16

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)


17

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


18

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.


19


20

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.


21

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


22

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


23

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


24

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”

Para complementar essa condição existe ELSE que executa caso a condição não seja

verdadeira

Estrutura de repetição:

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

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.

If (condição) {

corpo

}

If (condição) {

executa aqui se a condição

for verdadeira

} ELSE {

executa aqui caso a condição

for falsa

}

For (iniciação;Condição;incremento)

{

comandos a serem repetidos

}


25

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.

Delay(tempo); // pausa o programa por um tempo X

pinMode(pino,tipo); // comando obrigatório para informa tipo de porta

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


26

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.

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.

#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


27

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.

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.

void move(int DmF, int DmT, int EmF, int EmT)

{

analogWrite(DMF, DmF);

analogWrite(DMT, DmT);

analogWrite(EMF, EmF);

analogWrite(EMT, EmT);

}


28

Script da função

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.

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);

}


29

Script para desviar de obstáculo

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 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);

}

}

}

void setup () {

pinMode(SED,INPUT);

pinMode(SEE,INPUT);

Serial.begin(9600);

motor.attach(8);

motor.write(90);

delay(500);

}


30

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

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.

void loop () {

linha();

if (OurModule.Ranging(CM) < 15) {

delay(200);

if (OurModule.Ranging(CM) < 15) {

pedra();

}

}

}


31

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.


32

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.

robô seguidor de linha

Self Improvement