Crea un robot Arduino con módulo Bluetooth HC-05 paso a paso

Luis del Valle Hernández

hace 6 años

Uno de los proyectos más vistosos que puedes hacer es un robot Arduino que además se controle vía Bluetooth con un módulo HC-05.

Cuando necesitas conocer una tecnología es relativamente sencillo encontrar información.

Sólo tienes que poner las palabras robot Arduino Bluetooth HC-05 y obtendrás más de 18 millones de resultados en Google.

Ahí es nada, ponte a buscar si te atreves :)

Aunque te quedes con las primeras páginas que aparecen en los resultados, fabricar un robot con Arduino y Bluetooth HC-05 parece cosa de ingenieros o de gente superdotada.

Con este tutorial te quiero demostrar que no es tan difícil.

Porque como dijo Goethe: «las personas solo escuchan lo que son capaces de entender«.

Si sigues este tutorial de robot Arduino con Bluetooth HC-05, entenderás todo el proceso para poder fabricarlo tu mismo.

Indice de contenidos

1 ¿Qué es un robot Arduino?
2 Bluetooth Arduino HC-05
3 Montaje robot Arduino UNO y módulo Bluetooth HC-05
4 App Blynk Bluetooth para controlar el robot Arduino
5 Código robot Arduino y módulo Bluetooth HC-05
6 Conectar app Blynk con módulo Bluetooth Arduino HC-05

¿Qué es un robot Arduino?

Robot es una palabra muy ámplia y es difícil dar una definición concreta. Es como preguntar ¿qué es un vehículo? Aquí pueden entrar coches, camiones, motos o incluso patinetes

Pues con robot pasa más o menos lo mismo. Podemos ir a la definición que nos da la Wikipedia donde nos dice

Un robot es una entidad virtual o mecánica artificial. En la práctica, esto es por lo general un sistema electromecánico que, por su apariencia o sus movimientos, ofrece la sensación de tener un propósito propio.
Robot en Wikipedia

Bien, para nosotros un robot Arduino puede ser cualquier cosa mecánica que se mueva y tenga patas como un Zowi o un robot con ruedas que podamos controlar con un Arduino.

No voy a ser un purista es este sentido. Si estás buscando otra definición u otro tipo de robots, este no es el sitio.

Se llame como se llame, en este tutorial cuando diga robot Arduino me estaré refiriendo a un robot con ruedas. Más concreto el robot 4WD de DFRobot.

Pero vamos, que puedes utilizar cualquier otro robot Arduino que funcione con motores eléctricos. Cualquiera de estos te valdría:

Una vez tenemos el robot Arduino hay que controlarlo. Directamente con Arduino no se puede hacer como ya te dije en el artículo donde hablé del Motor Shield de Adafruit.

Necesitas un driver o controlador para mover los motores y darle velocidad. Puedes utilizar el que quieras yo te recomiendo el Motor Shield de Adafruit.

Este shield soluciona la parte de controlar los motores del robot Arduino. Pero vuelvo a repetir, no es obligatorio utilizar el robot de DFRobot ni el shield de Adafruit.

Puedes utilizar otros componentes que tengas por casa.

Antes de pasar a controlar el robot Arduino, vamos a ver el módulo Bluetooth HC-05 que nos permitirá controlar el vehículo desde un terminal móvil o tablet.

Bluetooth Arduino HC-05

Módulos Bluetooth Arduino hay de muchos tipos. Uno de los más populares y utilizados con Arduino es el HC-05.

Esto es debido que es muy económico y a que puedes comprarlo en Amazon por unos pocos euros.

Sin embargo, hay una gran confusión con respecto a qué módulo tienes entre manos ya que el módulo Bluetooth Arduino HC-05 se parece mucho al HC-06.

Así que lo primero que vamos a hacer es saber diferenciarlos.

Diferencia entre Bluetooth Arduino HC-05 y HC-06

El módulo Bluetooth Arduino HC-05 y el HC-06 son los más populares por su facilidad de uso y por su bajo precio.

Además, si no tienes mucha experiencia en estos módulos, puede que los confundas ya que su aspecto físico es muy parecido.

Sin embargo, existen grandes diferencias entre el módulo HC-05 y el HC-06 que se pueden ver a simple vista.

La primera es el número de pines. El módulo Bluetooth Arduino HC-05 tiene 6 pines mientras que el HC-06 tiene solo 4 pines.

También salta a la vista que el módulo HC-05 tiene un pulsador integrado en la placa y el HC-06 no lo tiene (luego veremos para qué se utiliza).

Con respecto a los módulos, el HC-05 utiliza el módulo Bluetooth EGBT-045MS y el HC-06 utiliza el módulo Bluetooth EGBT-046S.

Estos módulos son prácticamente iguales con respecto al hardware. La gran diferencia se encuentra en el firmware que utilizan.

Chip de radio	CSR BC417
Memoria	Flash Externa 8Mbit
Potencia de salida	-4 a +6dbm Clase 2
Sensibilidad	-80dbm típica
Bit rate	EDR, más de 3Mbps
Interfaz	UART
Antena	Integrada
Dimensiones	27mm x 13mm
Voltaje	3,1V a 4,2V
Corriente	40mA max
Bluetooth*	2.0

*Los módulos Bluetooth HC-05 y HC-06 se basan en Bluetooth 2.0 y esto hace que no sean compatibles con móviles de Apple. Tenlo en cuenta a la hora de utilizar este componente con un dispositivo con iOS.

La diferencia en cuanto al firmware hace que el módulo Bluetooth Arduino HC-05 pueda funcionar como maestro y esclavo mientras que el HC-06 pueda funcionar solo en modo esclavo.

Con esta información espero que puedas diferenciar un módulo de otro fácilmente.

A partir de aquí voy a seguir con el módulo Bluetooth Arduino HC-05 que es el que yo tengo pero puedes utilizar el HC-06 ya que el uso que le vamos a dar en este proyecto es de esclavo y no maestro.

Pineado Bluetooth Arduino HC-05

Vamos a comenzar por los pines. El módulo Bluetooth Arduino HC-05 tiene 6 pines.

EN: este pin es el ENABLED y sirve para habilitar (HIGH) o deshabilitar (LOW).
VCC: los módulos Bluetooth Arduino HC-05 incluyen un regulador de voltaje de 3,3V y esto permite que se pueda alimentar con un voltaje entre 3,6V y 6V por este pin.
GND: es el pin de tierra o GROUND.
TXD: es el pin serie de salida. Funciona a 3,3V. Todos los datos recibidos a través del Bluetooth se transmitirán a través de este pin.
RXD: es el pin serie de entrada. Funciona a 3,3V. Todos los datos en serie proporcionados a este pin se enviarán por Bluetooth.
STATE: es el pin de estado y proporciona información del estado en el que se encuentra el módulo Bluetooth Arduino HC-05. Si está en estado alto (HIGH) quiere decir que está conectado. En caso contrario (LOW) indica que el módulo no está conectado. Se puede utilizar en una entrada digital de Arduino para dentro del código saber el estado del módulo Bluetooth HC-05.

