Esp32 bluetooth de baixa energia (ble) - conectando a pulseira de fitness para acionar uma lâmpada

Como é legal acender as luzes automaticamente assim que você entrar em sua casa e desligá-las novamente ao sair! Sim, um aplicativo simples pode fazer isso por você. Aqui neste projeto, usaremos o ESP32 como cliente BLE e a banda de fitness como servidor BLE, portanto, sempre que uma pessoa usando a banda de fitness chegar na faixa do Bluetooth do ESP32, o ESP32 o detectará e ligará a luz. Quaisquer dispositivos Bluetooth que tenham recursos de servidor BLE podem ser usados como um dispositivo de gatilho para controlar qualquer aparelho doméstico usando ESP32.

Já exploramos as funcionalidades BLE (Bluetooth Low Energy) do módulo ESP32 e estou bastante entusiasmado com isso. Para recapitular, este módulo tem Bluetooth clássico e Bluetooth Low Energy (BLE), o Bluetooth clássico pode ser usado para transferir músicas ou arquivos e a opção BLE pode ser usada para aplicativos otimizados para bateria, como beacons Bluetooth, bandas de fitness, s de proximidade, etc. Também é possível usá-lo como um Bluetooth serial, como os módulos HC-05 ou HC-06 para projetos simples de microcontroladores.

Como você sabe, o ESP32 BLE pode operar em dois modos diferentes. Um é o modo de servidor que já discutimos, utilizando o serviço GATT para simular um serviço de indicador de nível de bateria. Nesse exercício, o ESP32 atuou como servidor e nosso celular como cliente. Agora, vamos operar o ESP32 como um cliente e tentar conectá-lo a outros servidores BLE, como minha banda de fitness.

Todos os servidores BLE, incluindo minha faixa de aptidão, estão em modo de propaganda constante, ou seja, podem ser sempre descobertos quando examinados por um cliente. Aproveitando esse recurso, podemos usar essas faixas de aptidão como um interruptor de proximidade, o que significa que essas faixas de aptidão estão sempre amarradas à mão do usuário e, ao procurar a faixa, podemos detectar se a pessoa está dentro do alcance. Isso é exatamente o que faremos neste artigo. Vamos programar o ESP32 para atuar como um cliente BLE e manter constantemente a varredura de dispositivos BLE; se encontrarmos a faixa de aptidão dentro do alcance, tentaremos nos conectar a ela e, se a conexão for bem-sucedida, podemos acionar uma lâmpada alternando um dos pinos GPIO no ESP32. O método é confiável porque cada servidor BLE(faixa de aptidão) terá um ID de hardware exclusivo, de forma que nenhum dispositivo de servidor BLE será idêntico. Interessante né? !!! Agora, vamos construir

Pré-requisitos

Neste artigo, presumo que você já esteja familiarizado sobre como usar a placa ESP32 com o IDE do Arduino, se não voltar para o tutorial de introdução ao ESP32.

Dividimos o ESP32 Bluetooth completo em três segmentos para facilitar o entendimento. Portanto, é recomendável passar pelos dois primeiros tutoriais antes de começar este.

Bluetooth serial no LED de alternância ESP32 do telefone móvel
Servidor BLE para enviar dados de nível de bateria para celular usando o serviço GATT
Cliente BLE para procurar dispositivos BLE e atuar como um farol.

Já cobrimos os dois primeiros tutoriais, aqui estamos procedendo com o último para explicar o ESP32 como cliente BLE.

Materiais requisitados

Placa de Desenvolvimento ESP32
Carga AC (lâmpada)
Módulo de Relé

Hardware

O hardware para este projeto ESP32 BLE Client é bastante simples, uma vez que a maior parte da mágica acontece dentro do código. O ESP32 deve alternar uma lâmpada AC (carga) quando o sinal Bluetooth é descoberto ou perdido. Para alternar essa carga, usaremos um relé e, como os pinos GPIO do ESP32 são compatíveis apenas com 3,3V, precisamos de um módulo de relé que pode ser acionado com 3,3V. Basta verificar qual transistor é usado no módulo de relé se for BC548 você está pronto para ir, senão construa seu próprio circuito seguindo o diagrama de circuito abaixo.

