Esptop 10 Bluetooth - Guía final

ESP32 es un tablero basado en microcontroladores que viene con soporte de Wi-Fi y Bluetooth. Es un tablero basado en IoT que se puede integrar con múltiples sensores para ejecutar instrucciones. La junta de ESP32 tiene una amplia aplicación donde se requiere comunicación inalámbrica.

ESP32 admite Bluetooth dual que contiene Bluetooth Classic y el Bluetooth baja energía (BLE). En este artículo discutiremos el funcionamiento de estos dos bluetooth.

Aquí hay una breve comparación de Bluetooth Classic con Bluetooth Low Energy:

Especificación	Bluetooth Classic	Bluetooth baja energía/ble
Tasa de transferencia de datos	2-3Mbps	1Mbps
Rango	~ 10-100m	~ 50m
Frecuencia de operación	79 RF	40 RF
Consumo de corriente máxima	~ 30 mapa	<15mA
El consumo de energía	1W	0.01-0.5W
Tiempo total para enviar datos	100 ms	3 ms
Aplicaciones	Audio, transmisión de música	Sensor, wearables

Para una comparación más detallada, haga clic aquí para visitar el sitio oficial de Bluetooth.

Los siguientes son los dos modos Bluetooth disponibles en la placa ESP32:

• Bluetooth Classic
• Bluetooth baja energía (BLE)

1: ESP32 Bluetooth Classic con Arduino IDE

La placa ESP32 viene con soporte de Bluetooth dual uno es Bluetooth Classic y el segundo es BLE (Bluetooth Low Energy). Hoy estaremos discutiendo solo Bluetooth Classic. La única diferencia que existe entre ambos es que Bluetooth Classic puede manejar una gran cantidad de transferencia de datos, pero consume batería a una velocidad más alta, sin embargo, Bluetooth baja energía es una variante de conservación de energía que se utiliza para comunicación a corta distancia. BLE permanece en modo de suspensión hasta que se inicialice para la transferencia de datos.

ESP32 Bluetooth Classic Serial Communication

ESP32 viene con módulos Bluetooth incorporados que primero reciben datos y luego los reenvían al procesador XTENSA. Entonces, para establecer esta comunicación "Bluetoothserial" Se utiliza la biblioteca, que es similar a la Biblioteca Serial Arduino, pero se encuentra solo dentro de ESP32. Las siguientes son algunas funciones ofrecidas por Bluetooth Serial Library:

• comenzar()
• disponible()
• escribir()
• leer()

LED controlado con Bluetooth usando ESP32

Escribamos un código simple que puede controlar un LED usando Bluetooth móvil sobre Bluetooth Wireless Communication. El siguiente es el hardware requerido para controlar el LED usando Bluetooth Serial Communication:

• ESP32
• CONDUJO
• Tablero de circuitos
• dispositivo Android
• Aplicación de terminal Bluetooth en serie

Circuito

Conecte el LED al pin digital 15 de ESP32 con terminal negativo conectado a GND de la placa ESP32. Para un límite de corriente segura, también podemos conectar la resistencia (220 ohmios) entre ellos:

Código

Abra Arduino IDE y seleccione la placa ESP32 en el Administrador de la Junta para ver cómo instalar la placa ESP32 en Arduino IDE Haga clic aquí. Después de seleccionar el tablero, escriba el código a continuación en la ventana del editor:

#Include /*Biblioteca de comunicación serie Bluetooth* /
#define LED_PIN 15 /*Pin LED inicializado* /
Bluetoothserial Serialbt;
byte bt_inp;
#si !definido (config_bt_enabled) || !definido (config_bluedroid_enabled)/*Verifique si hay bluetooth en sdk*/
#Error Bluetooth Off-Corre 'hacer menuconfig' para habilitarlo
#terminara si
Configuración vacía ()

PinMode (LED_PIN, salida); /*Pin de LED establecido como salida*/
De serie.comenzar (115200); /*Tasa de baudios para la comunicación en serie*/
Serialbt.comenzar(); /*Bluetooth Communication comienza*/
De serie.println ("Bluetooth está listo para emparejar ..."); /*Cuando Bluetooth se enciende*/

bucle vacío ()

