TCC II - 2015 - Aloízio e Gilzan

8/17/2019 TCC II - 2015 - Aloízio e Gilzan

1/71

Faculdades Santo Agostinho - FASA

Faculdade de Ciências Exatas e Tecnológicas – FACET

Curso de Sistemas de Informação

Montes Claros - MG

2015

UTILIZAÇÃO DE APLICATIVO ANDROID PARA CONTROLE DEMECANISMO VIA ARDUINO


2/71




Montes Claros - MG

2015

ALOÍSIO TADEU DE SOUZA JÚNIORGILZAN JUNEO LEAL E SILVA

UTILIZAÇÃO DE APLICATIVO ANDROID PARA CONTROLE DEMECANISMO VIA ARDUINO

Monografia apresentada a banca examinadora,como requisito parcial para a conclusão docurso de graduação e obtenção de título deBacharel em Sistemas de Informação nas

Faculdades Santo Agostinho.

Orientador(a):Prof. Ms. Eduardo Diniz Amaral


3/71




Montes Claros, 07 de novembro de 2015

Monografia intitulada “Tema”, de autoria do(s) acadêmico(s) Nome Completo,

aprovada pela banca examinadora constituída pelo(as) seguintes professore(s)(as):

__________________________________________Prof. Ms. Eduardo Diniz Amaral (Orientador)

__________________________________________

Prof. Jaime Gomes da Silva Neto

__________________________________________Prof. Geraldo Herystarley Veloso Cruz


4/71

Dedicamos a Deus e nossos pais


5/71

AGRADECIMENTOS

Agradecemos primeiro a Deus por nos protegerem em todos os

momentos da nossa vida e aos nossos pais por sempre nos aconselharem dando

forças tanto nos momentos felizes quanto nos momentos triste.


6/71

Quando se percebe que tudo é uma

piada, ser O Comediante é a única

coisa que faz sentido.(Alan Moore)


7/71

RESUMO

A comunicação entre dispositivos eletrônicos vem desenvolvendo-se de forma cadavez mais objetiva e diversificada.A crescente popularização dos aplicativos android somado com a capacidade doarduino de prototipar novas ideias foram fundamentais para motivação destetrabalho.O objetivo geral foi a produção e a avaliação do aplicativo android que controleremotamente mecanismo arduino e que receba informações do mesmo.Este trabalho é um estudo de natureza exploratória, pois utiliza de ações práticaspara estudar e avaliar a utilização de aplicativo android para controlar mecanismo viaarduino, ocorrendo processos preliminares antes da montagem final do mecanismo.Inicialmente os componentes que constituíram o veículo foram testados e avaliadosseparadamente. Foi montado um veiculo em miniatura para comportar a estruturafinal do mecanismo arduino. Por fim foi desenvolvido um aplicativo android parapoder enviar e receber informações da placa arduino.

Palavras-chave: Android, Arduino, Aplicativo, Sensor de Ultrassom, Sensor deLuminosidade, Sensor Bluetooth, Shield Motor.


8/71

LISTA DE FIGURAS

FIGURA 1: Quantidade de pesquisas realizadas ...................................................... 11

FIGURA 2: Componentes da Plataforma arduino ..................................................... 15

FIGURA 3: Principais símbolos usados em fluxogramas .......................................... 21

FIGURA 4: Encaixe do led diretamente no arduino ................................................... 33

FIGURA 5: Montagem do circuito para led na protoboard ........................................ 34

FIGURA 6: Fluxograma que descreve o algoritmo do ultrassom .............................. 35

FIGURA 7: Fluxograma que descreve o algoritmo do ultrassom alterado ................ 36

FIGURA 8: Calculo para encontrar o valor necessário para conversão das ondas

sonoras em centímetros ............................................................................................ 37

FIGURA 9: Montagem do circuito para o sensor de ultrassom ................................. 38

FIGURA 10: Montagem do circuito para o sensor de LDR ........................................ 39

FIGURA 11: Fluxograma que descreve o algoritmo do sensor de luminosidade ...... 40

FIGURA 12: Montagem do circuito para o sensor de ultrassom e de LDR Juntos .... 41

FIGURA 13: Montagem do circuito para o sensor bluetooth ..................................... 42

FIGURA 14: Montagem dos motores na shield motor ............................................... 43

FIGURA 15: Diagrama que descreve todas interações envolvendo o arduino.......... 44

FIGURA 16: Montagem da dianteira do veículo ........................................................ 45

FIGURA 17: Montagem da dianteira do veículo finalizado ........................................ 45

FIGURA 18: Eixo de rodas com engrenagem ........................................................... 46

FIGURA 19: Montagem da parte traseira finalizada .................................................. 46

FIGURA 20: Estrutura de veículo com arduino, visão aérea ..................................... 47

FIGURA 21: Estrutura de veículo com arduino, visão dianteira ................................ 47

FIGURA 22: Estrutura de veículo com arduino, visão traseira .................................. 48

FIGURA 23: Estrutura de veículo com arduino, visão lateral direita .......................... 48

FIGURA 24:Estrutura de veículo com arduino, visão latera esquerda ...................... 49

FIGURA 25: Tela do aplicativo desenvolvido ............................................................ 50

FIGURA 26: Fluxograma do algoritmo que descreve o funcionamento do aplicativo

android ...................................................................................................................... 51

FIGURA 27: Arduino com led .................................................................................... 52


9/71

FIGURA 28: Funcionamento do led na protoboard com o arduino ............................ 52

FIGURA 29: Funcionamento do ultrassom na distância de 10 cm ............................ 53

FIGURA 30: Ampliação dos resultado da figura 29 ................................................... 54

FIGURA 31: Funcionamento do ultrassom na distância de 5 cm .............................. 55

FIGURA 32: Funcionamento do ultrassom na distância de 12 cm ............................ 55

FIGURA 33: Ampliação da figura 32 ......................................................................... 56

FIGURA 34: Estrutura do circuito LDR ...................................................................... 57

FIGURA 35: Funcionamento do LDR em ambiente claro .......................................... 57

FIGURA 36: Funcionamento do LDR em ambiente escuro ....................................... 58

FIGURA 37: Estrutura do circuito dos dois sensores juntos ...................................... 59

FIGURA 38: Funcionamento dos dois sensores em conjunto ................................... 59FIGURA 39: Resultados da figura 38 ........................................................................ 60


10/71

LISTA DE ABREVIATURAS E SIGLAS

3D: 3 Dimensões.

AC: Alternating Current (Corrente Alternada).

ADT: Android Development Tools (Ferramenta de Desenvolvimento Android).

AOSP: Android Open Source Project (Projeto Android de Software Livre).

API: Application Programming Interface (Interface de Programação de Aplicativos).

CSS: Cascading Style Sheets (Folhas de Estilo em Cascata).DC: Direct Current (Corrente Direta).

DIP: Dual In-line Package (Pacote em Linha Dupla)

EEPROM: Electrically-Erasable Programmable Read-Only Memory (Memória

Elétrica Apagável e Programável Somente de Leitura).

GND: Ground (Terra).

GPS: Global Positioning System (Sistema de Posicionamento Global).

HTC: High Tech Computer corporation.HTML: Hyper Text Markup Language (Linguagem de Marcação de Hipertexto)

IDE: Integrated Development Environment (Ambiente Integrado de

Desenvolvimento).

IBM: International Business Machines.

IOREF: Input Output References (Referencia de Entrada e Saída).

IOS: iPhone Operating System.

IT: Information Technology (Tecnologia da Informação)

JVM: Java Virtual Machine (Máquina Virtual Java)

KB: KiloByte

LDRs: Light Dependent Resistors

LED: Ligth Emitting Diode (Diodo Emissor de Luz)

mA: Miliampere.

MHZ: Megahertz.

NG: Nuova Generazione (Nova Geração).

RAM: Random Access Memory (Memória de Acesso Aleatório)


11/71

RISC: Reduced Instruction Set Computing (Conjunto de Insturções Reduzidas de

Computador)

RX: Receptor

SDK: Software Development Kit (Kit de Desenvolvimento de Software).

SPI: Serial Peripheral Interface (Interface Periférica Serial).

SQL: Structured Query Language (Linguagem de Consulta Estruturada).

SWT: Standard Widget Toolkit.

TX: Transmitter (Transmissor).

URL: Uniform Resource Locator.

USB: Universal Serial Bus.

V: Volt.VIN: Input Voltage..


12/71

SUMÁRIO

1 INTRODUÇÃO ......................................................................................................... 9

2 FUNDAMENTAÇÃO TEÓRICA ............................................................................. 13

2.1 Definição sobre arduino ................................................................................... 13

2.2 Estrutura do arduino ........................................................................................ 14

