Tutorial ESP32 37/55 - Menggunakan Aplikasi Bluetooth dengan ESP32 BLE | Kit Pembelajaran IoT ESP32 SunFounder

Tutorial ESP32 37/55 - Menggunakan Aplikasi Bluetooth dengan ESP32 BLE | Kit Pembelajaran IoT ESP32 SunFounder

Dalam tutorial ini, kita akan menjelajahi cara menggunakan ESP32 sebagai server Bluetooth untuk mengirim dan menerima pesan dari aplikasi seluler. Ini memungkinkan komunikasi interaktif antara papan ESP32 Anda dan perangkat seluler Anda, menjadikannya tambahan yang serbaguna untuk proyek IoT Anda. Di akhir pelajaran ini, Anda akan dapat mengirim teks dari perangkat seluler Anda ke ESP32 dan melihatnya ditampilkan di monitor serial.

Kita akan memanfaatkan aplikasi LightBlue Explorer, yang tersedia di iOS dan Android, untuk berkomunikasi dengan ESP32. Tutorial ini merupakan dasar untuk memahami komunikasi Bluetooth Low Energy (BLE) dan menjadi landasan untuk proyek yang lebih lanjut. Untuk panduan visual, silakan merujuk pada video di (dalam video pada 02:00).

Penjelasan Perangkat Keras

Komponen utama dalam proyek ini adalah mikrokontroler ESP32, yang mengintegrasikan kemampuan Wi-Fi dan Bluetooth. Ini memungkinkan ESP32 bertindak sebagai server, menerima dan mengirim data secara nirkabel. Fungsi Bluetooth bawaan ESP32 mendukung BLE, menjadikannya efisien untuk aplikasi berdaya rendah.

Selain ESP32, kita akan menggunakan perangkat seluler dengan aplikasi LightBlue yang terinstal. Aplikasi ini memungkinkan pengguna untuk terhubung ke ESP32 dan mengirim data melalui Bluetooth. Integrasi komponen-komponen ini memungkinkan komunikasi yang lancar antara ESP32 dan perangkat seluler, meningkatkan interaksi pengguna.

Detail Datasheet

• Pastikan suplai daya stabil (3,3 V) untuk mencegah penurunan tegangan.
• Gunakan kapasitor untuk decoupling di dekat pin daya.
• Pertahankan pembuangan panas yang tepat jika menggunakan arus tinggi.
• Berhati-hatilah dengan tingkat tegangan pin GPIO; mereka toleran 3,3 V.
• Gunakan resistor pull-up atau pull-down sesuai kebutuhan untuk konfigurasi GPIO.
• Pantau koneksi BLE; pastikan aplikasi terpasangkan dengan benar.
• Verifikasi bahwa UUID untuk layanan dan karakteristik unik.
• Periksa monitor serial secara teratur untuk pesan debugging.
• Pertimbangkan menggunakan penganalisis logika untuk pemecahan masalah sinyal yang kompleks.

Instruksi Pengkabelan

Pengkabelan untuk proyek ini sederhana karena ESP32 terutama terhubung melalui USB untuk daya dan pemrograman. Hubungkan ESP32 ke komputer Anda menggunakan kabel micro USB. Pastikan port USB menyediakan daya yang cukup (biasanya 5 V). Monitor serial akan digunakan untuk debugging, jadi tidak diperlukan koneksi perangkat keras tambahan untuk aplikasi ini.

Saat menggunakan ESP32 dengan komponen eksternal di proyek mendatang, ingatlah untuk menghubungkan pin ground ke ground bersama. Ini memastikan bahwa ESP32 dan sensor atau modul yang terhubung berbagi titik referensi yang sama. Selain itu, jika Anda menggunakan baterai, hubungkan terminal positif ke pin 3,3 V dan terminal negatif ke pin ground di ESP32.

Contoh Kode & Panduan

Kode yang disediakan menginisialisasi server Bluetooth, menyiapkan layanan dan karakteristik yang diperlukan, dan menangani pesan masuk. Pengidentifikasi kunci termasuk bleName, yang mendefinisikan nama perangkat Bluetooth, dan receivedText, yang menyimpan pesan masuk dari aplikasi seluler.

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

Fungsi setup() menginisialisasi komunikasi serial dan pengaturan BLE. Ini sangat penting untuk membangun koneksi dengan aplikasi LightBlue.

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

Di dalam fungsi loop(), kode memeriksa pesan masuk. Jika pesan baru diterima, pesan tersebut dicetak ke monitor serial, dan notifikasi dikirim ke perangkat BLE yang terhubung.

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

Untuk pemahaman yang lengkap, lihat kode lengkap yang dimuat di bawah artikel. Ini akan memberi Anda semua detail yang diperlukan untuk mengimplementasikan proyek dengan sukses.

Demonstrasi / Apa yang Diharapkan

Setelah implementasi berhasil, Anda akan dapat mengirim pesan dari aplikasi LightBlue ke ESP32. Saat Anda mengetik pesan, seperti "Halo," pesan tersebut akan muncul di monitor serial. Selain itu, Anda dapat mengirim pesan kembali ke aplikasi, mengonfirmasi komunikasi dua arah. Jika Anda mengalami masalah seperti pesan tidak muncul, pastikan ESP32 terpasangkan dengan benar dengan aplikasi dan UUID cocok.

Stempel Waktu Video

• 00:00 Mulai
• 2:10 Pengenalan proyek
• 2:45 Halaman dokumentasi
• 4:04 Kode Arduino
• 6:31 Memasang Aplikasi Bluetooth
• 7:12 Memilih papan ESP32 dan port COM
• 8:54 Demonstrasi proyek

Gambar

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
}