Koyarwar ESP32 37/55 - Yin Amfani da App na Bluetooth tare da ESP32 BLE | Kayan Koyon IoT na SunFounder's ESP32

Koyarwar ESP32 37/55 - Yin Amfani da App na Bluetooth tare da ESP32 BLE | Kayan Koyon IoT na SunFounder's ESP32

A cikin wannan koyawa, za mu bincika yadda ake amfani da ESP32 a matsayin uwar garken Bluetooth don aika da karɓar saƙonni daga manhajar wayar hannu. Wannan yana ba da damar sadarwa mai mu'amala tsakanin allo ɗin ESP32 ɗinka da na'urar wayar hannu, yana mai da shi ƙari mai amfani ga ayyukan IoT ɗinka. A ƙarshen wannan darasi, za ka iya aika rubutu daga na'urar wayar hannu zuwa ESP32 kuma ka gan shi an nuna shi a kan serial monitor.

Za mu yi amfani da manhajar LightBlue Explorer, wadda ke samuwa akan iOS da Android, don sadarwa da ESP32. Wannan koyawa tushe ce don fahimtar sadarwar Bluetooth Low Energy (BLE) kuma tana shirya mataki don ayyuka masu ci gaba. Don jagorar gani, da fatan za a koma ga bidiyon a (a cikin bidiyo a 02:00).

Kayan Aiki Da Aka Bayyana

Babban ɓangaren wannan aikin shine microcontroller ɗin ESP32, wanda ya haɗa damar Wi-Fi da Bluetooth. Wannan yana ba da damar ESP32 ya zama uwar garken, yana karɓar da aika bayanai ba tare da waya ba. Aikin Bluetooth ɗin da ke cikin ESP32 yana goyan bayan BLE, yana mai da shi ingantacce don aikace-aikacen ƙarancin wutar lantarki.

Baya ga ESP32, za mu yi amfani da na'urar wayar hannu tare da manhajar LightBlue da aka shigar. Wannan manhajar tana ba da damar masu amfani su haɗa zuwa ESP32 kuma su aika bayanai ta hanyar Bluetooth. Haɗin waɗannan ɓangarorin yana ba da damar sadarwa mara matsala tsakanin ESP32 da na'urorin wayar hannu, yana haɓaka mu'amalar mai amfani.

Cikakkun Bayanai na Datasheet

• Tabbatar da samar da wutar lantarki mai ƙarfi (3.3 V) don hana raguwar wutar.
• Yi amfani da capacitors don decoupling kusa da fil ɗin wutar.
• Kula da zubar da zafi yadda ya kamata idan ana amfani da babban ƙarfin wuta.
• Yi hattara da matakan wutar fil ɗin GPIO; suna iya ɗaukar 3.3 V.
• Yi amfani da resistors na pull-up ko pull-down kamar yadda ake buƙata don saitunan GPIO.
• Kula da haɗin BLE; tabbatar da manhajar an haɗa ta da kyau.
• Tabbatar da UUIDs don ayyuka da halaye sun bambanta.
• A kai a kai duba serial monitor don saƙonnin gyara kuskure.
• Yi la'akari da amfani da logic analyzer don warware matsalolin sigina masu rikitarwa.

Umarnin Haɗin Waya

Haɗin waya don wannan aikin yana da sauƙi tunda ESP32 yana haɗawa da farko ta USB don wutar lantarki da shirye-shirye. Haɗa ESP32 zuwa kwamfutarka ta amfani da kebul na micro USB. Tabbatar cewa tashar USB tana ba da isasshen wutar lantarki (yawanci 5 V). Za a yi amfani da serial monitor don gyara kuskure, don haka babu buƙatar ƙarin haɗin kayan aiki don wannan aikace-aikacen.

Lokacin amfani da ESP32 tare da abubuwan waje a ayyukan gaba, ka tuna don haɗa fil ɗin ƙasa zuwa ƙasa ɗaya. Wannan yana tabbatar da cewa ESP32 da duk wani na'urori ko moduloli da aka haɗa suna raba wurin tunani ɗaya. Bugu da ƙari, idan kana amfani da baturi, haɗa ƙarshen tabbatacce zuwa fil ɗin 3.3 V kuma ƙarshen mara kyau zuwa fil ɗin ƙasa akan ESP32.

Misalan Lamba & Bayani

Lambar da aka bayar tana fara uwar garken Bluetooth, tana saita ayyuka da halaye masu dacewa, kuma tana sarrafa saƙonni masu shigowa. Maɓallan ganowa sun haɗa da bleName, wanda ke bayyana sunan na'urar Bluetooth, da receivedText, wanda ke adana saƙon da ke shigowa daga manhajar wayar hannu.

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

Aikin setup() yana fara sadarwar serial da saitin BLE. Wannan yana da mahimmanci don kafa haɗi tare da manhajar LightBlue.

void setup() {
  Serial.begin(115200);  // Fara tashar serial
  setupBLE();            // Fara Bluetooth BLE
}

A cikin aikin loop(), lambar tana duba saƙonni masu shigowa. Idan an karɓi sabon saƙo, ana buga shi a serial monitor, kuma ana aika sanarwa zuwa na'urar BLE da aka haɗa.

if (receivedText.length() > 0 && millis() - lastMessageTime > 1000) {
    Serial.print("An karɓi saƙo: ");
    Serial.println(receivedText);
    pCharacteristic->setValue(receivedText.c_str());
    pCharacteristic->notify();
    receivedText = "";
}

Don cikakkiyar fahimta, koma ga cikakkiyar lambar da ke ƙasa a ƙarƙashin labarin. Wannan zai ba ka duk cikakkun bayanai da ake buƙata don aiwatar da aikin cikin nasara.

Nunawa / Abin Da Za Ka Yi Tsammani

Bayan aiwatarwa cikin nasara, ya kamata ka iya aika saƙonni daga manhajar LightBlue zuwa ESP32. Yayin da kake rubuta saƙo, kamar "Sannu," zai bayyana a serial monitor. Bugu da ƙari, za ka iya aika saƙonni baya zuwa manhajar, yana tabbatar da sadarwar hanya biyu. Idan ka gamu da matsaloli kamar saƙonni ba su bayyana ba, tabbatar da cewa ESP32 an haɗa shi da kyau da manhajar kuma UUIDs sun dace.

Lokacin Bidiyo

• 00:00 Farawa
• 2:10 Gabatarwa ga aikin
• 2:45 Shafin takardu
• 4:04 Lambar Arduino
• 6:31 Shigar da Bluetooth App
• 7:12 Zaɓin allon ESP32 da tashar COM
• 8:54 Nunin aikin

Hotuna

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
}