2.2.1 Atmega 328 ............................................................................................... 15

2.2.2 USB plug ................................................................................................... 15

2.2.3 Conector DC ............................................................................................. 16

2.2.4 Conectores de Alimentação ...................................................................... 16

2.2.5 Entradas e Saídas ..................................................................................... 17

2.2.6 Sensores e Shield ..................................................................................... 17

2.3 Modelos de arduino ......................................................................................... 18

2.3.1 Arduino USB ............................................................................................. 19

2.3.2 Arduino Extreme ....................................................................................... 19

2.3.3 Arduino NG ............................................................................................... 19

2.3.4 Arduino Diecimila ...................................................................................... 19

2.3.5 Duemilanove ............................................................................................ 20

2.3.6 Arduino Uno .............................................................................................. 20

2.4 Lógica e Programação ..................................................................................... 20

2.4.1 Expressões ............................................................................................... 22

2.4.2 Declarações .............................................................................................. 22

2.4.3 Bloco de declarações ................................................................................ 23

2.4.4 Bloco de funções ....................................................................................... 23

2.4.5 Linguagem de programação C .................................................................. 23

2.4.6 Linguagem de programação java .............................................................. 24

2.5 Ambiente de desenvolvimento para arduino .................................................... 26

2.6 Ambiente de desenvolvimento para android .................................................... 27

2.6.1 Eclipse ....................................................................................................... 27

2.6.2 SDK android .............................................................................................. 28

2.7 História do android ........................................................................................... 28

2.8 Arquitetura do android ..................................................................................... 29


13/71

3 TRABALHO REALIZADO ..................................................................................... 32

3.1 Visão Geral do Estudo de Caso ....................................................................... 32

3.2 Ferramentas Utilizadas .................................................................................... 32

3.3 Missão do Estudo ............................................................................................ 32

3.4 Limites e Dificuldades ...................................................................................... 32

3.5 Avaliação do dispositivo arduino e da placa protoboard .................................. 33

3.6 Configuração dos sensores ............................................................................. 34

3.7 Configurando o Bluetooth e a Shield Motor ..................................................... 41

3.8 Montagem do Veiculo em Miniatura................................................................. 44

3.9 Desenvolvimento do aplicativo android ............................................................ 49

4 RESULTADOS OBTIDOS ..................................................................................... 52

5 CONCLUSÃO ........................................................................................................ 61

REFERÊNCIAS ......................................................................................................... 64


14/71

9

1 INTRODUÇÃO

Com o avanço da tecnologia juntamente com o surgimento da mobilidadeos celulares deixaram de ser simplesmente um artefato exclusivo para ligações e

passaram a possuir vários recursos adicionais como câmeras, músicas, bluetooth,

gps, jogos, acesso a internet, interface visual e outras aplicações. O sistema

operacional android surgiu com a proposta de integrar e operar todos esses

recursos. Os aplicativos para o android são flexíveis, pois permitem que o seu

acesso seja feito por qualquer pessoa, em qualquer momento e em qualquer lugar

do mundo desde que possua um dispositivo compatível: smartphones, tablets,wearables, televisores etc. Isso implica em alcance global, útil e de baixo custo, já

que se trata de um sistema operacional gratuito. Segundo Lecheta (2013), estudos

mostram que atualmente mais de 3 bilhões de pessoas possuem um aparelho

celular. Isso equivale aproximadamente a metade da população do planeta.

Um dos efeitos gerados pelos novos modelos de celulares é a

possibilidade de interligar outros objetos a ele. O arduino é uma plataforma que se

destaca por facilitar a criação de objetos inteligentes, capazes de interagir commuitos outros dispositivos, assim como um aparelho portador de aplicativos android.

O arduino é uma plataforma de protótipos eletrônicos de código e

hardware aberto sendo ambos baseados em flexibilidade. Um dos fatores que

influenciaram na escolha desta placa é o seu valor acessível em montar ou adquirir

uma placa pronta. Isto permite que os desenvolvedores ingressem nessa área sem

precisar desembolsar valores exorbitantes.

Apesar do arduino ser um dispositivo que pode ser conectado a varias

outras plataformas, um problema notoriamente observado é a maneira na qual essa

comunicação será realizada. A escolha da linguagem de programação para o

desenvolvimento do aplicativo android para melhor realizar essa interação também é

um fator importante, pois, a plataforma arduino utiliza a linguagem C.

As plataforma arduino lançada em 2005 e o android fundado em 2003 e

lançado em 2008, estão em grande ascensão no meio tecnológico. Impulsionado

pelo crescimento de ambos, este trabalho realiza estudos sobre a integração da

plataforma arduino com o sistema operacional android remotamente.


15/71

10

Utiliza-se o sistema operacional android por ser uma plataforma para

aplicações móveis completamente livre e de código aberto. Seus recursos visuais

possuem ótimas funcionalidades, permitindo ao usuário navegar por telas por meio

de touch screen.

Segundo Lecheta (2013) é possível desenvolver uma aplicação para o

android utilizando a linguagem java em ambiente de desenvolvimento eclipse, basta

adicionar um plug-in chamado Android Development Tools (ADT). Utilizando o ADT

é possível emular um dispositivo android diretamente do eclipse. Consequentemente

a linguagem java é a mais indicada para esse trabalho.

Ainda existem outras duas razões pela escolha da linguagem java.

Primeiro é a linguagem de computador mais usada no mundo (Schild e Skrien,2013). Em segundo lugar, seus recursos são projetados e implementados de uma

maneira mais clara para avaliar o código de programação.

QUADRO 1

Linguagens de programação mais usadas entre os profissionais de informática

Colocação Linguagem de programação

1º JavaScript2º Java3º PHP4º Python5º C#, C++, Ruby

Fonte: Adaptado de RedMonk, 14/01/2015

Outro objeto de estudo deste trabalho é a plataforma arduino. É destinada

a artistas, designers, hobbistas e qualquer pessoa interessada em criar objetos ou

ambientes interativos. Além da placa, o arduino conta com uma IDE que pode ser

baixada gratuitamente da internet e permite a programação do dispositivo utilizandoa linguagem C. O arduino conta ainda com uma intensa e ampla comunidade ao

redor do mundo que troca informações e permite a popularização da plataforma.

A escolha pelo arduino se deu por sua crescente popularização e pelo

aumento das pesquisas no site do Google.


16/71

11

FIGURA 1: Quantidade de pesquisas realizadas no google pela plataforma arduino.

Fonte: Google Trends, 2015

O arduino pode sentir o estado do ambiente que o cerca por meio darecepção de sinais de sensores e pode interagir com os seus arredores, controlando

luzes, motores e outros atuadores. Segundo o site oficial Arduino.cc (2015) a

plataforma rendeu um documentário em 2010 por alcançar uma marca de vendas de

50 mil unidades em apenas 5 anos.

Estudos sobre android e arduino são bem recentes e as matérias

publicados ainda são poucos. Este trabalho pretende com os resultados dos estudos

incentivar novas pesquisas de interação entre os dois e instigar a ideia de novosprodutos que podem ser gerados com essa combinação.

O trabalho visou o estudo e construção de um veículo em miniatura

movido a motor elétrico e constituído da plataforma arduino, juntamente com os

sensores de ultrassom e luminosidade. Esse veículo foi controlado por um aplicativo

android. A comunicação entre o dispositivo android e a plataforma arduino foi feito

por intermédio de um sensor bluetooth. Os sensores acoplados no veículo enviavam

informações, que eram apresentados pelo aplicativo android.O presente trabalho possui como objetivo geral produção e avaliação de

um aplicativo android que controle remotamente mecanismo arduino e que receba

informações do mesmo.

Assim, buscando compreender tais problemáticas, bem como propor e

esclarecer possibilidades, esse trabalho visa construir um veículo em miniatura para

avaliar e descrever a interação entre o aplicativo android e a plataforma arduino.

Para atingir o objetivo geral foram considerados os seguintes objetivos

específicos:


17/71

12

Estudar a programação e as funcionalidades da plataforma arduino;

Desenvolver códigos de programação para operar sensores conectados ao

arduino;

Desenvolver aplicativo android;

Realizar a comunicação entre a plataforma arduino e o aplicativo android;

Explorar e conectar veículo motorizado em miniatura com placa arduino.

Este foi um trabalho de natureza exploratória, pois envolve pesquisa

prática com o problema levantado. Também ocorrem análises dos processos

executados para compreender os objetivos.

No primeiro capitulo é apresentado uma introdução sobre o projeto,

fazendo uma descrição geral do trabalho, juntamente com a justificativa,

identificando o problema, os objetivos gerais e específicos a serem alcançados. O

terceiro capitulo apresenta a fundamentação teórica onde são abordados conceitos

