robô construtor autônomo

CENTRO UNIVERSITÁRIO DA FEI

ALLAN DINATO MARTINS

ANDRÉ FERRO KOPELINGH

DIEGO MENDES MORENO

ROBÔ AUTÔNOMO CONSTRUTOR

São Bernardo do Campo

2015

ALLAN DINATO MARTINS

ANDRÉ FERRO KOPELINGH

DIEGO MENDES MORENO

ROBÔ AUTÔNOMO CONSTRUTOR

Trabalho de Conclusão de Curso,

apresentado ao Centro Universitário da

FEI, como parte dos requisitos necessários

para obtenção do título de Bacharel em

Engenharia Elétrica, ênfase em Eletrônica,

orientado pelo prof. Luís Caldas.


2015

Martins, Allan Dinato

Kopelingh, André Ferro

Moreno, Diego Mendes

Robô construtor autônomo / Allan Dinato Martins, André

Ferro Kopelingh, Diego Mendes Moreno. – São Bernardo do

Campo, 2015.

104 f. : il.

Trabalho de Conclusão de Curso - Centro Universitário da

FEI.

Orientador: Prof. Luís Caldas

1. Braço robótico. 2. Robô autônomo. I. Título.

CDU 007.5

Allan Dinato Martins

André Ferro Kopelingh

Diego Mendes Moreno

Robô Autônomo Construtor

Trabalho de Conclusão de Curso – Centro Universitário da FEI

Comissão Julgadora

_________________________________________

Orientador

_________________________________________

Examinador (1)

_________________________________________

Examinador (2)


Data da aprovação

A nossa família que teve paciência nos

momentos que mais precisamos.

6

AGRADECIMENTOS

Primeiramente a Deus por nos dar força e saúde para superar os desafios e dificuldades

encontrados nesse projeto e na formação.

Ao Centro Universitário da FEI, e seu corpo docente, direção e administração. E aos

professores sem os quais não teríamos aprendido o necessário para nos formar e terminar o

projeto.

Ao nosso professor orientador Luis Caldas, por nos ajudar em nossas dúvidas e

dificuldades enfrentadas durante os últimos meses.

Aos nossos pais, que nos ajudaram e tiveram paciência quando mais precisamos e nos

deram força pra continuar e finalizar o projeto e nossa formação.

E a todos que contribuíram diretamente ou indiretamente com este projeto.

7

“Algo só é impossível até que alguém

duvide e prove o contrário.”

Albert Einstein

8

RESUMO

Nosso projeto tem como objetivo estudar as novas tecnologias para robôs com autonomia,

atividade muito discutida atualmente e que apresenta grande evolução nos últimos anos.

Exemplos como sondas espaciais explorando Marte ou cometas, e veículos guiados apenas

por coordenadas de GPS são grandes exemplos dessa tecnologia sendo aplicada. Nosso

projeto tem como objetivo o desenvolvimento de um robô capaz de reconhecer o espaço em

que se encontra e manusear peças de modo a construir uma estrutura pré-determinada.

O robô é constituído por uma base central com unidade de controle geral, motores de

movimentação e sensores para localização, e sobre esta base encontra-se o braço responsável

por manusear as peças.

Os desafios apresentados durante o desenvolvimento do projeto partiram da definição e

projeto dos componentes mecânicos, do desenvolvimento da programação autônoma até a

fase final de testes e integração dos diversos módulos de programas desenvolvidos

separadamente. E foram corrigidos.

Palavras-chave: robô autônomo. braço robótico.

9

ABSTRACT

This Project studies new autonomous robot technologies. This subject has been deeply

discussed nowadays and it has significantly evolved over the last few decades. The space

explorers and space probes that land on moving comets and explore planets solely using GPS

coordinates are good examples of this technology in action. This project aims to the

development of an autonomous robot capable of finding itself in an unknown space, and build

a structure with pieces located throughout the space.

The robot comprises a base equipped with the movement step motors and seven ultrasonic

position sensors, the mechanic arm controlled by four servo-motors, and finally the central

processing unit, which is a microcontroller development board from Arduino.

There were many challenges throughout all the stages of this project. Since the beginning,

developing and assembling the mechanical arm, writing the firmware to control the modules,

and the final tests during the integration of all the modules, many problems emerged and were

corrected.

Key words: autonomous robot. robotic arm.

10

SUMÁRIO

AGRADECIMENTOS ............................................................................................................................ 6

RESUMO ................................................................................................................................................ 8

ABSTRACT ............................................................................................................................................ 9

1. INTRODUÇÃO ............................................................................................................................ 13

2. ESTADO DA ARTE ..................................................................................................................... 15

2.1 Braço Robótico ...................................................................................................................... 16

2.2 Robôs Industriais ................................................................................................................... 17

2.2.1 Robôs Articulados ......................................................................................................... 19

2.2.2 Robôs SCARA .............................................................................................................. 19

2.2.3 Robôs Cartesianos ......................................................................................................... 20

2.3 Conceitos de Construção de um Braço Robótico .................................................................. 21

2.4 Robôs móveis ........................................................................................................................ 22

2.4.1 Modus operandi ............................................................................................................. 22

2.4.2 Principais tipos de robôs móveis ................................................................................... 23

2.4.2.1 Base diferencial ............................................................................................................. 23

2.5 Processadores, Sensores e Motores ....................................................................................... 24

2.5.1 Placa Arduíno ................................................................................................................ 24

2.5.2 Motores de passo ........................................................................................................... 25

2.5.3 Sensores ultrassônicos ................................................................................................... 26

2.5.4 Servo Motores ............................................................................................................... 26

3. DESENVOLVIMENTO ............................................................................................................... 28

3.1 Material ................................................................................................................................. 30

3.2 Braço Robótico – Módulo I ................................................................................................... 32

3.2.1 Características de Construção ....................................................................................... 33

3.4 Base robótica ......................................................................................................................... 45

3.4.1 Leitura de sensores ............................................................................................................ 45

3.4.1.1 Tratamento de dados ......................................................................................................... 49

3.4.2 Locomoção ........................................................................................................................ 49

3.4.2.1 Em linha reta ..................................................................................................................... 50

3.4.2.2 Curvas ............................................................................................................................... 51

3.5 Shield Arduino ...................................................................................................................... 54

3.6 Máquina de estados ............................................................................................................... 58

11

3.7 Bateria ................................................................................................................................... 59

3.8 Área de trabalho .................................................................................................................... 59

3.9 Principais dificuldades .......................................................................................................... 60

4. CONCLUSÃO .............................................................................................................................. 62

APÊNDICE A – Esquemático e layout da placa Shield ....................................................................... 63

APÊNDICE B – Programa .................................................................................................................... 66

APÊNDICE C – Modelo matemático no Matlab .................................................................................. 86

ANEXO A – Datasheet do Motor de passo ........................................................................................... 91

ANEXO B – Datasheet do driver de Motor de passo ............................................................................ 93

ANEXO C – Datasheet do Servo-motor pequeno ................................................................................. 97

ANEXO D – Datasheet do Servo-motor grande ................................................................................... 99

ANEXO E – Datasheet do sensor ultrassônico ................................................................................... 101

ANEXO F – Esquemático da placa Arduino Mega ............................................................................ 104

ANEXO G – Datasheet do microcontrolador ATmega2560/V ........................................................... 106

5. REFERÊNCIAS .......................................................................................................................... 109

12

ÍNDICE DE FIGURAS

Figura 1 – Prótese robótica com controle de sensibilidade ................................................................... 17

Figura 2 – Braço robóticos em processo de produção de um automóvel .............................................. 18

Figura 3 – Exemplo de braço articulado ............................................................................................... 19

Figura 4 – Articulações de um robô SCARA ........................................................................................ 20

Figura 5 – Eixos de um Robô Cartesiano .............................................................................................. 20

Figura 6 – Placa Arduino utilizada ........................................................................................................ 24

Figura 7 – Motor de passo utilizado no robô......................................................................................... 25

Figura 8 – Servo motor utilizado........................................................................................................... 27

Figura 9 – Primeiro sketch do braço ..................................................................................................... 29

Figura 10 – Primeiro sketch do conjunto .............................................................................................. 29

Figura 11 – Scorpion ............................................................................................................................. 32

Figura 12 – Diagrama demonstrando ângulos descritos pelo robô. ...................................................... 34

Figura 13 – Dimensões do braço ........................................................................................................... 35

Figura 14 – Disposição de atuadores ..................................................................................................... 37

Figura 15 – Garra Robótica Protótipo ................................................................................................... 38

Figura 16 – Garra: componentes e dimensões....................................................................................... 39

Figura 17 – Garra Completa .................................................................................................................. 40

Figura 18 – Plot do Matlab com todos os 8281 pontos ......................................................................... 41

Figura 19 – Plot do MatLab com primeiro Filtro .................................................................................. 42

Figura 20 – Posição dos sensores na base ............................................................................................. 46

Figura 21 – Posição dos sensores dianteiros ......................................................................................... 46

Figura 22 – Mapeamento do ambiente .................................................................................................. 47

Figura 23 – Mapeamento do ambiente com peça na frente ................................................................... 48

Figura 24 – Resultado da leitura de todos os sensores [cm] ................................................................. 48

Figura 25 – Sensores laterais ................................................................................................................. 50

Figura 26 – Robô desalinhado e correção ............................................................................................. 51

Figura 27 – Curvas na base diferencial ................................................................................................. 52

Figura 28 – Diâmetro da roda ............................................................................................................... 52

Figura 29 – Distância entre motores ..................................................................................................... 53

Figura 30 – Arco de giro de cada roda .................................................................................................. 53

Figura 31 – Protoboard com o Arduino ................................................................................................ 54

Figura 32 – Protótipo de shield para Arduino Mega [frente] ................................................................ 56

Figura 33 – Protótipo de shield para Arduino Mega [verso] ................................................................. 56

Figura 34 – Shield definitivo para Arduino Mega [frente].................................................................... 57

Figura 35 – Shield definitivo para Arduino Mega [verso] .................................................................... 57

Figura 36 - Shield definitivo ................................................................................................................. 57

Figura 37 - Máquina de estados ............................................................................................................ 58

13

1. INTRODUÇÃO

Este projeto fala sobre o estudo de robôs autônomos para uso científico e exploração e

