Apostila Arduino eBook - Prof. Davi

[ 2 ]

Davi Antonio Quierelli Antonio Augusto Da Roz Mazzi

Valdecir Aparecido Quierelli

Apostila de Arduíno

Controlando um carrinho pelo celular

1ª edição

Leme Davi Antonio Quierelli

2014

[ 4 ]

Todos os direitos reservados. Não é permitida a reprodução no todo ou em parte da presente obra sem prévia autorização do autor (Lei 9.610/98). Nota: Esta obra foi criada com o intuito de proporcionar um melhor aprendizado para o leitor. No entanto, podem ocorrer erros de digitação, impressão ou dúvidas quanto ao entendimento do conteúdo da mesma. Dessa forma, solicitamos que qualquer das hipóteses acima, entre em contato para que possamos esclarecer ou encaminhar a questão. Email do autor: [email protected] Apostila de Arduíno – Controlando um carrinho pelo celular / Davi Antonio Quierelli, Antonio Augusto Da Roz Mazzi, Valdecir Aparecido Quierelli – Leme-SP: Ed. Davi Antonio Quierelli, 2014.

83 p.

1. Arduíno. 2. Programação. 3. Android. 4. Celular. 5. AppInventor. 6. Eletrônica.

[ 6 ]

Dedico esta obra à minha esposa Elisandra e aos meus filhos Felipe e Gabriela, que sempre estão ao meu lado com apoio, compreensão e paciência.

Não viva para que a sua presença seja notada,

mas para que a sua falta seja sentida...

Bob Marley

[ 8 ]

SUMÁRIO

Introdução ................................................................................................................................................................... 10

O que é Arduíno ........................................................................................................................................................ 11

O projeto dessa apostila ...................................................................................................................................... 12

Lista de componentes para o projeto. ......................................................................................................... 13

Montando o carrinho ............................................................................................................................................. 17

Preparando o Arduíno com o Motor Shield ................................................................................................ 21

Programando o Arduíno ....................................................................................................................................... 30

Código do Arduíno ................................................................................................................................................... 31

Entendendo o funcionamento do código .................................................................................................... 37

A escolha do ambiente de controle ................................................................................................................ 38

App Inventor .............................................................................................................................................................. 39

Começando a aplicação ........................................................................................................................................ 44

Montando a tela ....................................................................................................................................................... 48

Programando a aplicação .................................................................................................................................... 55

Conexão com o sensor Bluetooth ................................................................................................................... 55

Movendo os motores.............................................................................................................................................. 66

Testando as variáveis e escrevendo na saída Bluetooth ................................................................... 70

Gerando o instalador para o celular .............................................................................................................. 78

Testando o carrinho ............................................................................................................................................... 81

Referências bibliográficas .................................................................................................................................. 83

[Apostila de Arduíno], por [Davi Antonio Quierelli, Antonio Augusto Da Roz Mazzi, Valdecir Aparecido Quierelli]

[ 10 ]

Introdução

A automação é uma área que fascina quem gosta de componentes eletrônicos, peças de computadores e dispositivo de informática.

Essa apostila tem a finalidade de demostrar de forma prática e didática o desenvolvimento de um projeto na construção de um carrinho de brinquedo controlado pelo celular.

A automação é possível por causa da placa controladora denominada Arduíno, que foi desenvolvida para facilitar e baratear o processo de automação que até então só era possível por profissionais ligados à área de eletrônica e engenharia. Dessa forma profissionais que gostam de eletrônica, informática e derivados podem aprender a manipular processos de automação, pois o mesmo fica simplificado comparado com os processos tradicionais. Outra vantagem dessa placa é o de poder usar recursos de programação para automatizar processos, dessa forma quem conhece lógica de programação pode se aventurar a desenvolver aplicativos para a mesma.


[ 11 ]

O que é Arduíno

O Arduíno é uma plataforma eletrônica que consiste de uma placa (hardware) com vários componentes permitindo o controle e automação de infinitos dispositivos. A ideia é que mesmo pessoas amadoras sem acesso aos controladores mais sofisticados e de maior custo possam trabalhar ou brincar com eletrônica e automação.

A plataforma foi construída usando o princípio de hardware livre, ou seja, foi projetado para que qualquer pessoa possa utilizá-la ou melhorá-la desde que siga os critérios exigidos pelas licenças de software livre. Ao invés de criar uma nova licença para o uso do hardware foi utilizada a licença que já é usada a muito tempo pelo software livre. A placa de Arduíno possui entradas e saídas digitais e analógicas além de interface serial e USB. A grande vantagem de utilizá-la é que ela pode ser programada para as tarefas as quais se destina, sendo assim, tanto os profissionais de eletrônica quanto de informática podem desenvolver projetos de automação. Existem no mercado vários modelos de placas de Arduíno sendo que uma das mais utilizadas e que será apresentada nessa apostila é a Uno ou qualquer que seja compatível com a mesma. Veja a foto a seguir:

Foto 1

Para a construção do projeto apresentado nessa apostila será necessário adquirir uma placa do tipo Uno igual à da foto acima. A mesma pode ser encontrada em lojas especializadas em eletrônica e automação ou diretamente em sites pela Internet.


[ 12 ]

O projeto dessa apostila

Para demonstrar de forma prática o uso do Arduíno será automatizado nessa apostila um carrinho de brinquedo que será controlado pelo Arduíno através do celular com o sistema Android. No carrinho de plástico deverá ser encaixado dois motores que serão responsáveis por faze-lo ir para frente e para trás, virar para a esquerda e para a direita e além disso controlar um braço com um guincho na ponta como se fosse um carrinho rebocador.

Para isso serão necessário alguns componentes específicos que seguem na lista abaixo:


[ 13 ]

Lista de componentes para o projeto.

Placa Arduíno compatível com o modelo Uno.

Foto 2

Carrinho de plástico ou caminhonete de preferência leve.

Foto 3

Cabos conectores do tipo macho/macho e macho/femea.


[ 14 ]

Foto 4

Dois micro servo 9g para levantar o braço e o guincho.

Foto 5

Um sensor Bluetooth.

Foto 6

Motor Shield L293D para controlar os motores.


[ 15 ]

Foto 7 e 8

Motor DC ou servo motor para usar na direção do carrinho. Motor DC com redutor para movimentar o carrinho para frente e para trás.

Foto 9

Palitos de sorvete.


[ 16 ]

Foto 10

Abraçadeiras de plástico

Foto 11


[ 17 ]

Montando o carrinho

O primeiro passo para iniciar o projeto é preparar o carrinho com os motores que serão controlados pelo Arduíno junto com o Motor Shield pelo celular.

Pegue o carrinho e remova as rodas traseiras e encaixe o eixo com o motor no lugar das mesmas. Use palitos de sorvete e abraçadeiras para fixar o mesmo no carrinho.