if (Serialbt.disponible ()) /*Verifique la disponibilidad de datos de Bluetooth* /

Bt_inp = serialbt.leer(); /*Leer datos Bluetooth del dispositivo*/
De serie.escribir (bt_inp); /*Imprima los datos de lectura*/

if (bt_inp == '1' ') /*if condición para el estado LED* /

DigitalWrite (LED_PIN, High); /*activar LED si se recibe 1 entrada*/

if (bt_inp == '0')

DigitalWrite (LED_PIN, Low);/*Apague LED si se recibe la entrada 0*/

Aquí en el código anterior, comenzamos incluyendo la biblioteca de serie Bluetooth para ESP32. A continuación, hemos incluido funciones de biblioteca de serie Bluetooth que habilitarán el Bluetooth ESP32.

El siguiente pin 15 de LED se inicializa y usa el PinMode () El pin de LED de la función se establece como salida.

En bucle, parte del código, el programa verificará la disponibilidad de datos de Bluetooth en serie. Si los datos de entrada son 1 LED se encenderá y si los datos recibidos son 0 LED se apagará.

Una vez que se carga el código. Bluetooth de la placa ESP32 se encenderá y el siguiente mensaje aparecerá en el monitor en serie:

Instalación de la terminal de Bluetooth en serie en el teléfono inteligente

Necesitamos un dispositivo Bluetooth que pueda enviar instrucciones a ESP32, por lo que utilizaremos un teléfono inteligente Android para interactuar con ESP32 Bluetooth. Primero, necesitamos instalar un terminal en serie en un teléfono Android. Siga los pasos dados a continuación para interactuar el teléfono Android con ESP32:

Paso 1: Abra Google Play Store en su teléfono inteligente y busque Terminal de Bluetooth en serie. Instale la aplicación a continuación mostrada:

Paso 2: Después de instalar, abra la configuración de Bluetooth de teléfono móvil. Busque Bluetooth ESP32 y haga clic para comenzar a emparejarlo con su teléfono inteligente haciendo clic en Par:

Paso 3: Después de tocar un Par, El teléfono móvil comenzará a emparejarse con ESP32 Bluetooth:

Etapa 4: Ahora abra la aplicación de terminal Bluetooth en serie y vaya a Dispositivos Desde el menú lateral:

Paso 5: Una vez que se abre la opción del dispositivo, solicitará algunos permisos o presionará el ACTUALIZAR Botón en la esquina superior derecha:

Paso 6: La siguiente ventana emergente vendrá a hacer clic en Ajustes y permita el permiso que solicite:

Paso 7: Ahora el tablero ESP32 está listo para tomar instrucciones sobre Bluetooth. Bajo Bluetooth Classic Opción Seleccione la placa ESP32:

Paso 8: Una vez que se selecciona ESP32, comenzará a conectarse y, si tiene éxito, un Conectado aparecerá el mensaje:

Paso 9: Ahora podemos enviar cualquier instrucción escribiéndola aquí. Tipo 1 y haga clic en el botón Enviar, LED en la placa ESP32 se encenderá. Del mismo modo, escribiendo 0 LED se apagará:

Del mismo modo, podemos ver la salida en el monitor en serie del Arduino IDE lo que está recibiendo:

Producción

LED se enciende después de enviar 1:

LED se apaga después de enviar 0:

Nota: También podemos configurar botones para instrucciones específicas como se muestran en la imagen a continuación. Para hacer esto, haga clic en los botones y establezca el valor que desee. Aquí hemos establecido dos botones uno para alto y otro para estado bajo. También puede configurar estos atajos en valores hexadecimales.

2: ESP32 Bluetooth baja energía (BLE) con Arduino IDE

Ble o Bluetooth Low Energy es un modo de ahorro de energía de Bluetooth. Su aplicación principal incluye la transferencia de datos a distancias cortas como entrada de puerta, relojes inteligentes, wearables, monitor de presión arterial, seguridad y automatización del hogar. BLE puede transferir datos limitados.

A diferencia de Bluetooth Classic, que permanece encendido durante todo el tiempo, BLE permanece en modo de suspensión, excepto cuando se llama, o se inicia la conexión. Esto hace que el BLE sea muy eficiente y consume 100 veces menos potencia que el clásico.

Servidor BLE y cliente

Bluetooth Low Energy admite el dispositivo de dos maneras diferentes debido a la cual ESP32 puede actuar como servidor y cliente para Bluetooth de baja energía.

Soporte BLE siguiendo modos de comunicación:

• Punto a punto: Comunicación entre dos puntos o nodos que es servidor y cliente.
• Modo de transmisión: El servidor transmite datos a muchos dispositivos.
• Red de malla: Múltiples dispositivos conectados juntos también conocidos como muchas a muchas conexiones.

Al actuar como servidor, ESP32 anuncia su existencia a los dispositivos de clientes cercanos. Una vez que los dispositivos del cliente escanean los dispositivos Bluetooth disponibles, el servidor establece la conexión entre ellos y transfiere los datos del servidor al dispositivo del cliente. Esta comunicación se llama punto a punto.

En este tutorial, tomaremos un ejemplo de comunicación punto a punto entre dos tableros ESP32.

Términos importantes en BLE

Aquí hay algunos términos importantes que uno debe saber mientras se trabaja con aplicaciones ESP32 BLE:

Gatt: Atributos GATT o genéricos que define una estructura jerárquica para las transferencias de datos entre dispositivos BLE utilizando el servicio y la característica. Define la forma en que dos dispositivos comunican datos entre ellos.

Servicio BLE: El nivel superior dentro de la jerarquía del GATT es un perfil que contiene uno o más servicios. BLE tiene más de un servicio. Cada uno de estos servicios tiene sus propias características que también pueden actuar como referencia para otros servicios.

Característica BLE: La característica es un grupo de información siempre propiedad del servicio; Es donde los datos reales se almacenan en la jerarquía (valor). Siempre contiene dos atributos:

• Declaración: Propiedades características como ubicación, tipo, lectura, escritura y notificación.
• Valor característico: Valor de datos de la característica.

Uuid: UUID (identificador universalmente único) se da a cada servicio y característica. Es una identificación única de 128 bits que se puede generar utilizando cualquier generador UUID en línea. Consulte este generador UUID gratuito. Un UUID de muestra se ve así:

583F8B30-74B4-4757-8143-56048FD88B25

Un grupo de interés especial de Bluetooth universal (SIG) ha predefinido algunos de los UUID acortados para diferentes tipos de servicios y perfil, para leerlos Haga clic aquí.

Configurar BLE en ESP32 con Arduino IDE

Para comprender el funcionamiento de BLE, usaremos dos tablas ESP32 diferentes, una de ellas actuará como servidor y anunciar una señal de Bluetooth mientras el otro ESP32 que actúa como un cliente Intentará conectar el servidor Bluetooth.

Arduino IDE tiene ejemplos separados tanto para escáner como para servidor.

Para ver cómo instalar una placa ESP32 con Arduino IDE en Windows, haga clic aquí.

Servidor BLE ESP32

Primero, subiremos el código de ejemplo del servidor dentro de nuestra primera placa ESP32 que actúa como un servidor.

Para abrir el ejemplo del servidor BLE, vaya a: Archivo> Ejemplos> ESP32 BLE Arduino> Ble_Server:

El siguiente código dado se abrirá en Arduino IDE.

Código de servidor

Cargue el siguiente código en la placa ESP32 usando Arduino IDE, pero asegúrese de desconectar la segunda placa durante un tiempo para evitar cargar el mismo código a una sola placa:

#incluir
#incluir
#incluir
#define Service_uuid "4FAFC201-1FB5-459E-8FCC-C5C9C331914B"
#define característica_uuid "Beb5483e-36e1-4688-b7f5-EA07361B26A8"
setup () void
De serie.comenzar (115200);
De serie.println ("iniciando el trabajo ble!");
Bledevice :: init ("esp32");
Bleserver *pServer = bledevice :: createServer ();
BlService *pService = pServer-> createService (servicio_uuid);
Blecharacteristic *pCharacteristic = PService-> CreateCharacteristic (
Característico_uuid,
Blecharacteristic :: Property_read |
Blecharacteristic :: Property_Write
);
pCharacteristic-> setValue ("Hola, digamos Linuxhint.com ");
pService-> start ();
// bleadvertising *padvertising = pServer-> getAdvertising (); // Esto todavía está funcionando para la compatibilidad hacia atrás
Bleadvertising *padvertising = bledevice :: getAdvertising ();
Padvertising-> addServiceUUid (Service_UUid);
Padvertising-> setScanResponse (verdadero);
padvertising-> setMinPrefered (0x06); // Funciones que ayudan con el problema de las conexiones de iPhone
padvertising-> setMinPrefered (0x12);
Bledevice :: startAdvertising ();
De serie.println ("característica definida! Servidor BLE listo ");

bucle void ()
// Pon tu código principal aquí, para ejecutar repetidamente:
retraso (2000);

El código comienza con los archivos de biblioteca Bluetooth necesarios. Entonces UUID se define tanto para el servicio como para la característica. Puede ir con el UUID predeterminado o generar utilizando el generador UUID gratuito. La próxima comunicación en serie se inicializa definiendo la tasa de baudios.

A continuación, creamos un dispositivo BLE llamado ESP32 y después de eso definimos el dispositivo BLE como un servidor utilizando el CreateServer () función y luego establecemos el valor característico. En el paso final comenzamos el servicio anunciándolo para que otros dispositivos puedan buscarlo.

Escáner BLE ESP32

Ahora cargaremos un ejemplo de escaneo ESP32 en la segunda placa ESP32. Para hacer esto, vaya a: Archivo> Ejemplos> ESP32 Ble Arduino> Ble_Scan:

El siguiente código estará abierto en el editor de Arduino IDE.

Código de escáner

El código dado se utilizará en la placa ESP32 del escáner. Abra IDE y cargue el código, recuerde desconectar otras placas antes de cargar el código del escáner.

#incluir
#incluir
#incluir
#incluir
int scantime = 5; //En segundos
Blescan* Pblescan;
clase myadvertedDeviceCallbacks: public bleadvertedDevicecallbacks
void onresult (bleadvertededdevice anunciSedDevice)
De serie.printf ("Dispositivo anunciado: %s \ n", anuncio de servicio anunciado.Encadenar().c_str ());

;
setup () void
De serie.comenzar (115200);
De serie.println ("escaneo ...");
Bledevice :: init ("");
pblescan = bledevice :: getScan (); // Crea un nuevo escaneo
pblescan-> setadvertedDeviceCallbacks (new MyadvertedDeviceCallbacks ());
pblescan-> setActivesCan (verdadero); // Active Scan usa más potencia, pero obtenga resultados más rápido
pblescan-> setInterval (100);
pblescan-> setWindow (99); // Valor SetInterval menos o igual

bucle void ()
// Pon tu código principal aquí, para ejecutar repetidamente:
BlescanResults FoundDevices = Pblescan-> Start (Scantime, False);
De serie.imprimir ("dispositivos encontrados:");
De serie.println (FundedDevices.getCount ());
De serie.println ("escaneo hecho!");
pblescan-> clearResults (); // Eliminar los resultados de Buffer Buffer para liberar la memoria
retraso (2000);

El código anterior buscará el número de dispositivos totales disponibles para BLE y mostrará su recuento total con direcciones. Después de cargar el código en la placa del escáner ESP32, presione el Permitir Botón, la placa ESP32 buscará automáticamente los dispositivos disponibles:

Producción

Una vez que el ESP32 escanee los dispositivos disponibles, aparecerá el siguiente resultado. Aquí ESP32 escaneó 9 dispositivos entre los cuales uno es una placa ESP32 con código BLE_SERVER y otro dispositivo es Mi Band 6. El resto de todos los dispositivos están disponibles cerca de mi ESP32.

Cómo arreglar la biblioteca de escaneo BLE ESP32 no contando dispositivos

El ejemplo de la biblioteca de escaneo ESP32 tiene un error de no contar el número total de dispositivos. Para rectificar este problema, vaya a la ubicación mencionada y reemplace el código que se proporciona a continuación:

C: \ Users \ UserName \ AppData \ Local \ Arduino15 \ Packages \ ESP32 \ Hardware \ ESP32 \ 1.0.6 \ Bibliotecas \ ble \ src \ blescan.CPP

Recuerda hides Todas las carpetas porque la carpeta AppData dentro del directorio C permanece oculta de forma predeterminada. Después de abrir el archivo fuente ble_scan .CPP Reemplace la condición dada a continuación dentro del código:

if (m_padvertedDeviceCallbacks)
m_padvertisedDeviceCallbacks-> onResult (*anunciSedDevice);

si (!M_WANTDUPLICATES && !encontró)
m_scanResults.m_vectoradvertedDevices.insertar (std :: par(AdvertisEdDdress.toString (), anunciedDevice));
debería delete = false;

Prueba del servidor BLE ESP32 con teléfono inteligente

La mayoría de los teléfonos inteligentes modernos trabajan con la tecnología BLE para comunicarse con diferentes dispositivos, como relojes inteligentes, wearables, sensores y otros dispositivos de automatización del hogar. Aquí ESP32 es un punto de acceso para dispositivos. Entonces, conectaremos un teléfono Android con una placa ESP32.

Código de servidor BLE para acceso a teléfonos inteligentes ESP32

Cargue el siguiente código dado en la placa ESP32:

#Include /*Biblioteca Bluetooth incluida* /
#incluir
#incluir
#define Service_uuid "A484A399-7272-4282-91CF-9018E075FC35"
#define característica_uuid "C7E084BD-5279-484D-8319-FFF7D917537D"
Clase MyCallbacks: Public BlecharacteristicCallbacks

Vacío de OnWrite (Blecharacteristic *pCharacteristic)

std :: string value = pcharacteristic-> getValue ();
if (valor.longitud ()> 0)

De serie.imprimir ("Valor característico actualizado:");
para (int i = 0; i createService (servicio_uuid);
Blecharacteristic *pCharacteristic = PService-> CreateCharacteristic (
Característico_uuid,
Blecharacteristic :: Property_read |
Blecharacteristic :: Property_Write
);
pCharacteristic-> setCallBacks (new MyCallBacks ());
pCharacteristic-> setValue ("Linuxhint.Com ");
pService-> start ();
Bleadvertising *padvertising = pServer-> getAdvertising ();
padvertising-> start ();

bucle vacío ()

retraso (2000);

Instalación de la aplicación BLE en el teléfono inteligente Android

Los siguientes pasos lo guiarán a instalar aplicaciones BLE en teléfonos inteligentes y ayudar a interactuar los dispositivos móviles con tableros ESP32.

Paso 1: Abra la instalación de Google Play Store Escáner ble solicitud:

Paso 2: Después de instalar, abra la aplicación y permita todo el permiso requerido y recuerde activar Bluetooth móvil:

Paso 3: Ahora escanee los dispositivos Bluetooth disponibles. Conecte la placa ESP32:

Etapa 4: Una vez que la placa ESP32 esté conectada al teléfono inteligente después de la especificación de la placa ESP32. Aquí podemos ver las direcciones UUID y podemos leer y escribir nuevos valores característicos:

Paso 5: Para leer el valor característico guardado, haga clic Riñonal. El resultado se mostrará como se menciona en la imagen a continuación:

Paso 6: Para escribir cualquier nuevo valor característico, haga clic W:

Paso 7: Aparecerá una nueva ventana emergente aquí donde podemos escribir cualquier valor característico y hacer clic De acuerdo:

Paso 8: El nuevo valor que se escribe aparecerá como se muestra en la imagen:

Paso 9: Además, podemos ver el mismo valor característico nuevo impreso en el monitor en serie de Arduino IDE:

Hemos conectado con éxito un dispositivo con ESP32 BLE.

Conclusión

ESP32 viene con Bluetooth dual que son Bluetooth Classic y Bluetooth Low Energy. Aquí en este artículo, discutimos tanto Bluetooth Classic como BLE y sus diversas aplicaciones y trabajar. Bluetooth Classic se usa para una alta transferencia de datos, mientras que BLE (Bluetooth baja energía) se usa para distancias cortas con menos requisitos de energía. Este artículo ofrece una guía final para el funcionamiento de Bluetooth de la placa ESP32 y cómo configurarlos.