Mafunzo ya ESP32 37/55 - Kutumia Programu ya Bluetooth na ESP32 BLE | Kifurushi cha Kujifunza cha IoT cha SunFounder cha ESP32

Mafunzo ya ESP32 37/55 - Kutumia Programu ya Bluetooth na ESP32 BLE | Kifurushi cha Kujifunza cha IoT cha SunFounder cha ESP32

Katika mafunzo haya, tutachunguza jinsi ya kutumia ESP32 kama seva ya Bluetooth kutuma na kupokea ujumbe kutoka kwa programu ya simu. Hii inaruhusu mawasiliano ya mwingiliano kati ya bodi yako ya ESP32 na kifaa chako cha simu, na kuifanya kuwa nyongeza yenye matumizi mengi kwenye miradi yako ya IoT. Kufikia mwisho wa somo hili, utaweza kutuma maandishi kutoka kwa kifaa chako cha simu hadi ESP32 na kuyaona yakionyeshwa kwenye kichunguzi cha mfululizo.

Tutatumia programu ya LightBlue Explorer, inayopatikana kwenye iOS na Android, kuwasiliana na ESP32. Mafunzo haya ni msingi wa kuelewa mawasiliano ya Bluetooth Low Energy (BLE) na kuweka hatua kwa miradi ya juu zaidi. Kwa mwongozo wa kuona, tafadhali rejea video kwenye (video kwenye 02:00).

Vifaa Vimeelezwa

Kipengele kikuu katika mradi huu ni kidhibiti cha ESP32, ambacho kinajumuisha uwezo wa Wi-Fi na Bluetooth. Hii inaruhusu ESP32 kufanya kazi kama seva, kupokea na kutuma data kwa njia isiyo na waya. Utendaji wa Bluetooth uliojengewa ndani wa ESP32 unaunga mkono BLE, na kuifanya kuwa bora kwa matumizi ya nishati ya chini.

Mbali na ESP32, tutatumia kifaa cha simu chenye programu ya LightBlue imewekwa. Programu hii inaruhusu watumiaji kuunganisha kwenye ESP32 na kutuma data kupitia Bluetooth. Ujumuishaji wa vifaa hivi huwezesha mawasiliano ya mfululizo kati ya ESP32 na vifaa vya simu, kuboresha mwingiliano wa mtumiaji.

Maelezo ya Datasheet

• Hakikisha usambazaji wa nishati thabiti (3.3 V) ili kuzuia kushuka kwa voltage.
• Tumia capacitors za kutenganisha karibu na pini za nishati.
• Dumisha uharibifu sahihi wa joto ikiwa unatumia mkondo wa juu.
• Kuwa makini na viwango vya voltage ya pini za GPIO; zinavumilia 3.3 V.
• Tumia resistors za kuvuta-juu au kuvuta-chini inapohitajika kwa usanidi wa GPIO.
• Fuatilia miunganisho ya BLE; hakikisha programu imeunganishwa vizuri.
• Thibitisha UUID za huduma na sifa ni za kipekee.
• Angalia mara kwa mara kichunguzi cha mfululizo kwa ujumbe wa utatuzi.
• Zingatia kutumia kichanganuzi cha mantiki kwa utatuzi wa ishara tata.

Maagizo ya Wiring

Wiring kwa mradi huu ni rahisi kwani ESP32 huunganishwa hasa kupitia USB kwa nishati na programu. Unganisha ESP32 kwenye kompyuta yako kwa kutumia kebo ya micro USB. Hakikisha kwamba bandari ya USB inatoa nishati ya kutosha (kawaida 5 V). Kichunguzi cha mfululizo kitatumika kwa utatuzi, kwa hivyo hakuna miunganisho ya ziada ya vifaa inayohitajika kwa programu hii.

Unapotumia ESP32 na vifaa vya nje katika miradi ya baadaye, kumbuka kuunganisha pini za ardhi kwenye ardhi ya pamoja. Hii inahakikisha kwamba ESP32 na sensorer au moduli zozote zilizounganishwa zinashiriki sehemu sawa ya kumbukumbu. Zaidi ya hayo, ikiwa unatumia betri, unganisha terminal chanya kwenye pini ya 3.3 V na terminal hasi kwenye pini ya ardhi kwenye ESP32.

Mifano ya Msimbo & Mwongozo

Msimbo uliotolewa huanzisha seva ya Bluetooth, huweka huduma na sifa muhimu, na hushughulikia ujumbe unaoingia. Vitambulisho muhimu vinajumuisha bleName, ambacho hufafanua jina la kifaa cha Bluetooth, na receivedText, ambacho huhifadhi ujumbe unaoingia kutoka kwa programu ya simu.

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

Kazi ya setup() huanzisha mawasiliano ya mfululizo na usanidi wa BLE. Hii ni muhimu kwa kuanzisha muunganisho na programu ya LightBlue.

void setup() {
  Serial.begin(115200);  // Anzisha bandari ya mfululizo
  setupBLE();            // Anzisha Bluetooth BLE
}

Ndani ya kazi ya loop(), msimbo huangalia ujumbe unaoingia. Ikiwa ujumbe mpya umepokelewa, unachapishwa kwenye kichunguzi cha mfululizo, na arifa inatumwa kwa kifaa cha BLE kilichounganishwa.

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

Kwa uelewa kamili, rejea msimbo kamili unaopakia chini ya makala. Hii itakupa maelezo yote muhimu ya kutekeleza mradi kwa mafanikio.

Maonyesho / Nini cha Kutarajia

Baada ya utekelezaji wa mafanikio, utaweza kutuma ujumbe kutoka kwa programu ya LightBlue hadi ESP32. Unapoandika ujumbe, kama vile "Hello," utaonekana kwenye kichunguzi cha mfululizo. Zaidi ya hayo, unaweza kutuma ujumbe kurudi kwenye programu, kuthibitisha mawasiliano ya njia mbili. Ikiwa utapata matatizo kama ujumbe usioonekana, hakikisha kwamba ESP32 imeunganishwa vizuri na programu na kwamba UUID zinalingana.

Vidyo Muhuri za Wakati

• 00:00 Anza
• 2:10 Utangulizi wa mradi
• 2:45 Ukurasa wa nyaraka
• 4:04 Msimbo wa Arduino
• 6:31 Kusakinisha Programu ya Bluetooth
• 7:12 Kuchagua bodi ya ESP32 na mlango wa COM
• 8:54 Maonyesho ya mradi

Bilder

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
}