como este assunto vem sendo muito discutidos ultimamente. A utilização destes robôs para

explorar outros planetas, cometas e lugares inacessíveis ao ser humano. Robôs que fazem

cirurgias de precisão, robôs que são usados na guerra, robôs que limpam casas sozinhos e

agora robôs que se organizam para realizar tarefas sozinhos e/ou em grupo. Trataremos então

de uma breve história de toda esta evolução e a descrição de todo o desenvolvimento de nosso

protótipo de Robô Construtor Autônomo.

Escolhemos esse tema para projeto exatamente pela repercussão que esse tipo de

evolução tecnológica tem tido em toda a comunidade científica e por conta de todas as

tecnologias que podem e são desenvolvidas durante essa evolução.

Atualmente, dentre todas as aplicações da robótica, muitos robôs são utilizados na

indústria, alguns deles são: robôs de automanutenção, robôs de desempenho em tarefas, robôs

de localização e navegação em ambientes fechados e robôs de localização e navegação em

ambientes aberto. O robô que utilizamos como base para o nosso projeto é o robô de

localização e navegação em ambiente fechado. Este utiliza sensores para verificar sua

posição, reconhecer as dimensões do local onde está e qual tarefa deve cumprir. Este tipo de

robô é de maior facilidade para ser desenvolvido, pois é projetado para atuar em um ambiente

controlado, sabendo exatamente qual tarefa deve executar e quais os possíveis impedimentos

que pode vir a ter para executa-la..

Nosso projeto é constituído por três módulos principais: a base de locomoção, o braço

robótico e a central de controle. A base é responsável pelo reconhecimento do ambiente e a

movimentação de todo o conjunto. O braço é responsável pelo manuseio das estruturas de

14

madeira. E a central de controle é responsável por adquirir os dados de sensores, processar

estes dados eliminando informações desnecessárias ou com ruídos e erros, e comandar os

atuadores da base de locomoção e do braço.

Basicamente trabalhamos com sete sensores para mapeamento do ambiente e

localização de peças, dois motores de passo para movimentação da base e 4 servo motores

responsáveis por toda a movimentação e posicionamento do braço.

O princípio básico de funcionamento de nosso protótipo é o de organizar blocos de

madeira para que uma estrutura seja montada sem nenhuma intervenção humana. As peças

serão posicionadas em locais pré-determinados, como se fossem estocadas em prateleiras,

antes do inicio de operação do robô. O mesmo terá armazenado em sua programação estas

localizações e fazendo uso de seus sensores irá buscar as peças, pega-las, uma a uma, e na

ordem certa, transporta-las até o local de posicionamento, posiciona-las na ordem correta e

finalizar sua operação.

Nas seções seguintes deste relatório discutiremos e detalharemos passo a passo todo o

processo de evolução de nosso projeto, partindo do planejamento gerencial e finalizando na

bateria de testes.

15

2. ESTADO DA ARTE

O conceito de robô data do início da história, quando os escritos fazem referência a

mecanismos que ganhavam vida. Na civilização grega antiga, os primeiros robôs que

encontramos eram de aparência humana ou animal e usavam sistemas de pesos e bombas

pneumáticas. Na civilização romana, Leonardo Da Vinci revolucionou a história da robótica

ao estudar extensivamente a anatomia humana e obter avanços significativos na criação de

articulações mecânicas.

A evolução da robótica se intensificou na revolução industrial com a criação de

animais mecânicos e robôs que eram controlados por onda de rádio. Jacques Vaucanson, no

início de 1738, criou um “tocador de flauta” automático, e 1 ano mais tarde criou mais 2

autómatos, “O tocador de tamborim” e o “O pato”. Este último conseguia andar, movimentar

asas, comer, digerir grão e dejetar. Este autómato era inteiro mecânico, feito com motores a

combustão e engrenagens.

Nikola Tesla, em 1898, apresentou o primeiro robô telecomandado, e se tratava de um

barco comandado por ondas de rádio. O exército americano recusou a ideia de utilizar robôs

em conflitos, mas Tesla continuou estudando e aprimorando seu projeto que foi utilizado por

vários países após a primeira guerra mundial.

O mundo após a segunda guerra mundial ingressou em uma etapa de profundas

evoluções no campo tecnológico desencadeada pela junção entre conhecimento cientifico e

produção industrial. Com isso vários campos da robótica passaram a evoluir grandemente, e

vários estudos começaram a ser desenvolvidos.

16

Essa tradição de desenvolvimento para a guerra é realidade até hoje, e vemos isso

quando vemos robôs de última geração sendo utilizados nas guerras atuais, como os “drones”,

que são aviões não-tripulados de controle a distância. Existem mais de 12000 robôs desse tipo

usados pelos norte-americanos no oriente médio atualmente e este numero só tem aumentado.

Nesse ritmo, é possível que robôs substituam humanos nos campos de batalhas antes do que

imaginávamos, mas é obvio que isso envolve questões morais que não vamos discutir aqui.

Mas robôs não são usados somente para guerra, pois este não foi seu principal

propósito de criação. Existem diversos tipos de robôs que são utilizados e contribuem muito

para a sociedade, robôs utilizados a medicina que realizam cirurgias de precisão, robôs que

são usados para exploração de outros planetas, robôs que exploram lugares de difícil acesso e

alta periculosidade para o homem e muito mais.

A questão é que pesquisas e estudos desse campo da robótica podem e contribuem

muito para o desenvolvimento científico como um todo, e nos levam a descobertas

magnificas. E se essa tecnologia evoluiu tanto em pouco tempo de história, só nos resta

imaginar onde ela pode chegar no futuro.

2.1 Braço Robótico

Para melhor compreensão de nosso projeto vamos, primeiro, entender o que é um

braço robótico e suas características. Por definição um braço robótico é um tipo de braço

mecânico com funcionalidade igual ou similar à funcionalidade de um braço humano, mas

com algumas limitações de movimento, principalmente por conta de sua estrutura mecânica

17

ou do controle utilizado para seus movimentos. Este pode funcionar isoladamente ou como

parte de um mecanismo mais complexo, como nosso projeto descrito neste relatório.

Composto por uma grande variedade de componentes e combinações de componentes,

os braços robóticos encontram hoje uma infinidade de aplicações, como robôs industriais

utilizados em linhas de produção de diversos produtos, robôs recreativos como brinquedos ou

até mesmo próteses que substituem membros humanos. Das diversas possíveis aplicações

encontramos na Robótica Industrial conceitos importantes, bons exemplos de estudo e uma

base sólida para nosso projeto.

Figura 1 – Prótese robótica com controle de sensibilidade

2.2 Robôs Industriais

A Organização Internacional de Padronização (ISO) define robô industrial como

“Manipulador multipropósito controlado automaticamente, reprogramável, e programável em

três ou mais eixos”. Na indústria braços robóticos são utilizados em processos de fundição,

18

soldagem, pintura, montagem, movimentação de cargas e realização de testes, realizando estas

tarefas com precisão, velocidade e robustez.

Figura 2 – Braço robóticos em processo de produção de um automóvel

Existem diversos tipos de configurações para robôs utilizados na indústria, sendo as

mais conhecidas e mais utilizadas:

- Robôs articulados

- Robôs SCARA

- Robôs cartesianos

Entender um pouco destas configurações será importante para compreendermos o

funcionamento de nosso projeto como um todo, então a seguir falaremos um pouco mais

sobre estes tipos de robôs.

19

2.2.1 Robôs Articulados

Muito comuns na indústria, suas características de construção possibilitam que eles

descrevam movimentos lineares e rotacionais combinando os movimentos de seus diversos

eixos. Por ser capaz de reproduzir movimento mais complexos, seu controle também é mais

complexo que os outros tipos de braços.

Figura 3 – Exemplo de braço articulado

2.2.2 Robôs SCARA

Do inglês “Selective Compliant Assembly Robot Arm” (SCARA), a tradução literal de

seu nome é “Braço Robótico Seletivo Compatível com Montagem”, nome este que já indica

seu principal objetivo, desempenhar movimentos de montagem específicos e limitados pelo

ambiente físico de linhas de montagem. Nestes robôs estão presentes juntas de revolução

20

horizontal e uma junta deslizante vertical, sendo este mais limitado e de mais fácil controle

que o braço articulado.

Figura 4 – Articulações de um robô SCARA

2.2.3 Robôs Cartesianos

São os robôs que executam movimentos somente nos eixos X, Y e Z, ou seja, podem

descrever apenas movimentos lineares por conta desta característica construtiva mais

simplória. Estes tipos de robôs são muito utilizados em tarefas onde a característica dos

movimentos exigida é simples, sem alteração de angulo e/ou rotações dos eixos.

Figura 5 – Eixos de um Robô Cartesiano

21

2.3 Conceitos de Construção de um Braço Robótico

Agora que já vimos um pouco sobre os principais tipos de braços robóticos vamos

entender um pouco sobre os principais conceitos de construção de um robô, também

considerados como características ou parâmetros do robô, são eles:

Número de eixos ou Graus de liberdade: determinam os movimentos do braço no

ambiente bidimensional ou tridimensional. Cada junta do robô define um ou dois

graus de liberdade e o numero de graus de liberdade de um robô é dado pela

somatória dos graus de liberdade de suas juntas

Cinemática: é a disposição física dos membros e juntas de um robô,

determinando os possíveis movimentos do robô

Ambiente de trabalho: é a região do espaço que engloba o alcance máximo de

um robô

Capacidade de carga: carga máxima que o robô pode manusear

Velocidade: agilidade de movimentação do robô

Precisão: resolução de movimentação do braço, considerando o erro de

posicionamento aceitável

Controle dos movimentos: Tipo de controle utilizado para os movimentos,

podendo ser controle autônomo, pré-programado, remoto e etc.

Fonte de energia: Fonte de alimentação para os atuadores do robô

Acoplamento: conexão entre os atuadores e as juntas do robô

Todos estes parâmetros serão descritos detalhadamente para nossa projeto mais a

frente, na seção de Desenvolvimento do projeto.

22

2.4 Robôs móveis

A necessidade de movimentação para robôs pode ter várias origens, como a

exploração de ambientes inóspitos, a movimentação de materiais de locais de carga para

locais de descarga ou até mesmo o reconhecimento e patrulha de terrenos de grande

proporção. A definição de robô móvel é: um veículo capaz de movimentação autônoma,