Aviso: O circuito lida com tensão direta de 220 V CA. Tenha cuidado com os fios energizados e certifique-se de não criar um curto-circuito. Você foi avisado.

A razão por trás do uso de BC548 em vez de BC547 ou 2N2222 é que eles têm uma baixa tensão de base-emissor que pode ser acionada com apenas 3,3V. O relé usado aqui é um relé de 5 V, então o alimentamos com o pino Vin que obtém 5 V do cabo de alimentação. O pino de aterramento é conectado ao aterramento do circuito. O resistor R1 1K é usado como um resistor limitador de corrente de base. O fio de fase é conectado ao pino NO do relé e o pino comum do relé é conectado à carga e a outra extremidade da carga é conectada ao neutro. Você pode trocar a posição de Fase e Neutro, mas tome cuidado para não vendê-los diretamente. A corrente deve sempre passar pela Carga (Bulbo).Eu usei um módulo de relé para manter as coisas simples e a carga aqui é uma lâmpada LED Focus. Minha configuração é parecida com esta abaixo

Se você quiser pular o hardware por enquanto, você pode usar o pino GPIO 2 em vez do pino GPIO 13 para alternar o LED on-board no ESP32. Este método é recomendado para iniciantes.

Obtenha o seu endereço Bluetooth do servidor (endereço da banda de fitness)

Conforme dito anteriormente, vamos programar o ESP32 para atuar como um cliente (semelhante ao telefone) e se conectar a um servidor que é minha banda de fitness (Lenovo HW-01). Para um cliente se conectar ao servidor, ele precisa saber o endereço Bluetooth do servidor. Cada servidor Bluetooth, como minha banda de fitness aqui, tem seu próprio endereço Bluetooth exclusivo, que é permanente. Você pode relacionar isso ao endereço MAC do seu laptop ou telefone celular.

Para obter este endereço do servidor, usamos um aplicativo chamado nRF connect de semicondutores nórdicos que já havíamos usado em nosso tutorial anterior. Ele está disponível gratuitamente para usuários IOS e Android. Basta fazer o download, iniciar o aplicativo e procurar os dispositivos Bluetooth próximos. O aplicativo irá listar todos os dispositivos BLE que encontrar. O meu se chama HW-01, basta olhar abaixo do nome e você encontrará o endereço de hardware do servidor conforme mostrado abaixo.

Portanto, o endereço de hardware ESP32 BLE da minha banda de aptidão é C7: F0: 69: F0: 68: 81, você terá um conjunto diferente de números no mesmo formato. Apenas anote isso, pois precisaremos quando programar nosso ESP32.

Obtenção do serviço e UUID de característica do servidor

Ok, agora identificamos nosso servidor usando o endereço BLE, mas para nos comunicarmos com ele precisamos falar a linguagem do Serviço e características, que você entenderia se tivesse lido o tutorial anterior. Neste tutorial, estou usando a característica de gravação do meu servidor (banda de aptidão) para emparelhar com ele. Portanto, para emparelhar com o dispositivo, precisamos do UUID de característica de serviço e que podemos obter novamente com o mesmo aplicativo.

Basta clicar no botão conectar do seu aplicativo e pesquisar algumas características de gravação, onde o aplicativo exibirá o UUID do serviço e o UUID da característica. O meu é mostrado abaixo

Aqui meu UUID de serviço e UUID de característica são os mesmos, mas não precisam ser os mesmos. Anote o UUID do seu servidor. O meu foi anotado como

UUID de serviço: 0000fee7-0000-1000-8000-00805f9b34fb UUID de característica: 0000fee7-0000-1000-8000-00805f9b34fb

Não é obrigatório usar as características de gravação; você pode usar qualquer serviço válido e UUID de característica do servidor que é mostrado no aplicativo.

Programar o ESP32 para atuar como um cliente para o aplicativo de chave de proximidade

