ESP32 Tutorial 37/55 - Een Bluetooth-app gebruiken met ESP32 BLE | SunFounder's ESP32 IoT-leerkit

ESP32 Tutorial 37/55 - Een Bluetooth-app gebruiken met ESP32 BLE | SunFounder's ESP32 IoT-leerkit

In deze tutorial verkennen we hoe je de ESP32 als Bluetooth-server kunt gebruiken om berichten te verzenden en ontvangen van een mobiele app. Dit maakt interactieve communicatie mogelijk tussen je ESP32-bord en je mobiele apparaat, waardoor het een veelzijdige toevoeging is aan je IoT-projecten. Aan het einde van deze les kun je tekst vanaf je mobiele apparaat naar de ESP32 sturen en deze op de seriële monitor zien verschijnen.

We gebruiken de LightBlue Explorer-app, beschikbaar op zowel iOS als Android, om met de ESP32 te communiceren. Deze tutorial is fundamenteel voor het begrijpen van Bluetooth Low Energy (BLE)-communicatie en legt de basis voor meer geavanceerde projecten. Voor een visuele handleiding verwijzen we naar de video op (in video op 02:00).

Hardware Uitgelegd

Het primaire onderdeel in dit project is de ESP32-microcontroller, die zowel Wi-Fi- als Bluetooth-mogelijkheden integreert. Hierdoor kan de ESP32 als server fungeren en draadloos gegevens ontvangen en verzenden. De ingebouwde Bluetooth-functionaliteit van de ESP32 ondersteunt BLE, waardoor het efficiënt is voor toepassingen met laag vermogen.

Naast de ESP32 gebruiken we een mobiel apparaat met de LightBlue-app geïnstalleerd. Deze app stelt gebruikers in staat om verbinding te maken met de ESP32 en gegevens via Bluetooth te verzenden. De integratie van deze componenten maakt naadloze communicatie tussen de ESP32 en mobiele apparaten mogelijk, wat de gebruikersinteractie verbetert.

Datasheet Details

• Zorg voor een stabiele voedingsspanning (3,3 V) om spanningsdips te voorkomen.
• Gebruik condensatoren voor ontkoppeling nabij de voedingspinnen.
• Zorg voor voldoende warmteafvoer bij gebruik van hoge stroom.
• Wees voorzichtig met spanningsniveaus op GPIO-pinnen; ze zijn 3,3 V-tolerant.
• Gebruik pull-up- of pull-down-weerstanden indien nodig voor GPIO-configuraties.
• Bewaak BLE-verbindingen; zorg ervoor dat de app correct is gekoppeld.
• Controleer dat UUID's voor services en kenmerken uniek zijn.
• Controleer regelmatig de seriële monitor voor foutopsporingsberichten.
• Overweeg een logische analyser te gebruiken voor complexe signaalproblemen.

Bedradingsinstructies

De bedrading voor dit project is eenvoudig omdat de ESP32 voornamelijk via USB wordt aangesloten voor voeding en programmering. Verbind de ESP32 met je computer met behulp van een micro-USB-kabel. Zorg ervoor dat de USB-poort voldoende stroom levert (meestal 5 V). De seriële monitor wordt gebruikt voor foutopsporing, dus er zijn geen extra hardwareverbindingen nodig voor deze toepassing.

Wanneer je de ESP32 in toekomstige projecten met externe componenten gebruikt, onthoud dan om de aardingspinnen op een gemeenschappelijke aarde aan te sluiten. Dit zorgt ervoor dat de ESP32 en eventuele aangesloten sensoren of modules hetzelfde referentiepunt delen. Als je een batterij gebruikt, sluit dan de positieve pool aan op de 3,3 V-pin en de negatieve pool op een aardingspin van de ESP32.

Codevoorbeelden & Uitleg

De meegeleverde code initialiseert de Bluetooth-server, stelt de benodigde services en kenmerken in en verwerkt inkomende berichten. Belangrijke identificatoren zijn bleName, die de naam van het Bluetooth-apparaat definieert, en receivedText, die het inkomende bericht van de mobiele app opslaat.

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

De setup()-functie initialiseert de seriële communicatie en de BLE-instelling. Dit is cruciaal voor het tot stand brengen van een verbinding met de LightBlue-app.

void setup() {
  Serial.begin(115200);  // Initialiseer de seriële poort
  setupBLE();            // Initialiseer de Bluetooth BLE
}

Binnen de loop()-functie controleert de code op inkomende berichten. Als er een nieuw bericht wordt ontvangen, wordt het op de seriële monitor afgedrukt en wordt er een melding naar het verbonden BLE-apparaat gestuurd.

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

Voor een volledig begrip verwijzen we naar de volledige code die onder het artikel wordt geladen. Dit biedt je alle benodigde details om het project succesvol te implementeren.

Demonstratie / Wat te Verwachten

Na een succesvolle implementatie kun je berichten van de LightBlue-app naar de ESP32 sturen. Terwijl je een bericht typt, zoals "Hallo", verschijnt het op de seriële monitor. Daarnaast kun je berichten terug naar de app sturen, wat de tweerichtingscommunicatie bevestigt. Als je problemen tegenkomt, zoals berichten die niet verschijnen, zorg er dan voor dat de ESP32 correct is gekoppeld met de app en dat de UUID's overeenkomen.

Videotijdstempels

• 00:00 Start
• 2:10 Inleiding tot het project
• 2:45 Documentatiepagina
• 4:04 Arduino-code
• 6:31 Bluetooth-app installeren
• 7:12 ESP32-board en COM-poort selecteren
• 8:54 Demonstratie van het project

Afbeeldingen

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
}