Esptop 10 Bluetooth - Guia Ultimate

O ESP32 é uma placa baseada em microcontrolador que vem com suporte Wi-Fi e Bluetooth. É uma placa baseada em IoT que pode ser integrada com vários sensores para executar instruções. A placa ESP32 tem uma ampla aplicação em que a comunicação sem fio é necessária.

O ESP32 suporta Bluetooth duplo contendo Bluetooth Classic e a Bluetooth Low Energy (BLE). Neste artigo, discutiremos o funcionamento de ambos os Bluetooth.

Aqui está uma breve comparação do Bluetooth Classic com Bluetooth Low Energy:

Especificação	Bluetooth Classic	Bluetooth Low Energy/BLE
Taxa de transferência de dados	2-3Mbps	1Mbps
Faixa	~ 10-100m	~ 50m
Frequência de operação	79 RF	40 RF
Consumo de corrente de pico	~ 30Ma	<15mA
Consumo de energia	1w	0.01-0.5W
Tempo total para enviar dados	100ms	3ms
Formulários	Áudio, streaming de música	Sensor, wearables

Para uma comparação mais detalhada, clique aqui para visitar o site oficial do Bluetooth.

A seguir, estão os dois modos Bluetooth disponíveis na placa ESP32:

• Bluetooth Classic
• Bluetooth Low Energy (BLE)

1: Esp32 Bluetooth Classic com Arduino IDE

A placa ESP32 vem com dupla suporte Bluetooth One é o Bluetooth Classic e a segunda é BLE (Bluetooth Low Energy). Hoje estaremos discutindo apenas o Bluetooth Classic. A única diferença que existe entre os dois é que o Bluetooth Classic pode lidar com muita transferência de dados, mas consome bateria a uma taxa mais alta, no entanto. BLE permanece no modo de suspensão até que seja inicializado para transferência de dados.

Esp32 Bluetooth Classic Serial Communication

O ESP32 vem com módulos Bluetooth embutidos que primeiro recebem dados e depois o encaminham para o processador XTENSA. Então, para estabelecer esta comunicação “Bluetoothserial” A biblioteca é usada que é semelhante à Biblioteca Série Arduino, mas está apenas dentro do ESP32. A seguir, estão algumas funções oferecidas pela Bluetooth Serial Library:

• começar()
• disponível()
• escrever()
• ler()

LED controlado por Bluetooth usando ESP32

Vamos escrever um código simples que possa controlar um LED usando o Bluetooth Mobile sobre a comunicação sem fio Bluetooth. A seguir, o hardware necessário para controlar o LED usando a comunicação serial bluetooth:

• Esp32
• LIDERADO
• Pão de pão
• Dispositivo Android
• Aplicação de terminal Bluetooth em série

O circuito

Conecte o LED no pino digital 15 do ESP32 com terminal negativo conectado no GND da placa ESP32. Para um limite de corrente seguro, também podemos conectar o resistor (220 ohms) entre eles:

Código

Abra o Arduino IDE e selecione a placa ESP32 no gerente do conselho para ver como instalar a placa ESP32 no Arduino IDE Clique aqui. Depois de selecionar a placa, escreva o código abaixo na janela do editor:

#include /*biblioteca de comunicação serial bluetooth* /
#Define led_pin 15 /*pino LED inicializado* /
Bluetoothserial Serialbt;
byte bt_inp;
#se !definido (config_bt_enabled) || !definido (config_bluedroid_enabled)/*verifique se há bluetooth em sdk*/
#error bluetooth fora-run 'Make Menuconfig' para ativá-lo
#fim se
configuração void ()

pinmode (led_pin, saída); /*PIN LED SET como saída*/
Serial.começar (115200); /*Taxa de transmissão para comunicação serial*/
Serialbt.começar(); /*A comunicação Bluetooth começa*/
Serial.println ("Bluetooth está pronto para emparelhar ..."); /*Quando o Bluetooth liga*/

Void Loop ()