Foto 12

Esse processo de fixação não tem como ser demonstrado nessa apostila, pois

depende do tipo e modelo do carrinho para poder fixar o eixo com o motor da melhor forma possível.

A exemplo das rodas traseiras retire as rodas dianteiras e fixe o motor no carrinho para que fique numa disposição que o eixo retirado possa ser fixado no motor para que o mesmo possa movimentar as rodas para a direita ou esquerda.

Veja como ficaria na foto abaixo:


[ 18 ]

Foto 13 No exemplo da foto anterior foi usado um micro servo hackeado, ou seja, os servos

motores geralmente giram apenas 180 graus, um servo hackeado significa que o mesmo gira de maneira constante de um lado igual um motor DC.

Não tem problema de usar um servo ou um motor normal, a forma como eles trabalham pode ser controlada via programação no Arduíno.

A partir do momento que os motores com os eixos estão fixados o carrinho deve ter a aparência das fotos abaixo:

Foto 14 e 15

Foto 16 Vamos fixar os servos no braço do guincho para podermos controlar o guincho do

carrinho pelo Arduíno. Nesse exemplo foi utilizado um pedaço de um guincho de um brinquedo e como o mesmo ficou curto, prolongamos com palitos de sorvete. Se não possuir um brinquedo que tenha o braço, pode ser criado de qualquer outro material ou até mesmo com os próprios palitos de sorvete. Veja na fotos abaixo:


[ 19 ]

Foto 17

Veja o servo fixado com abraçadeiras no braço de plástico que ficará fixado na parte

traseira do carrinho. Desse servo foi feito um prolongamento com palitos de sorvete para chegar até no guincho. Veja na foto:

Foto 18 Nesse servo o guincho é encaixado onde pode ser controlado pelo Arduíno.


[ 20 ]

Foto 19 e 20

Após a fixação dos servos no braço é necessário fixar o mesmo no carrinho na parte traseira. Utilize fios ou arames para que o mesmo fique firme e numa boa disposição para funcionar. Veja a foto do carrinho com o guincho fixado:

Foto 21


[ 21 ]

Preparando o Arduíno com o Motor Shield

O Arduíno controla facilmente motores servo, DC ou de passo, no entanto o controle se torna mais complexo quando os motores tem que girar nos dois sentidos o que aumenta as conexões eletrônicas em uma protoboard. Uma das opções seria comprar um circuito integrado (L923D) que faça isso, porém seria necessário além da protoboard fazer várias ligações com fios, diodos, resistores, etc. para poder controlar os motores em ambos os sentidos e não causar dano no Arduíno. Para facilitar esse processo existem os Motor Shields, que são placas prontas específicas para controlar motores. O Motor Shield L923D que utilizaremos nesse projeto já vem preparado para controlar até quatro motores DC, 2 servos e motores de passo, dessa forma é indicado para projetos que utilizem vários motores.

Esse Shield se encaixa em cima do Arduíno utilizando praticamente todas as portas de saída. Antes de fazer o encaixe temos que conectar o sensor bluetooth junto do Arduíno, como o sensor usa as portas digitais 0 (RX) e 1 (TX) e as mesmas serão usadas no encaixe do Shield em cima do Arduíno, teremos que adaptar dois cabos para serem fixados juntos com o encaixe.

O sensor geralmente vem com um cabo branco de quatro fios que deve ser colocado nos pinos do sensor prestando atenção na ordem dos pinos, na outra ponta deve ser fixado cabos macho/macho para poder conectá-los em seus respectivos lugares.

Note no sensor que cada pino tem sua descrição que é: VCC – Fonte de alimentação. GND – Fio terra do sensor. TXD e RXD. Para os pinos terra e de alimentação podemos deixar as pontas como estão pois, o

Shield possuí saídas com essas finalidades. Já os pinos TXD e RXD devem ser encaixados nos pinos 0 e 1 digital da placa do Arduíno. Como já foi mencionado esses pinos serão perdidos no momento do encaixe do Shield em cima do Arduíno, portanto devemos preparar as pontas dos cabos do sensor para no momento do encaixe fixar os cabos juntos. Veja na foto abaixo que as pontas foram mudadas para ter o formato de uma argola.


[ 22 ]

Foto 22

No momento do encaixe basta colocar as argolas do cabo do sensor nos pinos do Shield que serão encaixados no Arduíno. Porém, a disposição dos cabos deve ser invertida, ou seja, o pino RXD do sensor deve ir na porta (1) TX do Arduíno enquanto que o pino TXD do sensor deve ir na porta (0) RX do Arduíno. Veja na foto como fica:

Foto 23 e 24

Após concluir a conexão dos cabos RX e TX no Shield separe 6 cabos do tipo macho/macho e fixe um par dos mesmos na porta M1 do Shield. Faça o mesmo com o outro par de cabos na porta M2 e por último na área de alimentação externa. Veja a foto a seguir:


[ 23 ]

Foto 25

A porta M1 será a responsável por mover o motor do eixo frente/trás, a porta M2 será responsável por movimentar o motor que é responsável por direcionar o carrinho para a direita e para esquerda. Os cabos da alimentação externa que ficam na lateral direita na disposição da foto serão responsáveis por receber a energia de baterias para movimentar os motores e consequentemente o carrinho.

Dos 4 cabos do sensor bluetooth dois ainda não foram conectados, falta conectar o cabo de energia e o cabo do fio terra. Na parte de cima do Shield perto das portas M3 e M4 tem duas linhas de furos de 5v e GND, conecte os dois cabos restantes em seus respectivos furos, ou seja, furo de 5v do Shield no pino VCC do sensor e GND do Shield no GND do sensor para que o sensor possa funcionar. Veja a figura abaixo:

Foto 26 e 27

Note que para fixar melhor os cabos nos furos do Shield foi utilizado um elástico que envolve o Shield e o Arduíno ao mesmo tempo que fixa os cabos também. Se os cabos


[ 24 ]

ficarem soltos pode ocorrer na hora do carrinho se movimentar de um dos cabos ficarem com mal contato e desligar o sensor, ocasionando a perda de controle do carrinho.

Fixe o Arduíno e o Shield no carrinho de forma que a disposição dos fios que irão ligar os motores estejam corretos. Veja na foto:

Foto 28

A parte de montagem do carrinho com o Arduíno está pronta, falta apenas a

alimentação de energia que vai alimentar tanto o Arduíno com o Shield quanto os motores que irão controlar o carrinho.

A alimentação de energia é de extrema importância pois é através dela que tudo vai funcionar. Tanto o Arduíno quanto o Shield trabalham com voltagem entre 5v e 12v, nos manuais é descrito que ambos suportam até 20v, porém não é aconselhável testar a capacidade ao limite para evitar queima de componentes. Por estar usando dois motores DC, dois servos para o guincho e ainda o Arduíno e o Shield é necessário uma alimentação de energia que proporcione um bom desempenho tanto na movimentação quanto na duração das baterias.

