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.

¿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).

: 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.

: 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.

: 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.

: 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.

: 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.

Módulo Bluetooth Arduino HC-05 antiguo

¿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()); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 // 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.

: parpadeo muy lento con un periodo de aproximadamente 2 segundos. Modo pairing o emparejamiento : parpadeo muy rápido.

: 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()); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 // 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.

: devuelve la dirección Bluetooth (MAC) que puede hacer falta más adelante. AT+NAME : devuelve el nombre del módulo Bluetooth.

: 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() { } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 #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; 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 #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); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 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.

: velocidad ruedas lado izquierdo. byte vR : velocidad ruedas lado derecho.

: 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); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 // 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 } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 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(); } 1 2 3 4 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(); } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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.