if (serialbt.disponível ()) /*Verifique a disponibilidade de dados Bluetooth* /

Bt_inp = serialbt.ler(); /*Leia dados Bluetooth do dispositivo*/
Serial.escreva (bt_inp); /*Imprima os dados de leitura*/

if (bt_inp == '1') /*se condição para o estado do LED* /

DigitalWrite (led_pin, alto); /*Ligue o LED se 1 entrada for recebida*/

if (bt_inp == '0')

DigitalWrite (LED_PIN, baixo);/*Desligue o LED se a entrada 0 for recebida*/

Aqui no código acima, começamos incluindo a biblioteca serial Bluetooth para ESP32. Em seguida, incluímos funções da biblioteca serial bluetooth que permitirão o Esp32 Bluetooth.

O próximo pino LED 15 é inicializado e usando o pinmode () O pino de LED da função é definido como saída.

Na parte do loop do código, o programa verificará a disponibilidade de dados Bluetooth em série. Se os dados de entrada forem 1 LED será ativado e se os dados recebidos forem 0 LED desativará.

Depois que o código é carregado. O Bluetooth da placa ESP32 ligará e a mensagem a seguir aparecerá no monitor serial:

Instalando o terminal Bluetooth serial no smartphone

Precisamos de um dispositivo Bluetooth que possa enviar instruções para o ESP32, para que usaremos um smartphone Android para interface com o ESP32 Bluetooth. Primeiro, precisamos instalar um terminal serial em um telefone Android. Siga as etapas fornecidas abaixo para interface o telefone Android com o ESP32:

Passo 1: Abra o Google Play Store em seu smartphone e pesquise Terminal Bluetooth em série. Instale o aplicativo mostrado abaixo:

Passo 2: Após a instalação, abra configurações de bluetooth do telefone celular. Pesquise por esp32 bluetooth e clique para começar a emparelhá -lo com seu smartphone clicando em Par:

Etapa 3: Depois de tocar em um Par, O telefone celular começará a combinar com o ESP32 Bluetooth:

Passo 4: Agora abra o aplicativo de terminal Bluetooth em série e vá para Dispositivos Do menu lateral:

Etapa 5: Depois que a opção do dispositivo for aberta, ele solicitará algumas permissões ou pressionará o Atualizar Botão no canto superior direito:

Etapa 6: A seguir, o pop-up virá clicar em Configurações e permitir a permissão que pede:

Etapa 7: Agora a placa ESP32 está pronta para receber instruções sobre o Bluetooth. Sob Bluetooth Classic Opção Selecione a placa ESP32:

Etapa 8: Depois que o ESP32 for selecionado, ele começará a se conectar e se for bem -sucedido, um Conectado Mensagem aparecerá:

Etapa 9: Agora podemos enviar qualquer instrução digitando aqui. Tipo 1 e clique no botão Enviar, LED na placa ESP32 ativará. Da mesma forma, digitando 0 LED vai desligar:

Da mesma forma, podemos ver a saída no monitor serial do Arduino IDE o que ele está recebendo:

Saída

LED liga depois de enviar 1:

LED desliga depois de enviar 0:

Observação: Também podemos configurar botões para instruções específicas, como mostrado na imagem abaixo. Para fazer isso, clique nos botões e defina o valor que você deseja. Aqui definimos dois botões um para o alto e outro para o estado baixo. Você também pode configurar esses atalhos em valores hexadecimais.

2: Esp32 Bluetooth Low Energy (BLE) com Arduino IDE

BLE ou Bluetooth Low Energy é um modo de economia de energia do Bluetooth. Seu aplicativo principal inclui transferência de dados em distâncias curtas, como entrada de porta, relógios inteligentes, wearables, monitor de pressão arterial, segurança e automações domésticas. Ble pode transferir dados limitados.

Ao contrário do clássico Bluetooth, que permanece ativado o tempo todo, o ble permanece no modo de suspensão, exceto quando é chamado, ou a conexão é iniciada. Isso torna o ble muito eficiente em termos de energia e consome 100 vezes menos energia do que o clássico.

Servidor e cliente BLE

