Conectando con Arduino por Bluetooth

La mayoría de dispositivos móviles tiene la posibilidad de comunicación inalámbrica por Bluetooth. Este sistema es fácil de programar con AppInventor pero hay que tener una serie de cosas claras:

El otro elemento debe estar previamente emparejado, con nuestro Android, desde ajustes->Bluetooth->buscar dispositivos->seleccionar el dispositivo y colocar la clave de emparejamiento.
Se pueden enviar y recibir bytes. Estos bytes pueden ser interpretados como números o letras (caracteres ASCII). Luego se pueden mandar mensajes de texto u órdenes que puedan ser interpretadas por el otro dispositivo.

La propuesta que se plantea consiste en conectar el smartphone/tablet con Arduino. Para ello emplearemos un módulo HC-05 o HC-06 de JY-MCU, o similar, de bajo coste (sobre 6€).

Las tarjetas o módulos Ethernet, WIFI o Bluetooth y en general, en las redes informáticas, tienen un número que las identifica, como si fuera un número de serie, se denomina MAC (Control de Acceso a Medios). Esta MAC consta de 6 agrupamientos de cifras hexadecimales separados por ":". El código hexadecimal se basa en un sistema de 16 números distintos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. Donde las letras corresponderían a 10, 11, 12, 13, 14 y 15 respectivamente.

Por lo tanto, un ejemplo de MAC=00:B0:D0:86:BB:F7

NOTA: si no sabes qué es Arduino o no sabes programar una tarjeta Arduino pincha aquí.

Programa de configuración del módulo HC06

/* * Name: ConfigBt * Vers: v0.1alfa * Date: 27/03/2019 ddmmyyyy * Auth: FJRAC * Lang: Spanish * Descripción: * Configura el HC-06 con: * -Velocidad de conexión Bluetooth a 9600 * -Nombre del dispositivo --------> AT+NAME[nombre] * -Pin de emparejado(4dígitos) ---> AT+PIN[xxxx] * Se emplea la librería SoftwareSerial para compatibilizar * con cualquier tarjeta Arduino. SoftwareSerial.h * Se crea y configura la comunicación serie: * SoftwareSerial SerialBT(Rx,Tx); * Conexiones: * HC06 -------- Arduino (SoftwareSerial) * TX ---------> pin2 (RX) * RX <--------- pin3 (TX) * VCC <--------> 5V * GND <--------> GND * El Monitor serie debe estar "sin ajuste de linea" */#include <SoftwareSerial.h>#define Rx 3#define Tx 4#define velocidad 9600SoftwareSerial BT(Rx,Tx);char i=' ';void setup(){ Serial.begin(velocidad); while(!Serial); Serial.println("Comunicando por USB"); BT.begin(velocidad); delay(2000);}
void loop() { if(BT.available()){ i=BT.read(); Serial.print(i); } if(Serial.available()){ i=Serial.read(); BT.print(i); }}

Linterna Bluetooth (Básico)

La propuesta consiste en activar por bluetooth una luz conectada a un arduino. La luz puede ser un LED directamente o un Relé conectado a una bombilla convencional de 220V de alterna. Con una pequeña modificación puedes realizar el control del cierre de una puerta de garaje.

Al final de la página puedes descargarte todos los ficheros necesarios para reproducir o ejecutar el ejemplo

Programa AppInventor

Empezaremos con la parte Diseñador:

Se trata de colocar:

3 botones: On, Off y otro con la imagen de "Power" (centrados en el "Screen1")
1 Listpicker (SelectorDeLista) con el texto "CONECTA"
1 imagen decorativa de fondo de pantalla en "Screen1"
1 elemento BluetoothClient

De tal manera que antes de conectar con el dispositivo Bluetooth, debemos cargar la lista de dispositivos posibles:

Una vez pulsado el botón "CONECTA" se abre una lista con los dispositivos Bluetooth disponibles, tras pulsar uno (nuestro módulo HC-06) comprobamos si se ha abierto la conexión, si no, se desconecta.

Para salir del programa, al pulsar el botón "Salir", se cierra la aplicación.

Para activar la linterna, Se pulsa el botón ON. El proceso consiste en enviar el carácter "H" y se espera la respuesta: si se recibe "H", entonces el fondo del botón cambia a verde, si no, el fondo del botón será gris.

Para desactivar la luz de la linterna, se pulsa el botón de OFF. El procedimiento es muy parecido al del botón ON, se manda un carácter, en este caso "L" y se espera la respuesta, si se recibe el mismo carácter, el color de fondo del botón pasará a rojo, si no será gris.