Em testes foi constado que a bateria alcalina de 9v de 580 mAh duram muito pouco além de não ser barata pelo fato de não ser recarregável. As pilhas também não apresentaram desempenho melhor, sendo assim, foi testado bateria de 9v 260 mAh recarregável que aguentou menos de dois minutos.

A solução foi usar seis baterias recarregáveis de 1,2v de 2100mAh dispostas em linha que acaba por gerar 7.2v de 2100 mAh e gerou um desempenho satisfatório de 20 minutos de autonomia. Vale lembrar que quanto maior a amperagem (mAh) melhor é a autonomia do carrinho e não influencia no funcionamento do Arduíno e do Shield.


[ 25 ]

Para colocar as baterias em linha é necessário colocar as mesmas uma do lado da outra e com as polaridades invertidas. Veja na foto abaixo:

Foto 29

Depois é necessário soldar as pontas de uma forma que as baterias fiquem com as

polaridades em linha gerando a energia necessária. Veja a mesma foto com as ligações necessárias:

Foto 30

O problema de usar as baterias soldadas dessa forma é como as mesmas serão

recarregadas se estão soldadas.


[ 26 ]

A solução encontrada é pegar carrinhos de controle remoto quebrados que usem pilhas e tirar o compartimento de pilhas de dois ou mais carrinhos e montá-los para trabalhar da mesma forma das baterias em linha da foto anterior. Veja a foto abaixo:

Foto 31 Nesse caso foi usado dois compartimentos de pilhas ligados um no outro com

capacidade de três baterias cada um seguindo a disposição em linha do exemplo anterior. Após fazer a ligação entre os compartimentos cole os mesmos para ficarem firme, na

sequencia fixe os compartimentos na parte da frente do carrinho ou onde achar melhor. Veja na foto:

Foto 32


[ 27 ]

Conecte a fonte de alimentação nos cabos que foram reservados para receber a energia. Veja na foto:

Foto 33 Veja qual é o fio positivo das baterias e conecte no cabo respectivo do Shield, caso

contrário a alimentação de energia não ocorrerá. Aproveite e ligue também os cabos dos motores lembrando que o motor traseiro vai

ser conectado nos cabos M1 e o motor dianteiro nos cabos M2. Veja a foto:

Foto 34 Não se preocupe com a disposição dos cabos de cada motor agora, na hora que

forem ligados podemos saber se os cabos estão corretos ou se é necessário inverte-los. Se


[ 28 ]

estirem invertidos não ocorrerá problema algum apenas os motores irão girar no sentido contrário.

Falta ainda ligar os servos motores para funcionar o braço com o guincho, ligue o servo do braço no servo2 do Shield e o servo do guincho no servo1 do guincho. Verifique a sequência dos cabos, no Shield tem as seguintes descrições:

S => Sinal (fio laranja). + => Fio positivo (fio vermelho). - => Negativo, GND ou terra (fio marrom ou preto). Veja a foto:

Foto 35 Após as ligações o carrinho está pronto para receber a programação que irá

controlá-lo. Veja na foto:


[ 29 ]

Foto 36


[ 30 ]

Programando o Arduíno

Para fazer o carrinho movimentar é necessário criar um programa para o Arduíno e um para o celular.

O Arduíno possui uma IDE de desenvolvimento próprio que pode ser baixado do site:

http://arduino.cc/en/main/software Existem versões para Windows, Linux e Mac OS X, escolha a versão do seu sistema

operacional preferido e faça o download, nessa apostila a versão utilizada é do Windows. Após a instalação da IDE do Arduíno execute a mesma e veja como é o ambiente:

Foto 37 A programação envolvida no Arduíno não difícil é muito parecida com a linguagem C,

porém é necessário ter conhecimentos básicos em programação e lógica, pois do contrário fica difícil entender o que o código está fazendo. Na sintaxe de um programa para o Arduíno é necessário declarar duas funções principais para torna-lo funcional que são: setup() – Declarada no início, serve para inicializar variáveis e configurações iniciais. loop() – Funções que fica repetindo comandos, é onde tudo acontece.


[ 31 ]

Código do Arduíno Segue abaixo o código fonte que deverá ser inserido na placa do Arduíno, o mesmo está todo comentado para facilitar o entendimento: //Importa a bibliotecas necessárias para movimentar os motores e os servos #include <AFMotor.h> #include <Servo.h> //Cria o objeto motor1 e vincula com a porta M1 do Shield AF_DCMotor motor1(1,MOTOR12_64KHZ); //Cria o objeto motor2 e vincula com a porta M2 do Shield AF_DCMotor motor2(2,MOTOR12_64KHZ); //Criando objeto da classe Servo para controlar o servo 1. Servo servo1; //Criando objeto da classe Servo para controlar o servo 2. Servo servo2; //Pino digital associado ao controle do servomotor 1 int const servoMotor1Pin = 10; //Pino digital associado ao controle do servomotor 2 int const servoMotor2Pin = 9; //Variável que irá controlar o servo1 e sua posição inicial. int posicao1=90; //Variável que irá controlar o servo2 e sua posição inicial. int posicao2=90; //Rotina inicial que seta alguns valores iniciais de comunicação serial e dos //servos motores. void setup() { // Seta a quantidade de bits por segundo para transmissão serial. Serial.begin(9600); //Anexa o servo1 com seu respectivo pino. servo1.attach(servoMotor1Pin); //Servo 1 //Anexa o servo2 com seu respectivo pino. servo2.attach(servoMotor2Pin); //Servo 2 //Escreve o valor inicial no servo1.


[ 32 ]

servo1.write(posicao1); //Escreve o valor inicial no servo2. servo2.write(posicao2); } //Rotina que fica em loop constante e é onde tudo acontece. void loop(){ //Se ocorrer alguma transmissão serial. if(Serial.available()) { //Obtém o valor recebido da comunicação serial. char c = Serial.read(); //Sobe guincho se a letra Q foi recebida. if (c == 'Q') { posicao1=posicao1-5; servo1.write(posicao1); } //Desce guincho se a letra W foi recebida. if (c == 'W') { posicao1=posicao1+5; servo1.write(posicao1); } //Sobe braço se a letra E foi recebida. if (c == 'E') { posicao2=posicao2+1; servo2.write(posicao2); } //Desce braço se a letra R foi recebida. if (c == 'R') { posicao2=posicao2-1; servo2.write(posicao2); } //Move o motor para frente de forma lenta se a letra S foi recebida. if (c == 'S') { //Define a velocidade máxima 255 para o motor ter arranque. motor1.setSpeed(255);


[ 33 ]