A la hora de conectar los pines TXD y RXD con Arduino, como verás más adelante, debes tener ciertas precauciones. Los dos pines funcionan a 3,3V. Para conectar el TXD no hay problema ya que Arduino interpreta 3,3V como una señal alta sin embargo, con el pin RXD hay que llevar cuidado. No deberías conectar este pin directamente a Arduino ya que, aunque a corto plazo funciona, a largo plazo lo que conseguirás es dañar el pin RXD y dejarás inservible el módulo Bluetooth Arduino HC-05.

HC-05 y los comandos AT

Otro componente dentro del módulo Bluetooth Arduino HC-05 es el pulsador o botón. Sirve para poner el módulo en modo comandos AT es decir, poder comunicar con el HC-05 a través de los comandos AT.

Es algo así parecido a cómo lo hacíamos con el módulo ESP-01 basado en el ESP8266 en los orígenes de este SoC.

Para entrar en el modo comandos AT tienes que presionar el pulsador al iniciar el módulo Bluetooth Arduino HC-05. Realmente lo que sucede es que está poniendo un pin (el 34) del módulo en estado alto (HIGH).

En algunos módulos más antiguos no hay un pulsador dentro del módulo Bluetooth Arduino HC-05. Además, el pin EN no está accesible y por el contrario hay un pin que se llama KEY. Este pin funciona igual que el pulsador. Si antes de encender el módulo HC-05 pones el pin en alto (HIGH) el módulo entrará en modo AT.

¿Por qué poner el módulo Bluetooth Arduino HC-05 en modo AT?

El modo comandos AT permite cambiar algunas de las configuraciones del HC-05:

Cambiar el nombre.
Cambiar la velocidad en baudios.
Establecer si funciona en modo maestro o esclavo.
Obtener la dirección MAC.

Esto son solo una muestra de cosas que puedes hacer en este modo. A continuación te dejo la lista de comandos AT completa.

Trabajar con los comandos AT es un poco complejo (yo lo odio), sin embargo hay diferentes librerías que te facilitan su uso. A continuación te dejo unas cuantas con las que podrías trabajar:

Más adelante verás cómo entrar en el modo comandos AT para obtener algunos datos importantes del módulo Bluetooth HC-05.

Pero lo primer es ver cómo conectar el módulo HC-05 a Arduino.

Conexión módulo Bluetooth HC-05 con Arduino

Antes de empezar, el material necesario que vamos a utilizar es el siguiente:

Para conectar el módulo Bluetooth HC-05 y Arduino primero tienes que identificar qué tipo de componente tienes entre manos. Vamos a distinguir dos: el módulo con un pulsador en la placa y el módulo sin pulsador.

La primera opción es utilizar el módulo con pulsador y pin EN. El esquema de conexión sería el siguiente.

La segunda opción es utilizar un módulo Bluetooth HC-05 sin pulsador. En este caso la conexión se hace de forma diferente como veremos a continuación.

La diferencia entre los dos circuitos es que en este último he conectado el pin KEY y el pin de alimentación VCC a dos pines digitales, los pines 6 y 7.

La idea es poder controlar el estado del pin KEY antes de que se encienda el módulo Bluetooth Arduino HC-05.

No hay ningún problema a la hora de alimentar el módulo Bluetooth HC-05 a través de un pin digital. Según las especificaciones técnicas de este módulo, consume un máximo de 40 mA que es precisamente el máximo que pueden proporcionar los pines del Arduino UNO.

Bluetooth Arduino HC-05 y el modo comandos AT

Si hay algo que no me gusta nada ya desde los inicios del ESP8266, es el modo comandos AT. Acostumbrado a programar con C/C++ los comandos AT son muy poco intuitivos.

Aún así, es necesario entrar en este modo para poder ver cierta información del módulo Bluetooth HC-05 que luego nos hará falta.

Como tenemos dos posibles circuitos, también tendremos dos formas de entrar en el modo comandos AT. Vamos a empezar con el módulo HC-05 con pulsador.

Comandos AT módulo HC-05 con pulsador

Para entrar en el modo comandos AT en este caso es muy sencillo. Lo primero que tienes que hacer es cargar el siguiente código a tu placa Arduino UNO.

// Incluir librería para comunicación serie con módulo Bluetooth
#include <SoftwareSerial.h>

// Crear objeto de la clase SoftwareSerial
// El primer parámetro es el pin donde está conectado el TX del HC-05
// El segundo parámetro es el pin donde está conectado el RX del HC-05
SoftwareSerial moduloBluetooth(11, 10);

void setup()
{
  // Iniciamos comunicación serie
  // Por defecto utiliza la velocidad de 38400 baudios
  moduloBluetooth.begin(38400);

  // Iniciar comunicación serie para mostrar información
  // por el monitor serie
  Serial.begin(9600);
}

void loop()
{
  // Recibir
  // Comprobación de si hay algún dato 
  // en el puerto del módulo Bluetooth
  if (moduloBluetooth.available())
  {
    // Mostrar la información recibida en el monitor serie.
    Serial.write(moduloBluetooth.read());
  }

  // Enviar
  // Comprobar si hay algún dato en el monitor serie 
  // para ser enviado al módulo Bluetooth
  if (Serial.available())
  {
    // Enviar la información por Bluetooth
    moduloBluetooth.write(Serial.read());
  }
}

// Incluir librería para comunicación serie con módulo Bluetooth

#include <SoftwareSerial.h>

// Crear objeto de la clase SoftwareSerial

// El primer parámetro es el pin donde está conectado el TX del HC-05

// El segundo parámetro es el pin donde está conectado el RX del HC-05

SoftwareSerial moduloBluetooth(11, 10);

void setup()

{

// Iniciamos comunicación serie

// Por defecto utiliza la velocidad de 38400 baudios

moduloBluetooth.begin(38400);

// Iniciar comunicación serie para mostrar información

// por el monitor serie

Serial.begin(9600);

}

void loop()