básicos sobre arduino, android, eletrônica e programação.

O quarto capitulo remete aos trabalhos realizados que explica toda a

metodologia e os processos utilizados no trabalho.

O quinto capitulo apresenta os resultados obtidos coletados a partir dos

trabalhos realizados. Por ultimo o quinto capítulo apresenta as conclusões finaisdesse trabalho.


18/71

13

2 FUNDAMENTAÇÃO TEÓRICA

Para a elucidação dos conhecimentos necessários para a realizaçãodeste trabalho foram feitos estudos fundamentados na definição sobre arduino,

estrutura do arduino, modelos de arduino, linguagem de programação para arduino,

ambiente de desenvolvimento para arduino, história do sistema operacional android,

arquitetura do sistema operacional android, linguagem de programação java e

ambiente de desenvolvimento de aplicativos android.

2.1 Defin ição sobre arduino

Observa-se uma predisposição cada vez maior da inserção de inteligência

computacional nos equipamentos do dia a dia. Esses dispositivos possuem

microprocessadores no qual o computador é completamente encapsulado ou

dedicado ao equipamento que está inserido (CUNHA, 2015).

Os sistemas embarcados são dispositivos que possuem memória,

processador e interface de entrada e saída, sendo responsáveis em gerar

inteligência computacional a equipamentos (EMBEDDED, 2015).

O micro controlador é o principal componente do sistema embarcado, pois

segundo a ROBÓTICA LIVRE (2015), são circuitos integrados programáveis que

possui arquitetura de um microcomputador, porém baseado numa arquitetura RISC

(Reduced Instruction Set Computing), ou seja conjunto de instruções de computação

reduzida.

Arduino é um micro controlador de computação física com código aberto

baseado em uma simples placa com entradas e saídas. Foi desenvolvida na Itália

com intuito educacional. Também possui um ambiente de desenvolvimento que

implementa a linguagem C. Esse ambiente de desenvolvimento é multiplataforma

podendo criar as rotinas para Windows, Linux e Mac OS X. Sua linguagem de

programação é desenvolvida sobre uma biblioteca que simplifica a escrita da

programação em C/C++ (ARDUINO, 2015).


19/71

14

O hardware é livre, ou seja, está disponível para todos, legalmente,

baixarem o esquemático da internet e fazer a sua própria placa, sem ter que pagar

direitos autorais (THOMPSOM, 2008).

A plataforma arduino permite que qualquer pessoa possa trabalhar com

microcontroladores de forma simples. Os detalhes confusos e complexos de

programação desses componentes ficam alocados em um pacote chamado easy-to-

use (fácil de utilizar), oferecendo grande vantagem a professores, estudantes e até

pessoas que não possuem conhecimentos, mas que são interessados em sistemas

eletrônicos (ARDUINO, 2015). Outro ponto forte do arduino é em relação ao fácil

acesso, pois são relativamente baratos em comparação com outras plataformas de

microcontroladores (ARDUINO BR, 2015).

2.2 Estrutura do arduino

Segundo Gomes e Tavares (2015), o arduino consiste, por definição, em

um micro controlador de placa única e um conjunto de software para programá-lo. O

hardware é composto de um processador Atmel AVR, um cristal oscilador e um

regulador linear de 5 volts. A placa expõe os pinos de entrada e saída em um

encaixe padrão para que se possa conectar circuitos externos que agregam novas

funcionalidades.


20/71

15

FIGURA 2: Componentes da plataforma arduino

Fonte: Arduino, 2015

2.2.1 Atmega 328

O componente principal da placa arduino é o componente ATMEL atmega

328, um dispositivo de 8 bits da família AVR com arquitetura RISC avançada e com

encapsulamento DIP28. Ele conta com 32 KB de Flash (mas 512 Bytes são

utilizados pro bootloader ), 2 KB de RAM e 1 KB de EEPROM. Pode operar a até 20

MHz, porém a placa arduino opera em 16 MHz, valor do cristal externo que está

conectado aos pinos 9 e 10 do micro controlador (ARDUINO, 2015).

2.2.2 USB plug

A placa pode ser alimentada pela conexão USB e com o micro controlador

ATMEL que faz a comunicação com o computador (ARDUINO, 2015).


21/71

16

2.2.3 Conector DC

A alimentação externa é feita através do conector DC com regulador detensão, onde o valor de tensão da fonte externa deve estar entre os limites 6 V a 20

V (ARDUINO, 2015).

2.2.4 Conectores de Alimentação

O arduino pode ser alimentado pela conexão USB ou com uma fonte

externa. A entrada de alimentação é selecionada automaticamente. A alimentação

externa (não USB) pode vir de um adaptador AC-DC ou de uma bateria. O

adaptador pode ser conectado através de um plug de 2,1 milímetros de centro

positivo, no conector de energia da placa. A alimentação é feita através de uma

bateria ou por meio de pinos (ARDUINO, 2015). Os pinos são os seguintes:

IOREF: Fornece uma tensão de referência para que shields possam

selecionar o tipo de interface apropriada, dessa forma shields que funcionam

com a placas arduino que são alimentadas com 3,3 V. podem se adaptar para

ser utilizados em 5 V. e vice-versa (ARDUINO, 2015);

Reset: Pino conectado a pino de Reset do micro controlador. Pode ser

utilizado para um reset externo da placa arduino (ARDUINO, 2015);

3,3 V: Fornece tensão de 3,3 V. para alimentação de shield e módulos

externos. Corrente máxima de 50 mA (ARDUINO, 2015);

5 V: Fornece tensão de 5 V para alimentação de shields e circuitos externos.

GND: Estes dois pinos são conhecidos como terra, responsáveis por fechar o

circuito (ARDUINO, 2015);

VIN : Pino para alimentar a placa através de shield ou bateria externa.

Quando a placa é alimentada através do conector, a tensão da fonte estará

nesse pino (ARDUINO, 2015).


22/71

17

2.2.5 Entradas e Saídas

A placa arduino possui pinos de entrada e saídas digitais, assim comopinos de entradas e saídas analógicas (ARDUINO, 2015).

2.2.6 Sensores e Shield

A placa arduino pode ser incrementado com acessórios inteligentes,

denominados sensores ou shields. Esses acessórios ampliam as funcionalidades da

placa, assim se adaptando a vários projetos diferentes (BR-ARDUINO, 2015).

2.2.6.1 Sensor de Ultrassom

Sensores de ultrassom são sensores que utilizam ondas sonoras paramedir a distância entre o sensor e algum objeto. São uma boa opção para medir

distâncias sem entrar em contato direto com o objeto e são largamente utilizados na

robótica e também na indústria (ROBÓTICA LIVRE, 2015).

2.2.6.2 Sensor de Luminosidade LDR

Segundo o INSTITUTO NEWTON C BRAGA (2014) Os LDRs ou Light

Dependent Resistors, também conhecidos como foto-resistores e células de sulfeto

de cádmio são sensores do tipo foto condutivo. Neles, a resistência apresentada à

passagem de uma corrente elétrica depende da quantidade de luz que incide numa

superfície sensível à base de Sulfeto de Cádmio ou CdS. Resumindo o LDR é um

componente eletrônico, sensível a luz, que tem por finalidade limitar a corrente


23/71

18

elétrica que passa sobre ele, como um resistor comum, só que o grande diferencial é

que ele é um resistor variável que interage com a luz.

2.2.6.3 Sensor Bluetooth

“Bluetooth é o nome dado a um protocolo de rádio, baseado em saltos em

frequência de curto alcance, que visa substituir os cabos de conexão existentes por

uma conexão universal, sem fio, de maneira robusta, barata e de baixo consumo”

(PETERS, 2015).

2.2.6.4 Shield Motor

Segundo ARDUINO (2015), a shield motor possui dois chips L293D, cada

um composto por 2 pontes H, além de um CI 74HC595. Tudo isso para controlar até

4 motores DC, 2 Servos (alimentados por 5v) ou 2 motores de passo. Lembrando

que a corrente máxima suportada por cada L293D é de 600 mA, com picos de 1.2A.

2.3 Modelos de arduino

Existem várias placas arduino no mercado e sendo possível até mesmoconstruí-las domesticamente. Posteriormente será apresentado a linha de evolução

da plataforma arduino uno, a qual será utilizada neste trabalho (ARDUINO 2015).


24/71

19

2.3.1 Arduino USB

O Arduino USB foi a primeira placa rotulado como " Arduino". Estes foram

muito vendidos separadamente como kits. A primeira versão tinha uma pinagem

incorreta para o conector USB (ARDUINO 2015).

2.3.2 Arduino Extreme

O Arduino Extreme possui uma maior quantidade de superfície de

ligações de componentes do que as placas Arduino USB e vem com pinagem