equipado com atuadores controlados por um computador embarcado.

Os tipos de movimento assim como seu método de localização e meio por onde se

move variam conforme a aplicação do robô. Um robô pode se locomover no solo, através de

rodas, esteiras, trilhos, patas, etc. Pode se locomover pelo ar como um avião, balão ou

helicóptero. Na água como um barco ou submarino, ou até mesmo no espaço.

2.4.1 Modus operandi

Nosso robô utiliza sete sensores ultrassônicos para mapear a área ao seu redor e as

peças armazenadas nos locais definidos. Os sensores coletam informações de distância que

são processadas pela central de controle e assim o robô consegue se localizar na área de

trabalho e verificar as peças a serem coletadas e o local onde deve ser montada a estrutura.

Em conjunto com os sensores, os motores recebem sinais da placa de controle e se

movimentam conforme o necessário. O robô utiliza as distâncias medidas das paredes e até a

peça para gerar os sinais para os motores de passo e os motores do braço.

23

2.4.2 Principais tipos de robôs móveis

De construção mais simples e mais fáceis de controlar, os robôs com rodas constituem

a abordagem mais simples. Existem, entretanto, também várias tipologias, variando o número

de rodas, o tipo de tração e a forma como o robô pode mudar de direção.

Quatro rodas motrizes (ou mais)

Lagartas

Eixo de rotação

Omnidirecionais

Tração diferencial

Nosso projeto se baseia em um robô de base diferencial, que apresenta um projeto

mecânico mais simples e uma programação de controle mais otimizada.

2.4.2.1 Base diferencial

A base diferencial é composta por dois motores trabalhando separadamente, recebendo

sinais distintos do processador. Isso ajuda muito a questão de movimentação e montagem.

Para tal temos de ter em conta a capacidade de resposta aos três grandes problemas do robô;

“Onde estou? ”, “Para onde vou? ” e “Como vou?”.

Para responder a estas três preguntas e evitar a desorientação do robô, este segue um

ciclo fechado, conseguindo assim mover-se por um espaço sem ajuda externa e totalmente

autônomo. Neste sentido é muito importante a captação de dados através dos sensores, visto

que com ela o robô tem de ser capaz de se orientar no espaço que se lhe apresenta. A

24

informação dada pelos sensores tem de ser devidamente processada, sendo necessário, para

tanto, desenvolver um software de controle. E como resultado o software deve agir sobre os

diferentes motores.

2.5 Processadores, Sensores e Motores

O processador é o cérebro do projeto, recebendo sinais dos sensores, que são as vias

de comunicação com o mundo externo, tratando e processando estes sinais e enviando sinais

de controle para os atuadores.

2.5.1 Placa Arduíno

Utilizamos a placa Arduino Mega AT2560, que possui 54 pinos de entrada e saída,

sendo 15 deles de sinal PWM, 16 pinos de entrada analógica e 4 UARTS (portas seriais). Tem

ainda frequência de clock de 16 MHz. Utiliza tensão de operação de 5V (máximo de 12V),

40mA corrente de entrada e saída, e memória flash de 256K.

Figura 6 – Placa Arduino utilizada

25

2.5.2 Motores de passo

Um motor de passo é um dispositivo eletromecânico que converte os impulsos

eléctricos em movimentos discretos mecânicos. O eixo de um motor de passo gira em

incrementos discretos quando os impulsos de comando eléctricos são aplicados a ele na

sequência correta.

A rotação dos motores tem várias relações diretas a estes pulsos de entrada aplicados.

A sequência dos impulsos aplicados está diretamente relacionada com a direção de rotação do

eixo do motor, a velocidade de rotação do motor com a frequência dos impulsos de entrada e

o comprimento de rotação com o número de impulsos de entrada. Ou seja, para controlar o

motor de passo precisa-se aplicar tensão a cada uma das bobinas em uma sequência

específica.

Uma das vantagens mais significativas de um motor de passo é a sua capacidade de ser

controlado com precisão num sistema de circuito aberto, ou seja, circuito onde nenhuma

informação de feedback sobre a posição é necessária. Este tipo de controle elimina a

necessidade de caros sistemas de detecção, tais como codificadores ópticos. Sua posição é

conhecida simplesmente através do controle dos impulsos de entrada.

Figura 7 – Motor de passo utilizado no robô

26

Este motor é alimentado por 5v e utilizamos o esquema de ativação de 4 passos (full-

step, ou passo inteiro), que é o padrão utilizado pela biblioteca do Arduino onde o número de

passos para uma volta completa é 2048.

2.5.3 Sensores ultrassônicos

O sensor ultrassônico utilizado foi o HC-SR04, que opera como um detector de

objetos e permite medir distâncias mínimas de 2 centímetros podendo chegar a distancias

máximas de até 5 metros com uma precisão de 3 milímetros. Estes sensores emitem um sinal

ultrassônico que reflete em um objeto e retorna ao sensor (sinal de eco). O sinal de retorno é

captado, permitindo-se deduzir a distância do objeto ao sensor tomando o tempo de trânsito

do sinal.

A velocidade do sinal ultrassônico é de aproximadamente a velocidade do som no ar

que é 240 m/s, logo se o sensor estiver a uma distância “d” do objeto o sinal percorrerá uma

distância equivalente a “2d” para sair e retornar ao sensor. Sabendo esses conceitos é possível

calcularmos a distância de um objeto pela fórmula:

Equação 1 – Equação que fundamenta o sensor HC-SR04

2.5.4 Servo Motores

27

O servo motor é um atuador rotativo com alta precisão de controle de posicionamento

angular. É composto por um motor acoplado a um sensor de posição de feedback e um

servodrive. Este drive utiliza o sinal de feedback do sensor para controlar a posição angular

do motor de forma precisa. Esse é o controle em malha fechada, e por isso o servo motor é

considerado uma solução de alta performance a aplicações onde motores de passo ou motores

de indução não correspondem a necessidade. O Arduino possui uma biblioteca que trata o

ângulo que precisa ser posicionado o servo e manda um sinal PWM para a placa de controle

interna do servo e ele processa este sinal de modo a se movimentar conforme o desejado.

Essa biblioteca contribui muito para o desenvolvimento do software já que funções de

movimentação e posicionamento básico já estão preparadas para utilização.

Figura 8 – Servo motor utilizado

28

3. DESENVOLVIMENTO

Para o desenvolvimento de qualquer projeto a subdivisão e atribuição de tarefas é

essencial para sua evolução e para que haja uma maior facilidade no gerenciamento de todas

as etapas a serem desenvolvidas. Então para o projeto de robô autônomo descrito neste

relatório dedicamos uma fase inicial do projeto para planejamento e definição de estratégias,

atribuindo as tarefas a serem desenvolvidas de acordo com as habilidades de cada membro da

equipe, sempre trabalhando com metas e prazos a serem cumpridos.

Cronologicamente este projeto pode ser divido nas seguintes etapas:

Planejamento gerencial

Definição estrutural – mecânica

Definição estrutural – hardware eletrônico

Pesquisa – características mecânicas

Projeto mecânico

Pesquisa – compra de componentes

Protótipo I – Eletrônica em protoboard

Testes e análise de desempenho de protótipo I – desenvolvimento de software e

alterações estruturais

Protótipo II – Eletrônica em protoboard

Testes e análise de desempenho de protótipo II – desenvolvimento de software e

alterações estruturais

Projeto de placa de controle

Protótipo III – Eletrônica em placa de controle

29

Testes e análise de desempenho da placa de controle – desenvolvimento de

software, alterações estruturais e ajustes no design da placa de controle

Protótipo IV – Eletrônica em placa de controle oficial

Testes finais

O tempo total de projeto foi de aproximadamente 14 meses, desde os primeiros

esboços estruturais do robô até os últimos testes e ajustes. Abaixo estão duas imagens que

apresentam os primeiros sketches de como imaginávamos nosso projeto inicialmente.

Figura 9 – Primeiro sketch do braço

Figura 10 – Primeiro sketch do conjunto

Na etapa de planejamento foi realizado um estudo e levantamento das principais

características estruturais que nosso robô deveria possuir, isso para executar os movimentos e

tarefas requeridos para o manuseio e construção de pequenas estruturas de madeira. Nesta

etapa foi definido que o “corpo” do robô seria composto por três módulos distintos, sendo que

estes módulos precisaram ser projetados simultaneamente por conta da necessidade de

posterior integração entre eles. Nesta fase nasceram então três projetos distintos e igualmente

complexos.

30

Os três módulos são:

Braço robótico – responsável pelo manuseio de estruturas

Base robótica – responsável pela locomoção autônoma do conjunto integrado

Central de controle – responsável pelo processamento de todos as entradas e

controle das saídas

Considerando que todo projeto recebe um nome, ao conjunto composto por estes três

projetos integrados demos o nome de “Scorpion”, por conta de sua aparência física quando

está manuseando as estruturas de madeira. Scorpion é então, nosso robô capaz de manusear e

transportar pequenas estruturas de madeira de modo a acomodá-las em posições determinadas

para a construção de uma estrutura final.

3.1 Material

Este foi um ponto de decisão delicado para nosso projeto, dentre várias opções, os três

materiais que se mostraram mais viáveis foram: Madeira MDF, acrílico e alumínio. E os

principais motivos para focarmos o projeto todo nestes três materiais são: o custo do material,

o custo e facilidade de produção das peças em cada material, estabilidade da estrutura,

resistência à impacto e peso total da estrutura.

A tabela a seguir apresenta o levantamento realizado em relação à custo de compra de

material, custo de corte a laser (técnica que utilizamos para produção das peças) e o peso

específico do material.

31

Tabela 1 – Levantamento de dados materiais

Material Peso Específico

(g/cm3)

Preço Material (R$)

chapa de 1,0 x 0,5m

Corte de laser

(R$/cm de laser)

Acrílico (3mm) 1,18 55,00 0,50

Alumínio (2mm) 2,6 100,00 -

MDF (3mm) 0,750 30,00 0,50

Como pode ser observado na tabela, o custo da placa de MDF e o peso específico do

material são características muito vantajosas comparadas aos outros dois materiais

considerados. Alinhando estas características à resistência mecânica e à estabilidade

apresentada pelos protótipos que testamos, decidimos por construir 90% de nossas estruturas

em MDF.