//Gira o motor sentido horário. motor1.run(BACKWARD); //Controla o tempo de arranque. delay(50); //Define a velocidade de 80 para o motor. motor1.setSpeed(80); motor1.run(BACKWARD); } //Move o motor para frente de forma média se a letra D foi recebida. if (c == 'D') { //Define a velocidade de 150 para o motor. motor1.setSpeed(150); motor1.run(BACKWARD); } //Move o motor para frente de forma rápida se a letra F foi recebida. if (c == 'F') { //Define a velocidade máxima 255 para o motor. motor1.setSpeed(255); motor1.run(BACKWARD); } //Move o motor para trás de forma lenta se a letra Y foi recebida. if (c == 'Y') { //Define a velocidade máxima 100 para o motor. motor1.setSpeed(100); //Gira o motor sentido anti horário. motor1.run(FORWARD); } //Move o motor para trás de forma rápida se a letra T foi recebida. if (c == 'T') { //Define a velocidade máxima 200 para o motor. motor1.setSpeed(200); motor1.run(FORWARD); } //Para o motor se a letra P foi recebida. if (c == 'P') { //Define a velocidade máxima 0 para o motor. motor1.setSpeed(0); //Desliga o motor


[ 34 ]

motor1.run(RELEASE); } //Move o motor para direta se a letra L foi recebida. if (c == 'L') { //Define a velocidade de 255 para o motor da frente. motor2.setSpeed(255); motor2.run(BACKWARD); //Controla o tempo de giro para a esquerda. delay(5); //Para o motor. motor2.setSpeed(0); motor2.run(RELEASE); } //Move o motor para esquerda se a letra K foi recebida. if (c == 'K') { //Define a velocidade de 255 para o motor da frente. motor2.setSpeed(255); motor2.run(FORWARD); delay(5); motor2.setSpeed(0); motor2.run(RELEASE); } } } Salve o código com o nome “carrinho_guincho.ino”, veja na imagem:


[ 35 ]

Foto 38

Ao salvar a IDE criará uma pasta com o mesmo nome do arquivo e dentro da mesma o arquivo com o código fonte.

Para fazer upload do código para a placa do Arduíno conecte o cabo usb que vem com o Kit na placa do Arduíno e a outra ponta em uma porta usb e clique no ícone em destaque na imagem abaixo:

Foto 39

Se estiver tudo correto aparecerá uma mensagem na parte inferior da IDE informando o espaço que o programa ocupou no Arduíno e quanto é o limite total, veja nas imagens:


[ 36 ]

Foto 40

Foto 41


[ 37 ]

Entendendo o funcionamento do código

O código que foi para o Arduíno foi todo comentado, no entanto é necessário algumas explicações para facilitar o entendimento. O programa que foi importado para o Arduíno está preparado para receber informações de outro programa que será criado no ambiente Android para ser controlado pelo celular ou tablet. Que informação esse programa espera?

Após a inicialização dos objetos necessários no início do programa a função setup() define algumas configurações iniciais e deixa o ambiente pronto para receber as informações dentro da função loop().

Foi especificado letras para a comunicação entre os programas, por exemplo se quiser que o carrinho suba o guincho o programa espera receber a letra “Q” da comunicação com o celular. Cada vez que chegar a letra “Q” o código diminui 5 da variável posicao1 e reescreve para mudar a posição do servo. O mesmo acontece para descer o guincho porém a letra usada para isso é a letra “W” que ao invés de diminuir 5 da variável posicao1 ele aumenta 5. Para subir e descer o braço do guincho é usado a mesma lógica mudando apenas a variável para posicao2 e as letras, onde a letra “E” sobe o braço enquanto que a letra “R” desce o mesmo. Os motores também são acionados por letras que vem do celular onde foi configurado 3 velocidades para frente. S – Inicia o motor com um arranque potente e depois é reduzido em baixa rotação. D – Inicia o motor com rotação média. F – Inicia o motor com rotação máxima. O mesmo ocorre para movimentar o carrinho para trás, foi definido 2 velocidades nesse sentido. Y – Inicia o motor para trás com baixa rotação. T – Inicia o motor com rotação quase que total.

A letra “P” serve para parar o motor, isso não significa que caso o carrinho esteja em um declive que o mesmo irá parar, pois os motores não tem função de freio eles podem apenas ser desligados.

O motor que controla a direção do carrinho também funciona recebendo letras como instrução.

L – Inicia o movimento do motor para direita com força total e após um tempo

mínimo o motor é desligado. K – Inicia o motor para a esquerda com força total e depois de um tempo o mesmo

é desligado.


[ 38 ]

A escolha do ambiente de controle

Existem várias formas de controlar uma placa Arduíno para automatizar processos, pode-se usar infra vermelho, wifi, conexão serial, bluetooth, etc., cabe ao desenvolvedor escolher qual se adequa melhor a sua invenção.

Para esse exemplo foi escolhido a comunicação do tipo bluetooth, a escolha desse ambiente se deve ao fato de poder controlar o carrinho pelo celular.

A maioria dos celulares possui esse recurso e a distância que pode ser atingida favorece sua escolha, em testes o alcance do sinal do celular com o carrinho foi superior a 30 metros, em termos de controle de um carrinho é uma distância satisfatória.

Entre os vários modelos de celulares que existe no mercado com seus sistemas operacionais a escolha foi o Android pelo fato de a grande maioria dos celulares existentes são com ambiente Android e o ambiente de desenvolvimento de aplicações para o mesmo oferece algumas opções.

O ambiente tradicional de desenvolvimento para Android é o Eclipse ou NetBeans e em ambos a linguagem de programação é o Java. Porém, além desses ambientes de desenvolvimento o Android possui algumas opções que ajudam a facilitar o desenvolvimento em Java.

Entre essas opções se destaca o App Inventor, esse ambiente é open-source e foi criado inicialmente pelo Google. Atualmente quem mantem seu desenvolvimento é o Massachusetts Institute of Technology (MIT).

A grande vantagem de se usar esse ambiente é que o desenvolvimento não ocorre em Java e sim através de blocos de códigos que parecem um fluxograma. A ideia é que pessoas que não possuem afinidade em ambientes de programação possam desenvolver seu programa para Android bastando apenas conhecimento de lógica. Isso ajuda no desenvolvimento pelo fato de até pessoas que não conhecem Java pode arriscar criar um App, visto que em Java a curva de aprendizado é muito maior.


[ 39 ]

App Inventor

Para começar a desenvolver no ambiente App Inventor acesse o endereço:

http://appinventor.mit.edu/explore/

Existem duas versões que podem ser usadas para desenvolvimento, a versão beta que foi lançada no início do projeto que ainda está disponível para uso e a versão MIT App Inventor 2 que também é beta mas que possui melhorias em seu ambiente. Para esse projeto será usado a segunda versão, acesse o link citado anteriormente e clique no botão “Create”. Veja na figura:

Figura 42 Vale lembrar que para poder criar Apps é necessário ter uma conta no Google que ao abrir a tela do sistema será solicitado ao usuário. Veja a tela inicial do App Inventor:

Figura 43

Clique no botão “New Project” e coloque um nome para o projeto, no exemplo

abaixo foi colocado “carrinho_guincho”.


[ 40 ]

Figura 44 Veja a tela inicial do ambiente App Inventor 2:

Figura 45

A tela de projeto do App Inventor é dividida em algumas partes para facilitar o desenvolvimento.

Na parte superior é possível acessar o menu “Project” que permite criar, importar, salvar um projeto. No menu “Connect” é possível se conectar aos ambiente de testes da aplicação que está sendo desenvolvida tais como emulador e usb.

No menu “Build” é possível criar o App para ser descarregado no computador para posteriormente instalá-lo no celular ou fazer a instalação diretamente no celular usando o Wifi do mesmo.


[ 41 ]

Figura 46

Na parte logo abaixo da superior onde se encontra o nome do projeto existem botões para selecionar outra tela caso exista, adicionar novas e remove-las também. Á direita desse menu tem os botões “Designer” que é a própria tela de desenvolvimento da aplicação e o botão “Blocks” onde serão colocados os códigos e a lógica para aplicação funcionar.

Figura 47

O meio da tela é dividido em quatro partes, sendo que da esquerda para a direita tem a seção “Palette” onde fica os objetos para serem colocados na aplicação.


[ 42 ]

Figura 48

Na sequência tem a tela ”Viewer” de desenvolvimento onde são colocados os

objetos do “Palette” e mostra como ficará a tela do celular.

Figura 49

Em seguida tem a seção de “Components” onde pode ser selecionado os objetos

que foram colocados na “Viewer”.


[ 43 ]

Figura 50

E por último a direita a seção “Properties” onde ficam todas a propriedades dos

objetos que forem selecionados na seção “Components”.

Figura 51


[ 44 ]

Começando a aplicação

Para começar a colocar os objetos na tela “Viewer” é necessário configurar a tela inicial da aplicação. Selecione na seção “Componets” o objeto “Screen1” e na seção “Properties” mude as configurações igual da figura abaixo:

Figura 52

Arraste para a tela “Viewer” os componentes a seguir:


[ 45 ]

Figura 53

Componente “BluetoothClient” responsável por fazer a conexão do celular com o sensor “Bluetooth” do Arduíno.


[ 46 ]

Figura 54

Componente “Notifier” responsável por enviar mensagem de alerta para o usuário.


[ 47 ]

Figura 55

Componente “Clock” responsável por controlar o fluxo de informações da aplicação. Com o objeto “Clock1” selecionado mude a propriedade “TimerInterval” para 10. Esse componente auxiliará o controle de pressionamento dos botões durante a

execução da aplicação. No final a tela deve ficar como na figura abaixo. Note que esses componentes não

aparecem na tela, pois não são componentes que o usuário terá acesso, eles apenas são usados na programação.


[ 48 ]

Figura 56

Montando a tela Arraste um componente “HorizontalArrangement” da aba “Layout” para tela de

desenvolvimento e mude as propriedades “Width” para “Fill parent” e “AlignHorizontal” para Center. Veja na figura:

Figura 57

Arraste mais dois componentes “HorizontalArrangement” para a tela e configure as

propriedades de acordo com a anterior.


[ 49 ]

Figura 58

Na aba “User Interface” localize o objeto “Button” e arraste dois deles para a primeira “HorizontalArrangement”.

Selecione o primeiro botão e na parte inferior da aba “Components” clique no botão “Rename” e mude o nome dos botões para “btconectar” e “btdesconectar” respectivamente, veja na figura:

Figura 59

Esses botões serão os responsáveis por conectar e desconectar o celular no sensor Bluetooth do carrinho.

Mude as propriedades de cada botão conforme abaixo: BackgroundColor: Red. FontSize: 10. Shape: rounded. Text: “Conectar” e “Desconectar” respectivamente. Width: Fill parent. Height: 35 pixels.


[ 50 ]

Figura 60

Arraste mais dois botões na segunda “HorizontalArrangement” e renomeie para “btguinchosubir” e “btguinchodescer” respectivamente. Mude a propriedades conforme segue abaixo: BackgroundColor: Blue. FontBold: marcado. FontSize: 11. Shape: rounded. Text: “Guincho +” e “Guincho –“ respectivamente. Width: Fill parent. Height: 35 pixels.

Esses botões serão responsáveis por erguer o guincho do carrinho, veja na figura como ficou:


[ 51 ]

Figura 61

Arraste mais dois botões na terceira “HorizontalArrangement” e renomeie para “btbracosubir” e “btbracodescer” respectivamente. Mude a propriedades conforme segue abaixo: BackgroundColor: Orange. FontBold: marcado. FontSize: 14. Shape: rounded. Text: “Braço +” e “Braço –“ respectivamente. Width: Fill parent. Height: 35 pixels. Esses botões serão responsáveis por erguer o braço do carrinho, veja na figura como ficou:

Figura 62

Faltam ainda os botões que serão responsáveis por controlar o carrinho para frente e para trás e para esquerda e direita. Acrescente um objeto “TableArrangement” da aba


[ 52 ]

“Layout” e mude as propriedades “Columns” para três e “Rows” para seis, ou seja três colunas por seis linhas.

Figura 63 Acrescente oito botões dentro do objeto “TableArrangement” como na figura abaixo:

Figura 64 Mude as propriedades do botão “Button1” de acordo com a listagem abaixo: Name: btpfrapido. BackGroundColor: Red. FontBold: true. Shape: Rounded. Text: PF Rápido. Width: Fill parent. Height: 30 pixels. Mude as propriedades do botão “Button2” de acordo com a listagem abaixo:


[ 53 ]

Name: btpfmedio. BackGroundColor: Yellow. FontBold: true. Shape: Rounded. Text: PF Médio. Width: Fill parent. Height: 30 pixels. Mude as propriedades do botão “Button3” de acordo com a listagem abaixo: Name: btpflento. BackGroundColor: White. FontBold: true. Shape: Rounded. Text: PF Lento. Width: Fill parent. Height: 30 pixels. Mude as propriedades do botão “Button4” de acordo com a listagem abaixo: Name: btparar. FontBold: true. Shape: Rounded. Text: Parar. Width: Fill parent. Height: 30 pixels. Mude as propriedades do botão “Button5” de acordo com a listagem abaixo: Name: btptlento. BackGroundColor: White. FontBold: true. Shape: Rounded. Text: PT Lento. Width: Fill parent. Height: 30 pixels. Mude as propriedades do botão “Button6” de acordo com a listagem abaixo: Name: btptrapido. BackGroundColor: Red. FontBold: true. Shape: Rounded. Text: PT Rápido. Width: Fill parent. Height: 30 pixels. Mude as propriedades do botão “Button7” de acordo com a listagem abaixo:


