Návod pre ESP32 37/55 - Používanie Bluetooth aplikácie s ESP32 BLE | SunFounder's ESP32 IoT Learning kit

Návod pre ESP32 37/55 - Používanie Bluetooth aplikácie s ESP32 BLE | SunFounder's ESP32 IoT Learning kit

V tomto návode preskúmame, ako použiť ESP32 ako Bluetooth server na odosielanie a prijímanie správ z mobilnej aplikácie. To umožňuje interaktívnu komunikáciu medzi vašou doskou ESP32 a mobilným zariadením, čo z nej robí všestranný doplnok vašich IoT projektov. Na konci tejto lekcie budete schopní odosielať text z mobilného zariadenia do ESP32 a vidieť ho zobrazený na sériovom monitore.

Použijeme aplikáciu LightBlue Explorer, dostupnú pre iOS aj Android, na komunikáciu s ESP32. Tento návod je základom pre pochopenie komunikácie Bluetooth Low Energy (BLE) a pripravuje pôdu pre pokročilejšie projekty. Pre vizuálny sprievodcu si pozrite video na (vo videu o 02:00).

Vysvetlenie hardvéru

Hlavným komponentom v tomto projekte je mikrokontrolér ESP32, ktorý integruje možnosti Wi-Fi aj Bluetooth. To umožňuje ESP32 fungovať ako server, prijímať a odosielať dáta bezdrôtovo. Vstavaná funkcia Bluetooth ESP32 podporuje BLE, čo ho robí efektívnym pre aplikácie s nízkou spotrebou energie.

Okrem ESP32 použijeme mobilné zariadenie s nainštalovanou aplikáciou LightBlue. Táto aplikácia umožňuje používateľom pripojiť sa k ESP32 a odosielať dáta cez Bluetooth. Integrácia týchto komponentov umožňuje bezproblémovú komunikáciu medzi ESP32 a mobilnými zariadeniami, čím zvyšuje interakciu používateľa.

Podrobnosti z datasheetu

• Zabezpečte stabilné napájanie (3,3 V), aby ste predišli poklesom napätia.
• Použite kondenzátory na oddelenie pri napájacích pinoch.
• Zabezpečte správny odvod tepla pri použití vysokého prúdu.
• Buďte opatrní s úrovňami napätia na GPIO pinoch; sú tolerované do 3,3 V.
• Použite pull-up alebo pull-down rezistory podľa potreby pre konfigurácie GPIO.
• Sledujte BLE pripojenia; uistite sa, že aplikácia je správne spárovaná.
• Overte, že UUID pre služby a charakteristiky sú jedinečné.
• Pravidelne kontrolujte sériový monitor kvôli ladiacim správam.
• Zvážte použitie logického analyzátora na riešenie zložitých problémov so signálom.

Pokyny na zapojenie

Zapojenie pre tento projekt je jednoduché, pretože ESP32 sa primárne pripája cez USB na napájanie a programovanie. Pripojte ESP32 k počítaču pomocou mikrokábla USB. Uistite sa, že USB port poskytuje dostatočné napájanie (zvyčajne 5 V). Sériový monitor sa použije na ladenie, takže pre túto aplikáciu nie sú potrebné žiadne ďalšie hardvérové pripojenia.

Pri použití ESP32 s externými komponentmi v budúcich projektoch nezabudnite pripojiť uzemňovacie piny k spoločnej zemi. To zabezpečí, že ESP32 a všetky pripojené senzory alebo moduly zdieľajú rovnaký referenčný bod. Okrem toho, ak používate batériu, pripojte kladný pól k pinu 3,3 V a záporný pól k uzemňovaciemu pinu na ESP32.

Príklady kódu a vysvetlenie

Poskytnutý kód inicializuje Bluetooth server, nastaví potrebné služby a charakteristiky a spracováva prichádzajúce správy. Kľúčové identifikátory zahŕňajú bleName, ktorý definuje názov Bluetooth zariadenia, a receivedText, ktorý ukladá prichádzajúcu správu z mobilnej aplikácie.

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

Funkcia setup() inicializuje sériovú komunikáciu a nastavenie BLE. To je kľúčové pre nadviazanie spojenia s aplikáciou LightBlue.

void setup() {
  Serial.begin(115200);  // Inicializácia sériového portu
  setupBLE();            // Inicializácia Bluetooth BLE
}

V rámci funkcie loop() kód kontroluje prichádzajúce správy. Ak je prijatá nová správa, vytlačí sa na sériový monitor a pripojenému BLE zariadeniu sa odošle upozornenie.

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

Pre úplné pochopenie si pozrite celý kód, ktorý sa načíta nižšie pod článkom. To vám poskytne všetky potrebné podrobnosti na úspešnú implementáciu projektu.

Demonštrácia / Čo očakávať

Po úspešnej implementácii by ste mali byť schopní odosielať správy z aplikácie LightBlue do ESP32. Keď napíšete správu, napríklad „Ahoj", zobrazí sa na sériovom monitore. Okrem toho môžete odosielať správy späť do aplikácie, čím potvrdíte obojsmernú komunikáciu. Ak narazíte na problémy, ako sú správy, ktoré sa nezobrazujú, uistite sa, že ESP32 je správne spárované s aplikáciou a že UUID sa zhodujú.

Časové pečiatky videa

• 00:00 Začiatok
• 2:10 Úvod do projektu
• 2:45 Stránka dokumentácie
• 4:04 Kód Arduina
• 6:31 Inštalácia Bluetooth aplikácie
• 7:12 Výber dosky ESP32 a COM portu
• 8:54 Ukážka projektu

Images

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
}