Arduino Uno R3
	Modulo Bluetooth HC-06
	Cables Dupont Macho-Hembra
	Una Protoboard
	Un par de leds
	Un móvil

Una vez que hemos visto cómo usar los comandos AT para programar los módulos Bluetooth, en las sesiones anteriores, podemos pasar a la parte fácil que es usar nuestros móviles Android para controlar cualquier proyecto con BlueTooth. Es tan sencillo como conectarnos al módulo y escribir un pequeño programa que gobierne el flujo de control.

Podríamos hacerlo con comandos de texto directos, pero es demasiado poco elegante y aquí  nos gustan las cosas presentables, por lo que vamos a usar un programa de lo más simpático,  disponible para Android que se llama ArduDroid.

Está escrito por TechBitar, y podéis encontrar aquí su página Ardudroid.

Básicamente es un  programa Android con botones y deslizadores, más un esquema de programa Arduino que podemos usar para enviar y recibir comandos de una forma presentable, y que además funciona muy bien.

Para ello necesitaremos que descarguéis ArduDroid de la GooglePlay para Android y lo instaléis en vuestro teléfono.

• Siento tener que decir, de nuevo, que los módulos HC-05 y HC-06 no son capaces de conectar con los móviles de Apple o al menos yo no lo he conseguido

Después basta con conectar cualquiera de los dos módulos a nuestros Duinos con un par de cables para GND y Vcc más Rxd y Txd.

Vamos a dedicar esta sesión a ver como conectamos uno de los módulos para la conexión normal de trabajo y cómo usar el Ardudroid para gobernar mensajes de texto, pines digitales y ya puestos algún pin PWM.

Vamos a montar inicialmente un pequeño circuito con tres diodos LED para que veamos cómo controlarlos desde el móvil, y luego iremos complicando un poco más el montaje (No, no es una amenaza).

El montaje de la protoboard es trivial para gente tan experimentada:

Ardudroid incluye un programa Arduino, que podemos utilizar como esqueleto para nuestros propios proyectos. Pero nosotros vamos a hacer algunos cambios en la conexión que él hace, porque no me gusta nada que usemos los pines 0 y 1 para comunicarnos con Arduino, así que nosotros usaremos los pines 2 y 3 para la conexión con el módulo BlueTooth.

• Creo que ya comentamos que si usamos los pines 0 y 1 nuestro código funcionara, pero anularemos la conexión con el PC vía USB, que usa los pines 01 y 1.
• El autor, que es un hombre de mundo, no tiene problemas, porque prueba los programas con un segundo módulo BT, y cuando tiene el programa pulido, no necesita volver a reprogramar, pero yo soy un poco más torpe y prefiero no cerrar esa puerta mantener abierto el USB para mensajes por ejemplo.

Vamos a ir presentando el programa de control de Arduino en pequeñas dosis para evitar asustar a nadie, y que los sufridos lectores huyan despavoridos, y de ese modo, además, podremos ir viendo poco a poco las diferentes secciones del programa, que estoy seguro ayudara a su mejor comprensión.

En primer lugar, necesitamos saber, que el programa Ardudroid envía todos los comandos con una sintaxis sencilla. Todas las ordenes empiezan por * y terminan en #, y si la orden incluye múltiples datos, esto vienen separados por el símbolo |

Cuando ArduDroid envía una orden típica, es algo así:  *10|3|2#

Por eso, porque las órdenes se envían codificadas, vamos a empezar con algunas definiciones previas:

#define START_CMD_CHAR '*'
#define END_CMD_CHAR '#'
#define DIV_CMD_CHAR '|'
#define CMD_DIGITALWRITE 10
#define CMD_ANALOGWRITE 11
#define CMD_TEXT 12
#define CMD_READ_ARDUDROID 13
#define MAX_COMMAND 20  // max command number code. used for error checking.
#define MIN_COMMAND 10  // minimum command number code. used for error checking.
#define IN_STRING_LENGHT 40
#define MAX_ANALOGWRITE 255
#define PIN_HIGH 3
#define PIN_LOW 2

Además usaremos la librería SoftwareSerial, para hablar con el modulo BlueTooth, mediante los pines digitales 2 y 3:

#include <SoftwareSerial.h>
SoftwareSerial BT1(3, 2); // RX | TX

Definiremos unas variables para contener los valores que leeremos del comando:

int ard_command = 0;
int pin_num = 0;
int pin_value = 0;

El cuerpo principal del loop es muy sencillo, Vamos a empezar recibiendo mensajes de texto:

char get_char = ' ';  // Para leer BT1
if (BT1.available())
    {   get_char = BT1.read();
        delay(25);

        if (get_char != START_CMD_CHAR)
            return; // Si no hay *, vuelta a empezar

        ard_command = BT1.parseInt();  // Leemos la orden
        pin_num = BT1.parseInt();      // Leemos el pin
        pin_value = BT1.parseInt();    // Leemos valor

Recuerda que parseInt (), va leyendo caracteres hasta llegar a uno que no es un numero valido y entonces devuelve en un entero las cifras que ha leído.

Una vez que leemos ard_command, evaluamos que tipo de comando es, y si la orden es de tipo texto, llamamos a un viejo conocido GetLine () para conseguir el String:

if (ard_command == CMD_TEXT)     // Si el comando es de texto:
   {
        String s = GetLine();
        Serial.println(s);
   }

Si lo que recibimos es una orden que corresponde al boton GetData , enviamos algo, previamente pactado, por ejemplo la lectura de A0 (Aunque no tenemos nada conectado en este momento:

if (ard_command == CMD_READ_ARDUDROID)
   {   BT1.print(" Analog 0 = ");
       BT1.println(analogRead(A0));  // Leemos A0
       return;  // Done. return to loop();
       Y si la orden es un digitalWrite de algún pin:
       if (ard_command == CMD_DIGITALWRITE)
           processDW(pin_num, pin_value);
    }

He preferido procesar las órdenes con funciones, fuera del cuerpo principal para que sea un poco más limpio el programa.

La función GetLine es la habitual, simplemente modificada para leer de BT1 en lugar de Serial:

String GetLine()
  {   String S = "" ;
      if (BT1.available())
         {  char c = BT1.read(); ;
            while ( c != END_CMD_CHAR)    //Hasta que el caracter sea END_CMD_CHAR
              {  S = S + c ;
                 delay(25) ;
                 c = BT1.read();
              }
            return( S ) ;
         }
  }

Y en cuanto a la función processDW, que maneja las órdenes digitales:

void processDW(int pin_num, int pin_value)
   {   if (pin_value == PIN_LOW)
           pin_value = LOW;
       else if (pin_value == PIN_HIGH)
           pin_value = HIGH;
       else
           return; // Error

       digitalWrite( pin_num,  pin_value);
       return;
   }

Para manejar los comandos de escritura analogica, mediante PWM, tenemos, otro apartado de lo mas sencillo:

 if (ard_command == CMD_ANALOGWRITE) 
     { analogWrite( pin_num, pin_value ); 
       // add your code here
       return; // De vuelta alloop();
     }

Aquí os pongo una copia completa del programa Prog_72_1

¡Accede al contenido!

Y aquí teneís un minivídeo con el resultado del programa