Assista no YouTube

Tutorial ESP32 37/55 - Usando o App Bluetooth com ESP32 BLE | Kit de Aprendizado de IoT da SunFounder

Neste tutorial, exploraremos como usar o ESP32 como um servidor Bluetooth para enviar e receber mensagens de um aplicativo móvel. Isso permite uma comunicação interativa entre sua placa ESP32 e seu dispositivo móvel, tornando-o uma adição versátil aos seus projetos de IoT. Ao final desta lição, você será capaz de enviar texto do seu dispositivo móvel para o ESP32 e vê-lo exibido no monitor serial.

Utilizaremos o aplicativo LightBlue Explorer, disponível tanto para iOS quanto para Android, para nos comunicarmos com o ESP32. Este tutorial é fundamental para entender a comunicação Bluetooth Low Energy (BLE) e prepara o terreno para projetos mais avançados. Para um guia visual, consulte o vídeo em (no vídeo às 02:00).

Hardware Explicado

O componente principal deste projeto é o microcontrolador ESP32, que integra tanto as capacidades de Wi-Fi quanto de Bluetooth. Isso permite que o ESP32 atue como um servidor, recebendo e enviando dados sem fio. A funcionalidade Bluetooth embutida do ESP32 suporta BLE, tornando-o eficiente para aplicações de baixo consumo de energia.

Além do ESP32, usaremos um dispositivo móvel com o aplicativo LightBlue instalado. Esse aplicativo permite que os usuários se conectem ao ESP32 e enviem dados via Bluetooth. A integração desses componentes permite uma comunicação sem interrupções entre o ESP32 e os dispositivos móveis, aprimorando a interação do usuário.

Detalhes da Ficha Técnica

• Garanta um fornecimento de energia estável (3,3 V) para evitar quedas de tensão.
• Use capacitores para desacoplamento perto dos pinos de alimentação.
• Mantenha a dissipação de calor adequada se estiver usando alta corrente.
• Tenha cuidado com os níveis de voltagem dos pinos GPIO; eles são tolerantes a 3,3 V.
• Utilize resistores de pull-up ou pull-down conforme necessário para configurações de GPIO.
• Monitore as conexões BLE; certifique-se de que o aplicativo está devidamente emparelhado.
• Verifique se os UUIDs para serviços e características são exclusivos.
• Verifique regularmente o monitor serial em busca de mensagens de depuração.
• Considere usar um analisador lógico para solucionar problemas de sinais complexos.

Instruções de Fiação

A fiação para este projeto é simples, uma vez que o ESP32 conecta-se principalmente via USB para alimentação e programação. Conecte o ESP32 ao seu computador usando um cabo micro USB. Certifique-se de que a porta USB está fornecendo energia suficiente (tipicamente 5 V). O monitor serial será utilizado para depuração, portanto, nenhuma conexão de hardware adicional é necessária para esta aplicação.

Ao usar o ESP32 com componentes externos em projetos futuros, lembre-se de conectar os pinos de terra a uma terra comum. Isso garante que o ESP32 e quaisquer sensores ou módulos conectados compartilhem o mesmo ponto de referência. Além disso, se você estiver usando uma bateria, conecte o terminal positivo ao pino de 3,3 V e o terminal negativo a um pino de terra no ESP32.

Exemplos de Código e Passo a Passo

O código fornecido inicializa o servidor Bluetooth, configura os serviços e características necessárias e lida com mensagens recebidas. Identificadores-chave incluembleName, que define o nome do dispositivo Bluetooth, ereceivedText, que armazena a mensagem recebida do aplicativo móvel.

const char *bleName = "ESP32_Bluetooth";
String receivedText = "";

Osetup()A função inicializa a comunicação serial e a configuração do BLE. Isso é crucial para estabelecer uma conexão com o aplicativo LightBlue.

void setup() {
  Serial.begin(115200);  // Initialize the serial port
  setupBLE();            // Initialize the Bluetooth BLE
}

Dentro doloop()função, o código verifica mensagens recebidas. Se uma nova mensagem for recebida, ela é exibida no monitor serial e uma notificação é enviada para o dispositivo BLE conectado.

if (receivedText.length() > 0 && millis() - lastMessageTime > 1000) {
    Serial.print("Received message: ");
    Serial.println(receivedText);
    pCharacteristic->setValue(receivedText.c_str());
    pCharacteristic->notify();
    receivedText = "";
}

Para uma compreensão completa, consulte o código completo que carrega abaixo do artigo. Isso fornecerá todos os detalhes necessários para implementar o projeto com sucesso.