O projeto final foi construído como segue:

Componentes do braço robótico – madeira MDF de 3mm de espessura

Base do braço robótico – Acrílico de 5mm de espessura

Placa superior da base de locomoção – madeira MDF de 3mm de espessura

Cobertura geral da base de locomoção – madeira MDF de 3mm de espessura

Placa inferior da base de locomoção – Acrílico de 3mm de espessura

Suporte de fixação motores de locomoção – Bloco usinado em nylon

Suportes em geral – MDF de 3mm de espessura

Garra robótica – Alumínio

32

Figura 11 – Scorpion

De todos estes componentes que nosso projeto possui, o único não desenvolvido por

nós foi a garra robótica, que foi importada já montada, sendo esta preparada especificamente

para o tipo de manipulação que precisávamos.

3.2 Braço Robótico – Módulo I

O projeto de um braço robótico não é tarefa simples, e os fatores que influenciam a

definição das características do braço são os mais variados. Por exemplo: as dimensões

globais são definidas pelo alcance necessário, e limitadas pelo tamanho da área de trabalho; O

material do qual o braço é feito depende diretamente destas dimensões globais, da capacidade

de carga de cada atuador e da utilização, ou não, de um contrapeso; e estas capacidades de

carga dependem diretamente da função principal do braço. Podemos perceber então que cada

Braço Garra

Base do

Braço

Cobertura

geral da base

Placa superior

da base

33

característica deve ser muito bem projetada de modo que o conjunto seja preciso, veloz e

facilmente controlável.

3.2.1 Características de Construção

Nesta seção serão descritas e detalhadas as características de construção de nosso

braço robótico. Características como dimensões, graus de liberdade, material utilizado na

construção do braço e outros mais genéricos.

3.2.1.1 Dimensões globais e Graus de liberdade

Para definição das dimensões e características globais do braço precisamos saber

primeiro que tipo de robô desejamos construir, e comparando nosso robô com os tipos já

discutidos neste relatório podemos dizer que nosso braço robótico se caracteriza como um

“mix” de robôs cartesianos com robôs articulados, pois nosso braço é capaz de descrever

movimentos nos eixos X e Y por conta da movimentação da base ( ângulo θ altera a direção

do robô para X ou Y) e movimentos angulares no plano perpendicular ao solo no sentido

longitudinal da base (ângulos α e β).

Por conta dos atuadores utilizados nestas articulações identificamos uma limitação

mecânica que será detalhada mais a frente quando falarmos dos atuadores em si, mas o angulo

α possui uma limitação de movimentação de 180 graus e o angulo β uma limitação de

movimentação de 160 graus. Abaixo vemos um diagrama com as proporções reais do braço e

suas articulações com a indicação de cada um de seus ângulos de movimentação.

34

Figura 12 – Diagrama demonstrando ângulos descritos pelo robô.

Ainda falando sobre a movimentação do braço podemos descrever uma das principais

características de um braço robótico, seus graus de liberdade. Nosso braço é composto por 2

articulações de movimento do braço, uma de abertura e fechamento da garra, e tem como

suporte para sua base a base de locomoção por motores diferenciais. Podemos dizer então que

nosso robô possui dois graus de liberdade do próprio braço, que no diagrama mostrado acima

são os ângulos α e β, e mais um grau de liberdade que podemos considerar como sendo um

grau de liberdade virtual, pois não existe nenhuma articulação física para este que possibilite o

movimento de rotação do braço, mas por estar sobre uma base de locomoção com movimento

por motores diferenciais e por estar alinhado ao eixo de rotação destes motores o conjunto

completo proporciona estes movimentos rotacionais do braço. Encontramos então os três

graus de liberdade de nosso braço robótico.

Na fase de pesquisas e projeto do braço foi definido que a altura máxima que ele

deveria atingir estaria entre 30 e 35 centímetros quando todos seus ângulos estivessem

α

β

θ

35

alinhados perpendicularmente ao solo. Evoluindo através dos protótipos a versão final do

braço possui dimensões absolutas iguais a:

Base do braço – 12,5 x 11 x 0,5

Suporte base – 9 x 5 x 0,3

Braço – 18 x 3 x 0,3

Mão + Garra – 16 x 3 x 0,3

Figura 13 – Dimensões do braço

Os testes de nossos primeiros protótipos nos mostraram que estas são as melhores

dimensões, em proporção, para a aplicação que escolhemos. Com elas o alcance que

desejávamos é atingido, a estrutura é estável e os movimentos são precisos.

3.2.1.2 Movimento

16cm

9 cm

36

Como citamos anteriormente a fase de definição da capacidade de carga que cada

atuador deveria apresentar dependia diretamente da definição de dois principais fatores, massa

total da estrutura do braço e massa das estruturas a serem manipuladas. Com o material e

dimensões do braço, e material e dimensões das estruturas definidos, já temos uma base para

esta decisão.

Os atuadores utilizados neste projeto são servos motores muito utilizados para

aeromodelismo e automodelismo por suas dimensões menores e capacidades de carga

relativamente altas. Os modelos, dimensões e capacidades de carga utilizados em nosso

projeto são os que seguem.

Tabela 2 – Características técnicas Servo motores utilizados

Modelo

Servo-motor Torque (6V) Velocidade

Ângulo de

rotação

DGServo – S05NF 3,2 kg.cm 0,18 s/60° 180°

Hitec – HS422 4,1 kg.cm 0,16 s/60° 180°

Abaixo apresentamos um diagrama que representa a posição destes atuadores em

nosso braço robótico.

37

Figura 14 – Disposição de atuadores

Como pode ser visto, os atuadores com capacidade de carga maior (Hitec HS422) são

responsáveis pelo movimento do braço na junta inferior, ou seja, estes atuam na variação do

angulo α movimentando o “braço”, e também pelo movimento na junta superior, ou seja,

atuando na variação do ângulo β movimentando a “mão”. Para maior capacidade de carga e

maior estabilidade para os movimentos, foram utilizados dois servos na junta inferior (angulo

α) posicionados de frente um para o outro, de modo que a variação de um servo é de 0 a 180

graus enquanto o a variação do outro é de 180 a 0 graus. Na junta inferior foi utilizado apenas

um servo (ângulo β). Além destes foi utilizado um atuador DGservo S05NF para controle de

abertura e fechamento da garra, que será descrita na próxima seção.

3.2.1.3 Garra robótica

A garra robótica foi o único componente do braço que decidimos não desenvolver por

conta das dimensões complexas da engrenagem. Durante nossas pesquisas levantamos os

α

β

HS422

HS422

38

tipos de garras mais interessantes para nossa aplicação e a “garra de dois dedos” se mostrou a

mais aplicável.

Foi desenvolvido um protótipo para esta garra que segue na imagem abaixo, mas os

ajustes de movimento, principalmente na região das engrenagens impossibilitaram sua

utilização. Esta foi projetada por nós, e produzida em MDF, cortado a laser, mas mesmo com

a precisão do corte a laser, não foi atingido um ajuste bom entre as engrenagens.

Figura 15 – Garra Robótica Protótipo

Como não houve sucesso com este protótipo foi necessária a compra e importação de

uma garra já montada e fabricada em alumínio. A garra importada é a Sparkfun – MKII de

fabricação americana por empresa que desenvolve componente específicos para robótica. A

seguir é apresentada a garra, seus componentes e dimensões (em mm).

39

Figura 16 – Garra: componentes e dimensões.

Uma característica muito interessante dessa garra é a presença de uma embreagem

antitravamento em seu eixo de conexão das engrenagens da garra ao servo motor. Esta

embreagem contribui inclusive para a melhorar a pega da garra, garantindo que a peça sendo

manuseada não caia durante a movimentação do robô. Abaixo podemos ver uma imagem da

garra e está embreagem antitravamento.

S05NF

40

Figura 17 – Garra Completa

Para abertura e fechamento da garra utilizamos o servo motor já mencionado com

torque de 3,2 kg.cm. A função desenvolvida para este atuador varia seu ângulo de 40 a 160

graus, o que representa na ponta da garra uma abertura máxima de 5,5 cm, suficiente para a

manipulação das estruturas de madeira.

3.2.1.4 Modelo Matemático do Braço

Para melhor entender como o braço se comporta criamos um modelo matemático deste

e através do software MatLab implementamos este modelo para simulação antes de qualquer

programação.

O modelo criado a partir das dimensões apresentadas na FIGURA ??? – Dimensoes

braço robotico pode ser visto abaixo, onde são apresentadas as duas equações que descrevem

as posições possíveis para a ponta da garra (centro dos cubos a serem manipulados).

𝑥 = 15. cos 𝛼 16. sen 𝛽

Equação 2 – projeção das posições no eixo X

𝑦 = 15. sin 𝛼 + 16. sin 𝛽

Equação 3 – projeção das posições no eixo Y

Utilizando o MatLab podemos simular essas duas equações para obtermos todos os

pontos que a garra de nosso robô pode alcançar para x ≥ 0. No total, utilizando todas as

combinações possíveis de ângulos α e β, nas juntas inferior e superior, podemos descrever

41

8281 pontos. O algoritmo implementado no MatLab basicamente verifica todas as

combinações possíveis de ângulos e através das equações de nosso modelo matemático do

braço determina as coordenadas X e Y para cada combinação de ângulo. A imagem abaixo

apresenta esses mais de 8000 pontos.

Figura 18 – Plot do Matlab com todos os 8281 pontos

Com este plot inicial é possível verificar que há muitos pontos que estão abaixo do

nível do solo (Y= - 6cm) então podem ser descartados para nossa aplicação, e há também

pontos que se fossem utilizadas projetariam a garra do robô sobre a base de locomoção, sendo

assim estes pontos também podem ser descartados para nossa aplicação. Utilizando um filtro

implementado no algoritmo do MatLab obtivemos o seguinte resultado da imagem a seguir.

42

Figura 19 – Plot do MatLab com primeiro Filtro

Ainda analisando os dados obtidos através das simulações implementamos um novo

filtro no algoritmo para determinar quais destes pontos restantes estão próximos de

coordenadas absolutas, com até 0,2 cm de tolerância.

Com este modelo implementado e estas simulações em mãos temos uma referência

para o posicionamento do robô. Com uma tabela gerada pelo algoritmo temos os ângulos para

