ESP32 ટ્યુટોરિયલ 37/55 - ESP32 BLE સાથે બ્લૂટૂથ એપનો ઉપયોગ | SunFounderની ESP32 IoT લર્નિંગ કિટ

ESP32 ટ્યુટોરિયલ 37/55 - ESP32 BLE સાથે બ્લૂટૂથ એપનો ઉપયોગ | SunFounderની ESP32 IoT લર્નિંગ કિટ

આ ટ્યુટોરિયલમાં, આપણે ESP32 ને બ્લૂટૂથ સર્વર તરીકે કેવી રીતે ઉપયોગ કરવું તે શોધીશું, જેથી મોબાઇલ એપ્લિકેશનમાંથી સંદેશા મોકલી અને પ્રાપ્ત કરી શકાય. આ તમારા ESP32 બોર્ડ અને તમારા મોબાઇલ ઉપકરણ વચ્ચે સં�વાદાત્મક સંચારને મંજૂરી આપે છે, જે તેને તમારા IoT પ્રોજેક્ટ્સમાં બહુમુખી ઉમેરો બનાવે છે. આ પાઠના અંત સુધીમાં, તમે તમારા મોબાઇલ ઉપકરણમાંથી ESP32 પર ટેક્સ્ટ મોકલી શકશો અને તેને સીરિયલ મોનિટર પર પ્રદર્શિત થતો જોઈ શકશો.

અમે ESP32 સાથે વાતચીત કરવા માટે iOS અને Android બંને પર ઉપલબ્ધ LightBlue Explorer એપ્લિકેશનનો ઉપયોગ કરીશું. આ ટ્યુટોરિયલ બ્લૂટૂથ લો એનર્જી (BLE) સંચારને સમજવા માટે પાયારૂપ છે અને વધુ અદ્યતન પ્રોજેક્ટ્સ માટે સ્ટેજ સેટ કરે છે. વિઝ્યુઅલ માર્ગદર્શન માટે, કૃપા કરીને વિડિઓનો સંદર્ભ લો (વિડિઓમાં 02:00 પર).

હાર્ડવેર સમજાવ્યું

આ પ્રોજેક્ટમાં પ્રાથમિક ઘટક ESP32 માઇક્રોકંટ્રોલર છે, જે Wi-Fi અને બ્લૂટૂથ બંને ક્ષમતાઓને સંકલિત કરે છે. આ ESP32 ને સર્વર તરીકે કાર્ય કરવાની મંજૂરી આપે છે, જે ડેટા વાયરલેસ રીતે પ્રાપ્ત અને મોકલે છે. ESP32 ની બિલ્ટ-ઇન બ્લૂટૂથ કાર્યક્ષમતા BLE ને સપોર્ટ કરે છે, જે તેને ઓછી-શક્તિવાળા એપ્લિકેશનો માટે કાર્યક્ષમ બનાવે છે.

ESP32 ઉપરાંત, અમે LightBlue એપ્લિકેશન ઇન્સ્ટોલ કરેલ મોબાઇલ ઉપકરણનો ઉપયોગ કરીશું. આ એપ્લિકેશન વપરાશકર્તાઓને ESP32 સાથે કનેક્ટ થવા અને બ્લૂટૂથ દ્વારા ડેટા મોકલવાની મંજૂરી આપે છે. આ ઘટકોનું સંકલન ESP32 અને મોબાઇલ ઉપકરણો વચ્ચે સીમલેસ સંચાર સક્ષમ કરે છે, જે વપરાશકર્તા ક્રિયાપ્રતિક્રિયાને વધારે છે.

ડેટાશીટ વિગતો

• બ્રાઉનઆઉટ અટકાવવા માટે સ્થિર પાવર સપ્લાય (3.3 V) સુનિશ્ચિત કરો.
• પાવર પિન નજીક ડિકપ્લિંગ માટે કેપેસિટરનો ઉપયોગ કરો.
• જો ઉચ્ચ કરંટનો ઉપયોગ કરી રહ્યા હોવ તો યોગ્ય ગરમી વિસર્જન જાળવો.
• GPIO પિન વોલ્ટેજ સ્તરોથી સાવચેત રહો; તે 3.3 V સહિષ્ણુ છે.
• GPIO રૂપરેખાંકનો માટે જરૂરિયાત મુજબ પુલ-અપ અથવા પુલ-ડાઉન રેઝિસ્ટરનો ઉપયોગ કરો.
• BLE કનેક્શન્સનું નિરીક્ષણ કરો; ખાતરી કરો કે એપ્લિકેશન યોગ્ય રીતે જોડાયેલી છે.
• સેવાઓ અને લાક્ષણિકતાઓ માટે UUID અનન્ય છે તે ચકાસો.
• ડિબગિંગ સંદેશાઓ માટે સીરિયલ મોનિટર નિયમિતપણે તપાસો.
• જટિલ સિગ્નલ સમસ્યાનિવારણ માટે લોજિક એનાલાઇઝરનો ઉપયોગ કરવાનું વિચારો.