headers do sexo feminino. Ele também tem RX e TX LEDs que indicam quando os

dados estão sendo enviados para ou a partir da placa (ARDUINO 2015).

2.3.3 Arduino NG

O Arduino NG usa o USB-to-Serial conversor FTDI FT232RL, que exige

menos componentes externos que o FT232BM. Ele também tem um built-in LED no

pino 13 (que pode interferir com a comunicação SPI) (ARDUINO 2015).

2.3.4 Arduino Diecimila

A principal mudança no Arduino Diecimila é que ele pode ser reposto a

partir do computador, sem a necessidade de pressionar fisicamente o botão de reset

na placa. O Diecimila usa um regulador de tensão de abandono baixa, o que reduz o


25/71

20

consumo de energia da placa quando alimentado por uma fonte externa (adaptador

AC / DC ou bateria) (ARDUINO 2015).

2.3.5 Duemilanove

O Duemilanove seleciona automaticamente a fonte de alimentação

adequada (USB ou fonte de alimentação externa), eliminando a necessidade do

jumper de seleção de energia (ARDUINO 2015).

2.3.6 Arduino Uno

"Uno", significa o numeral um em italiano e é nomeado para marcar o

lançamento do Arduino 1.0. O Uno e versão 1.0 são as versões de referência do

arduino. O Uno é o mais recente de uma série de placas Arduino USB. Esta é a mais

recente revisão da placa USB básico Arduino. Ele se conecta ao computador com

um cabo USB padrão e contém tudo que é necessário para programar e usar a

placa. Ele pode ser estendido com uma variedade de shields, extensões

personalizadas de placas com características específicas (ARDUINO 2015).

2.4 Lógica e Programação

“O processo de definir as instruções que o computador deve executar é

conhecido como programação” (JAMSA, 1998). Toda linguagem de programação é

construída a partir das expressões, declarações, bloco de declarações e bloco de

funções (PURDUM, 2012).

Algoritmo é o procedimento para resolver um problema, definido por uma

sequência finita e ordenada de etapas executáveis (PEREIRA, 2010).


26/71

21

Para descrever as etapas que precisam ser efetuadas para que o

programa execute as tarefas que lhe são designadas utiliza-se algoritmos

(TECMUNDO, 2015).

Os fluxogramas apresentam os algoritmos de forma gráfica. A

representação de algoritmo por meio de fluxograma possuem uma série de

vantagens sendo a mais importante a facilidade gerada para a compreensão do

funcionamento do algoritmo, mesmo para os leigos (MEDINA e FERTIG, 2006).

Num fluxograma as etapas da programação são representados por

símbolos e a ordem de execução dessas etapas são representadas por setas

conectando os símbolos. Cada símbolo pode possuir uma anotação indicando sua

finalidade específica (PEREIRA, 2010).

FIGURA 3: Principais simbolos usados em fluxogramas

Fonte: Pereira, 2010


27/71

22

2.4.1 Expressões

“Conjunto de variáveis e constantes numéricas que se relacionam por meio deoperadores compondo uma fórmula que, uma vez avaliada, resulta em um valor”

(SOUZA, 2013). Variável é uma posição de memória cujo conteúdo pode ser

modificado durante a execução de um programa (ACTIVE INFO, 2015). A referência

a uma variável no programa é feita através do seu identificador; os valores que

podem ser nela armazenados dependem do seu tipo de dado (EVARISTO, 2001).

Constante numérica é uma posição na memória que armazena um valor que não é

alterado. Os operadores são ações matemáticas ou lógicas que estão presentes nomínimo uma ou várias vezes na expressão (PURDUM, 2012). Segue exemplos:

A + b (variável, operador matemático, variável);

5 + b - 3 (constante numérica, operador matemático, variável, operador

matemático, constante numérica);

a > d > 4 (variável, operador lógico, variável, operador lógico, constante

numérica);

w > c + 5 (variável, operador lógico, variável, operador lógico, constantenumérica).

2.4.2 Declarações

São valores ou expressões atribuídos a uma determinada variável. Utiliza-

se o símbolo de igualdade ( = ) para representar o operador de atribuição

(PURDUM, 2012). Possui a função de armazenamento de dados gerados pelo

próprio programa, alterações no conteúdo de variáveis e determinações de

resultados finais de um processamento são realizados através do comando de

declaração, que deve ser escrito com a seguinte sintaxe (EVARISTO, 2001).

Identificador de variável = expressão.


28/71

23

2.4.3 Bloco de declarações

São aglomerados de declarações agrupadas para serem vistas pelocompilador como se fossem uma única instrução (KUTTI, 2002).

Os blocos de declarações começam com uma chave de abertura ( { ) e

finaliza com uma chave de fechamento ( } ). Todas as declarações entre a abertura e

fechamento de chaves formam o corpo do bloco de declaração (PURDUM, 2012).

2.4.4 Bloco de funções

Desde que as primeiras linguagens de programação foram desenvolvidas,

houve um considerável avanço em termos de facilitação para que os programadores

pudessem escrever mais rapidamente o programa (SOUZA, 2013). Todo programa é

basicamente um conjunto de funções. Uma função tem um nome e argumentos

associados, e é composta por declarações de variáveis e blocos de comandos,

incluindo possivelmente chamadas a outras funções (KUTTI, 2002).

Um bloco de função é um conjunto de funções que é projetado para

realizar as tarefas da programação. Normalmente são desenvolvidos para criar

"caixas-pretas", em que os detalhes da escrita são enterrados na função. (PURDUM,

2012).

2.4.5 Linguagem de programação C

A linguagem C foi criada em 1972 e implementada em um computador

DEC PDP-11 por Dennis Ritchie no Bell Laboratories (CASAVELLA, 2015). C é o

resultado de um processo de desenvolvimento entre as linguagens Algol 68 e BCPL.

O BCPL também influenciou a linguagem B que por sua vez também contribuiu para

a linguagem C (JAMSA e KLANDER, 1998).


29/71

24

Considerada como uma linguagem de médio nível pois combina

elementos de alto nível com a funcionalidade das linguagens de baixo nível. A

característica principal da linguagem é ser estruturada, ou seja,

compartimentalização do código e dos dados (JAMSA e KLANDER, 1998).

Um programa típico no arduino consiste basicamente em duas funções, o

“void setup()” e a função “void loop()”, também existem inúmeras outras funções que

executam a leitura/escrita dos pinos digitais e analógicos (EVANS, 2007).

A função setup marca o ponto de partida para todos os programas em C

para arduino. Enquanto o programação C padrão inicia a execução do programa

pela função denominada main() já na programação C para arduino utiliza-se o

setup() (PURDUM, 2012). No arduino a função setup() é chamada no momento emque o programa começa. É usada para inicializar variáveis, definir os modos de

entrada ou saída dos pinos e indicar bibliotecas. Essa função é executada somente

uma vez, quando o arduino é iniciado ou quando é reinicializado (ARDUINO, 2015).

Se for preciso usar o setup() uma segunda vez, então será necessário

pressionar o botão de reset na placa arduino. O botão reset suspende a execução

atual do programa e o reinicia chamando o setup() (PURDUM, 2012).

A função loop() faz precisamente o que seu nome indica: ela repete-secontinuamente permitindo que o programa funcione dinamicamente. É utilizada para

controlar de forma ativa a placa (ARDUINO, 2015).

2.4.6 Linguagem de programação java

Desenvolvida pela Sun Microsystems em 1991 com o nome de Oak sendo

em 1995 renomeada para Java. Ela herda sua sintaxe da linguagem C e seu modelo

de objetos adaptado do C++ (SCHILDT e SKRIEN, 2013).

Java é uma linguagem de programação orientada a objetos e portável

entre diferentes plataformas e sistemas operacionais (DEITEL e DEITEL, 2003).

Esta portabilidade é obtida pelo fato da linguagem ser interpretada, ou

seja, o compilador gera um código independente de máquina chamado byte-code.


30/71

25

No momento da execução este bytecode é interpretado por uma máquina virtual

instalada no dispositivo (SCHILDT e SKRIEN, 2013).

Aplicação é o software mais geral escrito na linguagem Java. Não requer

um browser para sua execução (CAELUM, 2015).

O sistema operacional android não possui uma máquina virtual java (JVM)

e sim uma máquina virtual chamada Dalvik que é otimizada para a execução de

dispositivos móveis (LECHETA, 2013).

No android os bytecodes são convertidos para o formato Dalvik

Executable (.dex), em seguida os demais recursos são compactados chamado

Android Package File (.apk), que representa a aplicação final (LECHETA, 2013).

2.4.6.1 Activi ties do java andro id

Forma visível e proeminente de uma aplicação android. Uma activity

apresenta os elementos da interface com o usuário. Uma aplicação pode conter uma

