Arduino: Robot controlado por movimentos do telemóvel

Por Ricardo Sousa e Diogo Pinho para o Pplware.com

Temos apresentado neste segmento algumas boas novidades. Quem gosta de Arduino sabe que é um mundo infinito de possibilidades, das mais simples às mais complexas e arrojadas. É  isso que vamos hoje mostrar. Um projecto desenvolvido pelos nossos leitores, Ricardo Sousa e Diogo Pinho e que mostra uma vertente mais arrojada do Arduino.

Neste trabalho vamos desenvolver uma comunicação via Bluetooth entre um telemóvel com tecnologia Android e um microprocessador em placa Arduino, adaptado e desenvolvido para receber comandos e executa-los. Esta combinação vai ser feita com o intuito de guiar um pequeno robot telecomandado através de um telemóvel com tecnologia Android.

Para dar vida ao projecto, foi desenvolvida uma aplicação para correr em Android, com funções para envio e recepção de dados para uma plataforma Arduino através de um modulo Bluetooth.

O carro robot foi adaptado e desenvolvido com alguns componentes já existentes no mercado, e que tínhamos em nossa posse, para que fosse possível lhe dar movimento e reagir quando lhe fossem enviados alguns sinais específicos através de um smartphone, sendo assim uma simulação em tempo real. Ver vídeo no final do artigo!

Desenvolvimento Teórico

Material usado neste projecto

• 1 Arduino NANO V3.0
• 1 Bluetooth HC-05
• 1 Base de 4 relés
• 1 Breadboard
• 2 Motores DC
• 1 Bateria 7.2V-2100mA
• 1 7805
• 1 Roda livre
• 1 LDR

Arduino nano V3.0

Usámos esta versão de um Arduino por ter pequenas dimensões e possuir memória e portas suficientes para o projecto pretendido. Sendo possível ligar um dispositivo Bluetooth para fazer a comunicação com o telemóvel.

Potência

O Arduino Nano pode ser alimentado através da ligação USB Mini-B ou 5V fonte de alimentação externa (pino27).

A fonte de alimentação é seleccionada automaticamente para a fonte de maior tensão. A FTDI FT232RL chip na Nano só é alimentado se a placa estiver alimentada através de USB.

Como resultado, quando em execução do (não-USB) de energia externa, a saída 3.3V (que é fornecida pelo chip FTDI) não está disponível e os RX e TX LEDs irão piscar se pinos digitais 0 ou 1 forem elevados.

Memória

O ATmega328 tem 32 KB, (também com 2 KB usados ​​para o bootloader).

Entrada e Saída

Cada um dos 14 pinos digitais do nano pode ser utilizado como uma entrada ou uma saída, usando pinMode () , digitalWrite () , e digitalRead ().

Eles operam com 5 volts. Cada pino pode fornecer ou receber um máximo de 40mA e tem uma resistência pull-up interna de 20-50 kOhms. Além disso, alguns pinos têm funções especializadas:

• Serial: 0 (RX) e 1 (TX). Usados ​​para recepção (RX) e de transmissão (TX) de dados serie TTL. Estes pinos são ligados aos pinos correspondentes do USB-TTL chip serial FTDI.

• Interrupções externas: 2 e 3 Estes pinos podem ser configurados para disparar uma interrupção por um valor baixo, uma borda de subida ou queda, ou uma mudança de valor.

• PWM: 3, 5, 6, 9, 10, 11 e fornecer a saída PWM de 8 bits com a função analogWrite ().

• SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estes pinos suportam comunicação SPI, que, embora fornecido pelo hardware subjacente, não está incluída na linguagem Arduino.

• LED: 13. Há um built-in LED conectado ao pino digital 13 Quando o pino é de alto valor, o LED está ligado, quando o pino é LOW, este LED esta inserido na placa e externo ao chip.

O Nano tem 8 entradas analógicas, cada uma das quais com 10 bits de resolução (1024 valores diferentes). Por padrão elas medem de 0 até 5 volts, embora seja possível mudar o limite superior de sua faixa usando a função analogReference ().

Comunicação