Y ya está...

Programa Arduino

/******************************************NAME: linternaVERS: v0.1alphaDATE: 01/01/2018 (dd/mm/yyyy)AUTH: Francisco Javier Arteaga Cardineaubasado en el programa del módulo 3 realizadopor Javier García RealLANG: SpanishLICENSE: CC-BY-NC-SADESCRIPCION:Programa del Curso de Arduino+AppInventordel CRFP de Castilla-La ManchaEnciende y apaga un led asociado al pin13 con los datos recibidos por Bluetooth.* H -> Enciende el led* L -> Apaga el led
Tras recibir y ejecutar la orden debe enviar* H -> Ya encendido * L -> Ya apagado
Conexión de módulo Bluetooth HC-06RX -> pin3TX -> Pin4VCC-> 5VGND-> GND******************************************///-- Zona de librerías --// Comunicación serie por software#include <SoftwareSerial.h>
//-- Zona de definiciones --#define LED 13#define RX 3#define TX 4
//-- Zona de variables globalesSoftwareSerial BT1(RX,TX);
//-- Configuración --void setup() { pinMode(LED,OUTPUT); BT1.begin(9600);}//-- Programa principal --void loop() {//Zona de variables locales dato enviado por Androidchar recibido=0;//Si se ha recibido un dato if(BT1.available()==true){ recibido=BT1.read(); //Se carga en la variable recibido } switch(recibido){ case('H'): //Si es un carácter "H", se enciende el LED digitalWrite(LED,HIGH); delay(10); //Se lee el pin del LED si es de nivel alto, envía un carácter "H", por bluetooth if(digitalRead(LED)==HIGH){ BT1.write('H'); } break; case('L'): //Si es un carácter "L", se apaga el LED digitalWrite(LED,LOW); delay(10); //Se lee el pin del LED si es de nivel bajo, envía un carácter "L", por bluetooth if(digitalRead(LED)==LOW){ BT1.write('H'); } break; }}

Monitoreo (intermedio)

La propuesta consiste en monitorizar, vía Bluetooth, desde el dispositivo Android los pines digitales de entrada del 5 al 12 de una placa Arduino compatible.

Puedes encontrar todo lo necesario para reproducirlo al final de la página.

Interesante de este programa es la forma de comunicar el estado de Arduino a Android. Emplearemos una técnica muy empleada en microcontroladores.

Vamos a comunicar los valores de los 8 pines encapsulados en un byte, de tal manera que:

₇ ₆ ₅ ₄ ₃ ₂ ₁ ₀<--Peso

2 2 2 2 2 2 2 2 <--bits de un Byte

_{12 11 10 9 8 7 6 5} <--Pin correspondiente donde se guardará su valor

Un ejemplo:

0 0 1 1 0 0 0 1 => 1*2⁰ + 0*2¹ + 0*2² + 0*2³ + 1*2⁴ + 1*2⁵ + 0*2⁶ + 0*2⁷ =>1+16+32 =>49₁₀=>31_HEXADECIMAL

Del lado de la recepción, 31_H => dividir por 2 un byte es lo mismo que bit a bit moverlos hacia la derecha rescatando el resto:

0 1 2 3

00110001-> (/2)-> 00011000.1 -> (/2)-> 00001100.0 -> (/2)-> 00000110.0 -> (/2)-> 00000011.0 ->

4 5 6 7

(/2)-> 00000001.1 -> (/2)-> 00000000.1 -> (/2)-> 00000000.0 -> (/2)-> 00000000.0

De tal manera que si asociamos las posiciones, los restos y los pines:

Posición 0 ->1 = Pin5

Posición 1 ->0 = Pin6

Posición 2 ->0 = Pin7

Posición 3 ->0 = Pin8

Posición 4 ->1 = Pin9

Posición 5 ->1 = Pin10

Posición 6 ->0 = Pin11

Posición 7 ->0 = Pin12

Otra manera de volver a pasar de paralelo (Byte) a serie (bit a bit) que es utilizar una máscara de bits. Es decir, para extraer bit a bit:

00110001 AND 00000001=> 1 <-Pin5

00110001 AND 00000010=> 0 <-Pin6

00110001 AND 00000100=>0 <-Pin7

00110001 AND 00001000=>0 <-Pin8

00110001 AND 00010000=>1 <-Pin9

00110001 AND 00100000=>1 <-Pin10

00110001 AND 01000000=>0 <-Pin11