ou varias activities. No entanto elas trabalham juntas para gerar uma experiência

coesa ao usuário (ANDROID, 2015).

2.4.6.2 Services do java android

Entende-se como service a parte da aplicação que não possui interação

com o usuário (IBM, 2015). Um service é um componente que roda em segundoplano para executar operações de longa execução ou executar trabalhos para

processos remotos (ANDROID, 2015).


31/71

26

2.4.6.3 Content providers do java andro id

O Content Provider é o mecanismo android para a abstração doarmazenamento de dados, agindo como servidor de banco de dados (IBM, 2015).

Ele gera um conjunto compartilhado de dados de aplicativos (ANDROID, 2015). As

operações para ler e gravar conteúdo de um armazenamento de dados específico

deve ser passado através de um Content Provider apropriado, em vez de acessar

um arquivo ou um banco de dados diretamente (IBM, 2015). Através do Content

Provider , outros aplicativos podem consultar ou mesmo modificar os dados, caso

possuam as informações adequadas (ANDROID, 2015).

2.4.6.4 Broadcast receivers do java android

O broadcast receiver é um componente da aplicação que recebe pedido

para processar intentos, normalmente não possui interação com o usuário (IBM,

2015). Possui a função de responder às mensagens de transmissão de todo o

sistema. Podem criar uma notificação visível ao usuário para informar um evento de

transmissão (ANDROID, 2015).

2.5 Ambiente de desenvolvimento para arduino

Originário do inglês Integrated Development Environment (IDE), é um

software que reúne características e ferramentas de apoio ao desenvolvimento de

software com o objetivo de agilizar este processo (JAMSA e KLANDER, 1998).

O IDE para arduino possui um código aberto e faz com que seja fácil de escrever

instruções e enviá-los para a placa arduino. Ele roda em Windows, Mac OS X e

Linux. O ambiente é escrito em Java e baseado em processamento e em outros

softwares de código aberto (ARDUINO, 2015).


32/71

27

O Conjunto de instruções para arduino é conhecido como sketch. Os

sketchs criados são salvos pela IDE com extensão .pde (WARREN, ADAMS e

MOLLE, 2011).

A parte superior da IDE possui uma barra de ferramenta com ícones para

tarefas comuns. Nesta barra estão os botões de compilar, parar, novo, abrir, salvar,

enviar e monitor (ARDUINO,2015).

O ambiente arduino pode ser alargado através da utilização de

bibliotecas, assim como a maioria das plataformas de programação. Bibliotecas

oferecem funcionalidade extra para uso dos sketches. Um número de bibliotecas já é

natural da IDE, mas pode-se fazer o download ou criar a própria biblioteca

(WARREN, ADAMS e MOLLE, 2011).

2.6 Ambiente de desenvolvimento para android

2.6.1 Eclipse

Desenvolvido pela empresa IBM (International Business Machines), em

novembro de 2001 A empresa investiu cerca de 40 milhões de dólares para o

desenvolvimento de uma IDE de código aberto e de grande usabilidade. Ao longo do

tempo, o Eclipse tornou-se uns dos IDEs mais utilizados no mundo, especialmente

por utilizar SWT (The Standard Widget Toolkit) como biblioteca gráfica. (IBM, 2015).

Uma das grandes propriedades do Eclipse é o desenvolvimento baseado

em plugins. O projeto Eclipse foi e continua sendo um projeto tão grandioso que em janeiro de 2004 foi criado uma fundação sem fins lucrativos com membros que

fazem o suporte do projeto Eclipse, a The Eclipse Fundation, e fornece em geral

quatro serviços à comunidade Eclipse: IT (Information Technology) Infrastructure -

que fornece aos usuários e projetistas do Eclipse uma tecnologia evolutiva e segura;

Intellectual Property Management - que coordena a propriedade intelectual do

software, gerencia os serviços e a comercialização do mesmo; Development

Community Support - que contribui de maneira direta com melhorias nodesenvolvimento do software; e Ecosystem Development - onde a Fundação


33/71

28

promove reuniões, conferências e afins para promover toda a comunidade Eclipse

(ECLIPSE, 2015).

De acordo com Schildt e Skrien (2013) o eclipse é uma ferramenta IDE

(integrated development environment) que compreende vários tipos de linguagem e

que aceita a instalação de plugins para emular o desenvolvimento da plataforma.

Objetivo do Eclipse é desenvolver o mais rápido possível através do

arrastar-e-soltar do mouse, onde montanhas de código são gerados em background

e uma IDE auxiliando no desenvolvimento. (CAELUM, 2015).

2.6.2 SDK android

O SDK é uma sigla usada para o termo Software Development Kit, é um

pacote de ferramentas, cabeçalhos e bibliotecas que possibilita aos programadores

desenvolverem aplicações para sistema android, IOS, Iphone também muito

utilizado para complemento de Sistemas operacionais e alguns programas dentre

eles o Netbeans, Windows (LECHETA, 2013).

De acordo com Stark e Jepson (2012) o SDK contém ferramentas e

códigos para desenvolver aplicações nativas, o que significa que a SDK permite o

desenvolvimento, instalação, execução e testes das aplicações no simulador android

e também nos aparelhos. As duas forças que movem as aplicações nativas são o

Objective-C.

Segundo Lecheta (2013), o android SDK e o software utilizado para

desenvolver aplicações no android que tem um emulador para simular o celular.

Ferramentas utilitárias e uma API completa para a linguagem java. Com todas as

classes necessárias para desenvolver aplicações.

2.7 História do android

Segundo a Maia (2013) o android foi fundado por Andy Rubin, Rich Miner,Nick Sears e Chis White em 2000. Foi totalmente baseado no sistema Linux tendo


34/71

29

código livre para alterações. Depois de dois anos o android se tornou um sistema da

Google, adquirida em 2005 e conduzida por Andy Rubin. O mesmo desenvolveu

uma plataforma para telefones moveis que poderia ser utilizada em celulares e

tablets. O primeiro Android Beta SDK foi liberado em 2007 sendo todos os softwares

para desenvolvimento e as aplicações, gratuitas.

O primeiro aparelho com o sistema android foi o HTC Dream lançado em

22 de outubro de 2008 com o android 1.0 nativo, sua primeira atualização foi

lançada apenas para o aparelho T-Mobile G1 em 2009 aos poucos o android foi se

aprimorando e ganhando novas versões e ganhando cada vez mais mercado

(ANDROID, 2015). O sistema android tem atualmente 9 versões que são o Donut

1.6, Eclair 2.0, Froyo 2.2, Gingerbread 2.3, Honeycomb 3.0, Ice Cream Sandwich 4.0, Jelly Bean 4.1, Kit Kat 4.4 e a versão atual Lollipo 5.0 (MERCATO, 2014).

O android é um software open-source criado para os celulares e outros

dispositivos. O android Open Source Project (AOSP), liderado pelo Google, está

encarregado da manutenção e desenvolvimento do android. Muitos fabricantes de

dispositivos trouxeram ao mercado de dispositivos rodando o android, e eles são

disponíveis ao redor do mundo. O objetivo principal foi construir uma plataforma de

software excelente para usuários de todos os dias. Uma série de empresas juntamente com engenheiros desempenharam para atingir esse objetivo, e o

resultado foi uma produção total de produtos de consumo de qualidade, cuja fonte é

aberta para customização e portabilidade (LECHETA, 2013).

2.8 Arquitetura do android

A arquitetura do sistema operacional android e dividida em camadas,

onde cada parte e responsável por gerenciar os seus respectivos processos.

(LECHETA, 2013). Sua arquitetura e dívida em várias camadas que são vários

programas agrupados sendo eles Applications, Application Framework, Libraries e

Android Runtime; e Linux Kernel (ANDROID, 2015).

Na camada Linux Kernel está localizado o sistema operacional da

plataforma, que é baseado no Linux. Ela é responsável por serviços de mais baixo


35/71

30

nível da plataforma, como gerenciamento de memória e processos, segurança, etc.

(TOSIN, 2011).

Na camada Libraries estão as bibliotecas nativas escritas em C/C++ que

fazem parte da plataforma. Estão nesta camada APIs como o OpenGL ES (para

renderização 3D), SQLite (gerenciador de bancos de dados) e suporte a diversos

formatos de áudio e vídeo. (TOSIN, 2011).

A camada Android Runtime dá condições para que as aplicações

baseadas na plataforma sejam executadas. Um dos componentes desta camada são

as core libraries, que disponibilizam uma API Java utilizada para programação

(grande parte das funcionalidades encontradas no Java SE estão disponíveis para o

Android). Já o outro componente é a Dalvik Virtual Machine, que é uma máquinavirtual para suporte à execução de aplicações. (ANDROID, 2011).