cada junta quando queremos definir um determinado ponto X-Y. Os testes comparativos que

fizemos apresentaram um erro de aproximadamente ± 0,8cm em pontos projetados em X-Y.

3.2.1.5 Operação do braço robótico

Todo a movimentação do braço é implementada através de funções pré-programadas

no arduíno, e estas funções controlam os servos motores utilizando a biblioteca de controle de

servos do Arduíno. Então nossas funções definem o angulo que o servo deve apresentar e a

43

biblioteca define qual o pulso que deve ser enviado ao servo para que este se mova da posição

em que se encontra e até o angulo desejado.

No total desenvolvemos 17 funções para o controle de posições do braço. Todas estas

nossas funções trabalham com o movimento nas juntas do braço de Scorpion de maneira

simultânea, ou seja, para descrever o movimento de uma posição atual à outra posição

qualquer as funções variam os ângulos nas juntas em passos determinados dependendo do

movimento desejado, mas sempre com a seguinte ordem: primeiro na junta inferior e depois

da junta superior. Uma observação importante a ser feita é que todos os movimentos descritos

por nossas funções não levam em consideração a trajetória entre os dois pontos, e sim o ponto

inicial e o final, traçando trajetórias aleatórias entre os pontos baseadas apenas na proporção

dos passos simultâneos aplicados.

Esta técnica trouxe três grandes vantagens para o projeto. São elas:

Através desta técnica conseguimos otimizar o tempo que o braço leva para se

deslocar entre dois pontos, pois não é necessário aguardar uma junta finalizar seu

movimento para iniciar o movimento da próxima.

Conseguimos descrever movimentos retilíneos nos eixos X e Y, isso através da

combinação de passos diferentes no movimento simultâneo. Ex. Para movimento

retilíneo paralelo ao eixo X a proporção de passos é de 1:2, ou seja, a função

movimenta a junta superior 2 graus a cada grau de movimento da junta inferior

(isso no sentido positivo ou no sentido negativo do eixo).

A última grande vantagem foi a suavidade do movimento resultante quando as

duas juntas se movimentam simultaneamente, eliminando movimentos bruscos que

comprometiam a estrutura do braço e a eficácia da pega da garra.

44

As posições a serem apresentadas pelo braço foram determinadas experimentalmente

com base nas simulações do modelo matemático no MatLab. Então para cada posição de

nosso interesse efetuamos testes para verificar se os dados simulados eram suficientemente

precisos. Com estas posições armazenadas em vetores sabemos exatamente qual a posição que

o braço deve apresentar para pegar uma peça no ponto 1 e para qual posição ele deve se

dirigir para colocar essa peça no ponto 2.

A atuação destas funções que criamos é diretamente ligada ao movimento descrito

pela base e a seu funcionamento, pois as funções só atuam efetivamente quando a base

determina que certa peça está em posição para ser manuseada. Então pode-se dizer que o

braço depende quase que completamente do processamento das informações dos sensores

presentes na base, para poder manusear as estruturas no momento certo. Por isso os

sincronismos destes dois módulos são tão críticos para o bom funcionamento do projeto como

um todo.

45

3.4 Base robótica

O robô Scorpion utiliza a base diferencial, com dois motores de passo, e faz o controle

de posição com o auxílio de sete sensores ultrassônicos. A seguir, uma explicação detalhada

de cada componente da base.

3.4.1 Leitura de sensores

Para encontrar as peças, é necessário que o robô consiga detectá-las de alguma forma,

assim como, é necessário que ele saiba sua localização em relação à peça e em relação ao

ambiente em que ele se encontra.

Para isso, utilizamos sensores ultrassônicos, estrategicamente posicionados no corpo

da base. Os sensores ultrassônicos foram posicionados, um atrás, dois de cada lado, e dois na

frente. Cada uma de suas funções será explicada.

46

Figura 20 – Posição dos sensores na base

Figura 21 – Posição dos sensores dianteiros

A principal função dos sensores em conjunto, é mapear o ambiente a volta do robô, e

assim ter as coordenadas da sua localização.

47

Figura 22 – Mapeamento do ambiente

Para que o robô saiba sua localização a todos os momentos, é necessário que ele faça

leituras rotineiras dos sensores. Então, a cada número de execuções do Loop infinito, é feita a

leitura de um sensor da base, multiplexando as leituras de um sensor por vez, para que não

haja interferência. Veja um exemplo:

48

Figura 23 – Mapeamento do ambiente com peça na frente

Figura 24 – Resultado da leitura de todos os sensores [cm]

É importante observar que que o sensor dianteiro de detecção de peça, mostra um

valor menor (~10,4 cm) que o sensor dianteiro de mapeamento (~25,5 cm) porque há uma

peça a frente dele.

49

3.4.1.1 Tratamento de dados

Os sensores ultrassônicos tem uma precisão limitada, e eventualmente podem fazer

leituras incorretas, então se faz necessário um algoritmo de tratamento dos dados lidos dos

sensores.

Existem dois principais problemas que enfrentamos nos testes iniciais:

Leituras incorretas, com valores grandes (como mais de um metro, o que é

impossível senso que nosso ambiente de testes tem 100x50 [cm])

Alta variação de uma leitura para a outra

Para resolver esses problemas, foi desenvolvido um algoritmo que despreza leituras

incorretas (impossíveis), e que leva em conta uma média de valores medidos. E esse

algoritmo está escrito dentro de uma função que é chamada a cada leitura dos sensores,

checando se o valor é plausível (menor de um metro) e atualizando a média com o novo valor

medido.

3.4.2 Locomoção

Com o controle de localização confiável, o robô pode se locomover e realizar sua

aplicação.

50

3.4.2.1 Em linha reta

Apesar de o motor de passo ser bastante preciso, e de termos certo controle de

localização pelo número de passos que usamos para acioná-lo, há uma série de fatores que

pode interferir na precisão do seu movimento, fazendo-se necessário o controle por sensores.

Os principais fatores são:

Atrito entre as rodas e o piso

Pequenas diferenças de fabricação entre os dois motores

Então mesmo para andar em linha reta, é necessário o controle, porque um erro de

ângulo, mesmo que pequeno, vai se somando, fazendo com que o robô erre o seu alvo.

Para a correção desse erro, são usados os dois sensores laterais de cada um dos lados.

Figura 25 – Sensores laterais

Durante o trajeto, a diferença da distância entre os dois sensores é verificada para

comprovar se ele está andando em linha reta. Se os sensores mostrarem a mesma distância da

parede, ele está em linha reta, se os sensores mostrarem distâncias diferentes, significa que o

robô está desalinhado com a parede, e precisa ser corrigido. A correção é feita girando

51

somente um dos motores de passo até que o robô esteja alinhado de novo (verificação pelos

sensores).

Figura 26 – Robô desalinhado e correção

E foi colocada uma margem de tolerância entre as medidas, para que o robô não entre

na rotina de alinhamento todo o tempo. Essa margem foi encontrada experimentalmente e ela

serve para corrigir as imprecisões dos sensores.

3.4.2.2 Curvas

Como descrito anteriormente, na base diferencial há dois motores de passo. Quando os

dois giram para o mesmo sentido, o robô vai para frente ou para trás. E quando os dois giram

para sentidos contrários, o robô faz curvas.

52

Figura 27 – Curvas na base diferencial

Então é necessário saber o comprimento do arco de cada roda, assim como o diâmetro

da roda, para com esses dados saber quantos passos devem ser dados no motor para que a

roda ande um milímetro.

Figura 28 – Diâmetro da roda

Também é necessário medir a distância entre os motores, para saber o comprimento do

arco que cada uma das rodas vai fazer durante a curva, e assim saber quantos passos o motor

deve dar para girar um dado ângulo.

53

Figura 29 – Distância entre motores

Figura 30 – Arco de giro de cada roda

Fazendo os cálculos, a função de fazer curvas receberá o argumento de quanto girar

em ângulo e a fórmula a seguir calcula o número de passos para dar no motor (em sentidos

opostos):

54

𝑃𝑎𝑠𝑠𝑜𝑠 = [2048

(𝜋 × 𝟔𝟔)] × [

𝜋

180×

𝟏𝟔𝟓

2] × â𝑛𝑔𝑢𝑙𝑜

Equação 4 – cálculo do número de passos para curvas

3.5 Shield Arduino

O controlador do robô é a placa Arduino Mega, e o acesso aos pinos usados no robô

são por meio de conectores. E a alimentação dos motores por meio de baterias externas.

Na fase inicial do projeto, os testes foram feitos usando uma protoboard e cabos

unitários de protótipo. A protoboard era necessária pelo fato de os pinos da placa do Arduino

terem um limitado número de pinos de terra e VCC (5 V), e pelo fato de não haver acesso a

tensão maior requerida pelos motores (7 V).

Figura 31 – Protoboard com o Arduino

Depois que foi acertado e testado quantos e quais pinos do Arduino iríamos usar,

projetamos um protótipo de uma placa do tipo shield para se encaixar na placa Arduino para

55

termos acesso a todos os pinos que seriam utilizados, no formato dos conectores dos motores

e sensores ultrassom. Eram também necessárias duas alimentações diferentes: sete volts para a

placa do Arduino e para os motores, e cinco volts para os sensores.

Usando o software de projetos de circuito impresso, desenhamos a placa que encaixa

perfeitamente na placa do Arduino, tendo acesso a todos os pinos desejados. E encaminhando

os pinos para o formato dos conectores dos motores e dos sensores. Utilizamos também a

máquina prototipadora da FEI para o teste da placa shield, para a verificação do

funcionamento antes de fazer a placa definitiva.

56

Figura 32 – Protótipo de shield para Arduino Mega [frente]

Figura 33 – Protótipo de shield para Arduino Mega [verso]

Para a placa definitiva, mandamos fazer em uma empresa que faz placas de duas

camadas com alta qualidade. E o resultado funcionou perfeitamente.

57

Figura 34 – Shield definitivo para Arduino Mega [frente]

Figura 35 – Shield definitivo para Arduino Mega [verso]

Figura 36 - Shield definitivo

58

3.6 Máquina de estados

Com um sistema de sensores confiável, combinado com um algoritmo de controle do

movimento do robô, é possível programar a aplicação desejada. Então foi feita uma máquina

de estados que descreve o comportamento do robô para realizar a construção de forma

autônoma.