Demonstração / O Que Esperar

Após a implementação bem-sucedida, você deverá ser capaz de enviar mensagens do aplicativo LightBlue para o ESP32. À medida que você digita uma mensagem, como "Olá", ela aparecerá no monitor serial. Além disso, você pode enviar mensagens de volta para o aplicativo, confirmando a comunicação bidirecional. Se você encontrar problemas, como mensagens não aparecendo, certifique-se de que o ESP32 está corretamente emparelhado com o aplicativo e que os UUIDs correspondem.

Marcações de Vídeo

• 00:00 Início
• 2:10 Introdução ao projeto
• 2:45 Página de documentação
• 4:04 código Arduino
• 6:31 Instalando o aplicativo Bluetooth
• 7:12 Selecionando placa ESP32 e porta COM
• 8:54 Demonstração do projeto

Imagens

bluetooth_lightblue

bluetooth_lightblue

#include "BLEDevice.h"
#include "BLEServer.h"
#include "BLEUtils.h"
#include "BLE2902.h"

// Define the Bluetooth device name
const char *bleName = "ESP32_Bluetooth";

// Define the received text and the time of the last message
String receivedText = "";
unsigned long lastMessageTime = 0;

// Define the UUIDs of the service and characteristics
#define SERVICE_UUID           "your_service_uuid_here"
#define CHARACTERISTIC_UUID_RX "your_rx_characteristic_uuid_here"
#define CHARACTERISTIC_UUID_TX "your_tx_characteristic_uuid_here"

// Define the Bluetooth characteristic
BLECharacteristic *pCharacteristic;

void setup() {
  Serial.begin(115200);  // Initialize the serial port
  setupBLE();            // Initialize the Bluetooth BLE
}

void loop() {
  // When the received text is not empty and the time since the last message is over 1 second
  // Send a notification and print the received text
  if (receivedText.length() > 0 && millis() - lastMessageTime > 1000) {
    Serial.print("Received message: ");
    Serial.println(receivedText);
    pCharacteristic->setValue(receivedText.c_str());
    pCharacteristic->notify();
    receivedText = "";
  }

  // Read data from the serial port and send it to BLE characteristic
  if (Serial.available() > 0) {
    String str = Serial.readStringUntil('\n');
    const char *newValue = str.c_str();
    pCharacteristic->setValue(newValue);
    pCharacteristic->notify();
  }
}

// Define the BLE server callbacks
class MyServerCallbacks : public BLEServerCallbacks {
  // Print the connection message when a client is connected
  void onConnect(BLEServer *pServer) {
    Serial.println("Connected");
  }
  // Print the disconnection message when a client is disconnected
  void onDisconnect(BLEServer *pServer) {
    Serial.println("Disconnected");
  }
};

// Define the BLE characteristic callbacks
class MyCharacteristicCallbacks : public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *pCharacteristic) {
    // When data is received, get the data and save it to receivedText, and record the time
    std::string value = std::string(pCharacteristic->getValue().c_str());
    receivedText = String(value.c_str());
    lastMessageTime = millis();
    Serial.print("Received: ");
    Serial.println(receivedText);
  }
};

// Initialize the Bluetooth BLE
void setupBLE() {
  BLEDevice::init(bleName);                        // Initialize the BLE device
  BLEServer *pServer = BLEDevice::createServer();  // Create the BLE server
  // Print the error message if the BLE server creation fails
  if (pServer == nullptr) {
    Serial.println("Error creating BLE server");
    return;
  }
  pServer->setCallbacks(new MyServerCallbacks());  // Set the BLE server callbacks

  // Create the BLE service
  BLEService *pService = pServer->createService(SERVICE_UUID);
  // Print the error message if the BLE service creation fails
  if (pService == nullptr) {
    Serial.println("Error creating BLE service");
    return;
  }
  // Create the BLE characteristic for sending notifications
  pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_NOTIFY);
  pCharacteristic->addDescriptor(new BLE2902());  // Add the descriptor
  // Create the BLE characteristic for receiving data
  BLECharacteristic *pCharacteristicRX = pService->createCharacteristic(CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
  pCharacteristicRX->setCallbacks(new MyCharacteristicCallbacks());  // Set the BLE characteristic callbacks
  pService->start();                                                 // Start the BLE service
  pServer->getAdvertising()->start();                                // Start advertising
  Serial.println("Waiting for a client connection...");              // Wait for a client connection
}