Bluetooth Low Energy suporta o dispositivo de duas maneiras diferentes, devido às quais o ESP32 pode atuar como servidor e cliente para Bluetooth de baixa energia.

Suporte a seguir os seguintes modos de comunicação:

• Ponto a ponto: Comunicação entre dois pontos ou nós que são servidores e clientes.
• Modo de transmissão: O servidor transmite dados para muitos dispositivos.
• Malha de rede: Vários dispositivos conectados juntos também são conhecidos como muitos em muitas conexões.

Ao atuar como servidor, a ESP32 anuncia sua existência para dispositivos clientes próximos. Uma vez que os dispositivos clientes digitalizem os dispositivos Bluetooth disponíveis, o servidor estabelece a conexão entre eles e transfere os dados do servidor para o dispositivo cliente. Esta comunicação é chamada de ponto a ponto.

Neste tutorial, daremos um exemplo de comunicação ponto a ponto entre duas placas ESP32.

Termos importantes em ble

Aqui estão alguns termos importantes que devemos saber ao trabalhar com aplicativos ESP32 BLE:

Gatt: Atributos Gatt ou genéricos que definem uma estrutura hierárquica para transferências de dados entre dispositivos BLE usando serviço e característica. Ele define como dois dispositivos comunicam dados entre eles.

Serviço ble: Nível superior dentro da hierarquia gatt é um perfil que contém um ou mais serviços. Ble tem mais de um serviço. Cada um desses serviços tem suas próprias características que também podem atuar como referência para outros serviços.

Característica ble A característica é um grupo de informações sempre pertencentes ao serviço; É onde os dados reais são armazenados na hierarquia (valor). Ele sempre contém dois atributos:

• Declaração: Propriedades características, como localização, tipo, leitura, gravar e notificar.
• Valor característico: Valor de dados de característica.

Uuid: Uuid (identificador universalmente único) é dado a cada serviço e característica. É um ID único de 128 bits que pode ser gerado usando qualquer gerador UUID online. Verifique este gerador uuid grátis. Uma amostra uuid se parece com o seguinte:

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

Um grupo de interesse especial do Bluetooth Universal (SIG) predefiniu alguns dos UUIDs reduzidos para diferentes tipos de serviços e perfil, para lê -los, clique aqui.

Configurar o BLE no ESP32 com Arduino IDE

Para entender o funcionamento do BL, usaremos duas placas ESP32 diferentes, uma delas agirá como servidor e anuncie um sinal Bluetooth enquanto o outro ESP32, que está agindo como um cliente Vou tentar conectar o servidor Bluetooth.

Arduino IDE tem exemplos separados para o scanner e o servidor.

Para ver como instalar uma placa ESP32 com Arduino IDE no Windows, clique aqui.

Esp32 BLE Server

Primeiro, enviaremos o código de exemplo do servidor dentro de nossa primeira placa ESP32, que está atuando como um servidor.

Para abrir o exemplo do servidor, vá para: Arquivo> Exemplos> Esp32 Ble Arduino> ble_server:

O código dado abaixo será aberto no Arduino IDE.

Código do servidor

Carregue o código abaixo na placa ESP32 usando o Arduino IDE, mas não se esqueça de desconectar a segunda placa por um tempo para evitar o upload do mesmo código para uma única placa:

#incluir
#incluir
#incluir
#Define Service_uuid "4FAFC201-1FB5-459E-8FCC-C5C9C331914B"
#Define característica_uuid "BeB5483E-36E1-4688-B7F5-EA07361B26A8"
Void Setup ()
Serial.começar (115200);
Serial.Println ("Iniciando o trabalho ble!");
BLEDEVICE :: INIT ("ESP32");
Blesever *PSERVER = BLEDEVICE :: createServer ();
Bleservice *PSERVICE = PSERVER-> CreateService (Service_uuid);
BleCharacteristic *PCharacteristic = PSERVICE-> CreateCharacteristic (
Característica_uuid,
BleCharacteristic :: Property_read |
BleCharacteristic :: Property_write
);
PCharacteristic-> setValue ("Olá, diga Linuxhint.com ");
pService-> start ();
// bleadvertising *padvertising = pserver-> getAdvertising (); // Isso ainda está funcionando para compatibilidade com versões anteriores
Bleadvertising *padvertising = bledevice :: getAdvertising ();
Padvertising-> addServiceUuid (Service_uuid);
padvertising-> setScanResponse (true);
padvertising-> setMinPreferred (0x06); // Funções que ajudam com o problema do iPhone Connections
padvertising-> setMinPreferred (0x12);
BLEDEVICE :: startAdVertising ();
Serial.println ("característica definida! Servidor ble pronto ");