Figura 37 - Máquina de estados

Durante o estado E0, o robô mapeia o ambiente onde está, e vai para o estado E1, em

que anda em direção a primeira peça. Se sua distância até a parede for diferente da distância

programada da primeira peça, ele corrige indo mais para a direita (E4 e E6) ou mais para a

esquerda (E5 e E7).

59

Sempre que o robô estiver desalinhado com a parede, ele se corrige entrando nos

estados E2 ou E3, dependendo se ele necessita girar para direita ou esquerda para se alinhar.

Depois de alinhado e na distância correta com a parede, o robô verifica o sensor

dianteiro até achar a peça, então ele vai ao estado E8, que pega a peça e incrementa a

contagem de eventos. Então ele repete o processo para achar o ponto de entrega da peça e

coloca-la no lugar. Ele repete o mesmo processo até todas as pelas estiverem uma em cima da

outra na estrutura construída autonomamente.

3.7 Bateria

Utilizamos duas baterias de níquel cádmio de 7,2 V e 1500 mA/h que alimentam todos

os periféricos usados, drivers do motor de passo, motores de passo, servo motores, sensores

ultrassônicos e placa de controle Arduino Mega. Em operação ininterrupta a bateria possui

uma carga útil 4 horas e leva em média 4 horas para carregamento completo.

Escolhemos bateria de níquel cádmio por necessitarmos de uma bateria compacta e

uma carga alta para alimentação de todos os motores e sensores utilizados.

3.8 Área de trabalho

A área de trabalho do nosso robô é uma base de madeira de 1,0m x 0,50m com uma

parede de 15 cm de altura. A estruturas a serem manipuladas são cubos de madeira de 3 x 3

60

cm, e por conta da diversidade de estruturas possíveis para montagem estes foram as

estruturas básicas escolhidas.

3.9 Principais dificuldades

Encontramos dificuldades em todas as fases do projeto, como era de se esperar. Os

motores DC que inicialmente escolhemos para movimentação da base deram muitos

problemas como diferença de torque entre eles. Tivemos dificuldade para medir a velocidade

e posição, que são cruciais quando precisamos de precisão. Mesmo usando um encoder para

controle de posição, que media o número de passos com uma chave ótica, não foi suficiente

para fazer o controle dos motores DC com precisão. Tivemos que trocá-los por motores de

passo que funcionaram perfeitamente.

O braço robótico que teve dois protótipos. Dois dos motores usados queimaram

próximo a data de entrega, e tivemos que alterar a mecânica do braço porque só tínhamos um

motor reserva. No lugar do outro motor colocamos um rolamento e funcionou como esperado.

O mapeamento utilizando sensores ultrassônicos também trouxe algumas dificuldades,

como problemas para sincronizar os sete sensores, a placa shield inicial teve muitos

problemas de mal contato e trilhas rompidas. Então não estávamos conseguindo testar as

funcionalidades dos sensores e motores corretamente. Tivemos então que mudar a biblioteca

usada no Arduino, para que a leitura dos sensores funcionasse corretamente. E a placa shield

teve que ser refeita em uma empresa especializada.

A base do robô era de acrílico, mas com o peso do braço, servo motores, placa e

baterias ela estava envergando, então tivemos que adicionar uma base de madeira mais

61

resistente já com os suportes para os sensores. Durante os testes, observamos que o robô tinha

alguns problemas andando em linha reta, então tivemos que programar um controle de

posição com dois sensores ultrassônicos localizados em cada um dos lados. Para que, quando

ele se desalinhasse com a parede, a leitura dos sensores e a correção pelos motores de passo

realinhavam o robô.

62

4. CONCLUSÃO

Portanto, aprendemos muito tecnicamente e pessoalmente, como trabalhar em equipe e

resolver problemas. Vimos que com trabalho em grupo e divisão de tarefas conseguimos fazer

coisas incríveis, como criar um robô do zero sem um conhecimento prévio de mecânica e

resolver problemas inesperados como os descritos. Escolhemos um projeto muito complexo

de fazer, mas com esforço e muita luta conseguimos fazer do jeito que imaginamos como

seria o Scorpion.

Esse projeto foi uma prova de conceito da autonomia de um robô no desempenho de

uma atividade em um ambiente desconhecido. Usando somente seus próprios sentidos. Nesse

projeto, a atividade desempenhada foi a de construção de estruturas, mas essa pesquisa pode

ser expandida em reconhecimento de terrenos desconhecidos, ou análise de ambientes

inóspitos.

63

APÊNDICE A – Esquemático e layout da placa Shield

66

APÊNDICE B – Programa

67

/* Nome : scorpion_v7

*/

/* Includes */

#include <Stepper.h>

#include <Ultrasonic.h>

#include <Servo.h>

/* Pinos */

//Steppers

#define D1 22 //azul

#define D2 24 //rosa

#define D3 26 //amarelo

#define D4 28 //laranja

#define E1 30 //azul

#define E2 32 //rosa

#define E3 34 //amarelo

#define E4 36 //laranja

//Servos

#define serv_base_1 50 //servo da base direito

#define serv_base_2 52 //servo da base esquerdo

#define serv_brac_1 51 //servo do braço direito

#define serv_brac_2 53 //servo do braço esquerdo

#define serv_garra 8 //servo da garra

//Sensores Ultrasom

///Ultra 10

#define echoPin_f 48

#define trigPin_f 49

///Ultra 4

#define echoPin_fc 35

#define trigPin_fc 37

///Ultra 9

#define echoPin_d1 46

#define trigPin_d1 47

///Ultra 8

#define echoPin_d2 44

#define trigPin_d2 45

///Ultra 7

#define echoPin_e1 42

#define trigPin_e1 43

///Ultra 6

#define echoPin_e2 40

#define trigPin_e2 41

///Ultra 5

#define echoPin_t 38

#define trigPin_t 39

/* Defines */

//Orientação

#define NORTE 0

#define SUL 1

#define LESTE 2

#define OESTE 3

//Constantes

#define ATRASO 4

#define VAL_MEDIA 11

#define OFFSET_1 160

68

#define OFFSET_2 180

#define OFFSET_LATERAL 0.4

/* Subrotinas */

//Sensores Ultrasom

void leitura_sensores(void);

void ultrasom(void);

void ultra_valores(void);

void limpa_media(void);

//Steppers

void frente(float passos);

void tras(int passos);

void virar_dir(int graus);

void virar_esq(int graus);

//Braço

void inicial_servos();

void garra_abre();

void garra_fecha();

void base_avanca(int angbase);

void braco_avanca(int angbase, int angmeio);

void base_retorna(int angbase);

void braco_retorna(int angbase, int angmeio);

void braco_mix(int angbase, int angmeio);

void meio_avanca(int angmeio);

void meio_retorna(int angmeio);

void anda_reto(int passos);

void vai_base(int angbase);

void vai_braco(int angbase, int angmeio);

void pega(void);

void coloca_1st(void);

void coloca_2nd(void);

void coloca_3rd(void);

/* Variáveis Globais */

//Steppers

double passos_total = 2048; //Nº de passos p/ 1 rev.

int angulo = 90; //Angulo de rotacao do eixo

double numero_de_passos; //Nº de passos

int offset = 205;

//Ultrasom

volatile unsigned int cnt = 0;

volatile int flag_ultrasom = 1;

volatile float duration;

volatile float distancia_f[5]; //distancia[0] carrega a última média de

valores

volatile float distancia_fc[5]; //distancia[0] carrega a última média de

valores

volatile float distancia_d1[5]; //distancia[0] carrega a última média de

valores

volatile float distancia_d2[5]; //distancia[0] carrega a última média de

valores

volatile float distancia_e1[5]; //distancia[0] carrega a última média de

valores

volatile float distancia_e2[5]; //distancia[0] carrega a última média de

valores

volatile float distancia_t[5]; //distancia[0] carrega a última média de

valores

69

volatile int i = 1; //index dos valores de média

//Posicoes maximas dos motores

int posgarra = 30;

int posb_zero= 0;

int posb_fim= 180;

int posm_zero= 0;

int posm_fim= 180;

//contadores

int j;

int contb=0;

int contm=0;

// inicio base

int posb_dir=98;

int posb_esq=82;

//inicio meio

int posm_dir = 112;

int posm_esq = 43;

//velocidades

int delayb_avanco=40;

int delayb_retorno=40;

int delaym_avanco=40;

int delaym_retorno=50;

//pegar

int angb[5] = {90, 80, 70, 60, 0};

int angm[5] = {160, 130, 110, 90, 70};

//so enquanto testo e atualizo todo o programa

int angb_peg[5] = {90, 80, 70, 60, 50};

int angm_peg[5] = {150, 130, 110, 90, 70};

int angmhoje, angbhoje;

int d =500;

//Máquina de Estados

int ESTADO = 0;

int orientacao = NORTE;

volatile unsigned int cnt_mapa = 0;

float dist_alvo_d[6];

float dist_alvo_e[6];

int a = 0; //index dos valores de distância de alvo

int flag_ajuste = 1; //flag ajuste

float andar;

float dist_andar;

float passos_step;

//Definição dos steppers

Stepper stepper_dir(passos_total, D1, D3, D2, D4);

Stepper stepper_esq(passos_total, E1, E3, E2, E4);

//Definição dos servos

Servo servob_dir;

Servo servob_esq;

Servo servo_garra;

Servo servom_dir;

Servo servom_esq;

//------------------------------------------------------------------------

void setup()

{

/* Sensores Ultrasom */

pinMode(trigPin_f, OUTPUT);

pinMode(echoPin_f, INPUT);

70

pinMode(trigPin_fc, OUTPUT);

pinMode(echoPin_fc, INPUT);

pinMode(trigPin_d1, OUTPUT);

pinMode(echoPin_d1, INPUT);

pinMode(trigPin_d2, OUTPUT);

pinMode(echoPin_d2, INPUT);

pinMode(trigPin_e1, OUTPUT);

pinMode(echoPin_e1, INPUT);

pinMode(trigPin_e2, OUTPUT);

pinMode(echoPin_e2, INPUT);

pinMode(trigPin_t, OUTPUT);

pinMode(echoPin_t, INPUT);

/* Configuração dos Steppers */

stepper_dir.setSpeed(10);

stepper_esq.setSpeed(10);

//Servos

servob_dir.attach(serv_base_1);

servob_esq.attach(serv_base_2);

servo_garra.attach(serv_garra);

servom_dir.attach(serv_brac_1);

servom_esq.attach(serv_brac_2);

//seta o vetor de distancias

limpa_media();

//Distâncias da parede

dist_alvo_d[0] = 6;

dist_alvo_d[1] = 16;





dist_alvo_e[0] = 30;




dist_alvo_e[4] = 6;


inicial_servos();

}

