Auf YouTube ansehen

ESP32 Tutorial 37/55 - Verwendung der Bluetooth-App mit ESP32 BLE | SunFounders ESP32 IoT Lernkit

In diesem Tutorial werden wir untersuchen, wie man den ESP32 als Bluetooth-Server verwendet, um Nachrichten von einer mobilen App zu senden und zu empfangen. Dies ermöglicht eine interaktive Kommunikation zwischen Ihrem ESP32-Board und Ihrem mobilen Gerät und macht es zu einer vielseitigen Ergänzung Ihrer IoT-Projekte. Am Ende dieser Lektion werden Sie in der Lage sein, Text von Ihrem mobilen Gerät an den ESP32 zu senden und ihn im seriellen Monitor angezeigt zu sehen.

Wir werden die LightBlue Explorer-App nutzen, die sowohl für iOS als auch für Android verfügbar ist, um mit dem ESP32 zu kommunizieren. Dieses Tutorial ist grundlegend für das Verständnis der Bluetooth Low Energy (BLE) Kommunikation und bildet die Grundlage für fortgeschrittenere Projekte. Für eine visuelle Anleitung siehe das Video (im Video bei 02:00).

Hardware Erklärt

Die Hauptkomponente dieses Projekts ist der ESP32-Mikrocontroller, der sowohl Wi-Fi- als auch Bluetooth-Funktionen integriert. Dies ermöglicht es dem ESP32, als Server zu agieren und Daten drahtlos zu empfangen und zu senden. Die integrierte Bluetooth-Funktionalität des ESP32 unterstützt BLE, was ihn effizient für Anwendungen mit niedrigem Energieverbrauch macht.

Zusätzlich zum ESP32 werden wir ein mobiles Gerät mit der installierten LightBlue-App verwenden. Diese App ermöglicht es Benutzern, eine Verbindung zum ESP32 herzustellen und Daten über Bluetooth zu senden. Die Integration dieser Komponenten ermöglicht eine nahtlose Kommunikation zwischen dem ESP32 und mobilen Geräten, wodurch die Benutzerinteraktion verbessert wird.

Datenblattdetails

• Sichern Sie eine stabile Stromversorgung (3,3 V), um Stromausfälle zu verhindern.
• Verwenden Sie Kondensatoren zur Entkopplung in der Nähe der Versorgungspins.
• Stellen Sie eine ordnungsgemäße Wärmeableitung sicher, wenn Sie hohe Ströme verwenden.
• Sei vorsichtig mit den Spannungsebenen der GPIO-Pins; sie sind 3,3 V tolerant.
• Verwenden Sie bei Bedarf Pull-up- oder Pull-down-Widerstände für GPIO-Konfigurationen.
• Überwachen Sie BLE-Verbindungen; stellen Sie sicher, dass die App ordnungsgemäß gekoppelt ist.
• Überprüfen Sie, ob die UUIDs für Dienste und Merkmale einzigartig sind.
• Überprüfen Sie regelmäßig den seriellen Monitor auf Debugging-Nachrichten.
• Erwägen Sie die Verwendung eines Logikanalysators zur Fehlersuche bei komplexen Signalen.

Verdrahtungsanweisungen

Die Verkabelung für dieses Projekt ist unkompliziert, da der ESP32 hauptsächlich über USB mit Strom versorgt und programmiert wird. Schließen Sie den ESP32 mit einem Micro-USB-Kabel an Ihren Computer an. Stellen Sie sicher, dass der USB-Anschluss genügend Strom liefert (typischerweise 5 V). Der serielle Monitor wird zur Fehlersuche verwendet, sodass keine zusätzlichen Hardwareverbindungen für diese Anwendung erforderlich sind.

Bei der Verwendung des ESP32 mit externen Komponenten in zukünftigen Projekten, denken Sie daran, die Massepins mit einer gemeinsamen Masse zu verbinden. Dies stellt sicher, dass der ESP32 und alle angeschlossenen Sensoren oder Module denselben Referenzpunkt teilen. Darüber hinaus, wenn Sie eine Batterie verwenden, verbinden Sie den Pluspol mit dem 3,3 V-Pin und den Minuspol mit einem Massepin am ESP32.

Codebeispiele und Schritt-für-Schritt-Anleitungen

Der bereitgestellte Code initialisiert den Bluetooth-Server, richtet die erforderlichen Dienste und Merkmale ein und verarbeitet eingehende Nachrichten. Wichtige Kennungen umfassenbleName, das den Namen des Bluetooth-Geräts definiert, undreceivedText, das die eingehende Nachricht von der mobilen App speichert.

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

Dersetup()Die Funktion initialisiert die serielle Kommunikation und das BLE-Setup. Dies ist entscheidend für die Herstellung einer Verbindung mit der LightBlue-App.

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

Innerhalb derloop()Im Code prüft die Funktion eingehende Nachrichten. Wenn eine neue Nachricht empfangen wird, wird sie im seriellen Monitor ausgegeben und eine Benachrichtigung an das verbundene BLE-Gerät gesendet.

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

Für ein vollständiges Verständnis siehe den vollständigen Code, der unter dem Artikel geladen wird. Dies wird Ihnen alle erforderlichen Details bereitstellen, um das Projekt erfolgreich umzusetzen.

