UNIVERSIDADE NOVE DE JULHO CURSO DE CIÊNCIA DA COMPUTAÇÃO
BRUNO DOS SANTOS PARDIM DIEGO ANTONIO DA SILVA
ROBO HEXÁPODE CONTROLADOR POR ANDROID
TRABALHO DE CONCLUSÃO DE CURSO
SÃO PAULO 2014
DIEGO ANTONIO DA SILVA BRUNO PARDIM
ROBO HEXAPOD CONTROLADO POR ANDROID
Trabalho de Conclusão do Curso de graduação do Curso Superior em Ciência da Computação, apresentado como requisito parcial para obtenção do título de Cientista da Computação.
Orientador : Nilton Canto
SÃO PAULO
RESUMO
Utiliza- se os robôs do tipo hexápode na robótica referindo – se a robôs com 6 pernas. Robôs hexápodes normalmente são utilizados como mecanismo de estudos acadêmicos[1]. Objetivo Geral do projeto é controlar um robô do tipo hexápode através de um app para celular com sistema android. Foi preciso uma ampla pesquisa sobre hexápodes para chegarmos na ideia e conceitos básicos para o início desse projeto, passamos por várias etapas como a mecânica, construção, testes. O projeto do hexápode passa pelos seguintes processos: Mecânica, estrutura elétrica, hardware, firmware e interface gráfica. O corpo do robô tem 3 DOF ou seja ele consegue tem 3 tipos de movimento por perna, o corpo foi adquirido através do site armazém da Google um site com vários modelos em 3D disponíveis gratuitamente. Foi utilizado 18 motores modelo mg995 da empresa Tower pro, trabalham com torque 13kg/cm e voltagem de 3.0v ~7.2v, alimentados por uma bateria de 6400 mah 8.4 v Li-ion. Os hardwares utilizados foram os seguintes: uma placa controladora de servo motores ssc32 com capacidade de controlar até 32 motores com um micro controlador Atmel ATMEGA 168 -20PU velocidade 14.75 MHz, uma arduino mega2560 e um JY-MCU Bluetooth Serial[11].O firmware utilizamos linguagem de programação C e Java, a linguagem C é utilizada na arduino afim de coordenar a comunicação dos motores e movimentos do robô, a linguagem Java é utilizada na criação de uma interface chamada de hexapod control um app para android que emula um controle virtual.No fim tivemos um robô capaz de se movimentar e muitos terrenos, controlado por um aparelho android com Bluetooth. Pode ser utilizado como um robô de verificação de locais de difícil acesso ou até mesmo com intuído militar.
ABSTRACT
It uses the type hexapod robots robotics referring the robots with 6 legs. Robots are often used as hexapods academic [1] engine studies. General objective of the project is to control a robot hexapod type via a mobile app with android system. It took extensive research on hexapods to get the idea and basic concepts for the beginning of this project, we went through several stages as mechanics, construction, testing.The hexapod design through the following process: Mechanical, electrical structure, hardware, firmware and interface graphic. The body of the robot has 3 DOF so, he can have 3 types of movement per leg, the body was purchased through the site warehouse Google a site with multiple 3D models available for free.18 model MG995 Tower Pro motors company was used , work with 13kg/cm torque and voltage of 3.0V ~ 7.2V , powered by a battery 6400 mah 8.4 v Li -ion . The hardware used were as follows : one controller board with servo motors ssc32 ability to control up to 32 motors with a microcontroller Atmel ATMEGA 168 - 20PU speed 14.75 MHz , one arduino mega2560 and JY - MCU Serial Bluetooth[11]. The firmware used for C and Java programming language, C language is used in the arduino in order to coordinate communication engine and robot movements, the Java language is used to create an interface called hexapod control an app for android that emulates a control virtual. In the end we had a robot capable of moving and many lands, controlled by an android phone with Bluetooth. Can be used as a robot scan hard to reach places or even military intuited.
LISTA DE FIGURAS
Figura 1:Diagrama de blocos simplificado do projeto .......................................... 3 Figura 2:Diagrama de blocos do projeto .................................................................8 Figura 3:SSC32 Servo Controller .............................................................................9 Figura 4:Arduino Mega 2560 ..................................................................................10 Figura 5:Servo motor MG995 .................................................................................11 Figura 6:Mecânica interna servo motor ................................................................12 Figura 7:Figura onde mostra a variação do pulso .............................................. 12 Figura 8:Módulo Bluetooth .................................................................................... 13 Figura 10:Bateria Li-íon ..........................................................................................14 Figura 11:Esqueleto Hexápode ............................................................................. 15 Figura 12:Conjunto de peças do robô .................................................................. 16 Figura 13:Hexápode Corpo montado ................................................................... 17 Figura 14:Corpo montado ...................................................................................... 18 Figura 15:Interface software arduino ................................................................... 19 Figura 16:Interface Hexápode Control ..................................................................22 Figura 17:Pasta SDK .............................................................................................. 24 Figura 18:Interface hexapod control na ide eclipse ............................................ 25 Figura 19:Ícone administrar APIS ......................................................................... 25 Figura 20:Tela SDK funcionamento ...................................................................... 26 Figura 21:Tela Emulação ....................................................................................... 26 Figura 22:Interface de criação dispositivo virtual ............................................... 27 Figura 23:SplashScreenHexapod Control ............................................................ 31 Figura 24:tela principal hexápode Control ............................................................31 Figura 25:Tela efetuar conexão Bluetooth ........................................................... 32
Lista de siglas Mah
Miliampere – hora.
DOF
Grau de liberdade é de 3 eixos.
IDE
Ambiente integrado para desenvolvimento de software.
Shield
Placas de circuito impresso normalmente fixadas no topo do aparelho através de uma conexão alimentada por pinos-conectores. São expansões que disponibilizam várias funções específicas, desde a manipulação de motores até sistemas de rede sem fio10.
DC
DirectCurrent (Corrente Contínua)
APP
Application (Aplicação)
Drone
Veículo aéreo não tripulado.
FPV
(First Person View) Visão em primeira pessoa.
Su m ári o
1 Introdução ...............................................................................................................1 1.1 Motivação e justificativa ..................................................................................... 2 1.2 Objetivos e escopo ............................................................................................. 2 1.2.1 objetivo geral ............................................................................................... 2 1.2.2 objetivos específicos .................................................................................... 2
1.3 Requisitos do sistema ........................................................................................3 1.3.1 Requisitos funcionais ...................................................................................... 3 1.3.2 Requisitos não-funcionais ............................................................................... 4
1.4 Metodologia .........................................................................................................4 1.4.1 Fundamentos .................................................................................................. 4 1.4.2 Tecnologia ....................................................................................................... 4
1.5 Estrutura do trabalho ..........................................................................................5 1.5.1 Hardware......................................................................................................... 5 1.5.2 Software .......................................................................................................... 6
2 Estudos ...................................................................................................................6 2.1 Produtos similares .............................................................................................. 6 2.2 Vi ab il id ad e ........................................................................................................... 7
2.2.1 Viabilidade financeira ................................................................................... 7 2.2.2 Viabilidade Técnica ...................................................................................... 7
2.3 Dispositivos .........................................................................................................8 2.3.1 Diagrama de blocos ........................................................................................ 8 2.3.2 Servo controlador ssc32.................................................................................. 9 2.3.3 Arduino Mega2560 ........................................................................................ 10 2.3.4 Servo motor ................................................................................................... 11 2.3.5 Módulo Bluetooth .......................................................................................... 13 2.3.6 Bateria li-íon ................................................................................................. 14
2.3.7 Esqueleto Hexápode ..................................................................................... 15
2.4 Montagem do hexápode ...................................................................................16 3.0 Software e Desenvolvimento ............................................................................19 3.0.1 Sistema operacional Android ........................................................................ 23 3.0.2 Aplicativos Android ........................................................................................ 24 3.0.3 Android SDK ................................................................................................. 24
3.1 Desenvolvimento ...............................................................................................27 3.1.1 Hexa Control ................................................................................................. 27 3.1.2 Funcionamento interno do aplicativo............................................................. 27 3.1.3 Telas do aplicativo ........................................................................................ 31
4 Plano de testes .....................................................................................................32 4.1 Caso de teste I :Conexão com aplicativo ........................................................ 32 4.2 Caso de teste II: Conexão com o robô ............................................................. 33 4.3 Caso de teste III Posição de repouso do robô .................. ............................... 33
5 Gestão ...................................................................................................................33 5.1 Escopo ............................................................................................................. 34 5.2 Custo ................................................................................................................ 35 5.3 Análise de riscos .............................................................................................. 35
6 Conclusão .............................................................................................................36 7 Referências Bibliográficas ..................................................................................37
1
1.INTRODUÇÃ O
A robótica apareceu apenas no século 20, histórias sobre maquinas automatizadas desenvolvidas pelo homem é mais antiga. Engenheiro grego de Alexandria, escreveu dois textos, Pneumática e automata, que descrevia a existência de várias maquinas, capazes de produzir movimentos automatizados. [2] Leonardo Da Vinci iniciou esse caminho com um estudo amplo em anatomia humana para desenvolver robôs que fossem capazes de se movimentar como tal. Os primeiros modelos desse estudo foram robôs que moviam pernas, braços e olhos, apareceram nas figuras de animais com movimentos que mais tarde foram chamados de autômatos[3]. O fascínio por robôs fez surgir escritores e amantes da robótica como Isaac Asimov que publicou diversos livros de ficção cientifica contribuindo bastante para o estudo da robótica no mundo, criando até mesmo leis que deveriam ser aplicadas a robôs que um dia obtivessem a inteligência, abaixo citamos as 3 leis da robótica de Isaac Asimov. 1ª Lei: Um robô não pode ferir um ser humano ou, por inação, permitir que um ser humano sofra algum mal. 2ª Lei: Um robô deve obedecer as ordens que lhe sejam dadas por seres humanos exceto nos casos em que tais ordens entrem em conflito com a Primeira Lei. 3ª Lei: Um robô deve proteger sua própria existência desde que tal proteção não entre em conflito com a Primeira ou Segunda Leis[4]. Com o avanço da robótica em 1954, George Devol obteve a primeira patente sobre robótica neste mesmo ano. A primeira empresa a criar um robô foi a "Unimation", criada por George Devol e Joseph F. Engelberger em 1956. O robô da Unimation chamado de “Máquina de transferência programa" tinha o objetivo de transf erir um
objeto de ponto a outro[5]. A robótica evoluiu até chegarmos nos robôs atuais, tanto industriais quanto robôs que fazem cirurgia e ajudam na locomoção de pessoas com problemas físicos e também para o entretenimento, temos como avanço robótico o robô bigdog da empresa Boston Dinamics que tem como intuído ajudar na guerra a levar suprimentos aos soldados e também carregar um possível soldado ferido. Como o nome diz grande cachorro, um robô quadrupede com o que a de mais moderno em robótica atualmente. A Boston também tem seu robô humanoide
2
chamado de PETMAN, um robô com movimentações muito próximas a humana, que tem como objetivo a utilização em ambientes químicos e militares[6]. Na década de 90 foi possível a criação dos primeiros robôs hexápodes, graças ao avanço da computação[1]. A utilização de robôs hexápodes na indústria é muito ampla, ainda mais pela precisão e mobilidade que robôs deste tipo podem conter dependendo de sua engenharia[7].
1.1 Motivação e Justificativa A motivação que tivemos veio do hobby na área de robótica que adquirimos no decorrer de nosso curso, começamos a utilizar o conhecimento adquirido na faculdade na área de programação para programar nossos protótipos. Com o tempo conseguimos criar nosso primeiro robô hexápode, tivemos dificuldades e encontramos falhas em nosso projeto, com isso resolvemos fazer um novo robô afim de deixar ele mais moderno. Atualmente fora esses projetos estamos desenvolvendo um drone inicialmente controlamos por controle remoto, com mais estudo queremos tornar esse drone autônomo. 1.2 Objetivos e escop o
1.2.1 Objetivo geral O objetivo geral é desenvolver um robô hexápode que seja capaz de ser controlado por um dispositivo móvel no caso celulares com sistema Android, futuramente poderemos adicionar novos dispositivos como infravermelhos ou sistemas de varredura e câmeras utilizando sistema fpv para uma interação cada vez mais realista ao ambiente a ser explorado pelo robô.
1.2.2 Objetivos específicos O projeto está diretamente ligado a várias áreas do curso de ciência da computação. O objetivo principal é estudar e conhecer mais profundamente como funciona a criação de um robô hexápode tanto a parte mecânica, quanto a parte lógica o código propriamente dito. O hexápode precisa se comunicar diretamente com um aparelho celular que tenha sido instalado o aplicativo "HEXAPOD CONTROL", na interface do aparelho será solicitado ao usuário a permissão para ligar o dispositivo Bluetooth do aparelho, com isso é estabelecida a conexão com o robô, feito essa conexão o
3
usuário será capaz de controlar o robô em várias direções com o joystick do HEXAPOD CONTROL. Na figura 1 temos um diagrama de bloco simplificado dessa conexão.
Futuramente será possível efetuar essa comunicação por tecnologia WiFi, o hardware tem total compatibilidade com essa tecnologia. 1.3 Requis itos d e sis tema
1.3.1 Requis itos fu ncio nal
RF1. As pernas do robô devem estar em perfeito sincronismo proporcionando um estabilidade ao mesmo. RF2. Os movimentos das pernas devem estar funcionando. RF3. O hardware do robô precisa se comunicar com o aparelho móvel. RF4. Os movimentos do robô devem se iniciar assim que for enviado os comandos do aparelho celular. RF5. A biblioteca de comunicação do robô deve receber a comunicação sem fio do aparelho. RF6. A comunicação Bluetooth precisa ser estabelecida.
1.3.2 Requisitos não- funcionais
4
RNF1. O robô precisa ter 6 pernas. RNF2. O robô precisa ter motores RNF3. O robô precisa de um estrutura confiável RNF3. O robô precisa de uma bateria para ser alimentado. RNF4. O robô precisa de uma placa controladora 1.4 Metodolo gia
1.4.1 Fundamentos O projeto do Hexápode e suas funções exige um conhecimento em mecatrônica e eletrônica, esses conhecimentos são fundamentais tanto para a parte elétrica quanto para a estrutura do robô (esqueleto). Para utilizar os softwares necessários para programar a parte logica do robô será preciso ter conhecimento modelagem de dados e lógica de programação que são fundamentais para a estruturação do código aplicado na interface. Necessário também conhecimento em comunicação de portas digitais e analógica que são o meio de comunicação do software com o hardware, também em portas seriais.
1.4.2 Tecnologias As tecnologias aplicadas no projeto são: Comunicação sem fio (Bluetooth), linguagem C e Java, servo motores, a placa controladora de servos e a placa arduino. O controle dos servos é feito através da placa controladora ssc32 juntamente com a arduino que facilita a codificação do robô. No aparelho móvel (celular) temos um interface que faz a comunicação com o robô através de uma conexão sem fio. O hardware do módulo Bluetooth fica no robô e através de um protocolo de comunicação, é feito a conexão com o celular. A linguagem C escrita dentro de uma interface própria do arduino uma IDE simples de fácil domínio. A linguagem Java é escrita dentro de uma IDE Eclipse que tem pacotes para desenvolver programas em android . 1.5 Estru tura do trabalho
Esse trabalho por envolver robótica precisa fundamentalmente de hardware e software para sua conclusão. Nesse trecho traremos uma descrição dos hardwares e softwares que foram usados.
5
1.5.1 Hardware No processo de desenvolvimento do hexápode, foi utilizada inicialmente uma estrutura em acrílico, o design do robô foi feito pelo grupo, o mesmo não obteve sucesso, pois como não tínhamos recursos e ferramentas para projetar essa ideia, portanto, a ideia inicial foi abandonada. Em uma nova tentativa utilizando acrílico, porem dessa vez utilizando os serviços de uma empresa terceira para fabricar essas peças utilizando corte a laser. Tivemos um retorno muito bom, fabricamos o primeiro protótipo que foi fundamental para o entendimento tanto de hardware como de software do robô. Nesse corpo utilizamos inicialmente motores pequenos mais conhecidos com micro servo, motores visando a diminuição de custo do projeto, encontramos alguns obstáculos com esse motor, por se tratar de um motor barato e com baixo torque não obtivemos um retorno aceitável. Conforme o projeto foi sendo desenvolvido, sentimos a necessidade de criar um robô com servo motores mais fortes, é claro que com essa ideia o corpo antigo já não seria mais útil, desta vez usamos um corpo totalmente impresso em impressora 3D. O controle das pernas do robô foi feita através de uma placa controladora de servo motores, são hardwares desenvolvidos especialmente para controlar servo motores, muito utilizados em robôs desse gênero. A alimentação do robô inicialmente foi feita por um fonte tx comum de computador, facilitando assim um maior tempo de testes com o robô. Mesmo com uma fonte de computador tx 200w, o robô sentia uma grande dificuldade de se levantar e de se movimentar, como foi utilizado 3 motores por perna totalizando 18 motores, tornava a fonte incapaz de alimentar todos eles. Conseguimos reverter isso com uma bateria de li-ion6400 mah 8.4v que funcionou perfeitamente. Para a comunicação com os dispositivos moveis (aparelhos celulares) foi utilizado um módulo Bluetooth. A opção por utilizar o modulo Bluetooth e não um modulo WiFi foi visando o custo do projeto.
6
1.5.2 Software O robô recebe comandos de um App instalado em qualquer aparelho com sistema android, o que foi desenvolvido na linguagem Java a ferramenta utilizada para desenvolver esse software foi o eclipse (Android Developer Tools v22.0.1-685705), devido os membros do grupo ter uma maior familiaridade com essa plataforma tornando assim mais fácil nosso processo de criação da interface.Essa interface apenas chama as funções já criadas na linguagem C que ficam gravadas na placa arduino. 2. ESTUDO S
2.1 Produtos sim ilares
No início do projeto foi feito um estudo sobre robôs hexápodes. Vamos citar alguns robôs que nos ajudaram desenvolver esse projeto são robôs tanto da área academia, quanto comercial. O primeiro contato com esses modelos de robô foi através da empresa Lynsmotion uma empresa especializada em robôs hexápodes, quadrupedes, humanoides e braços robóticos. Seu modelo que chamou mais atenção foi o Phoenix walkingrobot um hexápode de 3 DOF (DOF – significa que seu grau de liberdade é de 3 eixos) um robô feito de alumínio controlado por um controle com Bluetooth. Esse robô e utilizado estudos e como brinquedo de hobbistas, esse robô pode ser encontrado no site da empresa por um valor de $793.00[8]. A empresa Intel também tem seu hexápode um robô que ficou muito famoso por ter sido comprado de um estudante chamado Matt Bunting, seu projeto de hexápode era diferente de muitos encontrados atualmente com cinemática reversa ou outro métodos, ele explorou mais além, ele é capaz através de estímulos sensoriais definir qual a melhor forma de movimentação que deve fazer, com essa analise pode definir qual o movimento e velocidade que cada motor deve fazer. A Intel comprou esse robô para apresentações de seus produtos, além disso, o robô de Matt virou uma espécie de celebridade dos hexápodes[9]. Grande parte de nosso estudo foi em fóruns e blogs onde encontrávamos pessoas como nós, que estavam iniciando ou já tinham algum conhecimento em robótica. Com essa gama de informações foi possível ao longo desse estudo elaborar uma ideia para iniciarmos nosso projeto.
7
2.2 Viabilidade 2.2.1 Viabilidade Financeira Os custos iniciais foram com a placas controladora essencial em nosso projeto, com esse placa em mãos conseguimos conhecer mais sua programação. Depois adquirido os motores, iniciaram-se os testes com uma única perna para entender como funcionavam realmente esses motores e a codificação da placa. Para uma melhor compreensão dos gastos com esses projetos temos uma tabela abaixa, onde citamos os produtos e seus respectivos valores.
Tabela 1: Preços dos componentes Fonte: Autoria própria
2.2.2 Viabilidade técnica O grupo já tinha conhecimento nas linguagem de programação C e Java que foi primordial para o entendimento do funcionamento da arduino e do aplicativos android. O conhecimento do módulo Bluetooth foi adquirido através de estudos e pesquisas na internet. Os servos motores não eram novidade para os membros do projeto. A maior dificuldade mesmo foi na mecânica e eletrônica que não tínhamos conhecimento no início do projeto.
8
2.3 Dispo sitiv os
2.3.1 Diagrama de Blocos Na figura 2, temos um diagrama de blocos do hardware. Basicamente apresenta a comunicação dos servo motores, comunicação do módulo Bluetooth com o aparelho celular e transmissão de energia par as placas.
Figura 2: Diagrama de blocos do projeto Fonte: Autoria própria
9
2.3.2 Servo Controlador SSC 32
Figura 3: SSC 32 Servo Controller Fonte:
A placa SSC 32 é uma placa controladora de servo motor. Possui alta resolução (1 uS) para posicionamento preciso. Com intervalo de 0,50 ms a 2,50 ms com uma quantidade enorme de movimento[9] ela conta com uma programação bem simples desenvolvida propriamente para ela com função de movimento em grupo e um software de fácil entendimento.Com essas funções de grupo é possível realizar qualquer combinação dos servos com início e termino dos movimentos, tudo ao mesmo tempo independente do pulso que cada servo deve receber.
10
2.3.3 Arduino mega 2560
Figura 4: Arduino mega 2560 Fonte:
Arduino é um hardware de computação de código aberto (open-source) constituindo uma placa com entradas e saídas analógicas e digitais. Conta com um ambiente próprio de desenvolvimento através da linguagem C.A placa arduino pode ser utilizada para fazer muitos tipos de projetos, de robôs até um simples piscar de um led. Essa placa conta com uma grande variedade de Shields que são outros hardwares que podem ser conectadas a arduino incrementando novas funções a placa arduino como Shields ethernet, WiFi, Bluetooth e etc.[10]
11
2.3.4 Servo motor
Figura 5: Servo motor MG995 Fonte:
Os servo motores são utilizados em diversos setores da indústria, estudos acadêmicos e projetos de entusiastas e estudantes do setor e mecânica, mecatrônica, eletrônica e informática. Muito utilizado em carinhos de controle remoto, aviões de controle remoto e robôs. Dentro do servo motor temos um motor que funciona através de pulsos elétricos que indica a quantidade de movimento em seu eixo. No interior temos um motor DC, potenciômetro e um circuito de controle, onde existem engrenagens que conduzem seu movimento. Quando o motor se movimenta ocorre uma mudança na resistência do potenciômetro que regula precisamente a quantidade de movimento que existe e em qual direção se mover. Sua velocidade é proporcional a diferença da sua posição atual com a desejada, se o motor está próximo da posição desejada vai se mover mais lentamente caso contrário se estiver longe vai se mover mais rápido. Seu controle é feito através de pulsos elétricos de largura variável, ou modulação por largura de pulso (PWM), através de um fio. Geralmente um servo motor pode girar de 0° a 180°[11]. Na figura 6 podemos ver o que a dentro de um servo motor.
Figura 6: mecânica interna servo motor
12
Fonte:
Na figura abaixo podemos ver a variação de pulso e sua respectiva posição.
Figura 7: Figura onde mostra a variação do pulso Fonte:
13
2.3.5 Módulo Bluetooth
Figura 8: Módulo Bluetooth Fonte:
Bluetooth é uma nomenclatura para identificar a comunicação de pouca distância entre redes sem fio. Utiliza o protocolo que trabalha na faixa licenciada pela ISM (Industrial, Scientific, and Medical), 2,45 giga-hertz até 723,1 kbit/s. A rede Bluetooth tem uma topologia dinâmica chamada de “PICONET” ou PAN (bandeja de) piconets
suportam de 2 a no máximo 8 dispositivos na rede[12].
14
2.3.6 Bateria Li-íon
Figura 10: Bateria Li-íon Fonte :
As baterias de íons de lítio são recarregáveis utilizadas em vários dispositivos eletrônicos. Sua caracteriza é a ausência de efeito de memória impedindo que a mesma vicie[13]. Bateria utilizada para alimentar o robô é um modelo li-íon 6400mAh com voltagem real de 8.4v.
15
2.3.7 Esqueleto Hexápode A estrutura(corpo) do robô foi adquirido no site armazém da Google onde existe projetos em 3d livres para download. O corpo escolhido foi uma hexápode desenvolvido por John Bacus diretor de Gestão de Produtos da Trimble Navigation, site que mantem os projetos em 3d da SketchUp da google.
Figura 11: Esqueleto Hexapod Fonte:
16
2.3.8 Montagem do hexápode O procedimento de montagem do hexápode basicamente referisse a integração dos servo motores a estrutura do robô. Primeiramente fizemos a medição dos motores para colocar o corpo. Como corpo do robô foi feito em uma impressora 3D, é comum que após a impressão de alguma peça ela tenha algumas rebarbas nas peças, por esse motivo para colocar os motores em seus devidos locais foi preciso fazer uma processo de lixamento desses locais para caber perfeitamente os motores. Na figura 12 abaixo podemos ver todas as peças desmontadas.
Figura:12 Conjunto de peças do robô Fonte:
17
Após o lixamento de cada peça foi feito a inserção dos motores como na figura13 baixo. Em seguida temos uma figura do robô montado por completo figura 14.
Figura13: Hexápode Corpo montado Fonte: Autoria própria
18
Figura 14: Corpo montado Fonte: Autoria própria
Após a montagem da estrutura foi inserido as placas controladora a ssc32 e Arduino mega 2560 e a bateria.
19
3.0 Software e Desenvolv im ento
Foi utilizado no projeto dois softwares distintos. O software responsável por armazenar as coordenadas de movimento do robô é a IDE do arduino como podemos ver na figura 15. Nesse software foram criadas as funções de movimento do robô, movimentar de se mover para frente e para os lados.
Figura 15: Interface software arduino Fonte:
20
Abaixo um trecho de código programado na IDE arduino referente a movimentação do hexápode, trechos responsáveis por realizar o giro para esquerda e direita do robô, Esses trechos são executados assim que a placa arduino recebe via Bluetooth, em sua porta serial 9600, um caractere e o mesmo é recebido por um switch onde cada case representa uma função. void setup(){ Serial.begin(9600); } void loop(){ int i; char comando; comando = Serial.read();
if(comando == 'w' || comando == 'u'){ andar(); } switch(comando){ case 'a': giroDir(); break; case 'd': giroEsq(); break; }
} void giroDir(){ int tempo = 500;
21
Serial.println("#0 P1500 #1 P1500 #2 P1500 T500"); Serial.println("#6 P1500 #7 P1500 #8 P1500 T500"); Serial.println("#19 P1500 #20 P1500 #21 P1500 T500"); delay(tempo); Serial.println("#3 P1800 #16 P1800 #22 P1800"); delay(tempo); Serial.println("#0 P1500 #1 P1925 #2 P1460 T500"); Serial.println("#6 P1500 #7 P1925 #8 P1460 T500"); Serial.println("#19 P1500 #20 P1925 #21 P1460 T500"); delay(tempo); Serial.println("#3 P1500 #4 P1500 #5 P1500 T500"); Serial.println("#16 P1500 #17 P1500 #18 P1500 T500"); Serial.println("#22 P1500 #23 P1500 #24 P1500 T500"); delay(tempo); Serial.println("#0 P1800 #6 P1800 #19 P1800"); delay(tempo); Serial.println("#3 P1500 #4 P1925 #5 P1460 T500"); Serial.println("#16 P1500 #17 P1925 #18 P1460 T500"); Serial.println("#22 P1500 #23 P1925 #24 P1460 T500"); delay(tempo); Serial.println("#0 P1500 #1 P1500 #2 P1500 T500"); Serial.println("#6 P1500 #7 P1500 #8 P1500 T500"); Serial.println("#19 P1500 #20 P1500 #21 P1500 T500"); delay(tempo); }
void giroEsq(){ int tempo = 500; Serial.println("#0 P1500 #1 P1500 #2 P1500 T500"); Serial.println("#6 P1500 #7 P1500 #8 P1500 T500"); Serial.println("#19 P1500 #20 P1500 #21 P1500 T500"); delay(tempo); Serial.println("#3 P1300 #16 P1300 #22 P1300"); delay(tempo); Serial.println("#0 P1500 #1 P1925 #2 P1460 T500");
22
Serial.println("#6 P1500 #7 P1925 #8 P1460 T500"); Serial.println("#19 P1500 #20 P1925 #21 P1460 T500"); delay(tempo); Serial.println("#3 P1500 #4 P1500 #5 P1500 T500"); Serial.println("#16 P1500 #17 P1500 #18 P1500 T500"); Serial.println("#22 P1500 #23 P1500 #24 P1500 T500"); delay(tempo); Serial.println("#0 P1300 #6 P1300 #19 P1300"); delay(tempo); Serial.println("#3 P1500 #4 P1925 #5 P1460 T500"); Serial.println("#16 P1500 #17 P1925 #18 P1460 T500"); Serial.println("#22 P1500 #23 P1925 #24 P1460 T500"); delay(tempo); Serial.println("#0 P1500 #1 P1500 #2 P1500 T500"); Serial.println("#6 P1500 #7 P1500 #8 P1500 T500"); Serial.println("#19 P1500 #20 P1500 #21 P1500 T500"); delay(tempo); }
Nosso segundo software e responsável por ler as funções do arduino e colocar as funções no controle virtual. Como podemos ver na figura 16 temos uma interface que emula um controle padrão com joystick como os que são usados em videogame.
Figura 16: interface Hexapod Control Fonte: Autoria própria
23
3.0.1 Sistema operacional Android
Andriod é um sistema operacional para dispositivos mobile baseado em um núcleo do Linux, originalmente o S.O android foi criado pela empresa Handset_Alliance que é liderada pela Google, atualmente mais de 1 bilhão de dispositivos mobile rodam esse sistema dentre eles smartphones, tablets, tvs, sendo personalizável, leve e ágil. O sistema pode ser aplicado a variados tipos de hardware, com suporte a vários tipos funcionalidades com por exemplo: wireless, Bluetooth, GPS, câmera, essa lista pode –se tornar enorme pois a possibilidade incorporada ao sistema é muito grande, o simples telefone que apenas realizava chamadas se tornou um grande computador[15].
24
3.0.2 Aplicativos Android
Aplicativos podem ser jogos, ferramentas como calculadoras assim como qualquer coisa que possa ser implementada com algum objetivo, por exemplo: criar um aplicativo para controlar um hexápode, criar um jogo, criar um sistema para administrar um serviço ou processo especifico são muitas possibilidade de criação de aplicativos com o sistema android. 3.0.3 Android SDK
O SDK SDK (Standard Development Kit) é um kit para desenvolvimento fornecido pela Google, com esse kit é possível criar aplicativos para android com as bibliotecas disponíveis nesse kit. Esse kit pode ser baixando no site do android para desenvolvedores. O SDK é composto pela IDE Eclipse com o pluginADT(Android Developer Tools), esse plugin torna possível o desenvolvimento para android e além disso seu ADT necessita ter uma versão mais recendo do android para emular seus aplicativos criados, abaixo imagens mostrando interface do software(imagens próprias). Primeira pasta contem a IDE eclipse, plataforma de desenvolvimento dos aplicativos para android, na segunda pasta contém todos os arquivos que constituem a sdk android, e por fim aplicativo SDK Manager gerencia as API´s (versões do O.S android) do android que estão instaladas e podem ser baixadas diretamente dos servidores da Google. As API’s Android são as versões do sistema disponíveis para desenvolvimento em cima sua plataforma, baseando-se na versão, suas novas funcionalidade caso tenha, a cada API lançada é uma versão nova do android é disponibilizada. [14]
Figura :17 Pasta SDK Fonte: Autoria própria
25
Na figura 18 temos a imagem da IDE eclipse originalmente usada para desenvolvimento, em geral, adaptado para o desenvolvimento para android.
Figura 18: Interface hexaControl dentro ide eclipse Fonte: Autoria própria
Figura 19: Ícone administrar APIS Fonte: Autoria própria
A seguir na imagem 20 temos a imagem do aplicativo SDK Manager em funcionamento, como padrão a Google manda a última versão do android, quando baixamos diretamente do site oficial do android para desenvolvedores.
26
Figura 20:Tela SDK funcionamento Fonte: Autoria própria
Na figura 21 temos o ícone do Android SDK, O Android Virtual Device Manager, onde é possível criar dispositivos virtuais android para o desenvolvedor rodar seu aplicativo no momento do desenvolvimento, isso facilita muito pois na mesma máquina que se desenvolve o aplicativo é possível emular fielmente versões de qualquer do android no computador.
Figura 21: Tela Emulação Fonte: Autoria própria Fonte: Autoria própria
Na imagem 22 temos a tela de interface de criação dos dispositivos virtuais.
27
Figura 22: Interface de criação dispositivo virtual Fonte: Autoria própria
3.1 Desenvolv im ento
3.1.1 Hexa Control
O Aplicativo Hexa Control foi criado com o intuito de controlar via conexão sem fio o Hexápode desenvolvido neste trabalho, através de comunicação Bluetooth, o aplicativo cria uma conexão com o dispositivo Bluetooth instalado no Hexápode. 3.1.2 Funcionamento interno do aplicativo
Como foi explicado, via comunicação Bluetooth o aplicativo instalado em um dispositivo com suporte a Bluetooth se comunica com o hexápode e seu dispositivo Bluetooth que recebe os comados. A comunicação entre Bluetooth se dá por meio de soquetes, portas de comunicação serial. No momento em que o aplicativo é iniciado uma permissão para habilitar o Bluetooth é solicitada ao usuário, assim que essa a solicitação é aceita o aplicativo cria um soquete. Esse soquete funciona como uma ponte entre o robô.
28
Explicação de método de conexão:
No método createBluetoothSocket (device), é chamado a criação de uma conexão via soquete segura ou seja, é preparada para a conexão com o dispositivo passando como parâmetro para a variável. Em seguida na linha de código: Bluetoothdevice = btAdapter.getRemoteDevice(adress), aplicamos na variável device do tipo Bluetooth um dispositivo Bluetooth remoto com o MAC ADRESS que informamos, assim o aplicativo iniciara a busca do dispositivo, esse processo ocorre muito rápido. Em seguida a busca é cancelada, a conexão via soquete é realizada criando uma ponte entre o dispositivo onde está executado o aplicativo e o hexápode. Abaixo código responsável pela solicitação para habilitar o Bluetooth, criar o soquete para conexão com o dispositivo Bluetooth do hexápode. //Preparando soquete para conexão private BluetoothSocket createBluetoothSocket (BluetoothDevice device) throws IOException { if(Build.VERSION.SDK_INT>= 10){ try { final Method m =
device.getClass().getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] { UUID.class }); return (BluetoothSocket) m.invoke(device, MY_UUID); } catch (Exception e) { Log.e(TAG, "Não foi possivel criar uma conexão segura"); } } return device.createRfcommSocketToServiceRecord(MY_UUID); } @Override Public void onResume () { super.onResume();
Log.d(TAG, "...onResume - tentando conectar..."); // Setado um pontei apontando para o dispositivo apontado para seu mac BluetoothDevice device = btAdapter.getRemoteDevice(address); try {
btSocket = createBluetoothSocket(device); } catch (IOException e1) { Log.d(TAG, "...erro onResume - tentando conectar..."); }
29
//Após alguns segundos a busca é cancelada pelo dispositvo. btAdapter.cancelDiscovery(); /*O soquete será criado com o bluetooth do hexapod nesta parte caso contrario o aplicativo indicará que o dispositivo esta desconectado*/ Log.d(TAG, "...Conectando..."); try { btSocket.connect(); status.setText("CONECTADO"); Log.d(TAG, "...Conectado..."); } catch (IOException e) { Log.d(TAG, "... erro ao criar soquete"); try { btSocket.close(); status.setText("DESCONECTADO"); } catch (IOException e2) { Log.d(TAG, "... erro ao fechar soquete"); } } // Cria um fluxo de dados para que possamos conversar com o servidor. try {
outStream = btSocket.getOutputStream(); } catch (IOException e) { Log.d(TAG, "... falha da saida de dados ..."); } }
// limpar caminho de saida de dados para sujeiras que possam ocorrer. Public void onPause () { super.onPause(); if (outStream != null ) { try {
outStream.flush(); } catch (IOException e) { Log.d(TAG, "... falha ao limpar saida de dados ..."); } } // fechamento de soquete { btSocket.close(); } catch (IOException e2) { Log.d(TAG, "... Falha ao fechar o soquete ..."); }
try
} Private void checkBTState () {
30
/*Checando por suporte a bluetooth e ligue Caso o dispositivo nao tenha suporte ao bluettoth irá retonar null */ if(btAdapter== null ) {
Log.d(TAG, "... Dispositivo não suporta bluetooth ..."); } else { if (btAdapter.isEnabled()) { Log.d(TAG, "...Bluetooth ligado..."); } else { //Pedi ao usuario para ligar o bluetooth Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); startActivityForResult(enableBtIntent, 1); } } } //metodo onde os carateres são passados com parametros e enviados via soquete Private void sendData (String message) { byte[] msgBuffer = message.getBytes();
Log.d(TAG, "...Envia dado: " + message + "..."); try {
outStream.write(msgBuffer); } catch (IOException e) { if (address.equals("00:00:00:00:00:00")); Log.d(TAG, "... Não a MAC ADRESS a ser encontrado ..."); finish(); } } }
Classes do aplicativo
Classe da MainActivity_splashscreen, classe responsável por mostrar na tela de splashScreen no início da aplicação. Classe principal MainActivity, classe principal da aplicação, responsável pelo funcionamento da aplicação, contendo métodos importantes etc. Classe MainActivity_sobres, responsável por mostrar informações sobre o aplicativo e desenvolvedores. Classe JoyStickClass, responsável por todas as funções do joystick, configurações, funções matemáticas para ângulo.
31
3.1.3 Telas do Aplicativo Na figura 23 temos a tela de SplashScreen do Aplicativo:
Figura 23:SplashScreen HexapodControl Fonte: Autoria própria
Tela principal do aplicativo na figura 24, contendo botões para controle e joystick
Figura 24:tela principal hexapodcontrol Fonte: Autoria própria
Na figura 25 temos o menu flutuante, com as opções reconectar, sobre e sair.
Reconectar : Possibilidade de reconectar ao dispositivo novamente caso necessário. Sobre: Informações sobre os desenvolvedores e universidade. Sair : Sair com segurança do aplicativo e finalizar conexões.
32
Figura 25:Tela efetuar conexão bluetooth Fonte: Autoria própria
4 Plano de Testes 4.1 Caso de teste I: conexão com driver
Pré - condição: o software deve estar instalado em algum dispositivo móvel com android. Etapa Instrução
Resultado esperado
Abrir o aplicativo hexapod control 1
instalado no aparelho móvel
A tela do aplicativo precisa ser exibida
Caso o Bluetooth seja habilitado pelo usuário, o aplicativo iniciará a 2
Aguardar a mensagem para habilitar
busca para se conectar ao
o Bluetooth
hexápode
4.2 Caso de teste II: Posição de repouso do robô
33
Pré - condição: Ligar toda a parte elétrica do robô. Etapa Instrução
Resultado esperado
Hexápode irá para sua posição de Com o aplicativo já conectado ao 1
hexápode pressionar o botão fechar
repouso, Recolhendo suas pernas.
4.3 Caso de teste III: Movimentação do robô Pré - condição: O software hexapod control precisa estar aberto e conectado ao robô. Etapa Instrução
Resultado esperado
Selecionar a seta para "Cima" e 1
verificar se o movimento do robô
Apertado o botão correto o robô deve
condiz com a respectiva seta.
se movimentar para frente.
Selecionar o botão “Direito” com o
2
botão pressionado, o robô deve girar
Se o botão estiver pressionado o robô
para direita, com o botão solto o robô
deve girar para direita, se estiver solto
deve parar.
o robô deve parar.
5 Gestão Em nosso projeto utilizamos o processo em espiral. Utilizamos três ciclos no projeto: "Estudos e validações", "Desenvolvimento do código", "Montagem e integração" e "testes". O primeiro ciclo referente a parte pesquisa e estudos sobre hexápodes, seu funcionamento o que precisaríamos para seu desenvolvimento, basicamente toda a teoria para a criação do robô. No segundo ciclo foi a parte de desenvolvimento do código para o funcionamento do robô. O desenvolvimento do código para movimentação do robô e o código de estruturação da interface e funcionamento do app para android. No ciclo três foi feito a montagem do robô instalação dos motores no corpo do robô, a instalação da placas de comunicação e instalação da parte elétrica. No último ciclo efetuamos todos testes lógicos do robô o teste dos códigos em arduino e todos os testes necessários para o funcionamento da interface gráfica.
34
5.1 Escopo Nosso objetivo principal é desenvolver um robô controlado um aplicativo, utilizando conexão sem fio. No decorrer do projeto tivemos muitos problemas pelo fato de que foi o primeiro robô que fizemos. Mas os objetivos básicos propostos no início do projetos foram atendidos como esperado. Utilizamos um comunicação sem fio confiável(Bluetooth) que atendeu perfeitamente nossas necessidades. Tivemos alguns obstáculos no projeto tornando o desenvolvimento do projeto mais demorado. As peças que foram compradas para o projeto grande parte foi adquira fora do pais tornando o recebimento do produto bem demorado. No ciclos iniciais onde era preciso uma pesquisa e estudos para o desenvolvimento do robô surgiam duvidas que foram tiradas com o orientados do projeto.
35
5.2 Custo Inicialmente foi feito algumas cogitações do valor total do projeto que acreditávamos estar entre R$1000,00 a R$2000,00. No decorrer do projeto encontramos muitas dificuldades para encontrar os hardwares no Brasil, quando encontrávamos o valor estava muito acima do esperado, então foi decidido comprar as peças fora do brasil mesmo com custos de taxação o valor era menor do que o valor encontrado no Brasil. O total gasto no projeto foi R$1.910,00, um valor que foi divido entre os membros do projeto. Sabíamos que o problema de comprar fora do pais era a demora para receber tais produtos, mesmo com esse risco que poderia impactar no atrasado do projeto ariscamos e compramos fora do pais.
5.3 Análise de Riscos Durante o processo de planejamento encontramos alguns riscos que teríamos que lidar. Primeiramente um dos riscos que mais impactariam no desenvolvimento do projeto era o tempo disponível para reuniões, era preciso inicialmente ter o grupo reunido para efetuarmos reuniões para decidir vários temas do projeto. Outro grande risco era a demora que ocorreria para chegar os equipamentos no Brasil levando em conta que muitas peças viriam de navio, e mesmo chegando ao brasil ainda teria um tempo até que as peças fosse definitivamente enviadas para o endereço solicitado. Relacionado as peças ainda teríamos o risco de queima de algumas peças (motor, placas), a queima de peças em projetos eletrônicos é muito comum. Teríamos que lidar com o fator de conhecimento nas tecnologias usadas no período de estudos foi preciso a troca de conhecimentos e entendimento de cada tecnologia entre os membros do grupo.
36
6. Conclusão O objetivo do projeto foi desenvolver um robô hexápode capaz de ser controlado por um aplicativo mobile. Optamos por desenvolver um robô hexápode devido ao seu baixo custo de desenvolvimento e ao pré-conhecimento do assunto por parte de alguns membros do grupo. O robô é controlado por um aplicativo que pode ser instalado em qualquer aparelho móvel que possua o sistema android, sendo assim possível alcançar a área mobile que está em evidência atualmente. A comunicação do aplicativo com o robô é feita através da tecnologia Bluetooth, que por sua vez é encontrada em quase todos os aparelhos celulares da atualidade.Com essa tecnologia, foi possível atingir nosso objetivo com êxito. Utilizamos uma placa responsável por controlar os motores com capacidade para até 32 servos. Para sincronizar e alinhar todos os comandos recebidos pela controladora, utilizamos uma placa arduino responsável por armazenar as funções: andar, abaixar, girar, levantar. Todas as funções criadas, foram importadas para o aplicativo. O corpo do robô é feito de material ABS (material plástico), que é bastante resistente e seu layout foi adquirido através de um site que distribui gratuitamente modelos no formato 3d. As peças foram todas impressas por uma impressora 3d, o que facilitou o encaixe e alinhamento. O robô é alimentado por baterias de li-íon de 6400 mah / 8.4v, tornando possível assim a movimentação do hexápode. Como resultado foi obtido um robô capaz de se movimentar em diversos terrenos como uma mobilidade e agilidade notável. Seu corpo em formato de circunferência, faz com que o robô seja capaz de andar em diversas direções. Dentre os resultados, podemos ressaltar também a possibilidade de incorporar ao hexápode muitas outras funções como a utilização de câmera para controlar a movimentação e sensores.
37
6 Refer ên ci as B ib lio gr áfi cas
[1] - FONTOURA, Felipe Michels; NASCIMENTO, Leandro Piekarski do; GIOPPO, Lucas Longe. “Robô hexápode controlador por FPGA 2013" 161 f. Trabalho de
conclusão de Curso - Universidade tecnologia Federal do Paraná, Curitiba 2013. Retirado de: http://repositorio.roca.utfpr.edu.br/jspui/handle/1/954. Acesso em 20/05/2014. [2] CIÊNCIA E TECNOLOGIA, Robótica - História e Desenvolvimento da Robótica Tecnologia. Site oficial. Acessível em :. Acessado em 25/05/2014 [3] ROBOTICS. Das Máquinas Gregas á Moderna Robótica Industrial. Site Oficial. Acessível em: . Acessado em 15/05/2014 [4] BLOOKS - Asimov e os robôs. Site Oficial. Acessível em: . Acessado em 15/05/2014 [5] CITI - História da robótica. Acessível em:. Acessado em 10/05/2014 [6] BOSTON DUNAMICS - site oficial. Acessado em: 20/04/2014 [7] REIMBOLD, Manuel M.P, CAMPOS, Mauricio Campos, SAUSEN, Airam Sausen, KINA, Jonatas R.Kina, NETO, DoriavalM.Neto, "PROTÓTIPO ROBÔ HEXÁPODE PARA INSPEÇAO EM TUBULAÇÕES DE AR CONDICIONADO", GAIC-Grupo de automação industrial e Controle, Dpto. De Ciência Exatas e Engenharias, UNIJUI. Site oficial . Acessado em: 15/05/2014. [8] LYNXMOTION - Site oficial . Acessado em 28/05/2014 [9] ROBOTSHOP - COX, William Cox, "The Story of Matt Bunting and the Hexapod that Intel Bought
