ESP32 Tutoriaal 37/55 - Gebruik van Bluetooth-toepassing met ESP32 BLE | SunFounder se ESP32 IoT-leerkit

ESP32 Tutoriaal 37/55 - Gebruik van Bluetooth-toepassing met ESP32 BLE | SunFounder se ESP32 IoT-leerkit

In hierdie tutoriaal gaan ons ondersoek hoe om die ESP32 as 'n Bluetooth-bediener te gebruik om boodskappe van 'n mobiele app te stuur en te ontvang. Dit maak interaktiewe kommunikasie tussen jou ESP32-bord en jou mobiele toestel moontlik, wat dit 'n veelsydige toevoeging tot jou IoT-projekte maak. Teen die einde van hierdie les sal jy teks van jou mobiele toestel na die ESP32 kan stuur en dit op die reeksmonitor vertoon kan sien.

Ons gaan die LightBlue Explorer-app gebruik, beskikbaar op beide iOS en Android, om met die ESP32 te kommunikeer. Hierdie tutoriaal is fundamenteel vir die verstaan van Bluetooth Low Energy (BLE)-kommunikasie en berei die weg voor vir meer gevorderde projekte. Vir 'n visuele gids, verwys asseblief na die video by (in video by 02:00).

Hardeware Verduidelik

Die primêre komponent in hierdie projek is die ESP32-mikrobeheerder, wat beide Wi-Fi- en Bluetooth-vermoëns integreer. Dit stel die ESP32 in staat om as 'n bediener op te tree, wat data draadloos ontvang en stuur. Die ESP32 se ingeboude Bluetooth-funksionaliteit ondersteun BLE, wat dit doeltreffend maak vir lae-kragtoepassings.

Benewens die ESP32, sal ons 'n mobiele toestel met die LightBlue-app geïnstalleer gebruik. Hierdie app stel gebruikers in staat om aan die ESP32 te koppel en data deur Bluetooth te stuur. Die integrasie van hierdie komponente maak naatlose kommunikasie tussen die ESP32 en mobiele toestelle moontlik, wat gebruikersinteraksie verbeter.

Datablad Besonderhede

• Verseker 'n stabiele kragtoevoer (3.3 V) om bruinonderbrekings te voorkom.
• Gebruik kapasitors vir ontkoppeling naby die kragpenne.
• Handhaaf behoorlike hitte-afvoer as jy hoë stroom gebruik.
• Wees versigtig met GPIO-pen spanningsvlakke; hulle is 3.3 V-verdraagsaam.
• Gebruik optrek- of aftrekweerstande soos nodig vir GPIO-konfigurasies.
• Monitor BLE-verbindings; verseker dat die app behoorlik gekoppel is.
• Verifieer dat UUID's vir dienste en kenmerke uniek is.
• Kontroleer gereeld die reeksmonitor vir ontfoutingsboodskappe.
• Oorweeg die gebruik van 'n logika-analiseerder vir komplekse seinprobleemoplossing.

Bedradingsinstruksies

Bedrading vir hierdie projek is eenvoudig aangesien die ESP32 hoofsaaklik via USB vir krag en programmering koppel. Koppel die ESP32 aan jou rekenaar met 'n mikro-USB-kabel. Verseker dat die USB-poort voldoende krag verskaf (tipies 5 V). Die reeksmonitor sal vir ontfouting gebruik word, dus is geen addisionele hardeware-verbindings vir hierdie toepassing nodig nie.

Wanneer jy die ESP32 met eksterne komponente in toekomstige projekte gebruik, onthou om die grondpenne aan 'n gemeenskaplike grond te koppel. Dit verseker dat die ESP32 en enige gekoppelde sensors of modules dieselfde verwysingspunt deel. Daarbenewens, as jy 'n battery gebruik, koppel die positiewe terminaal aan die 3.3 V-pen en die negatiewe terminaal aan 'n grondpen op die ESP32.

Kode Voorbeelde & Deurloop

Die verskafde kode initialiseer die Bluetooth-bediener, stel die nodige dienste en kenmerke op, en hanteer inkomende boodskappe. Sleutel-identifiseerders sluit in bleName, wat die naam van die Bluetooth-toestel definieer, en receivedText, wat die inkomende boodskap van die mobiele app stoor.

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

Die setup()-funksie initialiseer die reekskommunikasie en die BLE-opstelling. Dit is noodsaaklik vir die vestiging van 'n verbinding met die LightBlue-app.

void setup() {
  Serial.begin(115200);  // Initialiseer die reekspoort
  setupBLE();            // Initialiseer die Bluetooth BLE
}

Binne die loop()-funksie kontroleer die kode vir inkomende boodskappe. As 'n nuwe boodskap ontvang word, word dit op die reeksmonitor gedruk, en 'n kennisgewing word na die gekoppelde BLE-toestel gestuur.

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

Vir 'n volledige begrip, verwys na die volledige kode wat onder die artikel laai. Dit sal jou al die nodige besonderhede verskaf om die projek suksesvol te implementeer.

Demonstrasie / Wat om te VerwAg

By suksesvolle implementering behoort jy boodskappe van die LightBlue-app na die ESP32 te kan stuur. Soos jy 'n boodskap tik, soos "Hallo," sal dit op die reeksmonitor verskyn. Daarbenewens kan jy boodskappe terug na die app stuur, wat die tweerigting-kommunikasie bevestig. As jy probleme soos boodskappe wat nie verskyn nie, teëkom, verseker dat die ESP32 behoorlik met die app gekoppel is en dat die UUID's ooreenstem.

Video Tydstempels

• 00:00 Begin
• 2:10 Inleiding tot die projek
• 2:45 Dokumentasiebladsy
• 4:04 Arduino-kode
• 6:31 Installeer Bluetooth-toep
• 7:12 Kies ESP32-bord en COM-poort
• 8:54 Demonstrasie van die projek

Beelde

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
}