Tutorial ESP32 37/55 - Utilizarea aplicației Bluetooth cu ESP32 BLE | Kitul de învățare IoT ESP32 de la SunFounder

Tutorial ESP32 37/55 - Utilizarea aplicației Bluetooth cu ESP32 BLE | Kitul de învățare IoT ESP32 de la SunFounder

În acest tutorial, vom explora cum să folosim ESP32 ca server Bluetooth pentru a trimite și primi mesaje de la o aplicație mobilă. Acest lucru permite comunicarea interactivă între placa ESP32 și dispozitivul tău mobil, fiind o adăugire versatilă pentru proiectele tale IoT. La finalul acestei lecții, vei putea trimite text de pe dispozitivul mobil către ESP32 și să îl vezi afișat pe monitorul serial.

Vom utiliza aplicația LightBlue Explorer, disponibilă atât pe iOS, cât și pe Android, pentru a comunica cu ESP32. Acest tutorial este fundamental pentru înțelegerea comunicării Bluetooth Low Energy (BLE) și pregătește terenul pentru proiecte mai avansate. Pentru un ghid vizual, te rugăm să consulți videoclipul de la (în videoclip la 02:00).

Hardware Explicat

Componenta principală din acest proiect este microcontrolerul ESP32, care integrează atât capabilități Wi-Fi, cât și Bluetooth. Acest lucru permite ESP32 să acționeze ca server, primind și trimițând date fără fir. Funcționalitatea Bluetooth încorporată a ESP32 suportă BLE, făcându-l eficient pentru aplicații cu consum redus de energie.

În plus față de ESP32, vom folosi un dispozitiv mobil cu aplicația LightBlue instalată. Această aplicație permite utilizatorilor să se conecteze la ESP32 și să trimită date prin Bluetooth. Integrarea acestor componente permite comunicarea fără probleme între ESP32 și dispozitivele mobile, îmbunătățind interacțiunea cu utilizatorul.

Detalii din Fișa Tehnică

• Asigură o sursă de alimentare stabilă (3,3 V) pentru a preveni căderile de tensiune.
• Folosește condensatoare pentru decuplare lângă pinii de alimentare.
• Menține o disipare adecvată a căldurii dacă folosești curent ridicat.
• Fii atent la nivelurile de tensiune ale pinilor GPIO; acestea sunt tolerate la 3,3 V.
• Utilizează rezistențe de pull-up sau pull-down după cum este necesar pentru configurațiile GPIO.
• Monitorizează conexiunile BLE; asigură-te că aplicația este asociată corect.
• Verifică ca UUID-urile pentru servicii și caracteristici să fie unice.
• Verifică regulat monitorul serial pentru mesaje de depanare.
• Ia în considerare utilizarea unui analizor logic pentru depanarea semnalelor complexe.

Instrucțiuni de Cablare

Cablarea pentru acest proiect este simplă, deoarece ESP32 se conectează în principal prin USB pentru alimentare și programare. Conectează ESP32 la computer folosind un cablu micro USB. Asigură-te că portul USB furnizează suficientă putere (de obicei 5 V). Monitorul serial va fi folosit pentru depanare, deci nu sunt necesare conexiuni hardware suplimentare pentru această aplicație.

Când folosești ESP32 cu componente externe în proiecte viitoare, reține să conectezi pinii de masă la o masă comună. Acest lucru asigură că ESP32 și orice senzori sau module conectate împărtășesc același punct de referință. În plus, dacă folosești o baterie, conectează terminalul pozitiv la pinul de 3,3 V și terminalul negativ la un pin de masă de pe ESP32.

Exemple de Cod & Explicații

Codul furnizat inițializează serverul Bluetooth, configurează serviciile și caracteristicile necesare și gestionează mesajele primite. Identificatorii cheie includ bleName, care definește numele dispozitivului Bluetooth, și receivedText, care stochează mesajul primit de la aplicația mobilă.

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

Funcția setup() inițializează comunicarea serială și configurarea BLE. Acest lucru este crucial pentru stabilirea unei conexiuni cu aplicația LightBlue.

void setup() {
  Serial.begin(115200);  // Inițializează portul serial
  setupBLE();            // Inițializează Bluetooth BLE
}

În cadrul funcției loop(), codul verifică mesajele primite. Dacă un mesaj nou este primit, acesta este afișat pe monitorul serial și o notificare este trimisă către dispozitivul BLE conectat.

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

Pentru o înțelegere completă, consultă codul integral care se încarcă mai jos în articol. Acesta îți va oferi toate detaliile necesare pentru a implementa proiectul cu succes.

Demonstrație / Ce să Te Aștepți

La implementarea cu succes, ar trebui să poți trimite mesaje din aplicația LightBlue către ESP32. Pe măsură ce tastezi un mesaj, cum ar fi "Salut", acesta va apărea pe monitorul serial. În plus, poți trimite mesaje înapoi către aplicație, confirmând comunicarea bidirecțională. Dacă întâmpini probleme precum mesaje care nu apar, asigură-te că ESP32 este asociat corect cu aplicația și că UUID-urile se potrivesc.

Marcaje temporale video

• 00:00 Început
• 2:10 Introducere în proiect
• 2:45 Pagina de documentație
• 4:04 Codul Arduino
• 6:31 Instalarea aplicației Bluetooth
• 7:12 Selectarea plăcii ESP32 și a portului COM
• 8:54 Demonstrația proiectului

Imagini

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
}