O Arduino Nano tem uma série de facilidades para se comunicar com um computador, outro Arduino ou outros microcontroladores. O ATmega328 fornece UART TTL (5V) de comunicação serial, que está disponível nos pinos digitais 0 (RX) e 1 (TX). Um FTDI FT232RL nos canais de tabuleiro esta comunicação serial através da USB e os drivers FTDI (incluído com o software Arduino) fornecem uma porta COM virtual para o software no computador.

O software Arduino IDE inclui um monitor serial que permite que dados simples de texto sejam enviados de e para a placa Arduino. Os RX e TX LEDs na placa pisca quando os dados estão a ser transmitidos pelo chip FTDI e a conexão USB para o computador.

A biblioteca Software Serial permite comunicação serial em qualquer um dos pinos digitais do Nano.

O ATmega328 também suporta I2C (TWI) e comunicação SPI. O software Arduino inclui uma biblioteca Wire para simplificar o uso do I2C bus.

Programação

O Arduino Nano pode ser programado com o software Arduino. O ATmega328 no Arduino Nano vem com um bootloader que permite o envio de novos códigos sem o uso de um programador de hardware externo. Ele se comunica com o original STK500 protocolo. Também pode ignorar o bootloader e programar o microcontrolador através do ICSP (programação de série In-Circuit).

HC-05 Bluetooth

O modulo Bluetooth HC-05 permite a comunicação entre o Arduino e outros dispositivos Bluetooth por meio de transferência de dados Serial TTL.

Com esse módulo é possível controlar servos, motores, escrever textos num LCD, etc. Este módulo foi inserido e conectado com o Arduino para nos possibilitar a comunicação com o telemóvel através de um protocolo Bluetooth criado por nós.

Uma das suas vantagens é ser pequeno , leve e robusto tendo uma comunicação rápida e fiável (<10 metros=”” para=”” aceder=”” s=”” suas=”” configura=”” es=”” internas=”” como=”” o=”” nome=”” a=”” apresentar=”” pin=”” de=”” seguran=”” velocidade=”” comunica=”” deveremos=”” utilizar=”” comandos=”” at=”” p=””>).

Para o nosso projecto temos de usar alguns dos seguintes comandos:

• AT -> Testar a ligação
• AT+VERSION -> Para sabermos a versão do módulo
• AT+ROLE=1 -> Configurar o módulo como MASTER (0 é Slave)
• AT+CMODE=0 -> Para estabelecer ligação com o último dispositivo (automaticamente)
• AT+INIT -> Inicializar
• AT+INQ -> Pesquisar outros equipamentos bluetooth
• AT+INQC -> Terminar a pesquisa
• AT+RNAME -> Perguntar o nome de um determinado equipamento Bluetooth (através do seu endereço)
• AT+FSAD -> Pesquisar o referido equipamento na lista de autenticação de módulos já autenticados anteriormente (se existir)
• AT+BIND -> Para vincular um equipamento ao módulo HC-05
• AT+PAIR -> Efectuar o emparelhamento com o equipamento pretendido
• AT+LINK -> Estabelecer ligação

Mais informações sobre os comandos existentes: Ver aqui.

Características:

• Bluetooth v2.0+EDR
• Modo de operação Master ou Slave
• Frequência: 2.4GHz ISM band
• Modulação: GFSK(Gaussian Frequency Shift Keying)
• Potência: ≤4dBm, Class 2
• Sensibilidade: ≤-84dBm at 0.1% BER
• Velocidades: Assíncrona 2.1Mbps(Max) / 160 kbps, Síncrona: 1Mbps/1Mbps
• Segurança: Autenticação e Encriptação
• Perfil: Bluetooth serialport
• Alimentação: +3.3VDC 50mA
• Temperatura Ambiente: -20 ~ +75 C
• Dimensões: 28mm x 15 mm x 2.35mm

Módulo 4 relés 5v

Utilizamos neste projecto este módulo de relés, visto não possuirmos em “stock” nenhum componentes electrónico que fizeste o trabalho de Ponte-H para o controlo dos motores, sendo neste caso o componente ideal para este fim.

Este é um módulo de 4 relé de 5V (AC250V 10A; DC30V 10A) capaz de controlar vários dispositivos e equipamentos com grandes correntes. Este módulo pode ser controlador directamente por um microcontrolador: Arduino, 8051, AVR, PIC, DSP, ARM, ARM, MSP430, TTL logic.

