Configuración del Shield Bluetooth HC-05 en Modo Maestro y Esclavo - Monitoreo y Control

Escrito por Raúl Alvarez.

Configuracion_Bluetooth_HC-05_Maestro_Esclavo Una forma fácil de comunicar inalámbricamente dos dispositivos embebidos es usando Bluetooth, debido a que hoy por hoy es una tecnología ubicua. Dispositivos de uso diario como computadoras de escritorio, portátiles, teléfonos celulares y tabletas cuentan con esa tecnología de comunicación inalámbrica. Combinando un Shield Bluetooth con una placa Arduino podemos lograr controlar dispositivos mediante actuadores y leer variables desde sensores a una distancia máxima de alrededor de 10 metros.

En este tutorial aprenderemos a configurar el Shield Bluetooth tanto en modo esclavo como en modo maestro. Configurado en modo esclavo podemos conectarlo con un dispositivo en modo maestro, como por ejemplo un teléfono celular o una computadora; también podemos conectarlo con otro Shield que esté configurado en modo maestro.

Después de mostrar la configuración en ambos modos mostraremos finalmente un ejemplo de monitoreo y otro de control con dos nodos: uno con un Shield configurado en modo esclavo y el otro con el Shield configurado en modo maestro.

Videos

Configuración del Shield Bluetooth HC-05 en Modo Esclavo

Configuración del Shield Bluetooth HC-05 en Modo Maestro

Ejemplos de Monitoreo y Control con el Shield Bluetooth HC-05 en Modos Maestro y Esclavo

Si los videos no están visibles en esta página, puedes verlos directamente en nuestro canal de YouTube.

Tutorial 1: Configuración del Shield Bluetooth HC-05 en Modo Esclavo.

Tutorial 2: Configuración del Shield Bluetooth HC-05 en Modo Maestro

Tutorial 3: Ejemplo de monitoreo y control

Shield Bluetooth HC-05 Maestro - Esclavo

Configuracion Shield Bluetooth HC-05

Comunicación entre el Arduino y el Shield Bluetooth (Modos seriales)

El Shield Bluetooth que usamos tiene un switch rotulado “CMD” y “DAT” que sirve para cambiar el modo de funcionamiento del mismo. Cuando se selecciona “CMD” ingresa en modo de comando y el módulo puede recibir y responder a comandos AT en este modo. Cuando se selecciona "DAT" , entrará en modo de datos y no acepta comandos AT, más bien funciona de manera “transparente” derivando toda la información recibida por su puerto serial hacia el enlace inalámbrico y viceversa.

En este tutorial configuraremos dos shields, uno en modo esclavo y el otro en modo maestro de tal modo que cuando ambos dispositivos estén energizados se vincularán automáticamente.

Bluetooth en modo esclavo y modo maestro

Un dispositivo Bluetooth puede trabajar de dos maneras:
Modo Maestro: Este dispositivo es el administra la comunicación inalámbrica y puede conectarse directamente hast con 7 dispositivos esclavo.
Modo Esclavo: Este dispositivo solo responde a requerimientos enviados desde su nodo maestro y puede enviar y recibir datos solo hacia y desde su nodo maestro.

Configuración Maestro - Esclavo

Configuración del modo esclavo

Poner el jumper Tx en el pin 6 y el jumper Rx en el pin 7
Conectar el Shield Bluetooth al Arduino Uno
Poner el switch del Shield Bluetooth hacia el lado que indica “CMD”
Conectar el Arduino al computador y abrir el IDE de arduino en el ejemplo de “SoftwareSerialExample”

Modificar: SoftwareSerial mySerial(7, 6); //RX y TX
Modificar: mySerial.begin(38400); // Se modifica la tasa de transferencia por defecto del Shield Bluetooth para el modo de configuración en el que estamos actualmente y grabamos el código a la placa Arduino.

Abrir el puerto Serial del IDE de Arduino y elegir (baud rate: 57600)
Los comandos que utilizaremos para el modo esclavo son:

Correr el siguiente comando: AT , para verificar la correcta comunicación con el módulo.
Correr el siguiente comando para configurar el módulo Bluetooth en modo esclavo: AT+ROLE=0
Correr el siguiente comando para verificar que la configuración anterior se haya grabado correctamente: AT+ROLE?
Correr el siguiente comando para configurar el nombre del dispositivo Bluetooth: AT+NAME=Shield_BT_esclavo
Correr el siguiente comando para verificar que el nombre se haya grabado correctamente: AT+NAME?
Correr el siguiente comando para configurar la contraseña de acceso al dispositivo: AT+PSWD=1234
Correr el siguiente comando para verificar que la contraseña se haya grabado correctamente: AT+PSWD?

Desconectar el cable USB y cambiar el switch del Shield hacia el lado que indica “DATA”.

Configuración del modo maestro

