El ESP32 viene con Wi-Fi, Bluetooth Low Energy y Bluetooth Clásico. En este tutorial vas a aprender cómo usar el Bluetooth Clásico del ESP32 con Arduino IDE para intercambiar datos entre un ESP32 y un smartphone Android.
Controlaremos una salida del ESP32 y enviaremos lecturas de sensores a un smartphone Android usando Bluetooth Clásico.
Nota importante: este proyecto solo es compatible con smartphones Android, ya que iOS no permite el uso del perfil SPP (Serial Port Profile) que usa Bluetooth Clásico.
Bluetooth Clásico con el ESP32: la vía más sencilla
Por el momento, usar Bluetooth Clásico es mucho más sencillo que Bluetooth Low Energy. Si ya has programado un Arduino con un módulo Bluetooth como el HC-06, esto es muy similar. Usa el protocolo serie estándar y sus funciones, lo que lo hace muy intuitivo si vienes del mundo Arduino.
En este tutorial, empezaremos usando un ejemplo que viene con Arduino IDE. Después, construiremos un proyecto sencillo para intercambiar datos entre el ESP32 y tu smartphone Android.
Componentes necesarios
Para seguir este tutorial necesitas: una placa ESP32 DOIT DEVKIT V1, un smartphone Android con Bluetooth, un LED de 5 mm, una resistencia de 330 Ω, un sensor de temperatura DS18B20, una resistencia de 4,7 kΩ, cables jumper y una protoboard.
La aplicación Bluetooth Terminal
Para proceder con este tutorial, necesitas una aplicación Bluetooth Terminal instalada en tu smartphone. Recomendamos usar la app de Android “Serial Bluetooth Terminal”, disponible en Play Store. Es la app que usaremos para enviar y recibir los mensajes de texto con el ESP32.
Ejemplo base: Serial a Serial Bluetooth
Vamos a programar el ESP32 usando Arduino IDE, así que asegúrate de tener el soporte de placas ESP32 instalado antes de continuar. Abre tu Arduino IDE y ve a Archivo > Ejemplos > BluetoothSerial > SerialtoSerialBT.
Debería cargarse el siguiente código:
// Este código de ejemplo está en el Dominio Público (o licencia CC0, a tu elección).
// Por Evandro Copercini - 2018
//
// Este ejemplo crea un puente entre Serial y Bluetooth Clásico (SPP)
// y también demuestra que SerialBT tiene las mismas funcionalidades que un Serial normal
#include "BluetoothSerial.h"
#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif
BluetoothSerial SerialBT;
void setup() {
Serial.begin(115200);
SerialBT.begin("ESP32test"); // Nombre del dispositivo Bluetooth
Serial.println("The device started, now you can pair it with bluetooth!");
}
void loop() {
if (Serial.available()) {
SerialBT.write(Serial.read());
}
if (SerialBT.available()) {
Serial.write(SerialBT.read());
}
delay(20);
}
Cómo funciona este código
Este código establece una comunicación serie Bluetooth bidireccional entre dos dispositivos. El código empieza incluyendo la librería BluetoothSerial:
#include "BluetoothSerial.h"
Las siguientes tres líneas comprueban si Bluetooth está habilitado correctamente:
#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif
Después, se crea una instancia de BluetoothSerial llamada SerialBT:
BluetoothSerial SerialBT;
La función setup()
En el setup() se inicializa una comunicación serie a 115200 baudios. Después, se inicializa el dispositivo serie Bluetooth y se pasa como argumento el nombre del dispositivo Bluetooth. Por defecto se llama ESP32test, pero puedes renombrarlo y darle un nombre único:
SerialBT.begin("ESP32test"); // Nombre del dispositivo Bluetooth
La función loop()
En el loop() se envían y reciben datos vía Bluetooth Serial. En la primera sentencia if, comprobamos si hay bytes siendo recibidos en el puerto serie. Si los hay, enviamos esa información vía Bluetooth al dispositivo conectado:
if (Serial.available()) {
SerialBT.write(Serial.read());
}
SerialBT.write() envía datos usando Bluetooth serial. Serial.read() devuelve los datos recibidos en el puerto serie.
La siguiente sentencia if comprueba si hay bytes disponibles para leer en el puerto Bluetooth Serial. Si los hay, escribimos esos bytes en el Monitor Serie:
if (SerialBT.available()) {
Serial.write(SerialBT.read());
}
Será más fácil entender exactamente cómo funciona este sketch en la demostración.
Probar el código
Sube el código anterior al ESP32. Asegúrate de tener la placa y el puerto COM correctos seleccionados. Después de subir el código, abre el Monitor Serie a 115200 baudios. Pulsa el botón Enable del ESP32.
Después de unos segundos, deberías obtener un mensaje diciendo: “The device started, now you can pair it with bluetooth!”.
Ve a tu smartphone y abre la app “Serial Bluetooth Terminal”. Asegúrate de haber habilitado el Bluetooth de tu smartphone. Para conectar al ESP32 por primera vez, necesitas emparejar un nuevo dispositivo:
Ve a Devices (Dispositivos). Pulsa el icono de ajustes y selecciona Pair new device (Emparejar nuevo dispositivo). Deberías obtener una lista con los dispositivos Bluetooth disponibles, incluyendo ESP32test. Empareja con ESP32test. Después, vuelve a Serial Bluetooth Terminal. Pulsa el icono de la parte superior para conectar con el ESP32. Deberías obtener un mensaje de “Connected” (Conectado).
Después de eso, escribe algo en la app Serial Bluetooth Terminal. Por ejemplo, “Hello”. Deberías recibir ese mensaje instantáneamente en el Monitor Serie de Arduino IDE.
También puedes intercambiar datos entre tu Monitor Serie y tu smartphone. Escribe algo en la barra superior del Monitor Serie y pulsa el botón “Send”. Deberías recibir ese mensaje al instante en la app Serial Bluetooth Terminal.
Proyecto práctico: intercambiar datos usando Bluetooth Serial
Ahora que sabes cómo intercambiar datos usando Bluetooth Serial, puedes modificar el sketch anterior para hacer algo útil. Por ejemplo, controlar las salidas del ESP32 cuando recibes un mensaje determinado, o enviar datos a tu smartphone como lecturas de sensores.
El proyecto que construiremos envía lecturas de temperatura cada 10 segundos a tu smartphone. Usaremos el sensor de temperatura DS18B20. A través de la app Android, enviaremos mensajes para controlar una salida del ESP32. Cuando el ESP32 reciba el mensaje led_on, encenderemos el GPIO; cuando reciba led_off, apagaremos el GPIO.
Esquema de conexión
Antes de continuar con este proyecto, monta el circuito. Conecta un LED al GPIO 25 (ánodo al GPIO, cátodo a GND con resistencia de 330 Ω) y conecta el pin de datos del DS18B20 al GPIO 32 (con una resistencia pull-up de 4,7 kΩ entre el pin de datos y 3,3 V, que es obligatoria para el bus OneWire).
Instalar las librerías del DS18B20
Para trabajar con el sensor de temperatura DS18B20, necesitas instalar la librería One Wire de Paul Stoffregen y la librería Dallas Temperature.
Librería One Wire
Puedes instalarla desde el Gestor de Librerías de Arduino. Ve a Programa > Incluir Librería > Gestionar Librerías y busca “OneWire”. Selecciona la librería de Paul Stoffregen e instálala.
Librería Dallas Temperature
De la misma forma, busca “DallasTemperature” en el Gestor de Librerías y instálala. Una vez instaladas ambas librerías, reinicia Arduino IDE para que las detecte correctamente.
Código del proyecto completo
Después de montar el circuito e instalar las librerías necesarias, copia el siguiente sketch en tu Arduino IDE:
/*
Rui Santos
Detalles completos del proyecto en https://randomnerdtutorials.com
*/
// Carga las librerías
#include "BluetoothSerial.h"
#include <OneWire.h>
#include <DallasTemperature.h>
// Comprueba si las configuraciones de Bluetooth están habilitadas
#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif
// Objeto Bluetooth Serial
BluetoothSerial SerialBT;
// GPIO donde está conectado el LED
const int ledPin = 25;
// GPIO donde está conectado el DS18B20
const int oneWireBus = 32;
// Configura una instancia oneWire para comunicarse con cualquier dispositivo OneWire
OneWire oneWire(oneWireBus);
// Pasa nuestra referencia oneWire al sensor Dallas Temperature
DallasTemperature sensors(&oneWire);
// Maneja los mensajes recibidos y enviados
String message = "";
char incomingChar;
String temperatureString = "";
// Timer: variables auxiliares
unsigned long previousMillis = 0; // Almacena la última vez que se publicó la temperatura
const long interval = 10000; // Intervalo al que publicar lecturas del sensor
void setup() {
pinMode(ledPin, OUTPUT);
Serial.begin(115200);
// Nombre del dispositivo Bluetooth
SerialBT.begin("ESP32");
Serial.println("The device started, now you can pair it with bluetooth!");
}
void loop() {
unsigned long currentMillis = millis();
// Envía las lecturas de temperatura
if (currentMillis - previousMillis >= interval){
previousMillis = currentMillis;
sensors.requestTemperatures();
temperatureString = String(sensors.getTempCByIndex(0)) + "C " + String(sensors.getTempFByIndex(0)) + "F";
SerialBT.println(temperatureString);
}
// Lee los mensajes recibidos (comando de control del LED)
if (SerialBT.available()){
char incomingChar = SerialBT.read();
if (incomingChar != '\n'){
message += String(incomingChar);
}
else{
message = "";
}
Serial.write(incomingChar);
}
// Comprueba el mensaje recibido y controla la salida según corresponda
if (message =="led_on"){
digitalWrite(ledPin, HIGH);
}
else if (message =="led_off"){
digitalWrite(ledPin, LOW);
}
delay(20);
}
Cómo funciona el código paso a paso
Empezamos incluyendo las librerías necesarias: la librería BluetoothSerial para Bluetooth y las librerías OneWire y DallasTemperature para el sensor DS18B20. Después se crea una instancia de BluetoothSerial llamada SerialBT. Se crea una variable llamada ledPin para almacenar el GPIO que quieres controlar. En este caso, GPIO 25 tiene un LED conectado.
Después, se define el pin del sensor DS18B20 y se crean los objetos para hacerlo funcionar. El sensor de temperatura está conectado al GPIO 32. Se crea una cadena vacía llamada message para almacenar los mensajes recibidos. Se crea una variable char llamada incomingChar para guardar los caracteres que llegan vía Bluetooth Serial. La variable temperatureString almacena las lecturas de temperatura que se enviarán vía Bluetooth.
Finalmente, se crean variables auxiliares de temporizador para enviar lecturas cada 10 segundos:
unsigned long previousMillis = 0;
const long interval = 10000;
La función setup()
En el setup(), se establece ledPin como salida. Después, se inicializa el ESP32 como dispositivo Bluetooth con el nombre “ESP32”:
SerialBT.begin("ESP32");
La función loop()
En el loop(), se envían las lecturas de temperatura, se leen los mensajes recibidos y se ejecutan acciones según corresponda. El siguiente fragmento de código comprueba si han pasado 10 segundos desde la última lectura. Si es momento de enviar una nueva lectura, obtenemos la última temperatura y la guardamos en Celsius y Fahrenheit en la variable temperatureString. Después, para enviar temperatureString vía Bluetooth, usamos SerialBT.println().
Leer los mensajes entrantes
La siguiente sentencia if lee los mensajes entrantes. Cuando recibes mensajes vía serial, recibes un carácter a la vez. Sabes que el mensaje ha terminado cuando recibes \n. Así que comprobamos si hay datos disponibles en el puerto Bluetooth serial. Si los hay, guardamos los caracteres en la variable incomingChar. Si el incomingChar es diferente de \n, concatenamos ese carácter a nuestro mensaje. Cuando terminamos de leer los caracteres, limpiamos la variable message. De lo contrario, todos los mensajes recibidos se añadirían uno tras otro.
Controlar la salida según el mensaje
Después de eso, tenemos dos sentencias if para comprobar el contenido del mensaje. Si el mensaje es led_on, el LED se enciende. Si el mensaje es led_off, el LED se apaga.
Probar el proyecto
Sube el sketch anterior a tu placa ESP32. Después, abre el Monitor Serie y pulsa el botón Enable del ESP32. Cuando recibas el mensaje de confirmación, puedes ir a tu smartphone y conectar con el ESP32.
Después, puedes escribir los mensajes “led_on” y “led_off” para controlar el LED. La aplicación tiene varios botones en los que puedes guardar mensajes por defecto. Por ejemplo, puedes asociar M1 con el mensaje “led_on” y M2 con el mensaje “led_off”, de modo que con un solo toque envíes el comando correspondiente.
Ahora eres capaz de controlar los GPIO del ESP32. Al mismo tiempo, deberías estar recibiendo las lecturas de temperatura cada 10 segundos en la misma app.
Conclusión: lo que has aprendido
En resumen, el ESP32 soporta BLE y Bluetooth Clásico. Usar Bluetooth Clásico es tan simple como usar comunicación serie y sus funciones. Esta simplicidad lo convierte en la opción ideal cuando quieres comunicar el ESP32 con un smartphone Android de forma rápida y sin complicaciones, especialmente para proyectos de control remoto, monitorización de sensores o configuración de dispositivos.
Bluetooth Clásico es perfecto para: controlar salidas desde el móvil (luces, relés, motores), recibir lecturas de sensores en tiempo real, enviar comandos de texto o depurar proyectos con un terminal Bluetooth. Su limitación principal es que no funciona con iOS, así que si necesitas compatibilidad con iPhone, tendrás que usar BLE en su lugar.
Si quieres aprender cómo usar BLE con el ESP32, puedes leer nuestra guía específica de introducción a Bluetooth Low Energy, que te permitirá comunicarte también con iPhones y con dispositivos de bajo consumo.
Descubre más desde CIBERED
Suscríbete y recibe las últimas entradas en tu correo electrónico.