વાયરિંગ સૂચનાઓ

આ પ્રોજેક્ટ માટે વાયરિંગ સરળ છે કારણ કે ESP32 મુખ્યત્વે પાવર અને પ્રોગ્રામિંગ માટે USB દ્વારા કનેક્ટ થાય છે. માઇક્રો USB કેબલનો ઉપયોગ કરીને ESP32 ને તમારા કમ્પ્યુટર સાથે કનેક્ટ કરો. ખાતરી કરો કે USB પોર્ટ પૂરતો પાવર પ્રદાન કરી રહ્યો છે (સામાન્ય રીતે 5 V). સીરિયલ મોનિટર ડિબગિંગ માટે ઉપયોગમાં લેવાશે, તેથી આ એપ્લિકેશન માટે કોઈ વધારાના હાર્ડવેર કનેક્શનની જરૂર નથી.

ભવિષ્યના પ્રોજેક્ટ્સમાં બાહ્ય ઘટકો સાથે ESP32 નો ઉપયોગ કરતી વખતે, ગ્રાઉન્ડ પિનને સામાન્ય ગ્રાઉન્ડ સાથે કનેક્ટ કરવાનું યાદ રાખો. આ સુનિશ્ચિત કરે છે કે ESP32 અને કોઈપણ કનેક્ટેડ સેન્સર અથવા મોડ્યુલ સમાન સંદર્ભ બિંદુ શેર કરે છે. વધુમાં, જો તમે બેટરીનો ઉપયોગ કરી રહ્યા છો, તો હકારાત્મક ટર્મિનલને 3.3 V પિન સાથે અને નકારાત્મક ટર્મિનલને ESP32 પરના ગ્રાઉન્ડ પિન સાથે કનેક્ટ કરો.

કોડ ઉદાહરણો અને વોકથ્રુ

પ્રદાન કરેલ કોડ બ્લૂટૂથ સર્વરને પ્રારંભ કરે છે, જરૂરી સેવાઓ અને લાક્ષણિકતાઓ સેટ કરે છે, અને આવતા સંદેશાઓને હેન્ડલ કરે છે. મુખ્ય ઓળખકર્તાઓમાં bleName શામેલ છે, જે બ્લૂટૂથ ઉપકરણનું નામ વ્યાખ્યાયિત કરે છે, અને receivedText, જે મોબાઇલ એપ્લિકેશનમાંથી આવતા સંદેશાને સંગ્રહિત કરે છે.

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

setup() ફંક્શન સીરિયલ સંચાર અને BLE સેટઅપને પ્રારંભ કરે છે. LightBlue એપ્લિકેશન સાથે કનેક્શન સ્થાપિત કરવા માટે આ નિર્ણાયક છે.

void setup() {
  Serial.begin(115200);  // સીરિયલ પોર્ટ પ્રારંભ કરો
  setupBLE();            // બ્લૂટૂથ BLE પ્રારંભ કરો
}

loop() ફંક્શનની અંદર, કોડ આવતા સંદેશાઓ માટે તપાસે છે. જો નવો સંદેશો પ્રાપ્ત થાય છે, તો તે સીરિયલ મોનિટર પર છાપવામાં આવે છે, અને કનેક્ટેડ BLE ઉપકરણને સૂચના મોકલવામાં આવે છે.

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

સંપૂર્ણ સમજણ માટે, સંપૂર્ણ કોડનો સંદર્ભ લો જે લેખની નીચે લોડ થાય છે. આ તમને પ્રોજેક્ટને સફળતાપૂર્વક અમલમાં મૂકવા માટેના તમામ જરૂરી વિગતો પ્રદાન કરશે.

પ્રદર્શન / શું અપેક્ષા રાખવી

સફળ અમલીકરણ પર, તમે LightBlue એપ્લિકેશનમાંથી ESP32 પર સંદેશા મોકલી શકશો. જેમ તમે સંદેશો ટાઇપ કરો છો, જેમ કે "હેલો," તે સીરિયલ મોનિટર પર દેખાશે. વધુમાં, તમે એપ્લિકેશન પર પાછા સંદેશા મોકલી શકો છો, જે દ્વિ-માર્ગી સંચારની પુષ્ટિ કરે છે. જો તમને સંદેશાઓ દેખાતા નથી જેવી સમસ્યાઓ આવે છે, તો ખાતરી કરો કે ESP32 એપ્લિકેશન સાથે યોગ્ય રીતે જોડાયેલું છે અને UUID મેળ ખાય છે.

વિડિયો ટાઇમસ્ટેમ્પ્સ

• 00:00 શરૂઆત
• 2:10 પ્રોજેક્ટનો પરિચય
• 2:45 દસ્તાવેજીકરણ પૃષ્ઠ
• 4:04 આર્ડુઇનો કોડ
• 6:31 બ્લૂટૂથ એપ ઇન્સ્ટોલ કરવી
• 7:12 ESP32 બોર્ડ અને COM પોર્ટ પસંદ કરવું
• 8:54 પ્રોજેક્ટનું પ્રદર્શન

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
}