Void Loop ()
// Coloque seu código principal aqui, para executar repetidamente:
Atraso (2000);

O código começa com a inclusão de arquivos necessários da biblioteca Bluetooth. Então uuid é definido para serviço e característica. Você pode ir com o UUID padrão ou pode gerar usando o gerador UUID gratuito. A próxima comunicação serial é inicializada definindo a taxa de transmissão.

Em seguida, criamos um dispositivo BLE chamado Esp32 e, depois disso, definimos o dispositivo BLE como um servidor usando o CreateServer () função e mais tarde definimos o valor característico. Na etapa final, iniciamos o serviço anunciando -o para que outros dispositivos possam pesquisá -lo.

Esp32 Ble Scanner

Agora vamos fazer upload de um exemplo de varredura ESP32 na segunda placa ESP32. Para fazer isso, vá para: Arquivo> Exemplos> Esp32 Ble Arduino> ble_scan:

O código abaixo será aberto no Arduino IDE Editor.

Código do scanner

O código fornecido será usado na placa SCANNER ESP32. Abra o IDE e envie o código, lembre -se de desconectar outras placas antes de fazer o upload do código do scanner.

#incluir
#incluir
#incluir
#incluir
int escantime = 5; //Em segundos
BLOCAN* PBLESCAN;
classe MyAdvertisedDeviceCallbacks: public bleadvertisedDevicecallbacks
Void onResult (bleadvertisedDevice anunciouDevice)
Serial.printf ("Dispositivo anunciado: %s \ n", anunciado.para sequenciar().c_str ());

;
Void Setup ()
Serial.começar (115200);
Serial.println ("Digitalização ...");
BLEDEVICE :: init ("");
pbleScan = Bledevice :: getScan (); // Crie nova varredura
pbleScan-> setAdvertisedDeviceCallbacks (new MyAdvertisedDeviceCallbacks ());
pbleScan-> setActivescan (true); // A varredura ativa usa mais energia, mas obtenha resultados mais rapidamente
pbleScan-> setInterval (100);
pbleScan-> setWindow (99); // Menos ou igual valor de setInterval

Void Loop ()
// Coloque seu código principal aqui, para executar repetidamente:
BLESCANRESULTS FoundDevices = pbleScan-> Start (Scantime, False);
Serial.print ("dispositivos encontrados:");
Serial.Println (FoundDevices.getCount ());
Serial.println ("Scan Concluído!");
pbleScan-> clearResults (); // Exclua os resultados do buffer de bobes para liberar memória
Atraso (2000);

O código acima procurará o número total de dispositivos disponíveis para BLE e exibirá sua contagem total com endereços. Depois de fazer upload do código na placa de scanner Esp32, pressione o Habilitar Botão, a placa ESP32 pesquisará automaticamente os dispositivos disponíveis:

Saída

Depois que o ESP32 verifica os dispositivos disponíveis, o seguinte resultado aparecerá. Aqui, o ESP32 digitalizou 9 dispositivos entre os quais um é uma placa ESP32 com código ble_server e outro dispositivo é a banda Mi 6. Resto de todos os dispositivos está disponível perto do meu ESP32.

Como consertar a biblioteca de varredura ESP32 BLE não contando dispositivos

O exemplo da biblioteca de varredura ESP32 tem um bug de não contar o número total de dispositivos. Para corrigir esse problema, vá para o local mencionado e substitua o código abaixo:

C: \ Usuários \ Nome de usuário \ AppData \ Local \ Arduino15 \ Pacotes \ Esp32 \ Hardware \ Esp32 \ 1.0.6 \ bibliotecas \ ble \ src \ blascan.cpp

Lembrar de uncida Todas as pastas porque a pasta AppData dentro do diretório C permanece oculta por padrão. Depois de abrir o arquivo de origem ble_scan .cpp Substitua a condição abaixo dada dentro do código:

if (m_padvertisedDeviceCallbacks)
m_padvertisedDeviceCallbacks-> onResult (*anunciadoDevice);

se (!m_wantduplicates && !encontrado)
m_scanResults.m_vectorAdvertisedDevices.inserir (std :: par(AdvertedAddress.tostring (), anunciado));
devedelete = false;

Testando o servidor esp32 ble com smartphone

A maioria dos smartphones modernos trabalha com a tecnologia BLE para se comunicar com diferentes dispositivos, como smartwatch, wearables, sensores e outros dispositivos de automação residencial. Aqui o ESP32 é um ponto de acesso para dispositivos. Então, vamos conectar um telefone Android com uma placa ESP32.

Código do servidor ble para acesso ao smartphone ESP32

Carregue o código dado abaixo na placa ESP32:

#include /*biblioteca Bluetooth incluída* /
#incluir
#incluir
#Define Service_uuid "A484A399-7272-4282-91CF-9018E075FC35"
#Define característica_uuid "C7E084BD-5279-484D-8319-FFF7D917537D"
Classe MyCallbacks: Public BlecharacteristicCallbacks

Onwrite vazio (BleCharacteristic *PCharacteristic)

std :: string value = pCharacteristic-> getValue ();
if (valor.comprimento ()> 0)

Serial.print ("Valor característico atualizado:");
for (int i = 0; i createService (Service_uuid);
BleCharacteristic *PCharacteristic = PSERVICE-> CreateCharacteristic (
Característica_uuid,
BleCharacteristic :: Property_read |
BleCharacteristic :: Property_write
);
PCharacteristic-> setCallbacks (new MyCallbacks ());
PCharacteristic-> setValue ("Linuxhint.Com ");
pService-> start ();
Bleadvertising *padvertising = pserver-> getAdvertising ();
padvertising-> start ();

Void Loop ()

Atraso (2000);

Instalando o aplicativo BLE no smartphone Android

As etapas a seguir o guiarão a instalar aplicativos BLE em smartphones e ajudarão a interface os dispositivos móveis com as placas ESP32.

Passo 1: Open Google Play Store Install Scanner ble aplicativo:

Passo 2: Após a instalação, abra o aplicativo e permita toda a permissão necessária e lembre -se de ativar o Mobile Bluetooth:

Etapa 3: Agora digitalize os dispositivos Bluetooth disponíveis. Conecte a placa ESP32:

Passo 4: Depois que a placa ESP32 estiver conectada ao smartphone após a especificação da placa ESP32 aparecerá. Aqui podemos ver os endereços UUID e podemos ler e escrever novos valores característicos:

Etapa 5: Para ler o valor da característica salva clique R. O resultado será exibido conforme mencionado na imagem abaixo:

Etapa 6: Para escrever qualquer novo valor de característica, clique C:

Etapa 7: Um novo pop-up aparecerá aqui, onde podemos escrever qualquer valor característico e clicar OK:

Etapa 8: Novo valor escrito aparecerá como mostrado na imagem:

Etapa 9: Além disso, podemos ver o mesmo novo valor característico impresso no monitor serial do Arduino IDE:

Nós conectamos com sucesso um dispositivo com esp32 ble.

Conclusão

O ESP32 vem com Bluetooth duplo que são Bluetooth Classic e Bluetooth Low Energy. Aqui neste artigo, discutimos o Bluetooth Classic e o BLE e suas várias aplicações e o trabalho. O Bluetooth Classic é usado para transferência de dados alta enquanto BLE (Bluetooth Low Energy) é usado para distâncias curtas com menos requisitos de energia. Este artigo fornece um guia definitivo para o Bluetooth da placa ESP32 funcionando e como configurá -los.