[ 54 ]

Name: btesquerda. FontBold: true. Shape: Rounded. Text: <<<<<<. Width: Fill parent. Height: 30 pixels. Mude as propriedades do botão “Button8” de acordo com a listagem abaixo: Name: btdireita. FontBold: true. Shape: Rounded. Text: >>>>>>. Width: Fill parent. Height: 30 pixels. Veja como deve ficar a tela do celular depois de alterar os botões:

Figura 65


[ 55 ]

Programando a aplicação

Para programar o aplicativo não é necessário ter conhecimentos em Java que é a linguagem de programação padrão do Android, a programação será através de blocos que parecem com um fluxograma, bastando ter apenas lógica para criar uma aplicação. Clique no botão “Blocks” situado no canto direito da tela, veja na figura:

Figura 66

Conexão com o sensor Bluetooth

Na tela de blocos do lado esquerdo se encontra os componentes que fazem parte da tela da aplicação onde alguns deverão ser arrastados para o lado direito a fim de fazer o carrinho se movimentar. Selecione o componente “Screen1” e localize o bloco destacado na figura abaixo:

Figura 67 Arraste o mesmo para o lado direito da tela na parte em branco.


[ 56 ]

Figura 68

Selecione em “Blocks” o item “Built-in” e na opção “Control” selecione o bloco “if then”. Veja na figura:

Figura 69

Encaixe o bloco “if then” dentro do bloco “when Screen1” arrastado anteriormente.

Figura 70

No item “Built-in” selecione na opção “Logic” o bloco “not” e encaixe na frente do bloco “if”, veja na figura:


[ 57 ]

Figura 71

No item “Screen1” selecione o item “BluetoothClient1” e arraste o bloco “BluetoothClient1 Enabled”.

Figura 72

Arraste do item “Notifier1” o bloco “call Notifier1 .ShowChooseDialog” listado na figura abaixo:

Figura 73

No item “Built in” escolha “Text” e arraste o primeiro bloco da parte superior em cada encaixe do bloco “Notifier1”. Em cada bloco acrescente os textos listados na figura abaixo:


[ 58 ]

Figura 74

A lógica embutida nesse bloco é para testar se ao inicializar a tela do aplicativo o Bluetooth está conectado ou não. Se não estiver conectado será informado ao usuário através da mensagem desse bloco. Note que não foi necessário programar nenhum código até agora, tudo foi feito arrastando blocos para montar a lógica para funcionar a aplicação.

Depois que o usuário ver a mensagem que o Bluetooth não está conectado ele terá de escolher na mensagem o botão “OK” ou “Sair”.

Selecione no item “Notifier1” o bloco “when Notifier1 .AfterChoosing” e arraste abaixo do bloco da figura anterior em um local em branco. Selecione também no bloco “Built- in” no item “Control” o bloco “if then” e arraste dentro do bloco “when Notifier1 .AfterChoosing”.

Dentro desse bloco do lado esquerdo do “if” tem um ponto em destaque que deve ser selecionado para podermos arrastar o “else” dentro do bloco “if then”, veja na figura:

Figura 75

Note que a instrução “else” passa a incorporar o bloco condicional “if then”. No item “Built in” selecione “Math” e escolha a caixa em destaque da figura abaixo:


[ 59 ]

Figura 76

Na aba “Built-in” escolha o item “Variables” e arraste o bloco “get” para dentro da primeira caixa na frente do “if” e escolha “choice” na caixa de seleção.

Figura 77

Ainda na aba “Built-in” escolha “Text” e arraste dentro da segunda caixa depois do símbolo “=”. Mude o texto da caixa para “OK”.

Figura 78

No item “Notifier1” escolha o bloco “call Notifier1 .ShowAlert” e arraste na frente da opção “then”, junto com esse bloco coloque na frente uma caixa de texto “Text” e escreva a mensagem “Ative o Bluetooth”.


[ 60 ]

Figura 79

Arraste da aba “Built-in” no item “Control” o bloco “close application” e coloque na frente o bloco “else”.

Figura 80

A lógica desse bloco é que se o usuário clicar na mensagem no botão “OK” vai aparecer a mensagem “Ative o Bluetooth” caso contrário se o usuário clicar no botão sair o fluxo é desviado para o bloco “else” que encerrará a aplicação.

Na aba “Screen1” selecione o botão “btconectar” e arraste o bloco “when btconectar .Click” abaixo do bloco anterior em uma área em branco.

Figura 81

Arraste para dentro desse bloco um bloco “if then else” (aba Control) um bloco “not” (aba Logic) e um bloco “Bluetooth1 Enabled” (aba BluetoothClient1), veja na figura:


[ 61 ]

Figura 82

Na aba “Notifier1” selecione um bloco “call Notifier1.ShowAlert” e arraste na frente do “then” do bloco “if then else”, arraste também um bloco de texto da aba “Text”.

Figura 83

Para terminar esse bloco de código é necessário acrescentar um objeto na tela da aplicação que será o responsável por obter o MAC Address do sensor bluetooth do Arduíno para a aplicação se conectar a ele. Abra a tela da aplicação (botão Design, canto superior direito) e na aba “User Interface” selecione o objeto “ListPicker” e arraste abaixo dos botões.

Figura 84

Mantenha o objeto selecionado e na propriedade “Visible” mude para “hidden” para que o objeto não fique visível para o usuário na aplicação. Voltando na tela de código (Blocks) selecione o objeto “ListPicker1”, localize o bloco “call ListPicker1 .Open” e arraste na frente do bloco else. Veja na figura:


[ 62 ]

Figura 85

A lógica desse bloco é que se o bluetooth não estiver conectado no celular vai aparecer a mensagem ao usuário para ele ativar o mesmo, caso contrário o “ListenPicker” será aberto com o endereço MAC Address do sensor bluetooth.

Ainda falta acrescentar no objeto “ListPicker1” os endereços Mac encontrados, para isso devemos criar um bloco específico.

No objeto “ListPicker1” selecione o bloco “when ListPicker1 .BeforePicking” e arraste abaixo do bloco “when btconectar .Click”. Arraste também o bloco “set ListenPicker.Elements to” e encaixe dentro do bloco “when ListPicker1 .BeforePicking”.

Na frente do bloco “set ListenPicker.Elements to” selecione o objeto “BluetoothClient1” e arraste o bloco “BluetoothClient1.AdressesAndNames”. Esse objeto é que irá obter o endereço Mac do sensor e acrescentará ao objeto “ListPicker1”. Veja na figura:

Figura 86