Poner los jumpers de Tx en el pin 6 y el jumper Rx en el pin 7
Conectar el Shield Bluetooth al Arduino en la posición correspondiente
Poner el switch del Shield Bluetooth hacia el lado que indica “CMD”
Conectar el Arduino al computador y abrir el IDE de arduino en el ejemplo de “SoftwareSerialExample modificado” grabamos el código a la placa Arduino.
Abrir el puerto Serial(baud rate: 57600)
Los comandos que utilizaremos para el modo maestro son:

Correr el siguiente comando: AT , para verificar la correcta comunicación con el Arduino
Correr el siguiente comando para configurar el dispositivo Bluetooth en modo maestro: AT+ROLE=1
Correr el siguiente comando para verificar que el modo maestro se haya configurado correctamente: AT+ROLE?
Correr el siguiente comando para configurar el nombre con el que se publicará el dispositivo Bluetooth: AT+NAME=Shield_BT_maestro
Correr el siguiente comando para verificar que el nombre se haya grabado correctamente: AT+NAME?
Correr el siguiente comando para configurar la contraseña de conexión al dispositivo Bluetooth: AT + PSWD = 1234 .(OJO: Debe ser la misma contraseña que la programada en el dispositivo esclavo con el que emparejamos) ,
Correr el siguiente comando para verificar que la contraseña se haya grabado correctamente: AT+PSWD?
Correr el siguiente comando para que la conexión del maestro se realice solo con un dispositivo predeterminado: AT + CMODE = 0 (el que ya configuramos previamente)
Correr el siguiente comando para verificar que “AT + CMODE = 0” se haya grabado correctamente: AT + CMODE?
Correr el siguiente comando para iniciar el perfil de puerto serial (SPP): AT + INIT (Si se devuelve error(17) - ignorar porque el entorno ya está cargado)
Correr el siguiente comando para comenzar a buscar dispositivos Bluetooth cercanos: AT + INQ (antes de correr este comando nuestro nodo Bluetooth esclavo ya debe estar energizado)
Se mostrará una lista de los dispositivos encontrados.
El formato de la salida es: + INQ: dirección, tipo, señal.
Correr el siguiente comando para emparejar el módulo Bluetooth maestro a un módulo Bluetooth esclavo: AT + PAIR = <dirección>,<timeout >(OJO: el tiempo de espera “timeout” es en milisegundos )
La dirección del módulo es lo que necesitamos y está en el formato: 0123: 4: 567890
(OJO: necesitamos reemplazar los dos puntos por comas cuando usamos la dirección en los comandos a continuación)
0123, 4, 567890,1000 (tiempo de espera 1000 milisegundo)
Correr el siguiente comando para establecer un vínculo a la dirección del modulo Bluetooth esclavo: AT + BIND = <dirección>
Correr el siguiente comando para enlazarse con el modulo Bluetooth esclavo:AT + LINK= <dirección>

Ejemplo de Monitoreo

En este ejemplo se usará un módulo Joystick y un sensor inclinación conectados al nodo esclavo el cual enviará la información de los sensores al nodo maestro.

Pasos Para Probar el Ejemplo

Conectamos el sensor shield encima del shield Bluetooth esclavo
Conectamos el sensor digital a la entrada D4 y el sensor análogo a la entrada A0
Conectamos el Arduino al computador

Abrir el código para el nodo esclavo del Ejemplo de Monitoreo y grabarlo
Abrir la terminal serial y enviamos los datos
En el nodo maestro usamos el código “SoftwareSerialExample” modificado
Abrimos el monitor serial del nodo maestro y visualizamos la información recibida desde el nodo esclavo.

Ejemplo de Control

Shield_Bluetooth_HC-05_Control

En este ejemplo enviaremos comandos a través del nodo maestro que activa y desactiva un modulo rele conectado al nodo esclavo.

Pasos Para Probar el Ejemplo

Conectar el modulo rele al pin 13 del shield de conexiones al nodo esclavo
Conectar la placa Arduino al computador

Abrir el código para el nodo esclavo de ejemplo de control y grabarlo
Abrir el monitor serial en el nodo esclavo y esperar la recepción de comandos
Abrir el monitor serial en el nodo maestro y proceder a enviar comandos

B1@ = activa el relé
B0@ = desactiva el relé
B2@ = comando invalido
B1$ = comando invalido, los comandos terminan con @

Hardware del Proyecto

Arduino Uno
Cable para Arduino Uno
Shield Bluetooth HC-05
Shield de sensores version 5
Módulo de inclinación
Módulo Joystick
Módulo Relay
Jumpers hembra - hembra

Software del Proyecto

Código “SoftwareSerialExample” modificado

#include <SoftwareSerial.h>  //Abrir librería serial <softwareSerial.h>

SoftwareSerial mySerial(7, 6); //Puertos de recepción RX 7 y transmisión TX 6

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(57600);  // Tasa de transferencia entre la PC y Arduino
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.println("configuración!");

  // set the data rate for the SoftwareSerial port
  mySerial.begin(38400);   // Se modifica la tasa de transferencia por defecto
  //mySerial.println("Hello, world?");
}
void loop() { // run over and over
  if (mySerial.available()) {
    Serial.write(mySerial.read());
  }
  if (Serial.available()) {
    mySerial.write(Serial.read());
  }
}