Na camada Application Framework ficam as APIs do android que são

normalmente utilizadas pelas aplicações que executam sobre a plataforma. Os

gerenciadores de serviços de telefonia, localização e notificação são alguns

exemplos do que este framework disponibiliza. (TOSIN, 2011).

Por fim, a camada Applications representa as aplicações que executam

sobre a plataforma. Elas podem ser tanto aplicações nativas - como o gerenciadorde contatos, navegador, calendário, etc. - como aplicações criadas por terceiros.

Aliás, para o android não existe distinção entre aplicações nativas e aplicações

desenvolvidas por outras pessoas, e é esta característica que garante a ela o alto

grau de flexibilidade e extensibilidade da plataforma. (ANDROID, 2011).

A arquitetura web mobile android consiste basicamente em uma aplicação

web (hospedada em um servidor) que será acessada através do navegador

(browser ) dos dispositivos móveis. Seguindo esta abordagem, há as arquiteturasdistribuída e centralizada (BUDEL, BARBARA e MOLOSS, 2011).

Em seguida a arquitetura nativa consiste em aplicações elaboradas para

executar no ambiente do dispositivo móvel. Sendo assim precisam respeitar as

regras desse ambiente. Executando nativamente, dentro do dispositivo, as

aplicações conseguem acessar todos os recursos desses aparelhos, como por

exemplo: GPS, câmera, acelerômetro, lista de contatos, etc. Consequentemente

abre-se um leque muito grande de possibilidades para o desenvolvimento de

aplicações, muito mais ricos e dentro desta linha são abordadas as arquiteturas para


36/71

31

os ambientes dos sistemas operacionais android e iOS. Também é apresentada a

arquitetura PhoneGap, uma alternativa para simplificar o desenvolvimento nesses

ambientes (BUDEL, BARBARA e MOLOSS, 2011).

O termo arquitetura híbrida propõem um aplicativo que é desenvolvido em

sua maior parte utilizando tecnologias web como HTML5, CSS3 e Javascript mas

que é acessado como um aplicativo nativo, podendo ou não utilizar recursos vindos

da internet ou dispositivo. Já o aplicativo nativo utiliza a tecnologia de suporte do

framework da plataforma, no caso do android, Java (MENDES, GARBAZZA e

TERRA, 2014).


37/71

32

3 TRABALHO REALIZADO

3.1 Visão Geral do Estudo de Caso

O estudo realizado tem por finalidade estudar a interação da placa

arduino com aplicativo android, assim como analisar o uso de sensores na placa.

3.2 Ferramentas Utilizadas

As ferramentas utilizadas têm a função de construir o veículo em

miniatura e produzir o aplicativo para dispositivo android.

As ferramentas utilizadas são: arduino uno R3, sensor ultrassom HC-

SRO4, sensor ldr, protoboard de 830 furos, jumpers, cabo usb, sensor bluetooth,

shield motor, dois motores de passo, leds, plataforma de desenvolvimento eclipse e

plataforma de desenvolvimento arduino sketch. Todo o equipamento previamentetestado e funcionando corretamente.

3.3 Missão do Estudo

Analisar os processos executados para a construção de um veículo em

miniatura utilizando arduino. Desenvolver aplicativo android que possa interagir com

o mecanismo montado.

3.4 Limites e Dificuldades

Os equipamentos utilizados possuem limitações observadas durante todoo processo. O bluetooth usado para a comunicação possui um alcance muito curto,


38/71

33

de acordo com o observado durante o trabalho seria algo em torno de um raio de 5

metros.

O sensor de ultrassom possui um alcance entre 2cm e 400cm e

revestimentos acústicos podem atrapalhar o funcionamento do sensor.

Dificuldade de encontrar o material para o desenvolvimento do trabalho

na região, sendo necessário fazer o pedido para fornecedores distantes ou

reaproveitando peças de aparelhos inutilizados.

A bateria de alimentação, 9 volts, utilizado para fornecer energia ao

veiculo em miniatura possui curta duração, gerando alimentação para o correto

funcionamento por um curto período de tempo.

3.5 Avaliação do dispositivo arduino e da placa protoboard

Utilizando da linguagem de programação C no Arduino Sketch configurou-

se o pino digital 13 do dispositivo arduino para receber um led que ascende por um

segundo e apaga por um segundo continuamente. Um led foi ligado a placa com o

catodo no pino terra (GND) e o anodo no pino digital 13, figura 4.

FIGURA 4: Encaixe do led diretamente no arduino

Fonte : Própria


39/71

34

Posteriormente conectou-se dois jumpers em uma protoboard ao arduino

(ligou-se um jumper ao GND do arduino com a primeira coluna da linha B do

protoboard e o outro jumper ao pino digital 13 do arduino com a segunda coluna da

linha B, conforme) e transferindo o led que estava no arduino para a protoboard

(catodo na primeira coluna da linha D e o anodo na segunda coluna da linha D),

conforme a figura 4 e verificou-se o funcionamento do mesmo.

FIGURA 5: Montagem do circuito para led na protoboard

Fonte : Própria

3.6 Configuração dos sensores

Inicialmente foram avaliados os sensores separadamente. O primeiro

sensor a ser testado foi o de ultrassom. No Android Sketch configurou-se a porta

digital 12 para o trig do sensor (onde ocorrerá a saída do sinal), a porta digital 13


40/71

35

para o echo (onde ocorrerá a leitura do sinal) e por fim o calculo para transformar o

sinal em centímetro que. O resultado final do calculo foi impresso pela placa. Em

seguida modificou-se a programação para imprimir somente valores menores que

20cm.

FIGURA 6: Fluxograma que descreve o algoritmo do ultrassom

Fonte : Própria


41/71

36

FIGURA 7: Fluxograma que descreve o algoritmo do ultrassom alterado

Fonte : Própria

Para desenvolver o calculo de transformação do sinal para distancia,

primeiro calculou a velocidade do som no ar em centímetros que foi de 34000 cm/s.

Depois calculou-se quantos milissegundos o som leva para percorrer um centímetro

chegando ao resultado de 29,4 ms, então multiplicou-se o resultado por dois devido

o sinal fazer o percurso de ida e de volta obtendo um valor de 58,8 ms conforme a

figura 8.


42/71

37

FIGURA 8: Calculo para encontrar o valor necessario para convesão das ondas sonoras em

centímetro

Fonte : Própria

Em seguida conectou-se o sensor na placa protoboard, com auxílio de

jumpers ligou-se o vcc, o trig, o echo e o ground do sensor respectivamente ao 5v,

pino digital 12, pino digital 13 e gnd analógico da placa arduino, conforme figura 9.


43/71

38

FIGURA 9: Montagem do circuito para o sensor de ultrassom

Fonte : Própria

Posteriormente posicionou-se o sensor a 10cm, 5cm e 12cm de distancia

do obstáculo.

Após desmontar o sistema do sensor de ultrassom, iniciou-se a

montagem do sistema para avaliar o sensor de luminosidade usando um LDR.

Energizou-se a protoboard com 5V e com o ground através da placa arduino com o

auxílio de jumpers, que também conectou o 0 analógico em série com o LDR

seguido por um resistor de 10K, figura 10. Configurou-se a programação da placa

arduino para o LDR conectar a porta analógica 0 e informar quando o ambiente está

claro ou escuro. Essa informação é obtida devido aos valores da resistência serem

armazenados em uma variável e se o valor for maior que 800 ohms indicará que o

ambiente está escuro, caso contrário estará claro, como demonstra a figura 11.


44/71

39

FIGURA 10: Montagem do circuito para o sensor de LDR

Fonte : Própria


45/71

40

FIGURA 11: Fluxograma que descreve o algoritmo do sensor de luminosidade

Fonte : Própria

Em seguida montou-se as duas estruturas juntas, seguindo os mesmo

procedimentos descritos anteriormente, figura 12. Na programação, cada uma das

instruções anteriores foram transformadas em funções para melhor organizar o

código.


46/71

41

FIGURA 12: Montagem do circuito para o sensor de ultrassom e de LDR juntos

Fonte : Própria

3.7 Configurando o Bluetooth e a Shield Motor

Utilizando a protoboard ligou-se o RX, TX, Gnd e VCC do bluetooth respectivamente ao TX, RX, Gnd e 5V da placa arduino.


47/71

42

FIGURA 13: Montagem do circuito para o sensor bluetooth

Fonte : Própria

Os motores foram ligados a shield motor, sendo o primeiro conectado ao

M1A e M1B e o segundo conectado ao M4A e M4B, figura 14.

Para melhor identificação no momento da montagem do sistema completo

na placa protoboard utilizou-se jumpers de cores iguais para funções iguais.


48/71