{

// Recibir

// Comprobación de si hay algún dato

// en el puerto del módulo Bluetooth

if (moduloBluetooth.available())

{

// Mostrar la información recibida en el monitor serie.

Serial.write(moduloBluetooth.read());

}

// Enviar

// Comprobar si hay algún dato en el monitor serie

// para ser enviado al módulo Bluetooth

if (Serial.available())

{

// Enviar la información por Bluetooth

moduloBluetooth.write(Serial.read());

}

Una vez esté cargado, sigue estos pasos:

Desconecta el cable USB del Arduino UNO para quitar la alimentación.
Aprieta el pulsador del módulo Bluetooth HC-05.
Conecta el cable USB al Arduino UNO para comenzar a alimentar.

Para saber si el módulo Bluetooth Arduino HC-05 ha entrado en modo comandos AT, el LED que se encuentra en la placa parpadea de forma muy lenta. Más o menos con un periodo de 2 segundos.

El HC-05 puede estar en diferentes modos de funcionamiento y se puede saber el modo dependiendo de cómo parpadee el LED integrado en la placa.

Modo comandos AT: parpadeo muy lento con un periodo de aproximadamente 2 segundos.
Modo pairing o emparejamiento: parpadeo muy rápido.
Modo emparejado o conectado: parpadeo doble muy lento.

Comandos AT módulo HC-05 sin pulsador

La otra opción es utilizar el módulo Bluetooth HC-05 que no tiene pulsador pero que sí que tiene el pin KEY. La idea es utilizar este pin para activar el modo comandos AT del módulo Bluetooth HC-05.

Lo único que tienes que hacer es cargar el siguiente código a tu Arduino UNO.

// Incluir librería para comunicación serie con módulo Bluetooth
#include <SoftwareSerial.h>

// Crear objeto de la clase SoftwareSerial
// El primer parámetro es el pin donde está conectado el TX del HC-05
// El segundo parámetro es el pin donde está conectado el RX del HC-05
SoftwareSerial moduloBluetooth(11, 10);

// Pines alimentación y key
const byte pinPower = 7;
const byte pinKey = 6;

void setup()
{
  // Modo de los pines
  pinMode(pinPower, OUTPUT);
  pinMode(pinKey, OUTPUT);

  // Primero poner el pin KEY en modo HIGH
  digitalWrite(pinKey, HIGH);

  // Luego encender el módulo Bluetooth HC-05
  digitalWrite(pinPower, HIGH);
  
  // Iniciamos comunicación serie
  // Por defecto utiliza la velocidad de 38400 baudios
  moduloBluetooth.begin(38400);

  // Iniciar comunicación serie para mostrar información
  // por el monitor serie
  Serial.begin(9600);
}

void loop()
{
  // Recibir
  // Comprobación de si hay algún dato 
  // en el puerto del módulo Bluetooth
  if (moduloBluetooth.available())
  {
    // Mostrar la información recibida en el monitor serie.
    Serial.write(moduloBluetooth.read());
  }

  // Enviar
  // Comprobar si hay algún dato en el monitor serie 
  // para ser enviado al módulo Bluetooth
  if (Serial.available())
  {
    // Enviar la información por Bluetooth
    moduloBluetooth.write(Serial.read());
  }
}

// Incluir librería para comunicación serie con módulo Bluetooth

#include <SoftwareSerial.h>

// Crear objeto de la clase SoftwareSerial

// El primer parámetro es el pin donde está conectado el TX del HC-05

// El segundo parámetro es el pin donde está conectado el RX del HC-05

SoftwareSerial moduloBluetooth(11, 10);

// Pines alimentación y key

const byte pinPower = 7;

const byte pinKey = 6;

void setup()

{

// Modo de los pines

pinMode(pinPower, OUTPUT);

pinMode(pinKey, OUTPUT);

// Primero poner el pin KEY en modo HIGH

digitalWrite(pinKey, HIGH);

// Luego encender el módulo Bluetooth HC-05

digitalWrite(pinPower, HIGH);

// Iniciamos comunicación serie

// Por defecto utiliza la velocidad de 38400 baudios

moduloBluetooth.begin(38400);

// Iniciar comunicación serie para mostrar información

// por el monitor serie

Serial.begin(9600);

}

void loop()

{

// Recibir

// Comprobación de si hay algún dato

// en el puerto del módulo Bluetooth

if (moduloBluetooth.available())

{

// Mostrar la información recibida en el monitor serie.

Serial.write(moduloBluetooth.read());

}

// Enviar

// Comprobar si hay algún dato en el monitor serie

// para ser enviado al módulo Bluetooth

if (Serial.available())

{

// Enviar la información por Bluetooth

moduloBluetooth.write(Serial.read());

}

La diferencia está en la función setup() a parte de las conexiones del pin KEY y del pin VCC.

Para entrar en el modo comandos AT hay que poner el pin KEY en estado HIGH antes de que arranque el módulo Bluetooth Arduino HC-05. Esto se consigue poniendo en estado HIGH dicho pin antes de alimentar el módulo.

Se podría hacer con un pulsador pero no merece la pena ya que solo se necesita entrar al modo comandos AT al principio. Luego funcionará de forma normal.

Prueba comunicación comandos AT y módulo HC-05

Sea de un forma o de otra, si has seguido los pasos el módulo Bluetooth HC-05 estará en modo comandos AT. Para probarlo abre el monitor serie y selecciona la velocidad de 9600 baudio y en ajuste de línea selecciona Ambos NL & CR.

Para enviar el primer comando escribe en el campo de texto del monitor serie el comando AT y pulsa Enter o da al botón Enviar.

Como resultado, si todo ha ido bien, verás en el monitor serie la palabra OK. Eso quiere decir que el módulo Bluetooth HC-05 ha recibido el comando correctamente.

Ahora es cuestión de ir probando la lista de comandos AT que hemos visto antes. Te la pongo de nuevo aquí para que la tengas a mano.

Lleva cuidado porque hay comandos que modifican parámetros que puede que hagan que el módulo Bluetooth HC-05 deje de funcionar correctamente.

Los comandos que tienes que ejecutar para seguir con este tutorial son los siguientes:

AT+ADDR: devuelve la dirección Bluetooth (MAC) que puede hacer falta más adelante.
AT+NAME: devuelve el nombre del módulo Bluetooth.
AT+PSWD: devuelve la contraseña para emparejar o conectar el módulo Bluetooth HC-05.

Si ejecutas uno detrás de otro entrás algo parecido a esto. Guarda esta información porque luego nos hará falta.

Con esto terminamos esta parte donde hemos conseguido conectarnos al módulo Bluetooth HC-05 para ejecutar comandos AT y comprobar que el módulo funciona correctamente.

En la siguiente sección vamos a empezar a montar el robot Arduino con conexión a una app de Blynk a través del módulo Bluetooth HC-05.

Montaje robot Arduino UNO y módulo Bluetooth HC-05

No voy a profundizar mucho en el tema del montaje del robot Arduino y el motor shield. En los dos casos tienes material suficiente en los siguientes artículos:

El resumen de todo esto es que vas a necesitar el siguiente material.

Un robot Arduino como este o de características similares.
Una placa Adafruit Motor Shield o alguna parecida.

Además necesitarás todos los componentes que hemos visto en la sección anterior del módulo Bluetooth Arduino HC-05.

Con todo este material el circuito que nos queda sería como el siguiente.

Ojo, debajo del Adafruit Motor Shield estará el Arduino UNO, pero las conexiones se hacen en el shield ya que cuando se acopla con el Arduino, se conectan los pines del shield con los pines del Arduino.

Los motores, aunque en el esquema estén sueltos, deberían ser los cuatro motores del robot Arduino.

A la hora de conectar los motores guíate por la siguiente tabla.

Motor/Rueda	Conexión shield
Motor rueda izquierda delantera	M2
Motor rueda derecha delantera	M2
Motor rueda izquierda trasera	M3
Motor rueda derecha trasera	M4

Respecto a las conexiones del módulo Bluetooth Arduino HC-05 no hay ninguna diferencia entre el módulo con pulsador o sin pulsador. En los dos casos se conecta de la misma forma.

Para controlar el robot Arduino no vamos a utilizar los comandos AT, utilizaremos la app Blynk y su librería.

Cuando lo tengas montado puedes utilizar el siguiente código para comprobar si tu robot Arduino funciona correctamente.

Cuidado si lo tienes encima del escritorio ya que el siguiente código hará que las ruedas se muevan. Mantenlo en alto hasta que las ruedas se pare.

#include <Wire.h>
#include <Adafruit_MotorShield.h>
#include "utility/Adafruit_MS_PWMServoDriver.h"

// Motor shield objeto
Adafruit_MotorShield AFMS = Adafruit_MotorShield();

// Motores
Adafruit_DCMotor *myMotor1 = AFMS.getMotor(1);// Puerto M1
Adafruit_DCMotor *myMotor2 = AFMS.getMotor(2);// Puerto M2
Adafruit_DCMotor *myMotor3 = AFMS.getMotor(3);// Puerto M3
Adafruit_DCMotor *myMotor4 = AFMS.getMotor(4);// Puerto M4

// Velocidad
int velocidad = 40; // Velocidad de 0 a 255

void setup() {
  // Iniciamos el monitor serie para mostrar el resultado
  Serial.begin(9600);

  // Iniciamos el motor shield
  AFMS.begin();

  // Velocidad de los cuatro motores
  myMotor1->setSpeed(velocidad);
  myMotor2->setSpeed(velocidad);
  myMotor3->setSpeed(velocidad);
  myMotor4->setSpeed(velocidad);

  // Dirección de los cuatro motores
  myMotor1->run(FORWARD);
  myMotor2->run(BACKWARD);
  myMotor3->run(BACKWARD);
  myMotor4->run(FORWARD);

  delay(5000);

  // Paramos los cuatro motores
  myMotor1->run(RELEASE);
  myMotor2->run(RELEASE);
  myMotor3->run(RELEASE);
  myMotor4->run(RELEASE);
  }

  void loop() {
  
}

#include <Wire.h>

#include <Adafruit_MotorShield.h>

#include "utility/Adafruit_MS_PWMServoDriver.h"

// Motor shield objeto

Adafruit_MotorShield AFMS = Adafruit_MotorShield();

// Motores

Adafruit_DCMotor *myMotor1 = AFMS.getMotor(1);// Puerto M1

Adafruit_DCMotor *myMotor2 = AFMS.getMotor(2);// Puerto M2

Adafruit_DCMotor *myMotor3 = AFMS.getMotor(3);// Puerto M3

Adafruit_DCMotor *myMotor4 = AFMS.getMotor(4);// Puerto M4

// Velocidad

int velocidad = 40; // Velocidad de 0 a 255

void setup() {

// Iniciamos el monitor serie para mostrar el resultado

Serial.begin(9600);

// Iniciamos el motor shield

AFMS.begin();

// Velocidad de los cuatro motores

myMotor1->setSpeed(velocidad);

myMotor2->setSpeed(velocidad);

myMotor3->setSpeed(velocidad);

myMotor4->setSpeed(velocidad);

// Dirección de los cuatro motores

myMotor1->run(FORWARD);

myMotor2->run(BACKWARD);

myMotor3->run(BACKWARD);

myMotor4->run(FORWARD);

delay(5000);

// Paramos los cuatro motores

myMotor1->run(RELEASE);

myMotor2->run(RELEASE);

myMotor3->run(RELEASE);

myMotor4->run(RELEASE);

}

void loop() {

}

No te olvides de descargar las librerías y añadir la librería al IDE de Arduino para hacer funcionar el Adafruit Motor Shield. Lo puedes descargar desde GitHub.

Si todo ha ido bien ya estamos muy cerca de poder controlar el robot Arduino con una app Blynk gracias al módulo Bluetooth Arduino HC-05.

Ahora vamos a pasar a ver la app de Blynk para poder controlar el robot Arduino.

App Blynk Bluetooth para controlar el robot Arduino

Lo interesante de este proyecto es qu,e a parte de saber cómo funciona un módulo Bluetooth Arduino HC-05 y de cómo conectarlo a un robot Arduino, es conocer cómo controlarlo todo desde una app móvil.

Hay diferentes opciones para hacer esto. Quizás, una de las más interesantes sea utilizar App Inventor.

Esta plataforma te permite crear apps de una forma muy sencilla sin tener que programar. Incluso tiene una versión web para desarrollar aplicaciones. Sin embargo, no es tan sencillo como puede parecer.

Para crear una app móvil tienes que tener ciertos conocimientos en el desarrollo de apps que se salen fuera de este tutorial para crear un robot Arduino controlado por un módulo Bluetooth HC-05.

Una opción bastante más sencilla y práctica es utilizar una plataforma como Blynk. Ya me has oído más de una vez hablar de ella.

Esta plataforma consiste en todo lo necesario para poder controlar una placa como Arduino o ESP8266 a través de Bluetooth o WiFi. Incluso puedes controlar una placa por el puerto serie con Blynk.

Nos facilita las librerías, la plataforma en la nube y la app móvil. Vamos, todo lo necesario para nuestro proyecto con el robot Arduino.

El objetivo de este tutorial tampoco es enseñarte a utilizar todas las funciones que nos aporta esta plataforma. Si quieres saber cómo trabajar con ella te aconsejo que vayas directamente a la web de Blynk.

Podrás acceder a su documentación que aunque está en inglés, es muy completa.

La aplicación que he diseñado est la siguiente.

Como ves es muy sencilla. No hace falta que la diseñes tu. Sigue los siguientes pasos para instalar una copia de dicha aplicación en tu móvil.

El módulo Bluetooth Arduino HC-05 no es compatible con los teléfonos que usan iOS (Apple). Esto es debido a que estos módulos utilizan la versión Bluetooth 2.0 y en iOS solo permite comunicar con hardware que utilizan la versión 4.0 y BLE (Bluetooth Low Energy).

1. Descarga la aplicación Blynk de Google Play Store

Lo primero que tienes que hacer es descargar la aplicación Blynk de la tienda de apps Google Play Store.

2. Crea un usuario y escanea el código QR

Una vez tengas descargada la aplicación tendrás que darte de alta. Es muy sencillo, sólo tienes que poner un email y una contraseña.

Una vez tengas creada la cuenta debes escanear el siguiente código QR que te dejo a continuación.

Para escanearlo lo único que tienes que hacer es presionar el botón donde aparece un código QR en la pantalla aplicación de Blynk.

Esto abrirá la cámara y una vez esté escaneado, aparecerá la app para controlar el robot Arduino desde la app Blynk a través del módulo Bluetooth HC-05.

3. Obtener el auth key de la aplicación

Ya solo nos queda una cosa y es obtener el auth key de la aplicación que nos hará falta para insertarlo en el código. Es la clave de autorización para poder conectarte a tu Arduino desde la app de Blynk.

Lo primero es entrar a la configuración del proyecto. Asegúrate que está deshabilitado y haz click en la tuerca que aparece arriba en la parte derecha.

Una vez dentro tienes dos opciones. O copias uno a uno el carácter del auth key o te lo envías por email apretando el botón de E-Mail.

No hace falta que te diga que el auth key no deberías compartirlo con nadie. En el caso que lo hayas hecho (como yo ahora) puedes actualizarlo haciendo click en el botón Refresh.

Con esto ya podemos ir al código que necesitas cargar en la placa de Arduino UNO.

Código robot Arduino y módulo Bluetooth HC-05

Aunque parezca un código bastante complejo, la realidad es que es un código muy simple.

Vamos a verlo por partes. Ten en cuenta que no voy a entrar en profundidad a explicar el código completo. Me centraré en las partes más importantes.

Librerías y variables

#define BLYNK_PRINT Serial

#include <BlynkSimpleSerialBLE.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <Adafruit_MotorShield.h>
#include "utility/Adafruit_MS_PWMServoDriver.h"

// Auth token de la aplicación Blynk
char auth[] = "AQUI-PON-TU-AUTH-KEY";

// Configuración serial de módulo HC-05
SoftwareSerial SerialBLE(11, 10); // RX, TX

// Motor shield objeto
Adafruit_MotorShield AFMS = Adafruit_MotorShield();

// Motores
Adafruit_DCMotor *myMotor1 = AFMS.getMotor(1);// Puerto M1
Adafruit_DCMotor *myMotor2 = AFMS.getMotor(2);// Puerto M2
Adafruit_DCMotor *myMotor3 = AFMS.getMotor(3);// Puerto M3
Adafruit_DCMotor *myMotor4 = AFMS.getMotor(4);// Puerto M4


// Variables control vehículo
byte velocidad = 0;
boolean encendido = false;

#define BLYNK_PRINT Serial

#include <BlynkSimpleSerialBLE.h>

#include <SoftwareSerial.h>

#include <Wire.h>

#include <Adafruit_MotorShield.h>

#include "utility/Adafruit_MS_PWMServoDriver.h"

// Auth token de la aplicación Blynk

char auth[] = "AQUI-PON-TU-AUTH-KEY";

// Configuración serial de módulo HC-05

SoftwareSerial SerialBLE(11, 10); // RX, TX

// Motor shield objeto

Adafruit_MotorShield AFMS = Adafruit_MotorShield();

// Motores

Adafruit_DCMotor *myMotor1 = AFMS.getMotor(1);// Puerto M1

Adafruit_DCMotor *myMotor2 = AFMS.getMotor(2);// Puerto M2

Adafruit_DCMotor *myMotor3 = AFMS.getMotor(3);// Puerto M3

Adafruit_DCMotor *myMotor4 = AFMS.getMotor(4);// Puerto M4

// Variables control vehículo

byte velocidad = 0;

boolean encendido = false;

En esta primera parte del código se importan las librerías y se declaran todos los objetos y variables que nos harán falta a lo largo del programa.

En la línea 10 del código tendrás que sustituir el literal AQUI-PON-TU-AUTH-KEY por el auth key de tu aplicación.

Cabe destacar que tienes que instalar las librerías:

Estas librerías son fundamentales para poder controlar el robot Arduino desde la app Blynk con el módulo Bluetooth HC-05.

Si no sabes cómo se instalan sigue el tutorial de instalación de librerías con el IDE de Arduino.

Función moverVehiculo()

void moverVehiculo(byte vL, byte vR, boolean aDelante = true) {
  // Velocidad de los cuatro motores
  myMotor1->setSpeed(vL);
  myMotor4->setSpeed(vL);

  myMotor2->setSpeed(vR);
  myMotor3->setSpeed(vR);

#ifdef BLYNK_PRINT
  Serial.print("velocidadL, velocidadR = ");
  Serial.print(vL);
  Serial.print(", ");
  Serial.println(vR);
#endif

  // Si es hacia adelante
  if (aDelante) {
    // Dirección de los cuatro motores
    myMotor1->run(FORWARD);
    myMotor4->run(FORWARD);

    myMotor2->run(BACKWARD);
    myMotor3->run(BACKWARD);
    // Hacia atrás
  } else {
    // Dirección de los cuatro motores
    myMotor1->run(BACKWARD);
    myMotor4->run(BACKWARD);

    myMotor2->run(FORWARD);
    myMotor3->run(FORWARD);
  }
}

void moverVehiculo(byte vL, byte vR, boolean aDelante = true) {

// Velocidad de los cuatro motores

myMotor1->setSpeed(vL);

myMotor4->setSpeed(vL);

myMotor2->setSpeed(vR);

myMotor3->setSpeed(vR);

#ifdef BLYNK_PRINT

Serial.print("velocidadL, velocidadR = ");

Serial.print(vL);

Serial.print(", ");

Serial.println(vR);

#endif

// Si es hacia adelante

if (aDelante) {

// Dirección de los cuatro motores

myMotor1->run(FORWARD);

myMotor4->run(FORWARD);

myMotor2->run(BACKWARD);

myMotor3->run(BACKWARD);

// Hacia atrás

} else {

// Dirección de los cuatro motores

myMotor1->run(BACKWARD);

myMotor4->run(BACKWARD);

myMotor2->run(FORWARD);

myMotor3->run(FORWARD);

}

La función de moverVehiculo() hace precisamente eso, mover un vehículo.

Admite 3 parámetros:

byte vL: velocidad ruedas lado izquierdo.
byte vR: velocidad ruedas lado derecho.
boolean aDelante: indica si se mueve hacia adelante (true) o hacia atrás (false).

Dentro está la lógica para mover los motores según los parámetros.

Funciones de comunicación con la app Blynk

// Función que se ejecuta cuando la app se desconecta
BLYNK_APP_DISCONNECTED() {
  // Parar motores
  encendido = 0;
  myMotor1->setSpeed(0);
  myMotor4->setSpeed(0);
  myMotor2->setSpeed(0);
  myMotor3->setSpeed(0);
}

// Girar izquierda
BLYNK_WRITE(V0) {
  // Obtener si hay que girar izquierda
  byte izquierdaActiva = param.asInt();

  if (izquierdaActiva) {
    // Obtener la nueva velocidad ruedas izquierda
    byte velocidadL = (int)velocidad / 2;
    // Mover vehículo
    moverVehiculo(velocidadL, velocidad);
  } else {
    // Mover vehículo mismas velocidades
    moverVehiculo(velocidad, velocidad);
  }

#ifdef BLYNK_PRINT
  Serial.print("izquierdaActiva = ");
  Serial.println(izquierdaActiva);
#endif
}

// Girar derecha
BLYNK_WRITE(V3) {
  // Obtener si hay que girar derecha
  byte derechaActiva = param.asInt();

  if (derechaActiva) {
    // Obtener la nueva velocidad ruedas izquierda
    byte velocidadR = (int)velocidad / 2;
    // Mover vehículo
    moverVehiculo(velocidad, velocidadR);
  } else {
    // Mover vehículo mismas velocidades
    moverVehiculo(velocidad, velocidad);
  }

#ifdef BLYNK_PRINT
  Serial.print("derechaActiva = ");
  Serial.println(derechaActiva);
#endif
}

// Lectura acelerador
BLYNK_WRITE(V1) {
  // Velocidad de 0 a 255
  velocidad = param.asInt();

#ifdef BLYNK_PRINT
  Serial.print("velocidad = ");
  Serial.println(velocidad);
#endif

  // Si está arrancado
  if (encendido) {
    // Mover vehículo
    moverVehiculo(velocidad, velocidad);
  }
}

// Leer encendido
BLYNK_WRITE(V2) {
  // Almacenar encendido
  // On -> 1
  // Off -> 0
  encendido = param.asInt();

#ifdef BLYNK_PRINT
  Serial.print("Encendido = ");
  Serial.println(encendido);
#endif

  // Frenar
  if (encendido == 0) {
    velocidad = 0;
    Blynk.virtualWrite(V1, 0);
    moverVehiculo(velocidad, velocidad);
  }
}

// Función que se ejecuta cuando la app se desconecta

BLYNK_APP_DISCONNECTED() {

// Parar motores

encendido = 0;

myMotor1->setSpeed(0);

myMotor4->setSpeed(0);

myMotor2->setSpeed(0);

myMotor3->setSpeed(0);

}

// Girar izquierda

BLYNK_WRITE(V0) {

// Obtener si hay que girar izquierda

byte izquierdaActiva = param.asInt();

if (izquierdaActiva) {

// Obtener la nueva velocidad ruedas izquierda

byte velocidadL = (int)velocidad / 2;

// Mover vehículo

moverVehiculo(velocidadL, velocidad);

} else {

// Mover vehículo mismas velocidades

moverVehiculo(velocidad, velocidad);

}

#ifdef BLYNK_PRINT

Serial.print("izquierdaActiva = ");

Serial.println(izquierdaActiva);

#endif

}

// Girar derecha

BLYNK_WRITE(V3) {

// Obtener si hay que girar derecha

byte derechaActiva = param.asInt();

if (derechaActiva) {

// Obtener la nueva velocidad ruedas izquierda

byte velocidadR = (int)velocidad / 2;

// Mover vehículo

moverVehiculo(velocidad, velocidadR);

} else {

// Mover vehículo mismas velocidades

moverVehiculo(velocidad, velocidad);

}

#ifdef BLYNK_PRINT

Serial.print("derechaActiva = ");

Serial.println(derechaActiva);

#endif

}

// Lectura acelerador

BLYNK_WRITE(V1) {

// Velocidad de 0 a 255

velocidad = param.asInt();

#ifdef BLYNK_PRINT

Serial.print("velocidad = ");

Serial.println(velocidad);

#endif

// Si está arrancado

if (encendido) {

// Mover vehículo

moverVehiculo(velocidad, velocidad);

}

// Leer encendido

BLYNK_WRITE(V2) {

// Almacenar encendido

// On -> 1

// Off -> 0

encendido = param.asInt();

#ifdef BLYNK_PRINT

Serial.print("Encendido = ");

Serial.println(encendido);

#endif

// Frenar

if (encendido == 0) {

velocidad = 0;

Blynk.virtualWrite(V1, 0);

moverVehiculo(velocidad, velocidad);

}

Para poder comunicarse desde la app Blynk hacia el Arduino UNO a través del módulo Bluetooth HC-05, se utilizan los pines virtuales.

Dentro del código, cada vez que se cambie el valor de un pin virtual se ejecuta la función BLYNK_WRITE(VX) correspondiente.

Por ejemplo, el botón para girar a la izquierda está asociado al pin virtual V0. Cuando se aprieta dicho botón, ejecuta la función BLYNK_WRITE(V0) y todo el código que hay dentro de esa función.

Cada función tiene una lógica asociada a cada acción.

Por último la función BLYNK_APP_DISCONNECTED() se ejecuta en el caso de que la app Blynk se desconecte del módulo Bluetooth Arduino HC-05. En este caso la orden será hacer parar el robot Arduino.

Función setup()

void setup(){
#ifdef BLYNK_PRINT
  // Para hacer debug
  Serial.begin(9600);
#endif

  // Iniciar el motor shield
  AFMS.begin();

  // Iniciar HC-05
  // Si es HC-06 utilizar 9600
  SerialBLE.begin(38400);

  // Iniciar comunicación Blynk
  Blynk.begin(SerialBLE, auth);

#ifdef BLYNK_PRINT
  Serial.println("Esperando a conectar app Blynk...");
#endif
}

void setup(){

#ifdef BLYNK_PRINT

// Para hacer debug

Serial.begin(9600);

#endif

// Iniciar el motor shield

AFMS.begin();

// Iniciar HC-05

// Si es HC-06 utilizar 9600

SerialBLE.begin(38400);

// Iniciar comunicación Blynk

Blynk.begin(SerialBLE, auth);

#ifdef BLYNK_PRINT

Serial.println("Esperando a conectar app Blynk...");

#endif

}

En la función setup(), como siempre, implementamos todas las configuraciones necesarias. En este caso es necesario iniciar el motor shield de Arduino robot, llamar a la función para iniciar el módulo Bluetooth Arduino HC-05 y por último iniciar la comunicación con la app Blynk.

Función loop()

void loop(){
  // Proceso blynk y timer
  Blynk.run();
}

void loop(){

// Proceso blynk y timer

Blynk.run();

}

La función loop() es la más sencilla de todas ya que lo único que hace es llamar a la función Blynk.run() para comprobar si hay alguna acción pendiente enviada desde la app Blynk.

Y esto es todo el código que vas a necesitar para hacer funcionar el robot Arduino con el módulo Bluetooth HC-05.

A continuación te dejo el código completo.

Código completo robot Arduino y módulo Bluetooth HC-05

#define BLYNK_PRINT Serial

#include <BlynkSimpleSerialBLE.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <Adafruit_MotorShield.h>
#include "utility/Adafruit_MS_PWMServoDriver.h"

// Auth token de la aplicación Blynk
char auth[] = "AQUI-PON-TU-AUTH-KEY";

// Configuración serial de módulo HC-05
SoftwareSerial SerialBLE(11, 10); // RX, TX

// Motor shield objeto
Adafruit_MotorShield AFMS = Adafruit_MotorShield();

// Motores
Adafruit_DCMotor *myMotor1 = AFMS.getMotor(1);// Puerto M1
Adafruit_DCMotor *myMotor2 = AFMS.getMotor(2);// Puerto M2
Adafruit_DCMotor *myMotor3 = AFMS.getMotor(3);// Puerto M3
Adafruit_DCMotor *myMotor4 = AFMS.getMotor(4);// Puerto M4


// Variables control vehículo
byte velocidad = 0;
boolean encendido = false;

void moverVehiculo(byte vL, byte vR, boolean aDelante = true) {
  // Velocidad de los cuatro motores
  myMotor1->setSpeed(vL);
  myMotor4->setSpeed(vL);

  myMotor2->setSpeed(vR);
  myMotor3->setSpeed(vR);

#ifdef BLYNK_PRINT
  Serial.print("velocidadL, velocidadR = ");
  Serial.print(vL);
  Serial.print(", ");
  Serial.println(vR);
#endif

  // Si es hacia adelante
  if (aDelante) {
    // Dirección de los cuatro motores
    myMotor1->run(FORWARD);
    myMotor4->run(FORWARD);

    myMotor2->run(BACKWARD);
    myMotor3->run(BACKWARD);
    // Hacia atrás
  } else {
    // Dirección de los cuatro motores
    myMotor1->run(BACKWARD);
    myMotor4->run(BACKWARD);

    myMotor2->run(FORWARD);
    myMotor3->run(FORWARD);
  }
}

// Función que se ejecuta cuando la app se desconecta
BLYNK_APP_DISCONNECTED() {
  // Parar motores
  encendido = 0;
  myMotor1->setSpeed(0);
  myMotor4->setSpeed(0);
  myMotor2->setSpeed(0);
  myMotor3->setSpeed(0);
}

// Girar izquierda
BLYNK_WRITE(V0) {
  // Obtener si hay que girar izquierda
  byte izquierdaActiva = param.asInt();

  if (izquierdaActiva) {
    // Obtener la nueva velocidad ruedas izquierda
    byte velocidadL = (int)velocidad / 2;
    // Mover vehículo
    moverVehiculo(velocidadL, velocidad);
  } else {
    // Mover vehículo mismas velocidades
    moverVehiculo(velocidad, velocidad);
  }

#ifdef BLYNK_PRINT
  Serial.print("izquierdaActiva = ");
  Serial.println(izquierdaActiva);
#endif
}

// Girar derecha
BLYNK_WRITE(V3) {
  // Obtener si hay que girar derecha
  byte derechaActiva = param.asInt();

  if (derechaActiva) {
    // Obtener la nueva velocidad ruedas izquierda
    byte velocidadR = (int)velocidad / 2;
    // Mover vehículo
    moverVehiculo(velocidad, velocidadR);
  } else {
    // Mover vehículo mismas velocidades
    moverVehiculo(velocidad, velocidad);
  }

#ifdef BLYNK_PRINT
  Serial.print("derechaActiva = ");
  Serial.println(derechaActiva);
#endif
}

// Lectura acelerador
BLYNK_WRITE(V1) {
  // Velocidad de 0 a 255
  velocidad = param.asInt();

#ifdef BLYNK_PRINT
  Serial.print("velocidad = ");
  Serial.println(velocidad);
#endif

  // Si está arrancado
  if (encendido) {
    // Mover vehículo
    moverVehiculo(velocidad, velocidad);
  }
}

// Leer encendido
BLYNK_WRITE(V2) {
  // Almacenar encendido
  // On -> 1
  // Off -> 0
  encendido = param.asInt();

#ifdef BLYNK_PRINT
  Serial.print("Encendido = ");
  Serial.println(encendido);
#endif

  // Frenar
  if (encendido == 0) {
    velocidad = 0;
    Blynk.virtualWrite(V1, 0);
    moverVehiculo(velocidad, velocidad);
  }
}

void setup(){
#ifdef BLYNK_PRINT
  // Para hacer debug
  Serial.begin(9600);
#endif

  // Iniciar el motor shield
  AFMS.begin();

  // Iniciar HC-05
  // Si es HC-06 utilizar 9600
  SerialBLE.begin(38400);

  // Iniciar comunicación Blynk
  Blynk.begin(SerialBLE, auth);

#ifdef BLYNK_PRINT
  Serial.println("Esperando a conectar app Blynk...");
#endif
}

void loop(){
  // Proceso blynk y timer
  Blynk.run();
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

#define BLYNK_PRINT Serial

#include <BlynkSimpleSerialBLE.h>

#include <SoftwareSerial.h>

#include <Wire.h>

#include <Adafruit_MotorShield.h>

#include "utility/Adafruit_MS_PWMServoDriver.h"

// Auth token de la aplicación Blynk

char auth[] = "AQUI-PON-TU-AUTH-KEY";

// Configuración serial de módulo HC-05

SoftwareSerial SerialBLE(11, 10); // RX, TX

// Motor shield objeto

Adafruit_MotorShield AFMS = Adafruit_MotorShield();

// Motores

Adafruit_DCMotor *myMotor1 = AFMS.getMotor(1);// Puerto M1

Adafruit_DCMotor *myMotor2 = AFMS.getMotor(2);// Puerto M2

Adafruit_DCMotor *myMotor3 = AFMS.getMotor(3);// Puerto M3

Adafruit_DCMotor *myMotor4 = AFMS.getMotor(4);// Puerto M4

// Variables control vehículo

byte velocidad = 0;

boolean encendido = false;

void moverVehiculo(byte vL, byte vR, boolean aDelante = true) {

// Velocidad de los cuatro motores

myMotor1->setSpeed(vL);

myMotor4->setSpeed(vL);

myMotor2->setSpeed(vR);

myMotor3->setSpeed(vR);

#ifdef BLYNK_PRINT

Serial.print("velocidadL, velocidadR = ");

Serial.print(vL);

Serial.print(", ");

Serial.println(vR);

#endif

// Si es hacia adelante

if (aDelante) {

// Dirección de los cuatro motores

myMotor1->run(FORWARD);

myMotor4->run(FORWARD);

myMotor2->run(BACKWARD);

myMotor3->run(BACKWARD);

// Hacia atrás

} else {

// Dirección de los cuatro motores

myMotor1->run(BACKWARD);

myMotor4->run(BACKWARD);

myMotor2->run(FORWARD);

myMotor3->run(FORWARD);

}

// Función que se ejecuta cuando la app se desconecta

BLYNK_APP_DISCONNECTED() {

// Parar motores

encendido = 0;

myMotor1->setSpeed(0);

myMotor4->setSpeed(0);

myMotor2->setSpeed(0);

myMotor3->setSpeed(0);

}

// Girar izquierda

BLYNK_WRITE(V0) {

// Obtener si hay que girar izquierda

byte izquierdaActiva = param.asInt();

if (izquierdaActiva) {

// Obtener la nueva velocidad ruedas izquierda

byte velocidadL = (int)velocidad / 2;

// Mover vehículo

moverVehiculo(velocidadL, velocidad);

} else {

// Mover vehículo mismas velocidades

moverVehiculo(velocidad, velocidad);

}

#ifdef BLYNK_PRINT

Serial.print("izquierdaActiva = ");

Serial.println(izquierdaActiva);

#endif

}

// Girar derecha

BLYNK_WRITE(V3) {

// Obtener si hay que girar derecha

byte derechaActiva = param.asInt();

if (derechaActiva) {

// Obtener la nueva velocidad ruedas izquierda

byte velocidadR = (int)velocidad / 2;

// Mover vehículo

moverVehiculo(velocidad, velocidadR);

} else {

// Mover vehículo mismas velocidades

moverVehiculo(velocidad, velocidad);

}

#ifdef BLYNK_PRINT

Serial.print("derechaActiva = ");

Serial.println(derechaActiva);

#endif

}

// Lectura acelerador

BLYNK_WRITE(V1) {

// Velocidad de 0 a 255

velocidad = param.asInt();

#ifdef BLYNK_PRINT

Serial.print("velocidad = ");

Serial.println(velocidad);

#endif

// Si está arrancado

if (encendido) {

// Mover vehículo

moverVehiculo(velocidad, velocidad);

}

// Leer encendido

BLYNK_WRITE(V2) {

// Almacenar encendido

// On -> 1

// Off -> 0

encendido = param.asInt();

#ifdef BLYNK_PRINT

Serial.print("Encendido = ");

Serial.println(encendido);

#endif

// Frenar

if (encendido == 0) {

velocidad = 0;

Blynk.virtualWrite(V1, 0);

moverVehiculo(velocidad, velocidad);

}

void setup(){

#ifdef BLYNK_PRINT

// Para hacer debug

Serial.begin(9600);

#endif

// Iniciar el motor shield

AFMS.begin();

// Iniciar HC-05

// Si es HC-06 utilizar 9600

SerialBLE.begin(38400);

// Iniciar comunicación Blynk

Blynk.begin(SerialBLE, auth);

#ifdef BLYNK_PRINT

Serial.println("Esperando a conectar app Blynk...");

#endif

}

void loop(){

// Proceso blynk y timer

Blynk.run();

}

No te olvides de poner tu auth key de la app Blynk en la línea 10 del código.

Ahora ya tenemos todo preparado para hacer funcionar el robot Arduino controlado desde la app Blynk con el módulo Bluetooth Arduino HC-05.

Conectar app Blynk con módulo Bluetooth Arduino HC-05

Este es el último paso. Solo nos queda conectar (emparejar) el módulo Bluetooth Arduino HC-05 con la app Blynk para poder controlar el robot Arduino.

Si todo lo hemos configurado bien, quizás sea lo más sencillo que hay que hacer. Sigue los siguientes pasos.

1. Conecta el Arduino UNO a la alimentación

Cuando conectas el Arduino UNO y el motor shield a la alimentación, en principio no tendría que moverse ni un motor del robot Arduino.

Si te fijas en el módulo Bluetooth Arduino HC-05 habrá empezado a parpadear muy rápidamente. Esto es debido a que no está conectado a ningún maestro es decir, está en modo emparejamiento (pairing).

2. Conectar Blynk y con el módulo Bluetooth HC-05

Ahora toca emparejar la app Blynk con el módulo Bluetooth Arduino HC-05.

Abre la app Blynk y con la aplicación sin ejecutar (lo podrás saber porque aparece un triángulo en la parte superior derecha) y presiona en el símbolo de Bluetooth.

Esto abre una nueva pantalla donde puedes ver un botón que pone Connect Bluetooth Device. Presiona el botón.

Esto abrirá un menú desplegable donde podrás elegir el módulo Bluetooth Arduino HC-05 entre todos los dispositivos Bluetooth que estén al alcance.

Puede que el nombre HC-05 no aparezca y en cambio, aparezca la dirección MAC del módulo Bluetooth. Esta dirección es la que has obtenido cuando has enviado el comando AT+ADDR. Si no encuentras el dispositivo por nombre prueba a buscar por esta dirección.

Una vez tengas localizado el módulo Bluetooth Arduino HC-05 se asociará y aparecerá un mensaje HC-05 connected. Lo siguiente es dar a la flecha para ir a la pantalla principal del proyecto.

3. Iniciar aplicación Blynk y conectar con módulo Bluetooth Arduino HC-05

Ya queda el último paso y es arrancar la aplicación. Desde la pantalla principal del proyecto aprieta el botón Play de la aplicación Blynk.

Esto iniciará la comunicación con el robot Arduino a través del módulo Bluetooth HC-05.

En este punto, si antes no habías emparejado el módulo Bluetooth HC-05 con ese dispositivo, te pedirá la contraseña. Aquí tienes que utilizar la contraseña obtenida con el comando AT+PSWD.

Por defecto la contraseña es 1234.

Si todo ha ido bien, la aplicación Blynk se habrá conectado al módulo Bluetooth HC-05 y ya podrás controlar el robot Arduino desde tu móvil o tablet.

Al realizar la conexión, el LED del módulo Bluetooth Arduino HC-05 ha dejado de parpadear rápido y ahora hace un doble parpadeo (enciende y apaga rápido y luego se mantiene un rato más largo apagado).

En la aplicación podrás saber que está conectado porque ha desaparecido un punto rojo en el dibujo de la placa de Arduino UNO.

Y con esto damos por finalizado el extenso tutorial donde has aprendido con crear tu propio robot Arduino y poder controlarlo con una aplicación de Blink conectado a un módulo Bluetooth Arduino HC-05.

Agradezco mucho tu atención y espero tus comentarios justo aquí abajo.