En el código de Arduino usaremos la librería Software serial con una ligera modificación en el código”SoftwareSerialExample” para comunicarnos con el Shield Bluetooth a través del envío manual de comandos AT.

Código Monitoreo_inalambrico_Shield_Bluetooth

    #include <SoftwareSerial.h>
SoftwareSerial  mySerial(6, 7);  //Puertos de transmision y recepción RX, TX

void setup() {                
      Serial.begin(9600);         //Inicialización del Puerto Serial para depuración
      pinMode(13, OUTPUT);        //Inicializar el Pin 13 como salida
      pinMode(4, INPUT);          //Inicializar el Pin 4 como entrada
      digitalWrite(13, LOW);      //Escribir el Pin 13 como apagado
     delay(1000);                //Un tiempo de retardo en Milisegundos
     mySerial.begin(9600);
 
     mySerial.println("Monitoreo:");              //Imprimir "Digite su comando"
 
      Serial.println("%%% Monitoreo Inalambrico con Bluetooth %%%");
      Serial.println("      Shield HC-05 en Modo Esclavo");
      Serial.println();
      Serial.println("Esperando envio de datos...");
}

void loop()
{
      Serial.println("Enviando datos...");
      digitalWrite(13, HIGH);
 
int sensor_digital = digitalRead(4);     //Lee el valor digital del puerto 4 e introducirlo en la variable "sensor_digital"
      mySerial.print("sensor_digital ");         //Imprime los valores entre comillas
      mySerial.print("= ");
      mySerial.print(sensor_digital);            //Imprime el valor del sensor digital
      mySerial.print("\t");                      //Comando de comillas para texto
 
int sensor_analogo = analogRead(A0);     //Lee el valor analogo del puerto A0 e introducirlo en la variable "sensor_analogo"
      mySerial.print("sensor_analogo ");         // Imprime los valores entre comillas
      mySerial.print("= ");
      mySerial.println(sensor_analogo);          //Imprime el valor del sensor analogo
      delay(100);                              //Un retardo de tiempo de 100 milisegundos
}

Código Control_Inalambrico_Shield_Bluetooth

 #include <SoftwareSerial.h>
SoftwareSerial mySerial(6, 7);       //Puertos de transmision y recepción RX, TX

int rele = 13;                       //Variable que almacena el PIN al cual esta conectado el "rele"

void setup(){
  Serial.begin(9600);                //Inicialización del Puerto Serial para depuración
  pinMode(13, OUTPUT);               //Inicializar el Pin 13 como salida
  digitalWrite(13, LOW);             //Escribir el Pin 13 como apagado
  delay(1000);                        //Un tiempo de retardo en Milisegundos
  mySerial.begin(38400);

  Serial.println("%%% Control Inalambrico con Bluetooth %%%");
  Serial.println("      Shield HC-05 en Modo Esclavo");
  Serial.println();
  Serial.println("Esperando comandos remotos...");
}

void Vaciar_Buffer_Rx(void)                 
{
  while(Serial.available())
    Serial.read();
}

void loop()                                                 
{
    unsigned char comando = 0;  // Variable auxiliar
    unsigned char caracter = 0;  // Variable auxiliar
    
    if (mySerial.available() >= 3)  // Cada comando tiene mínimo 3 caracteres
    {    
        caracter = mySerial.read();  //Leer el primer caracter
        
        /* Verificar comandos que empiecen con la letra 'b' */
        if ((caracter == 'b') || (caracter == 'B'))
        {  
            comando = mySerial.read();  //Leer el 2do. caracter
            
            if (mySerial.read() == '@')  // Verificar que el 3er. caracter sea '@'
            {  
              Serial.println(">>> Comando recibido");
              switch(comando)
              {
                case '0':
                  digitalWrite(rele, LOW);
                  Serial.println("  +++ Sensor desactivado");       
                break;
                case '1':
                  digitalWrite(rele, HIGH);
                  Serial.println("  +++ Sensor activado");
                break;
                default: mySerial.println("\rNumero de comando invalido.\r");
                Serial.println("  *** Comando invalido");
                break;
              }   
            }
            else
            {
             mySerial.println("\rComando invalido.Todos los comandos terminan con '@'");
             Serial.println("  *** Comando invalido");
             Vaciar_Buffer_Rx();  // Vaciar buffer de recepción serial
            }
        }
  }
}

Recomendaciones

Se recomienda tener cuidado al momento de conectar correctamente los jumpers para la comunicación entre el Arduino y el Shield Bluetooth, no confundiendo el pin de transmisión con el de recepción.
Si el ejemplo no funciona, revisar todas las conexiones y el cableado, además de y las modificaciones del código al ejemplo “SoftwareSerial” original del IDE de Arduino.
Se recomienda seguir cada paso al pie de la letra para la correcta configuración del modo maestro o esclavo.