void loop()

{

++cnt;

if(cnt >= ATRASO)

{

cnt = 0;

leitura_sensores();

}

//Máquina de Estados

switch(ESTADO)

{

case 0 :

//localizar-se

if(cnt_mapa < 2000)

71

{

++cnt_mapa;

}

else

{

//vai_braco(80, 70);

if(distancia_f[0] > 10 && distancia_fc[0] > 10)

{

//limpa_media();

ESTADO = 1;

}

}

break;

case 1 :

//E8

if(distancia_f[0] <= 10)

{

//arrumar-se

ESTADO = 9;

}

if(a != 4)

{

//E2

if(distancia_d1[0] > (distancia_d2[0] + OFFSET_LATERAL))

{

ESTADO = 2;

break;

}

//E3

if(distancia_d1[0] < (distancia_d2[0] - OFFSET_LATERAL))

{

ESTADO = 3;

break;

}

}

else if(a == 4)

{

//E2

if(distancia_e1[0] < (distancia_e2[0] - OFFSET_LATERAL))

{

ESTADO = 2;

break;

}

//E3

if(distancia_e1[0] > (distancia_e2[0] + OFFSET_LATERAL))

{

ESTADO = 3;

break;

}

}

if(a != 4)

{

//E4

if(distancia_d1[0] > (dist_alvo_d[a] + OFFSET_LATERAL))

{

72

if(flag_ajuste == 1)

{

ESTADO = 4;

flag_ajuste = 0;

}

else

{

ESTADO = 6;

}

break;

}

//E5

if(distancia_d1[0] < (dist_alvo_d[a] - OFFSET_LATERAL))

{

ESTADO = 7;

break;

}

}

if(a == 4)

{

//E4

if(distancia_e1[0] < (dist_alvo_e[a] - OFFSET_LATERAL))

{

ESTADO = 6;

break;

}

//E5

if(distancia_e1[0] > (dist_alvo_e[a] + OFFSET_LATERAL))

{

if(flag_ajuste == 1)

{

ESTADO = 5;

flag_ajuste = 0;

}

else

{

ESTADO = 7;

}

break;

}

}

frente(1);

break;

case 2 :

stepper_esq.step(-1);

ESTADO = 1;

break;

case 3 :

stepper_dir.step(1);

ESTADO = 1;

break;

case 4 :

//cálculo

if(distancia_d1[0] > 6)//10)

73

{

andar = distancia_d1[0] - 6.0;

dist_andar = andar/0.707;

passos_step = (dist_andar/20.0)*2048.0;

//andar

virar_dir(45);

frente(passos_step);

virar_esq(45);

}

ESTADO = 1;

break;

case 5 :

//cálculo

if(distancia_e1[0] > 6)//10)

{

andar = distancia_e1[0] - 6.0;

dist_andar = andar/0.707;

passos_step = (dist_andar/20.0)*2048;

//andar

virar_esq(45);

frente(passos_step);

virar_dir(45);

}

ESTADO = 1;

break;

case 6 :


frente(5);

ESTADO = 1;

break;

case 7 :


frente(5);

ESTADO = 1;

break;

case 8 :

if(a == 0 || a == 2 || a == 4)

{

pega();

}

else if(a == 1)

{

coloca_1st();

}

else if(a == 3)

{

coloca_2nd();

}

else if(a == 5)

{

coloca_3rd();

}

//Vira no sentido inverso e reocmaça o ciclo

tras(500);

74

virar_dir(180);

++a;

if(a > 5)

{

while(1); //Término da construção

}

else

{

ESTADO = 0; //recomeçar o ciclo

}

break;

case 9 :

if(a != 4)

{

if(distancia_d1[0] > (distancia_d2[0] + 0.2))

{

stepper_dir.step(-1);


}

else if(distancia_d1[0] < (distancia_d2[0] - 0.2))

{


stepper_esq.step(1);

}

else

{

//Pegar

ESTADO = 8;

}

}

else if(a == 4)

{

if(distancia_e1[0] > (distancia_e2[0] + 0.2))

{



}

else if(distancia_e1[0] < (distancia_e2[0] - 0.2))

{



}

else

{

//Pegar

ESTADO = 8;

}

}

break;

}

}

//-------------------------------------------------------------------------

/* Subrotina : leitura_sensores

* Descrição :

*/

void leitura_sensores(void)

{

75

if(flag_ultrasom <= 7)

{

ultrasom();

++flag_ultrasom;

}

else

{

if(i <= 4) //quantidade de medições para a média

{

++i;

}

else

{

i = 1;

}

flag_ultrasom = 1;

ultrasom();

}

ultra_valores();

}

/* Subrotina : ultrasom

* Descrição :

*/

void ultrasom(void)

{

switch(flag_ultrasom)

{

case 1 :

//Ultrasom frente

digitalWrite(trigPin_f, HIGH);

delayMicroseconds(10);

digitalWrite(trigPin_f, LOW);

duration = pulseIn(echoPin_f, HIGH);

distancia_f[i] = (340*duration/2)/10000;

break;

case 4 :

//Ultrasom frente cima

digitalWrite(trigPin_fc, HIGH);


digitalWrite(trigPin_fc, LOW);

duration = pulseIn(echoPin_fc, HIGH);

distancia_fc[i] = (340*duration/2)/10000;

break;

case 2 :

//Ultrasom dir1

digitalWrite(trigPin_d1, HIGH);


digitalWrite(trigPin_d1, LOW);

duration = pulseIn(echoPin_d1, HIGH);

distancia_d1[i] = (340*duration/2)/10000;

break;

case 3 :

//Ultrasom dir2

digitalWrite(trigPin_d2, HIGH);


digitalWrite(trigPin_d2, LOW);

duration = pulseIn(echoPin_d2, HIGH);

distancia_d2[i] = (340*duration/2)/10000;

break;

76

case 5 :

//Ultrasom esq1

digitalWrite(trigPin_e1, HIGH);


digitalWrite(trigPin_e1, LOW);

duration = pulseIn(echoPin_e1, HIGH);

distancia_e1[i] = (340*duration/2)/10000;

break;

case 6 :

//Ultrasom esq2

digitalWrite(trigPin_e2, HIGH);


digitalWrite(trigPin_e2, LOW);

duration = pulseIn(echoPin_e2, HIGH);

distancia_e2[i] = (340*duration/2)/10000;

break;

case 7 :

//Ultrasom tras

digitalWrite(trigPin_t, HIGH);


digitalWrite(trigPin_t, LOW);

duration = pulseIn(echoPin_t, HIGH);

distancia_t[i] = (340*duration/2)/10000;

break;

}

}

/* Subrotina : ultra_valores

* Descrição :

*/

void ultra_valores(void)

{

int j = 1;

switch(flag_ultrasom)

{

case 1 :

//Ultrasom frente

for(j = 1;j <= 4; j++)

{

if(distancia_f[j] > 2 && distancia_f[j] < 100)

{

distancia_f[0] = (distancia_f[1]/4) + (distancia_f[2]/4) +

(distancia_f[3]/4) + (distancia_f[4]/4);

}

else

{

distancia_f[j] = distancia_f[0]; //se o valor estiver fora,

igualar a média

}

}

break;

case 2 :

//Ultrasom frente cima

for(j = 1;j <= 4; j++)

{

if(distancia_fc[j] > 2 && distancia_fc[j] < 100)

{

distancia_fc[0] = (distancia_fc[1]/4) + (distancia_fc[2]/4) +

(distancia_fc[3]/4) + (distancia_fc[4]/4);

77

}

else

{

distancia_fc[j] = distancia_fc[0]; //se o valor estiver fora,

igualar a média

}

}

break;

case 3 :

//Ultrasom dir1

for(j = 1;j <= 4; j++)

{

if(distancia_d1[j] > 2 && distancia_d1[j] < 100)

{

distancia_d1[0] = (distancia_d1[1]/4) + (distancia_d1[2]/4) +

(distancia_d1[3]/4) + (distancia_d1[4]/4);

}

else

{

distancia_d1[j] = distancia_d1[0]; //se o valor estiver fora,

igualar a média

}

}

break;

case 4 :

//Ultrasom dir2

for(j = 1;j <= 4; j++)

{

if(distancia_d2[j] > 2 && distancia_d2[j] < 100)

{

distancia_d2[0] = (distancia_d2[1]/4) + (distancia_d2[2]/4) +

(distancia_d2[3]/4) + (distancia_d2[4]/4);

}

else

{

distancia_d2[j] = distancia_d2[0]; //se o valor estiver fora,

igualar a média

}

}

break;

case 5 :

//Ultrasom esq1

for(j = 1;j <= 4; j++)

{

if(distancia_e1[j] > 2 && distancia_e1[j] < 100)

{

distancia_e1[0] = (distancia_e1[1]/4) + (distancia_e1[2]/4) +

(distancia_e1[3]/4) + (distancia_e1[4]/4);

}

else

{

distancia_e1[j] = distancia_e1[0]; //se o valor estiver fora,

igualar a média

}

}

break;

case 6 :

78

//Ultrasom esq2

for(j = 1;j <= 4; j++)

{

if(distancia_e2[j] > 2 && distancia_e2[j] < 100)

{

distancia_e2[0] = (distancia_e2[1]/4) + (distancia_e2[2]/4) +

(distancia_e2[3]/4) + (distancia_e2[4]/4);

}

else

{

distancia_e2[j] = distancia_e2[0]; //se o valor estiver fora,

igualar a média

}

}

break;

case 7 :

//Ultrasom tras

for(j = 1;j <= 4; j++)

{

if(distancia_t[j] > 2 && distancia_t[j] < 100)

{

distancia_t[0] = (distancia_t[1]/4) + (distancia_t[2]/4) +

(distancia_t[3]/4) + (distancia_t[4]/4);

}

else

{

distancia_t[j] = distancia_t[0]; //se o valor estiver fora,

igualar a média

}

}

break;

}

}