Quando o usuário selecionar o Mac do sensor a aplicação se conectará ao mesmo, para demonstrar que a conexão ocorreu com sucesso será criado na sequencia um bloco de código que mudará o texto do botão conectar para “Conectado” e também mudará a cor do botão de vermelho para verde.

Selecione o bloco “when ListPicker1.AfterPicking” e dentro do mesmo acrescente um bloco “if then else”.


[ 63 ]

Figura 87

Acrescente na frente do “if” um bloco “call BluetoothClient1.Connect address” do objeto “BluetoothClient1", arraste também o bloco “ListPicker1.Selection” do objeto “ListPicker1” na frente do bloco “call BluetoothClient1.Connect address”. Veja na figura:

Figura 88

Para programar o bloco “then” arraste do objeto “btconectar” o bloco “set btconectar.BackgroundColor to” e na frente encaixe da aba “Colors” o bloco da cor verde.

Figura 89

Ainda falta mudar o texto do botão para “Conectado” para isso arraste abaixo do bloco “set btconectar.BackgroundColor to” dentro do bloco “then” o bloco “set btconectar.Text to” e na frente um bloco de texto escrito “Conectado”. Veja na figura:


[ 64 ]

Figura 90

No bloco “else” arraste um bloco “call Notifier1.ShowAlert” com um bloco de texto escrito “Não foi possível conectar.”. Abaixo desse bloco copie o bloco “set btconectar.BackGroundColor to” e acrescente a cor vermelha para mostrar ao usuário que não ouve conexão.

Figura 91

A parte de conexão do botão “Conectar” está pronta falta agora programar o botão “Desconectar” para isso arraste o bloco “when btdesconectar.Click” e dentro do mesmo um bloco “if then else”.

Figura 92


[ 65 ]

Na frente do “if” arraste o bloco “BluetoothClient1.IsConnected” do objeto

“BluetoothClient1”. No bloco “then” arraste do objeto “BluetoothClient1” o bloco “call BluetoothClient1.Disconnect”. Abaixo desse bloco acrescente do objeto “Notifier1” o bloco “call Notifier1.ShowAlert” e na frente um bloco de texto escrito “Conexão desativada.”.

Acrescente também abaixo do bloco “call Notifier1.ShowAlert” um bloco “set btconectar.BackgroundColor to” com a cor vermelha na frente para mudar a cor do botão “Conectar” quando a conexão for interrompida.

Figura 93

No bloco “else” copie o bloco “call Notifier1.ShowAlert” com a mensagem de conexão desativada e mude a mensagem para “Não existe conexão ativa.”. Veja na figura:

Figura 94


[ 66 ]

Movendo os motores

Para mover os motores temos que programar cada botão, porém o comportamento dos botões tem algumas particularidades que devem ser ressaltadas. Os botões que moverão o carrinho para frente e para trás devem ao ser clicado enviar uma letra para o programa que está no Arduíno. Por exemplo, se o motor deve girar para frente de forma lenta deve ser enviada a letra “S” pela conexão Bluetooth e isso ocorre com cada botão que movimenta os motores bastando apenas um clique em cada botão.

Porém o braço do guincho assim como o próprio guincho deve subir ou descer de forma contínua enquanto os botões estiverem pressionados e ao parar de pressioná-los ambos devem parar. Dessa forma o comportamento desses botões deve ser diferente, pois se for enviada uma letra uma única vez para o Arduíno através de um clique apenas o guincho irá se mover apenas poucos centímetros e daí irá parar. Para resolver essa questão foi acrescentado o objeto “Clock1” na tela da aplicação, através desse objeto é possível enviar de forma contínua a letra necessária para que o guincho se mova enquanto o botão estiver pressionado. Dessa forma é necessário criar variáveis globais para que seja possível controlar o pressionamento de cada botão. Crie uma variável global através da aba “Variables”, escolha o bloco “initiaze global to” e arraste em uma área em branco do código. Mude o nome da mesma para “bracodesce” e na frente da mesma acrescente da aba “Logic” um bloco “false”. Veja na figura:

Figura 95 Acrescente uma variável para cada botão seguindo a relação de nomes abaixo: bracodesce bracosobe guinchodesce guinchosobe flento fmedio frapido tlento


[ 67 ]

trapido parar esquerda direita Veja as variáveis criadas na figura abaixo:

Figura 96

As variáveis flento, fmedio e frapido são para movimentar o motor para frente em três velocidades. As variáveis tlento e trapido são para mover o motor para trás. Esquerda e direita são para controlar o servo da direção enquanto que a variável parar obviamente é para parar o motor.

Com as variáveis criadas é possível programar os eventos de cada botão para controlar os motores. Localize na aba do botão “btbracosubir” o bloco “when btbracosubir.TouchDown” e arraste para a área em branco do código. Esse evento ocorrerá quando o botão “btbracosubir” for pressionado e a variável “bracosobe” passa e ser “true”.

Coloque dentro desse evento o bloco “set to” da aba “Variables”, mude o nome na parte interna para “global bracosobe”. Na frente encaixe um bloco “true” da aba “Logic”, veja na figura:

Figura 97

Acrescente o bloco “when btbracosubir.TouchUp” na parte em branco do código e encaixe à variável "global bracosobe” com o valor “false”.

Figura 98


[ 68 ]

A lógica desses eventos é que quando o botão “btbracosubir” for pressionado a

variável “global bracosobe” fica “true”, ao soltar o botão através do evento “TouchUp” a variável “global bracosobe” passa a ficar “false”.

É necessário fazer o mesmo procedimento para todos os botões e suas respectivas variáveis que foram criadas. Botão “btbracodescer”:

Figura 99 Botão “btguinchosubir”:

Figura 100 Botão “btguinchodescer”:

Figura 101 Botão “btpfrapido”:

Figura 102 Botão “btpfmedio”:

Figura 103 Botão “btpflento”:


[ 69 ]

Figura 104 Botão “btptrapido”:

Figura 105 Botão “btptlento”:

Figura 106 Botão “btparar”:

Figura 107 Botão “btesquerda”:

Figura 108 Botão “btdireita”:

Figura 109


[ 70 ]

Testando as variáveis e escrevendo na saída Bluetooth

As variáveis e seus respectivos eventos já estão prontos, note que foram criados dois eventos para cada variável. O evento “TouchDown” ocorre quando o usuário pressiona um botão e a variável fica “true”, o evento “TouchUp” ocorre quando o usuário solta o botão e a variável passa a ser “false”.

Falta somente programar as letras que serão enviadas via Bluetooth para o programa que está instalado na placa do Arduíno e que foi programado anteriormente.

Para enviar os valores será feito uso do bloco “when Clock1.Timer”, esse bloco fica verificando a cada instante qual variável mudou de valor em algum momento e através de testes condicionais possa escrever as letras correspondentes para o Arduíno.