00110001 AND 10000000=>0 <-Pin12

Este método también es muy utilizado y más fácil de automatizar con AppInventor.

En Arduino, el Byte se construye de tal manera que el pin5 sea el bit de menor peso y el pin12 sea el bit de mayor peso. El algoritmo es el siguiente: se inicializa el dato a "0", se establece una repetición

dato=0

repite peso de 1 a 8

dato=dato+valor[pin]*2^(peso)

fin repite

Donde:

dato: variable donde se guarda el Byte
valor[pin]: valor del pin correspondiente
peso: posición que ocupará el valor del pin en el byte

En AppInventor, se obtiene cada pin, dividiendo por 2, cada vez, y ver resto: si el resto es 0, el bit es "0"; si el resto es mayor de 0, el bit es "1". El algoritmo es el siguiente:

repite peso de 1 a 8si(resto(dato/2)>0) dato_pin[peso]=1si no dato_pin[peso]=0fin sidato=entero_inferior(dato/2)fin repite

Donde:

dato: byte recibido
dato_pin: valor del pin correspondiente

Nota:

resto: ve el resto de una división
entero_inferior: quita la parte decimal del número dividido por 2

El segundo método descrito, su algoritmo es el siguiente:

repite peso de 1 a 8dato_pin[peso]=(dato&&2^(peso-1));fin repite

Programa Arduino

/**********************************************NAME: monitorizaVERS: v0.1alphaDATE: 01/01/2018AUTH: Francisco Javier Arteaga CardineauLANG: SpanishLICENSE: CC-BY-NC-SADESCRIPCION:Programa del Curso de Arduino-AppInventordel CRFP de Castilla-La ManchaMonitoriza las entradas digitales de Arduinopor Bluetooth. Del Pin5 al Pin12, convirtiendolos datos en un byte para ser transmitido. 7 6 5 4 3 2 1 0 ->posicion2 2 2 2 2 2 2 2 p12 p11 p10 p9 p8 p7 p6 p5 ->pinPin a pin se guarda en dato_pinpara construir el byte, emplearemos:dato=dato+dato_pin*2^posicionConexion del modulo Bluetooth HC-06:RX-->Pin3TX-->Pin4Vcc->5VGND->GND**********************************************///--Zona de librerias--//Comunicacion serie por software#include <SoftwareSerial.h>//--Zona de definiciones--#define RX 3#define TX 4//--Zona de variables globales--SoftwareSerial BT1(RX,TX);//--Configuracion--void setup() { pinMode(5,INPUT); pinMode(6,INPUT); pinMode(7,INPUT); pinMode(8,INPUT); pinMode(9,INPUT); pinMode(10,INPUT); pinMode(11,INPUT); pinMode(12,INPUT); BT1.begin(9600);}//--Programa principal--void loop() { //Variables locales boolean dato_pin; byte dato=0; for(int posicion=0;posicion<8;posicion++) { //encapsulado bit a bit del byte dato_pin=digitalRead(posicion+5); dato=dato+dato_pin*2^posicion; delay(1); } BT1.write(dato); //Envía el dato delay(250); //Espera 1/4 de segundo para que le dé tiempo a procesar la parte de Android}

Programa AppInventor

Básicamente es la imagen de una Arduino UNO con los pines correspondientes (5-12):

Gris->0V o
Rojo->5V

La pantalla queda de la siguiente manera, para ello utilizaremos:

ListPicker (Lista de selección) para la selección y conexión con el dispositivo Bluetooth. Visible al iniciar el programa y, cuando se haya conectado con el dispositivo por Bluetooth, lo haremos invisible.
Button (botón) para salir de la aplicación, invisible al principio, cuando desaparezca el elemento "ListPicker" anterior, hacemos visible este.
Canvas (lienzo o zona gráfica): de 80% de alto, para que se vean los botones y 100% de ancho con la imagen "UNO.PNG" de fondo y que puedes encontrar al final de la página.
7 ball (pelotas) que situaremos encima de los pines que llevan su nombre y utilizaremos para mostrar el estado de las entradas.
BluetoothClient (cliente Bluetooth) para conectar con el módulo HC-06 asociado a Arduino
Clock (reloj) para refrescar la monitorización de manera periódica

Como con la aplicación de la linterna, empezaremos con el elemento ListPicker (ListaDispositivos), parecido a un botón, con el texto "Conecta", que consta de dos grandes grupos de bloques así como el botón de "Salir":

Google Sites

Report abuse