/* Subrotina : limpa_media

* Descrição :

*/

void limpa_media(void)

{

//frente

distancia_f[0] = VAL_MEDIA;





}

/* Subrotina : frente

* Descrição :

*/

void frente(float passos)

{

int i = 0;

for(i = 0;i < passos;i++)

{



}

}

79

/* Subrotina : tras

* Descrição :

*/

void tras(int passos)

{

int i = 0;

for(i = 0;i < passos;i++)

{



}

}

/* Subrotina : virar_dir

* Descrição :

*/

void virar_dir(int graus)

{

int i = 0;

//Quantidade de passos, baseado no angulo determinado

numero_de_passos = offset + 2*(graus / (360 / passos_total));

for(i = 0;i < numero_de_passos;i++)

{



}

}

/* Subrotina : virar_esq

* Descrição :

*/

void virar_esq(int graus)

{

int i = 0;

//Quantidade de passos, baseado no angulo determinado

numero_de_passos = offset + 2*(graus / (360 / passos_total));

for(i = 0;i < numero_de_passos;i++)

{



}

}

/* Subrotina : inicial_servos

* Descrição :

*/

void inicial_servos()

{

servob_dir.write(posb_dir);

servob_esq.write(posb_esq);

servom_esq.write(posm_esq);

servom_dir.write(posm_dir);

servo_garra.write(posgarra);

}

80

/* Subrotina : garra_abre

* Descrição :

*/

void garra_abre()

{

while(posgarra < 160)

{


++posgarra;

delay(10);

}

}

/* Subrotina : garra_fecha

* Descrição :

*/

void garra_fecha()

{

while(posgarra > 40)

{


--posgarra;

delay(10);

}

}

/* Subrotina : base_avanca

* Descrição :

*/

void base_avanca(int angbase)

{

while(posb_dir > angbase)

{



--posb_dir;

++posb_esq;

delay(delayb_avanco);

}

}

/* Subrotina : braco_avanca

* Descrição :

*/

void braco_avanca(int angbase, int angmeio)

{


{



--posb_dir;

++posb_esq;

delay(delaym_avanco);

if(posm_dir< angmeio)

{



81

++posm_dir;

--posm_esq;

}

}

while(posm_dir < angmeio)

{



++posm_dir;

--posm_esq;


}

}

/* Subrotina : base_retorna

* Descrição :

*/

void base_retorna(int angbase)

{

while(posb_dir < angbase)

{



++posb_dir;

--posb_esq;

delay(delayb_retorno);

}

}

/* Subrotina : braco_retorna

* Descrição :

*/

void braco_retorna(int angbase, int angmeio)

{


{



++posb_dir;

--posb_esq;

delay(delaym_retorno);

if(posm_dir > angmeio)

{



--posm_dir;

++posm_esq;

}

}

while(posm_dir > angmeio)

{



--posm_dir;

++posm_esq;

82


}

}

/* Subrotina : braco_mix

* Descrição :

*/

void braco_mix(int angbase, int angmeio)

{


{



--posb_dir;

++posb_esq;


if(posm_dir< angmeio)

{



++posm_dir;

--posm_esq;

}


{



--posm_dir;

++posm_esq;

}

}


{



++posb_dir;

--posb_esq;



{



--posm_dir;

++posm_esq;

}

if( posm_dir < angmeio)

{



++posm_dir;

--posm_esq;

}

}

//completa movimento meio


83

{



--posm_dir;

++posm_esq;


}

//completa movimento meio


{



++posm_dir;

--posm_esq;


}

}

/* Subrotina : meio_avanca

* Descrição :

*/

void meio_avanca(int angmeio)

{


{



++posm_dir;

--posm_esq;


}

}

/* Subrotina : meio_retorna

* Descrição :

*/

void meio_retorna(int angmeio)

{


{



--posm_dir;

++posm_esq;


}

}

/* Subrotina : anda_reto

* Descrição :

*/

void anda_reto(int passos)

{

int angbase = posb_dir;

int angmeio = posm_dir;

j=passos;

while(j>0){

84

angbase= angbase-1;

angmeio= angmeio-2;

base_avanca(angbase);

meio_retorna(angmeio);

delay(10);

j--;

}

}

/* Subrotina : vai_base

* Descrição :

*/

void vai_base(int angbase)

{

if(angbase < posb_dir){

base_avanca(angbase);

}

if(angbase > posb_dir){

base_retorna(angbase);}

}

/* Subrotina : vai_braco

* Descrição :

*/

void vai_braco(int angbase, int angmeio)

{

if(posb_dir > angbase && posm_dir < angmeio)

braco_avanca(angbase, angmeio);

if( posb_dir < angbase && posm_dir > angmeio)

braco_retorna(angbase,angmeio);

else

braco_mix(angbase, angmeio);

}

/* Subrotina : pega

* Descrição :

*/

void pega(void)

{

//Anda até o bloquinho

delay(1000);

garra_abre();

vai_braco(45, 14);

delay(d);

frente(OFFSET_1);

delay(500);

vai_braco(45, 14);

delay(d);

garra_fecha();

delay(1000);

tras(400);

vai_braco(90, 14);//60, 80);

delay(d);

}

85

/* Subrotina : coloca_1st

* Descrição :

*/

void coloca_1st(void)

{


delay(1000);

frente(OFFSET_2);

delay(500);

vai_braco(57, 9);

delay(d);

garra_abre();

}

/* Subrotina : coloca_2nd

* Descrição :

*/

void coloca_2nd(void)

{


delay(1000);

frente(OFFSET_2);

delay(500);

vai_braco(57, 9);

delay(d);

garra_abre();

}

/* Subrotina : coloca_3rd

* Descrição :

*/

void coloca_3rd(void)

{

vai_braco(69, 7);

delay(d);

garra_abre();

}

86

APÊNDICE C – Modelo matemático no Matlab

87

clear;

clc;

format short

%vetor com angulos TETA

tetaD = (90:-1: 0)

tetaR = (2*pi / 360) * tetaD;

%vetor com angulos RO

roD = (0:1:90)

roR = (2*pi / 360) * roD;

%Calculo de posicoes X-Y com todas as combinacoes de Tetas e Ros

n=1;

for i=1:1:91

for c=1:1:91

x(n) = (15*cos(tetaR(i))) + (16*cos(roR(c)));

y(n) = (15*sin(tetaR(i))) - (16*sin(roR(c)));

%Tabela com valores resultantes

tabela(n,:)= [tetaD(i) roD(c) x(n) y(n)];

n=n+1;

end

end

%Plot de posicoes possiveis

figure

plot(x,y, '.b')

grid minor

axis([0,32,-17,16])

title('Scorpion - Total de pontos')

xlabel('X (cm)')

ylabel('Y (cm)')

%Plot de possiveis com filtro 1

figure

plot(x,y, 'b.')%, x(1:90),y(1:90), 'r*')

grid minor

axis([0,32,-5,16])%,[11,32,-5,16] )

title('Scorpion - Filtro 1')

xlabel('X (cm)')

ylabel('Y (cm)')

88

05

10

15

20

25

30

-15

-10-505

10

15

Scorp

ion -

Tota

l de p

onto

s

X (

cm

)

Y (cm)

89

05

10

15

20

25

30

-202468

10

12

14

16

Scorp

ion -

Filt

ro 2

X (

cm

)

Y (cm)

90

05

10

15

20

25

30

-4-202468

10

12

14

16

Scorp

ion -

Filt

ro 1

X (

cm

)

Y (cm)

91

ANEXO A – Datasheet do Motor de passo

93

ANEXO B – Datasheet do driver de Motor de passo

97

ANEXO C – Datasheet do Servo-motor pequeno

99

ANEXO D – Datasheet do Servo-motor grande

101

ANEXO E – Datasheet do sensor ultrassônico

104

ANEXO F – Esquemático da placa Arduino Mega

106

ANEXO G – Datasheet do microcontrolador ATmega2560/V

109

5. REFERÊNCIAS

CITI. História da Robótica. Disponível em:

<http://www.citi.pt/educacao_final/trab_final_inteligencia_artificial/historia_da_robotica.html>.

Acesso em:

20 abr. 2015.

ESABOT. História da Robótica: A revolução industrial. Disponível em:

<http://esabot.blogspot.com.br/2011/05/historia-da-robotica-revolucao.html>. Acesso em:

20 abr. 2015.

VEJA. Os robôs vão à guerra. Disponível em:

<http://veja.abril.com.br/noticia/ciencia/os-robos-vao-a-guerra/>. Acesso em:

20 abr. 2015.

KOLLMORGEN. Servo Motor. Disponível em:

<http://www.kollmorgen.com/pt-br/products/motors/servo/servomotores/>. Acesso em:

20 abr. 2015.

WIKIPEDIA. Motor de passo. Disponível em:

<http://pt.wikipedia.org/wiki/Motor_de_passo>. Acesso em:

20 abr. 2015.

FILIPEFLOP. Sensor Ultrassônico HC-SR04. Disponível em:

<http://blog.filipeflop.com/sensores/sensor-ultrassonico-hc-sr04.html>. Acesso em:

20 abr. 2015.

FILIPEFLOP. Controlando um motor de passo 5V com Arduino. Disponível em:

<http://blog.filipeflop.com/motores-e-servos/controlando-um-motor-de-passo-5v-com-arduino.html >.

Acesso em:

20 abr. 2015.

ARDUINO. Arduino Mega 2560. Disponível em:

<http://www.arduino.cc/en/Main/ArduinoBoardMega2560>. Acesso em:

20 abr. 2015.

GIL, Àlex Romaguera de. ISRobot: Robot móvel de tracção diferencial.. 2007. f. 112-113. Dissertação

(Mestrado em Ciências) - Universidade de Coimbra Faculdade de Ciências e Tecnologia, Portugal,

2003. Disponível em: <

http://www2.isr.uc.pt/~urbano/NCT04/publications/PAPERS/%5b40%5dMSc-Thesis-Alex.pdf>.

Acesso em: 23 mai. 2015. 9:02:27.

(FOONTE IMAGEM ROBOS SCARA - fonte imagem: adaptação de MOURA, José Luiz de.

Robôs Articulados. Mecatrônica Atual, São Paulo, edição 16, jul. 2004.)

robô construtor autônomo

Documents