A ideia do programa é fazer com que o ESP32 atue como um cliente que fica procurando por dispositivos Bluetooth quando encontra nosso servidor (banda de fitness), ele verifica o ID do hardware e vai acender a luz através do pino 13 do GPIO. Tudo bem! !, mas há um problema com isso. Todos os servidores BLE terão um alcance de 10 metros, o que é um pouco demais. Então se estamos tentando fazer com que o interruptor de proximidade acenda a luz de uma porta aberta, esse alcance é muito alto.

Para reduzir o alcance do servidor BLE, podemos usar a opção de emparelhamento. Um servidor BLE e um cliente permanecerão emparelhados apenas se ambos estiverem a uma distância de 3-4 metros. Isso é perfeito para nosso aplicativo. Portanto, fazemos o ESP32 não apenas para descobrir o servidor BLE, mas também para se conectar a ele e ter certeza de que ele permanece emparelhado. Enquanto estiverem emparelhados, a lâmpada CA permanecerá acesa, quando o intervalo exceder o emparelhamento será perdido e a lâmpada será desligada. O programa completo de exemplo ESP32 BLE para fazer o mesmo é fornecido no final desta página. Abaixo aqui, vou quebrar o código em pequenos trechos e tentar explicá-los.

Depois de incluir o arquivo de cabeçalho, informamos ao ESP32 o endereço BLE, o serviço e o UUID característico que obtivemos por meio do aplicativo nRF connect, conforme explicado nos títulos acima. O código se parece com abaixo

serviço BLEUUID estáticoUUID ("0000fee7-0000-1000-8000-00805f9b34fb"); // Serviço UUID de fitnessband obtido através do aplicativo de conexão nRF static BLEUUID charUUID ("0000fee7-0000-1000-8000-00805f9b34fb"); // UUID característico da faixa de aptidão obtida através do aplicativo nRF connect String My_BLE_Address = "c7: f0: 69: f0: 68: 81"; // Hardware Bluetooth MAC da minha banda de fitness , irá variar para cada banda obtida através do aplicativo de conexão nRF

Seguido por isso no programa, temos o connectToserver e MyAdvertisedDeviceCallback, ao qual voltaremos mais tarde. Então, dentro da função de configuração , inicializamos o monitor serial e fazemos o BLE no ESP para escanear o dispositivo. Após a verificação ser concluída para cada dispositivo BLE descoberto, a função MyAdvertisedDeviceCallbacks é chamada.

Também habilitamos a varredura ativa, uma vez que estamos alimentando o ESP32 com energia da rede elétrica, para aplicação de bateria ele é desligado para reduzir o consumo de corrente. O pino de disparo do relé está conectado ao GPIO 13 em nosso hardware, portanto, também declaramos que o pino 13 do GPIO é a saída.