43

FIGURA 14: Montagem dos motores na shield motor

Fonte : Própria

A shield motor irá se encaixar totalmente na placa arduino ocupando

todos os pinos. A partir desse momento os sensores ligados ao arduino passaram a

ser ligados a shield juntamente com os motores, conforme figura 15.


49/71

44

FIGURA 15: Diagrama que descreve todas interações envolvendo o arduino

Fonte : Própria

3.8 Montagem do Veiculo em Miniatura

Para a montagem do veículo em miniatura foi utilizado a estrutura de com

carrinho de brinquedo. A estrutura já estava toda montada sendo necessáriosomente realizar algumas modificações para fixar os exios motores e a estrutura

montada anteriormente.

Na parte da frente foi encaixado uma engrenagem meia lua fixada por um

pino, o qual permite a movimentação do veículo pelas laterais. A engrenagem meia

lua possui um limitador de curso de 180º para cada lado. Acima da engrenagem

apoiou-se o motor de passo frontal, figura 16. E por fim o apoio para o eixo e motor

foi conectado com a finalidade de proteger a estrutura montada, figura 17.


50/71

45

FIGURA 16: Montagem da dianteira do veiculo

Fonte : Própria

FIGURA 17: Montagem da dianteira do veiculo finalizado

Fonte : Própria

Terminando a parte frontal deu inicio a parte traseira do veiculo. Utilizou-

se um eixo com rodas nas pontas e com engrenagem de tracionamento no meio,

como mostra a figura 18. Em seguida foi posicionado um motor para girar a

engrenagem e assim movimentar o veiculo para frente e para trás, figura 19.


51/71

46

FIGURA 18: Eixo de rodas com engrenagem

Fonte : Própria

FIGURA 19: Montagem da parte traseira finalizada

Fonte : Própria

Por fim montou-se toda a estrutura do arduino anteriormente descrita na

superfície do veiculo construído. Devido ao centro do veículo está localizado a 15 cm

da sua frente, utilizou-se uma segunda placa protoboard de 170 furos para

posicionar o sensor ultrassom na frente do veículo. Foram seguidas os mesmos

processos de montagem anteriormente descritos.


52/71

47

FIGURA 20: Estrutura de veiculo com arduino , visão aérea

Fonte : Própria

FIGURA 21: Estrutura de veiculo com arduino , visão dianteira

Fonte : Própria


53/71

48

FIGURA 22: Estrutura de veiculo com arduino , visão traseira

Fonte : Própria

FIGURA 23: Estrutura de veiculo com arduino , visão lateral direita

Fonte : Própria


54/71

49

FIGURA 24: Estrutura de veiculo com arduino , visão lateral esquerda

Fonte : Própria

3.9 Desenvolvimento do aplicativo android

Inicialmente para desenvolver o aplicativo android utilizou-se de uma

tecnologia chamada Amarino, o qual é composta por duas partes: bibliotecas eaplicativo. O aplicativo presente no Amarino foi utilizado para localizar, conectar e

identificar o ID do bluetooth. Já as bibliotecas, uma foi utilizada na programação do

arduino e a outra na programação do aplicativo android.

O ID do bluetooth é adicionado ao código do aplicativo para fazer a

comunicação entre o android e o arduino.

Para receber as informações captadas pelos sensores, criou-se duas

caixas de texto para receber as informações e assim exibí-las.

Em seguida configurou-se quatro botões para o controle dos motores do

veículo. Os botões de direita e esquerda enviam comandos para o motor de passo

mover para a direita e esquerda. Os botões acima e abaixo em viam o comando

para acelerar e dar ré no veiculo.

O layout do aplicativo pode ser visto na figura 25 e o funcionamento na

figura 26.


55/71

50

FIGURA 25: Tela do aplicativo desenvolvido

Fonte : Própria


56/71

51

FIGURA 26: Fluxograma do algoritmo que descreve o funcionamento do aplicativo android

Fonte : Própria


57/71

52

4 RESULTADOS OBTIDOS

Os resultados obtidos neste trabalho serão mostrados neste capítuloestão todos vinculados aos procedimentos descritos no capítulo anterior.

Ao realizar a comparação entre o led ligado diretamente a placa arduino e

ao led ligado a protoboard, foi observado que o led se comporta perfeitamente

conforme a programação nas duas situações, não havendo nenhuma diferença entre

os dois testes. No entanto ao utilizar a placa protoboard pode-se nota a sua

importância para serem ligados mais de um dispositivo.

FIGURA 27: Arduino com led

Fonte : Própria

FIGURA 28: Funcionamento do led na protoboard com o arduinoFonte : Própria


58/71

53

Observou-se muita precisão nos resultados obtidos com os testes

utilizando o sensor de ultrassom. Foi trabalhado com valores inteiros na medição das

distâncias e foi conferido que nas três medições o sensor retornou valores precisos.

FIGURA 29: Funcionamento do ultrassom na distancia de 10 cm

Fonte : Própria


59/71

54

FIGURA 30: Ampliação dos resultados da figura 29

Fonte : Própria


60/71

55


Fonte : Própria


Fonte : Própria


61/71

56

FIGURA 33: Ampliação da figura 32

Fonte : Própria

O experimento com o sensor LDR também demonstrou resultados

positivos com a variação de luminosidade com bastante exatidão.


62/71

57

FIGURA 34: Estrutura do circuito do LDR

Fonte : Própria

FIGURA 35: Funcionamento do LDR em ambiente claro

Fonte : Própria


63/71

58

FIGURA 36: Funcionamento do LDR em ambiente escuro

Fonte : Própria


64/71

59

No momento em que os dois sensores forma montados juntos, pode-se

perceber que não houve interferência entre os sensores e que o desempenho dos

sensores continuaram o mesmo.

FIGURA 37: Estrutura do circuito dos dois sensores juntos

Fonte : Própria

FIGURA 38: Funcionamento dos dois sensores em conjunto

Fonte : Própria


65/71

60

FIGURA 39: Resultados da figura 39 ampliada

Fonte : Própria

Finalmente depois de toda a estrutura do arduino, mecânica e do

aplicativo prontos, observou-se que o bluetooth é um excelente meio de

comunicação entre a placa arduino e o aplicativo android. Mais uma vez os valores

obtidos pelos sensores foram colhidos com exatidão e enviados sem percas para o

aplicativo, utilizando o bluetooth.

A movimentação também responderam perfeitamente aos comandos do

aplicativo. A estrutura dianteira do veiculo comandava o direcionamento esquerda e

direita, sendo necessário manter o botão pressionado para realizar a conversão,

caso contrário as rodas voltam para o estado de repouso. A parte traseira estava

responsável pelo tracionamento do veiculo, mantendo-se pressionado o botão

superior o veículo movia-se para frente e mantendo-se pressionado o botão inferior o

veiculo movia-se para trás.

Os valores captados pelo sensor de ultrassom e tratado pelo arduino

foram enviados pelo bluetooth ate o dispositivo android com a mesma qualidade dos

testes anteriores. Também foram obtidos resultados positivos com sensor LDR. Os

valores captados por ele foram tratados pelo arduino e enviados via blutooth até o

dispositivo android no qual aparecia escrito claro ou escuro de acordo com a

luminosidade do ambiente.


66/71

61

5 CONCLUSÃO

Esse trabalho apresentou por meio de uma pesquisa prática a análise dautilização do aplicativo android para controlar um veículo em miniatura estruturado

com placa arduino, sensor de ultrassom e sensor de luminosidade. Demonstrou-se

no estudo uma compatibilidade muito grande entre a placa arduino e o dispositivo

android possibilitando a troca de informação entre as duas tecnologias.

Usualmente as funções dos smartphones estão relacionados aos seus

dispositivos. O bluetooth é um desses dispositivos que atualmente está presente na

maioria dos smartphones, principalmente os portadores do sistema operacionalandroid. Por realizar a comunicação entre dispositivos através de ondas de rádios e

com baixo consumo de energia escolheu-se o bluetooth como o intermediador entre

o android e o arduino, apesar de possuir limitação de distancia de 5 metros de raio.

O uso da amarino teve uma grande importância no trabalho para

possibilitar uma troca de informação entre as tecnologias utilizadas por intermédio do

bluetooth. O uso do aplicativo amarino possibilitou identificar o bluetooth usado no

trabalho as bibliotecas inseridas aos códigos de programação do arduino e doandroid, possibilitaram a troca de informação entre eles.

Ao iniciar a pesquisa com a análise separa de cada componente utilizado,

possibilitou um melhor aprofundamento sobre cada peça. Pode-se também

desenvolver os códigos de programação com maior especificação. A forma de

programação utilizada foi estruturada e utilizou-se de recursos da linguagem de

programação C.