Características

• Módulo de 4 relés de 5V
• Equipado com 4 relés de alta-corrente: AC250V 10A ; DC30V 10A
• Interface Standard que pode ser controlada directamente por um microcontrolador: Arduino, 8051, AVR, PIC, DSP, ARM, MSP430, TTL logic
• 4 LED de indicação de estado da saída do relé
• Sinal de controlo TTL de 3,5V-12V
• Há um contacto normalmente aberto e um contacto normalmente fechado
• A bobine do relé é accionado por um transístor e não directamente pelo microcontrolador.
• O circuito dos pinos é pull-down para prevenir flutuações no relé

Motor DC

Estes dois equipamentos são as nossas fontes de energia cinética que nos permite movimentar o nosso carro telecomandado.

Quando o Arduino recebe ordens para se movimentar este da indicação aos relés para abrir ou fechar consoante o que pretendemos o que nos dá a liberdade de mover o carro telecomandado num sentido ou no sentido oposto, assim para além de termos deslocamento em linha recta podemos manobrar o carro telecomandado em 360º a sua volta porque cada motor e alimentado e comandado individualmente.

Características:

• Opera entre os 3-6v
• Diâmetro 65mm
• 120RPM (6v)
• 100mA (3v), 120mA (6v)
• Redutora 1:120

Pela forma em que ele se encontrava montado, para o controlo de movimentos os relés funcionavam da seguinte forma:

*Estes movimentos poderão alterados caso sejam trocados os condutores que alimentam o respectivo motor DC.

Bateria 7.2V-2100mA

Bateria para fornecer energia a todo equipamento instalado no carro.

Esta bateria tem uma grande autonomia o que nos permite estar longos períodos em actividade com o equipamento.

Limitador de tensão 7805

Tivemos de integrar este componente, porque segundo as características do Arduino nano não podemos usar uma tensão superior a 5v na entrada externa do Arduino, para que tal não acontecesse colocámos um 7805 para baixar a tensão para os 5V na entrada visto que temos uma bateria que nos fornece 7,2v.

Roda livre

Este componente permite o carro virar 360º livremente e com menos atrito. Assim podemos manobrar o carro com as duas rodas motorizes e facilitar os movimentos em sítios apertados, ou com pouca liberdade de movimento.

LDR

Com este componente vamos verificar e enviar valores por Bluetooth para o telemóvel onde poderemos observar a luminosidade a que o carro esta a ser sujeito enquanto este se vai movimentando.

LDR (Light Dependent Resistor) possui uma característica que faz com que sua resistência varie conforme a luminosidade incidida sobre ele. Isto possibilita a utilização deste componente para desenvolver um sensor que é activado (ou desactivado) quando sobre ele incidir uma certa luminosidade ou utilizar esses dados para variar um PWM que pode estar ligado a motores ou luzes, etc.

A resistência do LDR varia de forma inversamente proporcional à quantidade de luz incidente sobre ele, isto é, enquanto o feixe de luz estiver incidindo sobre ele, o LDR oferece uma resistência muito baixa, e quando este feixe é cortado, sua resistência aumenta.

Desenvolvimento Prático

Hardware

Montagem abaixo realizada em software de esquemas eléctricos, representado os esquemas utilizados neste projecto:

Abaixo poderemos ver uma foto das ligações reais realizadas entre os vários componentes:

Software

Código Arduino