Arraste um bloco “when Clock1.Timer” do objeto “Clock1” na área em branco do código, veja na figura:

Figura 110

Dentro do bloco “when Clock1.Timer” acrescente um bloco “if” com vários “else if”

encadeado, veja na figura como deve ficar:

Figura 111

No “if” assim como em cada “else if” será testada cada variável para poder escrever

ou não na conexão Bluetooth. Na aba “Math” selecione e arraste o bloco da figura abaixo na frente da condicional

“if”.


[ 71 ]

Figura 112

Acrescente na caixa vazia do lado esquerdo do bloco que foi adicionado

anteriormente um bloco “get” da aba “Variables”. Do lado direito acrescente na caixa em branco um bloco “true” da aba “Logic”. Veja como deve ficar:

Figura 113

Na frente do “then” arraste do objeto “BluetoothClient1” o bloco “call

BluetoothClient1.SendText” e na frente da opção “text” coloque da aba “Text” uma caixa de texto com a letra “E” dentro, veja na figura:

Figura 114


[ 72 ]

Dessa forma se o botão “btbracosubir” for pressionado a variável “bracosobe” passa a ser “true” e através dessa rotina no objeto “Clock1.Timer” é testado quais variáveis estão “true”, ou seja, é verificado qual botão foi pressionado para enviar a letra correspondente para o programa instalado no Arduíno. Nesse caso da figura anterior é enviado via Bluetooth a letra “E” que quando chegar ao programa do Arduíno vai acionar o servo motor para erguer o braço do guincho. Agora que o primeiro bloco condicional está pronto basta ir copiando os blocos e alterando as propriedades para enviar todas as letras necessárias para o Arduíno mover os motores. Segue abaixo como deve ficar cada envio de letra: Bloco a variável “bracodesce” enviando a letra “R”.

Figura 115 Bloco da variável “guinchosobe” enviando a letra “Q”.


[ 73 ]

Figura 116 Bloco da variável “guinchodesce” enviando a letra “W”.

Figura 117 Bloco da variável “flento” enviando a letra “S”.

Figura 118 Bloco da variável “fmedio” enviando a letra “D”.


[ 74 ]

Figura 119 Bloco da variável “frapido” enviando a letra “F”.

Figura 120 Bloco da variável “tlento” enviando a letra “Y”.


[ 75 ]

Figura 121 Bloco da variável “trapido” enviando a letra “T”.

Figura 122 Bloco da variável “parar” enviando a letra “P”.


[ 76 ]

Figura 123 Bloco a variável “direita” enviando a letra “L”.

Figura 124 Bloco a variável “esquerda” enviando a letra “K”.


[ 77 ]

Figura 125

Depois de programar o objeto “when Clock1.Timer” com as variáveis e suas respectivas letras a aplicação já esta pronta para ser testada.


[ 78 ]

Gerando o instalador para o celular

Com a aplicação do celular finalizada é necessário gerar o instalador da aplicação para poder ser instalado no celular.

Proceda da seguinte forma, abra no celular o endereço do Google play e localize o app “App MIT AI2”.

Essa é a versão dois dessa aplicação, a versão 1 ainda pode ser baixada porém funciona de forma diferente, portanto verifique se o app que está sendo baixado é realmente a versão dois, veja nas figuras abaixo: Tela de busca

Figura 126 Tela da aplicação

Figura 127

Após o download e instalação do app MIT AI2 no celular é necessário gerar o instalador da aplicação para ser instalado no celular.


[ 79 ]

Existem várias formas de gerar o instalador, uma delas é gerar o arquivo “apk” e fazer o download do mesmo para ser copiado no celular e posteriormente ser feita a instalação. Para isso acesse o menu “Build” do site do MIT e escolha a segunda opção “App(save .apk to my computer)”como mostra a figura abaixo:

Figura 128

Outra forma é gerar um QR code no próprio site do MIT através do menu “Build” e depois usando o app “MIT AI2” do celular fazer a leitura do QR code através do scanner do mesmo e deixar que o app se encarregue de fazer o download e instalação da aplicação.

Figura 129 Barra de progresso de geração da aplicação:

Figura 130

Após a geração da aplicação aparece o QR code para ser scaneado pelo celular através do app do MIT. Para esse procedimento é necessário o celular estar conectado á Internet para ser feito o download e instalação. Veja o QR code na figura a seguir:


[ 80 ]

Figura 131

Abra o app do MIT, acione o scanner do mesmo e coloque o celular perto da tela do computador para que seja feita a leitura do QR code. Assim que a leitura for feita é iniciado o download e instalada a aplicação.


[ 81 ]

Testando o carrinho

Concluída a construção do carrinho e das aplicações no Arduíno e no celular é necessário testar se o carrinho se movimenta pelos comandos do celular.

Conecte todos os cabos descritos nos passos iniciais dessa apostila, anexe a fonte de alimentação de energia construída com as baterias em um local que não atrapalhe o movimento do carrinho. Veja na figura abaixo que a fonte de alimentação foi colocada na parte da frente do carrinho.

Figura 132

Depois de fixar a fonte de alimentação faças as ligações com os cabos de alimentação externa do “Motor Shield”, veja na figura:

Figura 133


[ 82 ]

Terminado as ligações o sensor deve ficar piscando aguardando a conexão do

celular, assim que a conexão ocorrer o mesmo fica aceso enquanto estiver conectado. Para conectar inicie a aplicação do celular e pressione o botão “Conectar”, na

sequencia irá aparecer o número “MAC Address” do sensor para ser selecionado, se a conexão ocorrer normalmente o botão conectar muda da cor vermelho para o verde. A partir daí é só pressionar qualquer botão da aplicação para que o motor respectivo seja acionado.

Se por algum motivo não houver reação dos motores, verifique a conexão dos cabos do sensor Bluetooth do Arduíno principalmente os cabos que estão ligados ao Motor Shield.


[ 83 ]

Referências bibliográficas

Arduíno, What is Arduíno. Disponível em: <http://www.arduino.cc> Acesso em 8 de Junho de 2104.

MIT App Inventor, Getting Started with MIT App Inventor 2. Disponível em:

<http://appinventor.mit.edu/explore/get-started?> Acesso em 9 de Julho de 2104. MIT App Inventor 2. Getting Started with MIT App Inventor 2. Disponível em:

<http://ai2.appinventor.mit.edu> Acesso em 9 de Julho de 2104. Blog FILIPEFLOP, Controle Motor DC 12V com Arduíno Motor Shield L293D.

Disponível em: http://blog.filipeflop.com/motores-e-servos/controle-motor-dc-arduino-motor-shield.html>. Acesso em 25 de Junho de 2104.

Apostila Arduino eBook - Prof. Davi

Documents

Transcript of Apostila Arduino eBook - Prof. Davi