O primeiro teste com a placa arduino e o led mostrou a importância do

uso da protoboard que tornou-se a base para a montagem de todos os testes

posteriores. Vale ressaltar a importância do rigor nos métodos de montagem dos

sensores para a obtenção de resultados precisos. A padronização de cores dos

jumpers utilizados facilitou-se para identificar as conexões feitas na protoboard entre

o arduino e os demais componentes.

Para obter resultados satisfatórios o processo de montagem mostrou-se

muito importante para todo o trabalho. Fez-se necessário seguir os processos

rigorosamente e seguindo padronizações para fazer as ligações com os jumpers. A


67/71

62

ligação de jumpers iguais para funções iguais facilita a montagem e o diagnóstico de

problemas e erros.

A dificuldade para encontrar as peças necessárias na montagem do

veículos em miniaturas possibilitou-se a reutilização de uma estrutura já existente.

Essa reutilização gerou uma mudança no planejamento inicial na montagem do

veículo. Em primeira instância os dois motores seriam instalados cada um em uma

roda traseira do veiculo e as rodas dianteiras serem livres para facilitar as

conversões para direita e para a esquerda. A movimentação do veiculo era baseada

na potencia e direcionamento de rotação individual de cada motor. Não havendo a

possibilidade da montagem dessa estrutura alterou-se para um motor se conectar

com as rodas da frente e serem responsáveis pelas conversões e o segundo motorfoi ligado as rodas traseiras com a finalidade de tracionar o veiculo para frente e para

trás.

O aplicativo android desenvolvido, possui somente uma tela. Essa tela é

auto explicativa. Os botões de movimentação conseguem enviar perfeitamente as

instruções para o deslocamento do veiculo em miniatura. As áreas para exibição dos

alertas estão em destaque para melhor visualização.

Uma outra dificuldade apresentada por esse trabalho, foi o processo dealimentação de todo o mecanismo montado. Foi utilizada uma bateria de 9 volts para

a alimentação, inicialmente o mecanismo funcionou muito bem, mas com pouco

tempo de uso a bateria já mostrava desgastes. Em poucas horas de uso o motor

frontal responsável pela direção do veículo já não possuía força e em seguida

somente possuindo energia para manter o dispositivo de bluetooth. Estudos futuros

podem analisar métodos para manter o veículo em miniatura em funcionamento por

mais tempo.Este trabalho contribui com o meio de pesquisa abrindo caminho para

novos trabalhos relacionados, pois a combinação arduino e android possibilita a

criação de novos dispositivos, assim como o estudo dos sensores podem ser

aproveitados em outros tipos de trabalhos.

Por fim pode-se avaliar que o aplicativo android juntamente com o arduino

se completam abrindo portas para futuros estudos. Em próximos estudos o veiculo

em miniatura pode ser aperfeiçoado com outros sensores ou ate mesmo sendo

melhorado para explorar locais perigosos ou inacessíveis. Também para estudos


68/71

63

futuros podem ser experimentados outras vias de comunicação entre o android e o

arduino para poder ter o controle a maiores distancias.


69/71

64

REFERÊNCIAS

ACTIVE INFO. Curso de Lógica de Programação. Disponível em:. Acesso em: 22abr. 2015.

ANDROID, Site Oficial. Application Fundamentals. Disponível em: <http://developer.android.com/guide/components/fundamentals.html>. Acesso em: 05mai. 2015.

ANDROID, Site Oficial. História do Android. .Acesso em: 23 abr. 2015.

ARDUINO, Site Oficial. Disponível em:. Acesso em: 19 abr. 2015.

ARDUINO, Site Oficial. Disponível em:. Acesso em: 19 abr. 2015.

ARDUINO. Site Oficial. Disponível em: < http://www.arduino.cc/en/Main/Products >.Acesso em: 19 abr. 2015.

ARDUINO. Site Oficial. Disponível em: < http://www.arduino.cc/en/main/Software >.

Acesso em: 19 abr. 2015.ARDUINO. Site Oficial. Disponível em: . Acesso em: 19 abr.2015.

BR-ARDUINO. Do LED ao Arduino: aprendendo eletrônica no século 21. Disponívelem: Acesso em: 10 abr. 2015.

BUDEL, Cleverson; BARBARA, Giuliano; MOLOSS, Ramon. Arquiteturas paraaplicações móveis. Paraná: Celepar, 2011.

CAELUM. Eclipse IDE. Disponível em: . Acesso em: 20 abr. 2015.

CAELUM. O que é Java. Disponível em: < http://www.caelum.com.br/apostila-java-orientacao-objetos/o-que-e-java/>. Acesso em: 20 abr. 2015.

CUNHA, Alessandro F. O que são sistemas embarcados?. Disponível em: Acessoem: 10 abr. 2015.

DEITEL, Paul; DEITEL, Harvey . Java – como programar. Bookman, 2003.

ECLIPSE. Site Oficial. Disponível em: . Acesso 10 abr. 2015.


70/71

65

EMBEDDED. O que é um sistema embarcado. Disponível em:. Acesso em: 10 abr. 2015.

EVANS, Brian W. Arduino Programming Notebook. San Francisco: Creative Comms,2007.

EVARISTO, Jaime. Aprendendo a Programar Programando na Linguagem C. BookExpress. 2001.

GOMES, Evandro Luís Brandão e TAVARES Luís Antônio. Uma solução comArduino para controlar e monitorar processos industriais. Disponível em: <http://www.inatel.br/pos/index.php/downloads/doc_download/26-luis-tavares-arduino> Acesso em: 26 abr. 2015.

GOOGLE TRENDS. Site Oficial. Disponível em:. Acesso em: 11 abr. 2015.

IBM, Site Oficial. Desenvolver Aplicações Android com o Eclipse. Disponível em: <https://www.ibm.com/developerworks/br/library/os-eclipse-android/>. Acesso em: 05mai. 2015.

INSTITUTO NEWTON C BRAGA. Como funcionam os sensores fotoelétricos.Disponível em Acesso: 03 nov. 2015.

JAMSA, Kris; KLANDER, Lars. Programando em C/C++ - A bíblia. São Paulo:Makron Books, 1998.

KUTTI, N.S. C and Unix Programming: A Comprehensive Guide. Lightspeed Books,2002.

LECHETA, Ricardo R. Google Android: aprenda a criar aplicações para dispositivosmóveis com o Android SDK. São Paulo: Novatec, 2013.

MAIA, Felipe. A história de Andy Rubin, a mente por trás do Android. 2013.

Disponível em: . Acesso em: 23 abr. 2015.

MEDINA, Marco e FERTIG, Cristina. Algoritmos e Programação: Teoria e Prática.São Paulo: Novatec Editora, 2006

MENDES, Mariana Ribeiro; GARBAZZA, Itagildo Edmar; TERRA, Daniela Costa.Desenvolvimento híbrido versus desenvolvimento nativo de aplicativos móveis.Disponível em: .Acesso em: 26 abr. 2015.

MERCATO, Mattia. A doce história do Android. 2014. Disponível em:. Acesso em: 23 abr. 2015.


71/71

66

PURDUM, Jack. Programing C for Arduino: Learn C Programing for Arduino andCompatible Microcontrollers. Technology in action, 2012.

PEREIRA, Silvio do Lago. Algoritmos e lógica de programação em C: Umaabordagem didática. São Paulo: Érica, 2010.

PETERS, Eduardo; Bluetooth. Disponível em: Acesso: 03 nov. 2015.

REDMONK. The RedMonk Programming Language Rankings: January 2015.Disponível em:.Acesso em: 11 abr. 2015.

ROBÓTICA LIVRE. Introdução a programação de micro controladores. Disponível

em:. Acesso em: 10 abr. 2015.

SCHILDT, Herbert; SKRIEN, Dale. Programação com Java, uma introduçãoabrangente. Porto Alegre: Mc Graw Hill, 2013.

SOUZA, Fábio. Arduino - Primeiros Passos. 2013. Disponível em:. Acesso em: 22 abr.2015.

STARK, Jonathan; JEPSON, Brian. Construindo Aplicativos Android com HTML,CSS e JavaScript. Novatec, São Paulo: 2012.

TECMUNDO, O que é algoritmo? Disponível em: Acessoem: 03 nov. 15

THOMPSOM, Clive. Build it. Share it. Profit. Can Open Source Hardware Work?.Wired Magazine, 2008.

TOSIN, Carlos. Conhecendo o Android. Disponível em: Acesso em: 26 abr.2015.

WARREN, John-David; ADAMS, Josha; MOLLE, Harald. Arduino Robotics.Technology in action 2011

TCC II - 2015 - Aloízio e Gilzan

Documents

Transcript of TCC II - 2015 - Aloízio e Gilzan