#include SoftwareSerial mySerial(0, 1);
// Portas para comunicação RX, TX PARA O ARDUIN
char state; //para guardar o valor recebido por bluetooth
///////declaração de saidas para os reles para controlo de mov de motores dc /
int LED = 8; //luz presença robot
int MTR0 = 9; //saida para o relé 0
int MTR1 = 10; //saida para o relé 1
int MTR2 = 11; //saida para o relé 2
int MTR3 = 12; //saida para o relé 3
int LEDst = 1;
//para leitura de valores de LDR ligado à porta analogica 5 const int analogInPin = A5;
int sensorValue = 0;
//
void setup() {
// inicializa as portas Serial para o terminal e para o bluetooth para inici
Serial.begin(9600);
Serial.println(“Inicio comunicacao bluetooth”);
mySerial.begin(9600);
mySerial.println(“Inicio comunicacao bluetooth”); //declara as portas de saida
pinMode(LED, OUTPUT);
pinMode(MTR0, OUTPUT);
pinMode(MTR1, OUTPUT);
pinMode(MTR2, OUTPUT);
pinMode(MTR3, OUTPUT);
// declara o estado inicial das portas de saida
digitalWrite(LED,LOW);
digitalWrite(MTR0,HIGH);
digitalWrite(MTR1,HIGH);
digitalWrite(MTR2,HIGH);
digitalWrite(MTR3,HIGH); }

void loop() {
if (mySerial.available()) {
// SE comunicaçao disponivel
state = mySerial.read();// le o valor recebido pelo bluetooth,
// direita /////////////////////////////////////////
if (state == ‘R’ || state == ‘r’) {
digitalWrite(MTR0,LOW);
digitalWrite(MTR1,HIGH);
digitalWrite(MTR2,HIGH);
digitalWrite(MTR3,LOW); }
// esquerda /////////////////////////////////////////
if (state == ‘L’ || state == ‘l’) {
digitalWrite(MTR0,HIGH);
digitalWrite(MTR1,LOW);
digitalWrite(MTR2,LOW);
digitalWrite(MTR3,HIGH); }
// frente /////////////////////////////////////////
if (state == ‘F’ || state == ‘f’) {
digitalWrite(MTR0,LOW);
digitalWrite(MTR1,HIGH);
digitalWrite(MTR2,LOW);
digitalWrite(MTR3,HIGH); }
// tras /////////////////////////////////////
if (state == ‘B’ || state == ‘b’) {
digitalWrite(MTR0,HIGH);
digitalWrite(MTR1,LOW);
digitalWrite(MTR2,HIGH);
digitalWrite(MTR3,LOW); }
// PARAR/////////////////////////////////////////
if (state == ‘S’ || state == ‘w’) {
digitalWrite(MTR0,HIGH);
digitalWrite(MTR1,HIGH);
digitalWrite(MTR2,HIGH);
digitalWrite(MTR3,HIGH); }
// leitura de sensor //////////////////////////////////
sensorValue = analogRead(analogInPin);
Serial.println(sensorValue);
// envia para TERMINAL e BLUETOOTH valor ////////////// Ligar/desligar luz ////////////////////////
if (state == ‘0’) {
digitalWrite(LED,LOW);
}
if (state == ‘1’) {
digitalWrite(LED,HIGH);
} /////////////////////////////////////////////////////////////////////////////////
delay(100);
} }

Aplicação Android

Este programa foi desenvolvido na aplicação APP Inventor2:

Código Android

Aqui pode fazer download do ficheiro ponte para utilizar no APP Inventor 2

Menu 1

Menu 2

Menu 3

Conclusão

Neste trabalho encontrámos um nível de dificuldade acrescido devido à comunicação ser feita através de um telemóvel com tecnologia Android o que exigia a aprendizagem de uma nova linguagem para programar uma aplicação que nos possibilitasse a comunicação com o carro telecomandado e assim enviar as ordens para ele se movimentar.

Depois de muita pesquisa, e bastantes ensaios foi possível a desenvolver uma aplicação para telemóvel que nos permitisse enviar comandos. Na mesma aplicação ainda integramos a possibilidade de ler os valores obtidos pelo LCD instalado no robot, assim obtivemos uma comunicação bi-direccional.

Criámos um código em linguagem Arduino para poder executar as ordens, testámos e montámos um protótipo para podermos simular em tempo real e visualizar o carro telecomandado a mover. Tivemos alguns problemas em criar o carro devido ao curto espaço de tempo e falta de material mas com alguma destreza e criatividade concluímos com êxito o projecto que nos tínhamos proposto: Um carro/robot comandado sem á distancia, através de movimentos de um smartphone.

Resultado em vídeo:

Primeira parte:

Segunda parte:

Este projecto abriu novos horizontes e motivou nos para novos projectos com graus de complexidade superiores.