configuração vazia () { Serial.begin (115200); // Iniciar o monitor serial Serial.println ("Programa ESP32 BLE Server"); // Mensagem de introdução BLEDevice:: init (""); pBLEScan = BLEDevice:: getScan (); // cria uma nova varredura pBLEScan-> setAdvertisedDeviceCallbacks (new MyAdvertisedDeviceCallbacks ()); // Chame a classe definida acima pBLEScan-> setActiveScan (true); // a varredura ativa usa mais energia, mas obtém resultados mais rápido pinMode (13, OUTPUT); // Declara o pino de LED embutido como saída }

Dentro da função MyAdvertisedDeviceCallbacks , imprimimos uma linha que listará o nome e outras informações dos dispositivos BLE que foram descobertos. Precisamos do ID de hardware do dispositivo BLE que foi descoberto para que possamos compará-lo com o desejado. Portanto , usamos a variável Server_BLE_Address para obter o endereço do dispositivo e também para convertê-lo do tipo BLEAddress para string.

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks { void onResult (BLEAdvertisedDevice advertisedDevice) { Serial.printf ("Resultado da varredura:% s \ n", advertisedDevice.toString (). c_str ()); Server_BLE_Address = novo BLEAddress (advertisedDevice.getAddress ()); Scaned_BLE_Address = Server_BLE_Address-> toString (). C_str (); } };

Dentro da função de loop , varremos por 3 segundos e colocamos o resultado dentro de foundDevices, que é um objeto de BLEScanResults. Se encontrarmos um ou mais dispositivos na digitalização, começamos a verificar se o endereço BLE descoberto corresponde ao que inserimos no programa. Se a correspondência for positiva e o dispositivo não estiver emparelhado anteriormente, tentamos emparelhar usando a função connectToserver. Também usamos algumas declarações seriais para fins de compreensão.

while (foundDevices.getCount ()> = 1) { if (Scaned_BLE_Address == My_BLE_Address && emparelhado == false) { Serial.println ("Dispositivo encontrado: -)… conectando ao servidor como cliente"); if (connectToserver (* Server_BLE_Address)) {

Dentro da função connectToserver , usamos o UUID para emparelhar com o servidor BLE (banda de aptidão). Para se conectar a um servidor, o ESP32 deve atuar como um cliente, portanto, criamos um cliente usando a função createClient () e, em seguida, conectamos ao endereço do servidor BLE. Em seguida, procuramos o serviço e a característica usando os valores UUID e tentamos nos conectar a ele. Quando a conexão é bem-sucedida, a função retorna um verdadeiro e, se não, retorna um falso. Observe que não é obrigatório ter um UUID de serviço e característico para emparelhar com um servidor, isso é feito apenas para sua compreensão.

bool connectToserver (BLEAddress pAddress) { BLEClient * pClient = BLEDevice:: createClient (); Serial.println ("- Cliente criado"); // Conecte-se ao servidor BLE. pClient-> conectar (pAddress); Serial.println ("- Conectado a fitnessband"); // Obtenha uma referência para o serviço que procuramos no servidor BLE remoto. BLERemoteService * pRemoteService = pClient-> getService (serviceUUID); if (pRemoteService! = nullptr) { Serial.println ("- Encontrou nosso serviço"); return true; } else return false; // Obtenha uma referência para a característica no serviço do servidor BLE remoto. pRemoteCharacteristic = pRemoteService->getCharacteristic (charUUID); if (pRemoteCharacteristic! = nullptr) Serial.println ("- Encontrou nossa característica"); return true; }

Se a conexão for bem-sucedida, o pino 13 do GPIO torna-se alto e o controle é enviado para fora do loop usando a instrução break. A variável booleana emparelhada também é definida como verdadeira.

if (connectToserver (* Server_BLE_Address)) { emparelhado = verdadeiro; Serial.println ("******************** LED LIGADO ********************** ** "); digitalWrite (13, ALTO); pausa; }

Depois que o emparelhamento for bem-sucedido e o pino GPIO for ativado, temos que verificar se o dispositivo ainda está dentro do alcance. Como agora o dispositivo está emparelhado, o serviço de digitalização BLE não será mais capaz de vê-lo. Só o encontraremos novamente quando o usuário sair da área. Então, simplesmente temos que procurar o servidor BLE e, se descobrirmos, temos que definir o pino GPIO para baixo, conforme mostrado abaixo

if (Scaned_BLE_Address == My_BLE_Address && emparelhado == true) { Serial. println ("Nosso dispositivo saiu do alcance"); emparelhado = falso; Serial. println ("******************** LED OOOFFFFF **************************"); digitalWrite (13, LOW); ESP.restart (); pausa; }

Trabalho e Teste

Quando estiver pronto com o programa e a configuração do hardware, basta fazer upload do código para o ESP32 e organizar toda a configuração conforme mostrado abaixo.

Você deve notar que a lâmpada é ligada assim que a banda de fitness (servidor) emparelha com o ESP32. Você também pode verificar isso observando o símbolo de conexão Bluetooth na pulseira de fitness. Uma vez emparelhado, tente se afastar do ESP32 e quando você cruzar 3-4 metros, você notará que o símbolo Bluetooth no relógio desaparece e a conexão é perdida. Agora, se você olhar para a lâmpada, ela se apagará. Quando você volta para dentro, o dispositivo é emparelhado novamente e a luz acende. O funcionamento completo do projeto pode ser conferido no vídeo abaixo.

Espero que você tenha gostado do projeto e aprendido algo novo no caminho. Se você teve algum problema para fazê-lo funcionar, fique à vontade para postar o problema nos fóruns ou mesmo na seção de comentários abaixo