Samouczek ESP32 37/55 - Korzystanie z aplikacji Bluetooth z ESP32 BLE | Zestaw do nauki IoT ESP32 od SunFounder

Samouczek ESP32 37/55 - Korzystanie z aplikacji Bluetooth z ESP32 BLE | Zestaw do nauki IoT ESP32 od SunFounder

W tym samouczku odkryjemy, jak używać ESP32 jako serwera Bluetooth do wysyłania i odbierania wiadomości z aplikacji mobilnej. Umożliwia to interaktywną komunikację między płytką ESP32 a urządzeniem mobilnym, co czyni ją wszechstronnym dodatkiem do projektów IoT. Po ukończeniu tej lekcji będziesz w stanie wysyłać tekst z urządzenia mobilnego do ESP32 i zobaczyć go wyświetlonego na monitorze szeregowym.

Wykorzystamy aplikację LightBlue Explorer, dostępną zarówno na iOS, jak i Androida, do komunikacji z ESP32. Ten samouczek stanowi podstawę do zrozumienia komunikacji Bluetooth Low Energy (BLE) i przygotowuje grunt pod bardziej zaawansowane projekty. Aby uzyskać wizualny przewodnik, zapoznaj się z filmem (na filmie o 02:00).

Wyjaśnienie Sprzętu

Głównym elementem tego projektu jest mikrokontroler ESP32, który integruje zarówno Wi-Fi, jak i Bluetooth. Pozwala to ESP32 działać jako serwer, odbierając i wysyłając dane bezprzewodowo. Wbudowana funkcja Bluetooth ESP32 obsługuje BLE, co czyni go wydajnym w zastosowaniach o niskim poborze mocy.

Oprócz ESP32 użyjemy urządzenia mobilnego z zainstalowaną aplikacją LightBlue. Aplikacja ta umożliwia użytkownikom połączenie się z ESP32 i wysyłanie danych przez Bluetooth. Integracja tych komponentów umożliwia płynną komunikację między ESP32 a urządzeniami mobilnymi, zwiększając interakcję z użytkownikiem.

Szczegóły z Karty Katalogowej

• Zapewnij stabilne zasilanie (3,3 V), aby zapobiec spadkom napięcia.
• Użyj kondensatorów do odsprzęgania w pobliżu pinów zasilania.
• Zachowaj odpowiednie odprowadzanie ciepła, jeśli używasz wysokiego prądu.
• Zachowaj ostrożność z poziomami napięcia na pinach GPIO; są one tolerancyjne na 3,3 V.
• Użyj rezystorów podciągających lub ściągających w razie potrzeby dla konfiguracji GPIO.
• Monitoruj połączenia BLE; upewnij się, że aplikacja jest prawidłowo sparowana.
• Zweryfikuj, czy identyfikatory UUID dla usług i charakterystyk są unikalne.
• Regularnie sprawdzaj monitor szeregowy pod kątem komunikatów debugowania.
• Rozważ użycie analizatora logicznego do rozwiązywania złożonych problemów z sygnałami.

Instrukcje Podłączania

Podłączanie w tym projekcie jest proste, ponieważ ESP32 łączy się głównie przez USB do zasilania i programowania. Podłącz ESP32 do komputera za pomocą kabla micro USB. Upewnij się, że port USB zapewnia wystarczające zasilanie (zwykle 5 V). Monitor szeregowy będzie używany do debugowania, więc żadne dodatkowe połączenia sprzętowe nie są potrzebne dla tej aplikacji.

Podczas używania ESP32 z zewnętrznymi komponentami w przyszłych projektach pamiętaj o podłączeniu pinów masy do wspólnej masy. Zapewnia to, że ESP32 i wszelkie podłączone czujniki lub moduły mają ten sam punkt odniesienia. Dodatkowo, jeśli używasz baterii, podłącz dodatni biegun do pinu 3,3 V, a ujemny do pinu masy na ESP32.

Przykłady Kodów i Omówienie

Dostarczony kod inicjalizuje serwer Bluetooth, konfiguruje niezbędne usługi i charakterystyki oraz obsługuje przychodzące wiadomości. Kluczowe identyfikatory obejmują bleName, który definiuje nazwę urządzenia Bluetooth, oraz receivedText, który przechowuje przychodzącą wiadomość z aplikacji mobilnej.

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

Funkcja setup() inicjalizuje komunikację szeregową i konfigurację BLE. Jest to kluczowe dla nawiązania połączenia z aplikacją LightBlue.

void setup() {
  Serial.begin(115200);  // Inicjalizacja portu szeregowego
  setupBLE();            // Inicjalizacja Bluetooth BLE
}

W funkcji loop() kod sprawdza przychodzące wiadomości. Jeśli nowa wiadomość zostanie odebrana, jest drukowana na monitorze szeregowym, a powiadomienie jest wysyłane do podłączonego urządzenia BLE.

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

Aby w pełni zrozumieć, zapoznaj się z pełnym kodem, który znajduje się poniżej artykułu. Zapewni Ci to wszystkie niezbędne szczegóły do pomyślnego wdrożenia projektu.

Demonstracja / Czego Się Spodziewać

Po pomyślnym wdrożeniu powinieneś być w stanie wysyłać wiadomości z aplikacji LightBlue do ESP32. Podczas wpisywania wiadomości, takiej jak „Hello", pojawi się ona na monitorze szeregowym. Dodatkowo możesz wysyłać wiadomości z powrotem do aplikacji, potwierdzając dwukierunkową komunikację. Jeśli napotkasz problemy, takie jak brak pojawiających się wiadomości, upewnij się, że ESP32 jest prawidłowo sparowany z aplikacją i że identyfikatory UUID są zgodne.

Znaczniki czasu wideo

• 00:00 Start
• 2:10 Wprowadzenie do projektu
• 2:45 Strona dokumentacji
• 4:04 Kod Arduino
• 6:31 Instalacja aplikacji Bluetooth
• 7:12 Wybór płytki ESP32 i portu COM
• 8:54 Prezentacja projektu

Obrazy

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
}