Demonstration / Was zu erwarten ist

Bei erfolgreicher Implementierung sollten Sie in der Lage sein, Nachrichten von der LightBlue-App an den ESP32 zu senden. Während Sie eine Nachricht wie "Hallo" eingeben, wird sie im seriellen Monitor angezeigt. Darüber hinaus können Sie Nachrichten zurück an die App senden, um die bidirektionale Kommunikation zu bestätigen. Wenn Sie Probleme wie nicht angezeigte Nachrichten haben, stellen Sie sicher, dass der ESP32 richtig mit der App gekoppelt ist und dass die UUIDs übereinstimmen.

Video-Zeiten

• 00:00 Start
• 2:10 Einführung in das Projekt
• 2:45 Dokumentationsseite
• 4:04 Arduino-Code
• 6:31 Bluetooth-App installieren
• 7:12 Auswahl des ESP32-Boards und des COM-Ports
• 8:54 Demonstration des Projekts

Bilder

bluetooth_lightblue

bluetooth_lightblue

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

 // Definieren Sie den Bluetooth-Gerätenamen
const char *bleName = "ESP32_Bluetooth";

 // Definieren Sie den empfangenen Text und die Zeit der letzten Nachricht.
String receivedText = "";
unsigned long lastMessageTime = 0;

 // Definieren Sie die UUIDs des Dienstes und der Merkmale.
#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"

 // Definiere die Bluetooth-Eigenschaft
BLECharacteristic *pCharacteristic;

void setup() {
  Serial.begin(115200); // Initialisiere den seriellen Anschluss
  setupBLE(); // Bluetooth BLE initialisieren
}

void loop() {
 // Wenn der empfangene Text nicht leer ist und die Zeit seit der letzten Nachricht über 1 Sekunde liegt
 // Senden Sie eine Benachrichtigung und drucken Sie den empfangenen Text aus.
  if (receivedText.length() > 0 && millis() - lastMessageTime > 1000) {
    Serial.print("Received message: ");
    Serial.println(receivedText);
    pCharacteristic->setValue(receivedText.c_str());
    pCharacteristic->notify();
    receivedText = "";
  }

 // Lesen Sie Daten vom seriellen Port und senden Sie sie an die BLE-Eigenschaft.
  if (Serial.available() > 0) {
    String str = Serial.readStringUntil('\n');
    const char *newValue = str.c_str();
    pCharacteristic->setValue(newValue);
    pCharacteristic->notify();
  }
}

 // Definiere die BLE-Server-Rückruffunktionen.
class MyServerCallbacks : public BLEServerCallbacks {
 // Drucken Sie die Verbindungsnachricht, wenn ein Client verbunden ist.
  void onConnect(BLEServer *pServer) {
    Serial.println("Connected");
  }
 // Drucken Sie die Trennnachricht, wenn ein Client getrennt wird.
  void onDisconnect(BLEServer *pServer) {
    Serial.println("Disconnected");
  }
};

 // Definieren Sie die BLE-Eigenschafts-Callbacks
class MyCharacteristicCallbacks : public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *pCharacteristic) {
 // Wenn Daten empfangen werden, hole die Daten und speichere sie in receivedText und zeichne die Zeit auf.
    std::string value = std::string(pCharacteristic->getValue().c_str());
    receivedText = String(value.c_str());
    lastMessageTime = millis();
    Serial.print("Received: ");
    Serial.println(receivedText);
  }
};

 // Bluetooth BLE initialisieren
void setupBLE() {
  BLEDevice::init(bleName); // Initialisieren Sie das BLE-Gerät
  BLEServer *pServer = BLEDevice::createServer(); // Erstelle den BLE-Server
 // Drucken Sie die Fehlermeldung, wenn die Erstellung des BLE-Servers fehlschlägt.
  if (pServer == nullptr) {
    Serial.println("Error creating BLE server");
    return;
  }
  pServer->setCallbacks(new MyServerCallbacks()); // Setzen Sie die BLE-Server-Callback-Funktionen

 // Erstellen Sie den BLE-Dienst
  BLEService *pService = pServer->createService(SERVICE_UUID);
 // Drucken Sie die Fehlermeldung aus, wenn die Erstellung des BLE-Dienstes fehlschlägt.
  if (pService == nullptr) {
    Serial.println("Error creating BLE service");
    return;
  }
 // Erstellen Sie die BLE-Eigenschaft zum Senden von Benachrichtigungen.
  pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_NOTIFY);
  pCharacteristic->addDescriptor(new BLE2902()); // Fügen Sie den Deskriptor hinzu.
 // Erstellen Sie die BLE-Eigenschaft zum Empfangen von Daten.
  BLECharacteristic *pCharacteristicRX = pService->createCharacteristic(CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
  pCharacteristicRX->setCallbacks(new MyCharacteristicCallbacks()); // Setzen Sie die BLE-Charakteristik-Callbacks
  pService->start(); // Starte den BLE-Dienst
  pServer->getAdvertising()->start(); // Starten Sie die Werbung
  Serial.println("Waiting for a client connection..."); // Warten auf eine Client-Verbindung
}