Bluetooth : BT Shield (Slave) V2.1 + Android app

O módulo adquirido da Itead Studio ficou guardado por mais de um ano. Algumas dificuldades técnicas e o advento do Raspberry Pi, deixaram de lado os projetos de conectividade usando a configuração Arduino + Shield. Privar nossos amigos de conhecer os segredos do Bluetooth não faz parte da filosofia do Solucionática. Assim, deixamos a acomodação de lado e fomos testar nosso shield.

Como na maioria das vezes, usamos o sketch de demonstração (demo code) fornecido no site do fabricante (ftp://imall.iteadstudio.com/IM120417006_BT_Shieldv2.1/DC_IM120417006_BT_Shield_Slave.zip). A simplicidade do código é surpreendente, pois usa a porta serial ou o bluetooh para ligar ou desligar o led (on board) do Arduino controlado pelo pino 13.

Primeiramente, vamos testar o sketch usando o cabo usb, ou seja, com o bluetooth desligado. Para isso é preciso mudar a chave de controle para FT232, ou seja, o módulo deve ser direcionado para a porta serial (usb). Usando o monitor serial do IDE do Arduino podemos enviar o caracter '1' para ligar o led e '0' para desligar.

Agora a hora da verdade: o teste do Bluetooth. Para tanto precisamos de um smartphone Android e vamos baixar e instalar o app gratuito Bluearduino (Asaxen) que atende plenamente ao nosso propósito. Antes de parear o Arduino com o Android, é preciso mudar a chave seletora do módulo de "FT232" para a posição "to board". Agora, procede-se ao pareamento, com a senha padrão 1234. Vejam a sequencia de telas disponível no Google Play.

O funcionamento do módulo quando no modo "to board", ou seja, conectado via bluetooth ao smartphone, é idêntico à porta serial. Digamos que o modulo seja "transparente" ao Arduino e ao Android. Mas, a conexão pode cair, pois seria preciso acrescentar uma rotina para monitorar essa conexão, o que não há no nosso sketch. Quando a conexão cair, não tem problema, pois o lado do Arduino continua ativo e é só repetir o procedimento (exceto o pareamento que já foi feito) e retomar o controle do dispositivo. Use sua imaginação e aproveite o sketch para suas próprias aplicações.

Coincidentemente, o criador do app usou o mesmo tipo de módulo (linvor) que estamos testando. Na última tela vemos o campo para escrever a mensagem. Basta escrever o número 1 e clicar em send que o led vai acender no Arduino. Enviando um '0' o led apaga. Pronto, bem simples como as coisas deveriam ser...mas fica sem graça.

Abaixo, temos a foto do módulo e o sketch para ser carregado no Arduino.

Para quem quer tentar uma boa modificação no sketch, basta trocar os blocos if(temp== ) por blocos switch/case. Assim podemos ter, por exemplo, "cases" de '0' a '9' e de 'a' 'A' a 'z' 'Z'. Usando todas as possibilidades teremos facilmente 36 blocos de ação. Quem quiser ampliar, pode usar os caracteres especiais (!@#$%....) e estruturar melhor os blocos de decisão. Por exemplo:

switch (temp) { case 1: //faça algo quando temp = 1 break; case 2: //faça algo quando temp = 2 break; default: // se não for nenhum deles, execute o default // default é optional }

Observem que o default pode ser um novo bloco switch/case. Aí vamos refinando e amarrando

as possibilidades.

Vamos a um exemplo para ilustrar:

switch (temp) { case 1: //faça algo quando temp = 1

digitalWrite(10,HIGH);//ativa, p.ex, um relé conectado ao pino 10 do Arduino.

LcdClear();

gotoXY(0,24);

LcdString("Relé Ligado");

break; case 2: //faça algo quando temp = 2

digitalWrite(10,HIGH);//ativa, p.ex, um relé conectado ao pino 10 do Arduino.

LcdClear();

gotoXY(0,24);

LcdString("Relé Desligado");

break; default:

LcdClear();

gotoXY(0,24);

LcdString("Função inválida");// quando temp é diferente de 1 ou 2.

gotoXY(0,34);

LcdString("Tente de novo");

}

Obs: Como se percebe, usando switch/case fica bem mais estruturado. No exemplo acima, podemos controlar a saída digital 10 do Arduino para ligar ou desligar um relé (lembre de "ajudar" o Arduino acrescentando um transistor npn para reforçar a corrente de saída). O relé, por sua vez acionará uma carga maior, como uma lâmpada. Uma vez que todas as funções forem definidas, podemos partir para desenvolver o nosso próprio aplicativo Android, com uma tela amigável, com as funções bem identificadas na tela. O céu é o limite!

O pessoal do Solucionática fez umas modificações dessa forma: incluiu parte do sketch usado no Voltímetro Digital com LCD Nokia 5110/3310 e acrescentou outros if (temp== ). Para fins didáticos, vamos marcar com azul as instruções emprestadas do sketch do Voltímetro. O núcleo do sketch de teste do módulo foi pintado de vermelho. O restante é o setup do programa, onde inicializamos o lcd, a porta serial etc. Vou tentar fazer uma arte para explicar cada bloco do sketch modificado.

#define PIN_SCE 7 >>>>>>>> Neste bloco temos a correspondência entre os pinos do Arduino e

#define PIN_RESET 6 >>>>>>>> do LCD. Cuidado com o RESET, é muito importante para o bom funcionamento

#define PIN_DC 5 >>>>>>>> do display LCD.

#define PIN_SDIN 4 >>>>>>>>

#define PIN_SCLK 3 >>>>>>>>

#define LCD_C LOW >>>>>>>> Aqui estão definidos os valores iniciais das variáveis LCD_C (comando) e #define LCD_D HIGH >>>>>>>> LCD_D (dados.)

#define LCD_X 84 >>>>>>>> O LCD usado é de 84X48 pixels.

#define LCD_Y 48 >>>>>>>>

#define LCD_CMD 0 >>>>>>>> Esta variável controla o set de comandos extendidos do display.

int contraste=0xB1; >>>>>>>> Valor inicial do contraste do LCD (0xB1 em hexa equivale a 177 em decimal).

#include "Arduino.h" >>>>>>>> Esta instrução é para manter a compatibilidade com o IDE 1.0.

char temp; >>>>>>>> Primeira instrução do sketch de teste do módulo BT. A variável temp é do tipo char.

static const byte ASCII[][5] = >>>>>>>>>>>>>>>>>>>>>Todo esse bloco são as definições dos caracteres.

{

{0x00, 0x00, 0x00, 0x00, 0x00} // 20

,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !

,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "

,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #

,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $

,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %

,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &

,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '

,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (

,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )

,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *

,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +

,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,

,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -

,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .

,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /

,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0

,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1

,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2

,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3

,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4

,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5

,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6

,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7

,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8

,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9

,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :

,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;

,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <

,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =

,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >

,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?

,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @

,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A

,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B

,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C

,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D

,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E

,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F

,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G

,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H

,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I

,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J

,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K

,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L

,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M

,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N

,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O

,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P

,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q

,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R

,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S

,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T

,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U

,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V

,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W

,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X

,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y

,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z

,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [

,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥

,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]

,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^

,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _

,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `

,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a

,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b

,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c

,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d

,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e

,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f

,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g

,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h

,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i

,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j

,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k

,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l

,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m

,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n

,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o

,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p

,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q

,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r

,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s

,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t

,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u

,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v

,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w

,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x

,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y

,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z

,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {

,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |

,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }

,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←

,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f →

};

void LcdCharacter(char character) >>>>>>>>>> Aqui temos a sub-rotina que escreve um único caractere no display.

{

LcdWrite(LCD_D, 0x00);

for (int index = 0; index < 5; index++)

{

LcdWrite(LCD_D, ASCII[character - 0x20][index]);

}

LcdWrite(LCD_D, 0x00);

}

void LcdClear(void) >>>>>>>>>> Sub-rotina que limpa a tela do display.

{

for (int index = 0; index < LCD_X * LCD_Y / 8; index++)

{

LcdWrite(LCD_D, 0x00);

}

}

void LcdInitialise(void) >>>>>>>>>> Sub-rotina que inicializa o display.

{

pinMode(PIN_SCE, OUTPUT);

pinMode(PIN_RESET, OUTPUT);

pinMode(PIN_DC, OUTPUT);

pinMode(PIN_SDIN, OUTPUT);

pinMode(PIN_SCLK, OUTPUT);

digitalWrite(PIN_RESET, LOW);

delay(1);

digitalWrite(PIN_RESET, HIGH);

LcdWrite( LCD_CMD, 0x21 ); // LCD Extended Commands.

LcdWrite( LCD_CMD, 0xC4 ); // Set LCD Vop (Contrast). //B1

LcdWrite( LCD_CMD, 0x04 ); // Set Temp coefficent. //0x04

LcdWrite( LCD_CMD, 0x14 ); // LCD bias mode 1:48. //0x13

LcdWrite( LCD_CMD, 0x0C ); // LCD in normal mode. 0x0d for inverse

LcdWrite(LCD_C, 0x20);

LcdWrite(LCD_C, 0x0C);

}

void LcdString(char *characters) >>>>>>>>>>>> Sub-rotina que escreve uma sequencia de caracteres dada pelo

{ >>>>>>>>>>>> valor de characters que é o tamanho da string de caracteres.

while (*characters)

{

LcdCharacter(*characters++);

}

}

void LcdWrite(byte dc, byte data) >>>>>>>>>>>> Sub-rotina que escreve um dado (dc=1 ou comando dc=0)

{

digitalWrite(PIN_DC, dc);

digitalWrite(PIN_SCE, LOW);

shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);

digitalWrite(PIN_SCE, HIGH);

}

void gotoXY(int x, int y) >>>>>>>>>>>> Sub-rotina que posiciona o cursor no ponto x,y do display.

{

LcdWrite( 0, 0x80 | x); // Column.

LcdWrite( 0, 0x40 | y); // Row.

}

void loop(void) >>>>>>>>>>>>> Ronda principal (loop). Estes comandos abaixo fazem o ajuste >>>>>>>>>>>>>automático do contraste, controlado pela variável

>>>>>>>>>>>>> contraste.

{

LcdWrite( LCD_CMD, 0x21 ); // LCD Extended Commands.

LcdWrite( LCD_CMD, contraste ); // Set LCD Vop (Contrast). //B1

LcdWrite( LCD_CMD, 0x04 ); // Set Temp coefficent. //0x04

LcdWrite( LCD_CMD, 0x14 ); // LCD bias mode 1:48. //0x13

LcdWrite( LCD_CMD, 0x0C ); // LCD in normal mode. 0x0d for inverse

LcdWrite(LCD_C, 0x20);

LcdWrite(LCD_C, 0x0C);

while(1) >>>>>>>>>>>>>> Aqui é o restante da ronda principal. Os blocos iniciados por "if" >>>>>>>>>>>>>>>testam os caracteres recebidos do smartpone e

{ >>>>>>>>>>>>>>> executam as respectivas funções (ligar um led, acionar um relé, >>>>>>>>>>>>>>>>limpar o display etc.

if (Serial.available() > 0 )

{

temp = Serial.read();

if(temp == '1'){

digitalWrite(13,HIGH);

LcdClear();

gotoXY(0,24);

LcdString("Ligado");

}

if(temp == '0'){

digitalWrite(13,LOW);

LcdClear();

gotoXY(0,24);

LcdString("Desligado");

}

if(temp == 'l'|| 'L'){

digitalWrite(12,HIGH);

LcdClear();

gotoXY(0,24);

LcdString("Buzzer ligado");

}

//Serial.print(temp);

if(temp == 'd'||'D'){

digitalWrite(12,LOW);

LcdClear();

gotoXY(0,24);

LcdString("Buzzer desligado");

}

if(temp == 't'||'T'){

digitalWrite(11,HIGH);

LcdClear();

gotoXY(0,24);

LcdString("Modo Texto");

//while (Serial.read()!='#')

//{

//temp=Serial.read()

LcdClear();

LcdString(temp);

}

}

}

}

void setup() >>>>>>>>>>>>> Aqui é o setup, ou seja, a configuração inicial das sub-rotinas, dos pinos de >>>>>>>>>>>>>i/o etc.

{

LcdInitialise();

LcdClear();

LcdString("BTMensageiro");

gotoXY(0,42);

LcdString("Solucionatica");

char temp;

pinMode(13,OUTPUT);

pinMode(12,OUTPUT);

pinMode(11,OUTPUT);

Serial.begin(9600);

}