Artikel ini membahas implementasi protokol Bluetooth Low Energy (BLE) menggunakan MicroPython pada mikrokontroler ESP32. Pembahasan mencakup dasar-dasar operasi BLE, termasuk proses pengiklanan (advertising) untuk membuat perangkat dapat ditemukan, serta pengelolaan pertukaran data melalui karakteristik GATT (Generic Attribute Profile). Anda akan mempelajari cara membuat ESP32 berperan sebagai server BLE yang mengirim data (data exposure) dan merespons interaksi dari perangkat klien (write detection).
Mengenal Bluetooth Low Energy (BLE)
Sebelum masuk ke implementasi kode, penting untuk memahami landasan konseptual dan arsitektural dari teknologi Bluetooth, khususnya varian Low Energy (BLE). Bagian ini akan menguraikan prinsip-prinsip fundamental yang membedakan BLE dari Bluetooth Klasik serta komponen utama dalam ekosistem BLE.
Apa Itu Bluetooth?
Bluetooth adalah teknologi nirkabel untuk komunikasi jarak dekat antarperangkat. Varian standar ini dikenal sebagai Bluetooth Klasik (Classic Bluetooth). Dirancang untuk transmisi data berkecepatan tinggi, Bluetooth Klasik umumnya digunakan untuk aplikasi seperti penyambungan headset ke ponsel, koneksi keyboard atau mouse ke komputer, serta transfer file antarperangkat.
Memahami Bluetooth Low Energy (BLE)
Bluetooth Low Energy (BLE), atau disebut juga Bluetooth Smart, merupakan varian Bluetooth yang dioptimalkan untuk efisiensi daya. Fokus utamanya adalah transmisi data dalam jumlah kecil (low bandwidth) pada jarak pendek. Berbeda dengan Bluetooth Klasik yang beroperasi secara konstan, BLE dirancang dengan pola kerja sleep mode yang dominan; perangkat hanya aktif sesaat saat koneksi diperlukan. Arsitektur ini menghasilkan konsumsi daya yang jauh lebih rendah, sekitar 100 kali lebih hemat dibandingkan Bluetooth Klasik (bergantung pada skenario penggunaan).
Perbandingan Bluetooth Klasik vs Bluetooth Low Energy
Secara mendasar, Bluetooth Klasik dan Bluetooth Low Energy (BLE) dikembangkan untuk tujuan dan kasus penggunaan yang berbeda. Berikut adalah perbedaan utama antara keduanya:
1. Bluetooth Klasik cocok untuk aplikasi yang membutuhkan laju transfer data tinggi dan koneksi yang terus-menerus (continuous streaming), seperti audio streaming (headset, speaker) atau transfer file. Namun, konsumsi dayanya yang relatif besar membuatnya kurang optimal untuk perangkat berbaterai berdaya rendah. Dari sisi pengembangan, Bluetooth Klasik seringkali lebih mudah diimplementasikan untuk pemula karena menggunakan model komunikasi serial yang mirip dengan UART (Serial Port Profile).
2. Bluetooth Low Energy (BLE), di sisi lain, dirancang dengan prioritas utama pada efisiensi daya. BLE mengadopsi model komunikasi client-server dengan struktur data yang terdefinisi melalui GATT (Generic Attribute Profile). Laju transfer datanya lebih rendah, tetapi pola kerjanya yang hemat energi, dengan mekanisme sleep yang dominan dan hanya aktif pada connection interval tertentu, menjadikannya ideal untuk aplikasi IoT, wearables, sensor nirkabel, dan otomasi rumah berbasis ESP32 yang mengutamakan umur baterai panjang.
Ringkasnya, pilihan antara Bluetooth Klasik dan BLE bergantung pada kebutuhan aplikasi: kecepatan data vs efisiensi daya, serta model komunikasi serial vs arsitektur client-server berbasis GATT. Untuk analisis lebih mendalam mengenai perbedaan teknis kedua protokol ini, Anda dapat merujuk ke sumber khusus yang membahas perbandingan detail Bluetooth Classic dan BLE.
Konsep Dasar Arsitektur Bluetooth Low Energy
Sebelum melanjutkan ke implementasi, penting untuk memahami beberapa konsep kunci dalam arsitektur BLE.
Peripheral vs Central (Peran dalam Jaringan BLE)
Dalam komunikasi Bluetooth Low Energy (BLE), dua peran utama yang harus dipahami adalah peripheral (perangkat perifer) dan central (perangkat pengendali/pusat). Dinamika komunikasi BLE didasarkan pada hubungan asimetris antara kedua entitas ini.
ESP32 sebagai Peripheral dan Central dalam BLE
ESP32 memiliki kemampuan untuk berperan ganda dalam ekosistem BLE, baik sebagai peripheral maupun central. Saat berfungsi sebagai peripheral, ESP32 akan mengonfigurasi profil GATT dan melakukan advertising untuk mempublikasikan layanan beserta karakteristiknya, sehingga dapat dibaca atau dikendalikan oleh perangkat Central. Sebaliknya, dalam mode central, ESP32 mampu menginisiasi koneksi ke perangkat BLE lain untuk membaca atau berinteraksi dengan profil dan karakteristik yang mereka ekspos.
Pada ilustrasi di atas, ESP32 berperan sebagai BLE Peripheral yang bertindak sebagai penyedia data atau layanan. Smartphone atau komputer Anda berfungsi sebagai BLE Controller (Central) yang mengelola koneksi dan komunikasi dengan ESP32.
Model Server dan Klien BLE
Dalam arsitektur BLE, terdapat dua tipe perangkat berdasarkan fungsionalitas, yaitu server dan klien. ESP32 dapat dikonfigurasi sebagai klien maupun server. Pada gambar di bawah, ESP32 bertindak sebagai server BLE yang mengekspos struktur GATT-nya beserta data yang dimilikinya. Server BLE berperan sebagai provider data atau layanan, sedangkan klien BLE berfungsi sebagai consumer yang mengakses atau memanfaatkan layanan tersebut.
Server BLE mengiklankan (advertise) keberadaannya agar dapat ditemukan oleh perangkat lain, serta menyimpan data yang dapat dibaca atau dikendalikan oleh klien. Sementara itu, Klien BLE melakukan pemindaian (scan) terhadap perangkat di sekitarnya. Ketika server target ditemukan, klien akan membangun koneksi dan berinteraksi dengan perangkat tersebut melalui operasi baca (read) atau tulis (write) pada karakteristiknya.
Pada dasarnya, Server BLE merupakan peran yang diambil oleh Peripheral sebelum koneksi terbentuk, sedangkan Klien BLE adalah peran Central sebelum terhubung. Dalam banyak konteks, istilah-istilah ini sering digunakan secara bergantian.
GATT (Generic Attribute Profile)
GATT (Generic Attribute Profile) merupakan konsep inti dalam teknologi Bluetooth Low Energy (BLE). Secara esensial, GATT berfungsi sebagai kerangka standar yang mengatur bagaimana perangkat BLE saling berkomunikasi. Dapat diandaikan sebagai bahasa terstruktur yang digunakan oleh dua perangkat BLE untuk bertukar informasi secara terorganisir dan interoperabel.
Struktur Data GATT
- Profil (Profile): kumpulan layanan standar yang didefinisikan untuk kasus penggunaan tertentu (misalnya: profil kesehatan, profil pengisian daya);
- Layanan (Service): kumpulan informasi terkait yang mewakili suatu fungsi (seperti pembacaan sensor, tingkat baterai, atau detak jantung);
- Karakteristik (Characteristic): entitas penyimpan data aktual dalam hierarki (berisi value yang dapat diakses);
- Deskriptor (Descriptor): metadata yang menjelaskan sifat atau konfigurasi data;
- Properti (Properties): menentukan cara interaksi yang diperbolehkan terhadap nilai karakteristik, seperti: read, write, notify, broadcast, indicate, dan lainnya.
Layanan BLE (BLE Service)
Dalam hierarki GATT, layanan (service) merupakan komponen utama yang mengelompokkan fungsionalitas tertentu. Setiap layanan berisi satu atau lebih karakteristik (characteristic) yang menampung data aktual.
Untuk memastikan interoperabilitas antar perangkat dari berbagai vendor, Bluetooth Special Interest Group (SIG) telah mendefinisikan standar untuk sejumlah layanan yang telah ditentukan (Predefined Services). Layanan-layanan ini memiliki UUID (Universally Unique Identifier) 16-bit yang telah dialokasikan secara resmi. Beberapa contoh standar meliputi:
- Battery Service: untuk memantau tingkat baterai.
- Heart Rate Service: untuk mengirimkan data detak jantung.
- Environmental Sensing Service: untuk data sensor lingkungan seperti suhu dan kelembaban.
Daftar lengkap semua angka yang ditetapkan, termasuk UUID untuk semua layanan, karakteristik, dan deskriptor standar, dapat ditemukan dalam dokumen resmi Assigned Numbers di situs web Bluetooth SIG: (https://www.bluetooth.com/specifications/assigned-numbers/). Merujuk pada dokumen ini sangat penting saat mengembangkan perangkat yang perlu sesuai dengan profil Bluetooth standar.
UUID (Universally Unique Identifier)
UUID adalah identifikasi digital unik yang digunakan dalam BLE dan GATT untuk membedakan serta merujuk secara spesifik pada layanan (services), karakteristik (characteristics), dan deskriptor (descriptors). Fungsinya mirip seperti label atau alamat unik yang memastikan setiap komponen dalam ekosistem perangkat Bluetooth dapat diidentifikasi secara tepat, mencegah tabrakan atau ambiguitas.
Setiap layanan, karakteristik, dan deskriptor harus memiliki UUID-nya sendiri. Standar UUID dalam BLE adalah format 128-bit (16 byte). Namun, untuk efisiensi dalam komunikasi, jika UUID mengikuti spesifikasi yang telah ditetapkan oleh Bluetooth SIG, ia dapat direpresentasikan dalam bentuk singkat 16-bit (2 byte) atau 32-bit (4 byte).
Contoh:
55072829-bc9e-4c53-938a-74a6d4c78776
- Layanan Baterai Standar (Battery Service)**: UUID 16-bit = `0x180F`
- Karakteristik Tingkat Baterai (Battery Level Characteristic)**: UUID 16-bit = `0x2A19`
UUID 16-bit ini sebenarnya adalah representasi singkat dari UUID 128-bit penuh yang telah dialokasikan secara resmi, dengan pola dasar: `0000xxxx-0000-1000-8000-00805F9B34FB`, di mana `xxxx` digantikan oleh nilai 16-bit (misalnya, `180F` untuk Layanan Baterai).
Bluetooth SIG telah menetapkan serangkaian UUID yang dipersingkat (16-bit atau 32-bit) untuk layanan dan karakteristik standar. Penggunaan UUID standar ini memastikan interoperabilitas universal. Artinya, saat Anda menemukan perangkat BLE yang menggunakan UUID standar (misalnya, Layanan Baterai `0x180F`), Anda sudah mengetahui dengan pasti struktur dan cara berinteraksi dengan data yang disediakannya tanpa perlu dokumentasi tambahan.
Di sisi lain, Anda dapat membuat UUID kustom (128-bit penuh) untuk keperluan khusus, misalnya ketika data yang dipertukarkan tidak sesuai dengan kategori standar atau untuk mengimplementasikan fungsionalitas proprietary. UUID kustom dapat digenerate menggunakan alat seperti UUID Generator Online, yang akan menghasilkan identifier 128-bit yang secara statistik hampir pasti unik di seluruh dunia.
Mekanisme Komunikasi antara Perangkat BLE
Proses komunikasi antara dua perangkat BLE mengikuti sekuens standar untuk membangun koneksi dan bertukar data. Berikut adalah tahapan umum yang menggambarkan alur komunikasi tersebut:
1. ESP32 sebagai BLE Peripheral (server) melakukan advertising untuk memberitahukan keberadaannya.
2. Perangkat BLE Central (client) memindai (scan) perangkat BLE di sekitarnya.
3. Ketika perangkat central menemukan peripheral yang dicari, ia akan melakukan koneksi ke perangkat tersebut.
4. Setelah terhubung, central membaca profil GATT dari peripheral dan mencari layanan yang dibutuhkan (contoh: environmental sensing).
5. Jika layanan ditemukan, central dapat mulai berinteraksi dengan karakteristik yang ada, misalnya membaca nilai suhu (temperature value).
Instalasi Paket aioble
Untuk mengimplementasikan komunikasi Bluetooth Low Energy (BLE) pada ESP32 dengan MicroPython, kita akan menggunakan paket `aioble`, yang saat ini merupakan library rekomendasi untuk komunikasi BLE dengan MicroPython. Sebelum melanjutkan ke contoh program, pastikan Anda telah menginstal paket ini ke dalam papan ESP32.
Langkah Instalasi:
1. Hubungkan papan ESP32 (yang telah memiliki firmware MicroPython, pastikan prasyarat terpenuhi) ke komputer Anda.
2. Buka koneksi ke papan tersebut melalui Thonny IDE.
3. Pada Thonny IDE, navigasikan ke menu Tools > Manage packages…
4. Pada kotak dialog yang muncul, cari `aioble`, lalu klik pada pilihan paket `aioble` yang tersedia untuk memulai proses instalasi.
Proses ini akan mengunduh dan memasang library beserta dependensinya secara langsung ke dalam sistem file internal ESP32 Anda.
Selanjutnya, klik tombol "Install" untuk memulai proses instalasi.
Tunggu beberapa saat hingga proses instalasi selesai. Setelah instalasi berhasil, Anda dapat melanjutkan ke pembahasan contoh kode program.
ESP32 sebagai BLE Peripheral
Pada contoh ini, kita akan mengatur ESP32 sebagai BLE Peripheral. Kita akan menunjukkan cara mengiklankan (advertise) layanan, mengubah nilai karakteristik, dan mendeteksi jika perangkat BLE lain menulis data ke karakteristik ESP32. Berikut penjelasan singkat cara kerja proyek ini:
1. ESP32 akan berperan sebagai BLE Peripheral/BLE Server yang mengiklankan keberadaannya.
2. Struktur GATT ESP32 akan memiliki satu layanan (service) dengan dua karakteristik (characteristics):
- Karakteristik sensor: tempat menyimpan nilai yang berubah seiring waktu, misalnya hasil pembacaan sensor.
- Karakteristik LED: tempat menyimpan status GPIO. Dengan mengubah nilai karakteristik ini, kita dapat mengendalikan LED yang terhubung ke GPIO tersebut.
3. ESP32 akan menulis nilai baru ke karakteristik sensor secara berkala.
4. Kita akan menggunakan aplikasi nRF Connect untuk terhubung ke perangkat BLE ESP32, membaca karakteristik sensor, dan menulis ke karakteristik LED untuk mengontrol LED onboard.
Kode MicroPython untuk ESP32 sebagai BLE Peripheral
Salin kode berikut ke dalam editor Thonny IDE:
from micropython import const
import asyncio
import aioble
import bluetooth
import struct
from machine import Pin
from random import randint
# Init LED
led = Pin(2, Pin.OUT)
led.value(0)
# Init random value
value = 0
# See the following for generating UUIDs:
# https://www.uuidgenerator.net/
_BLE_SERVICE_UUID = bluetooth.UUID('19b10000-e8f2-537e-4f6c-d104768a1214')
_BLE_SENSOR_CHAR_UUID = bluetooth.UUID('19b10001-e8f2-537e-4f6c-d104768a1214')
_BLE_LED_UUID = bluetooth.UUID('19b10002-e8f2-537e-4f6c-d104768a1214')
# How frequently to send advertising beacons.
_ADV_INTERVAL_MS = 250_000
# Register GATT server, the service and characteristics
ble_service = aioble.Service(_BLE_SERVICE_UUID)
sensor_characteristic = aioble.Characteristic(ble_service, _BLE_SENSOR_CHAR_UUID, read=True, notify=True)
led_characteristic = aioble.Characteristic(ble_service, _BLE_LED_UUID, read=True, write=True, notify=True, capture=True)
# Register service(s)
aioble.register_services(ble_service)
# Helper to encode the data characteristic UTF-8
def _encode_data(data):
return str(data).encode('utf-8')
# Helper to decode the LED characteristic encoding (bytes).
def _decode_data(data):
try:
if data is not None:
# Decode the UTF-8 data
number = int.from_bytes(data, 'big')
return number
except Exception as e:
print("Error decoding temperature:", e)
return None
# Get sensor readings
def get_random_value():
return randint(0,100)
# Get new value and update characteristic
async def sensor_task():
while True:
value = get_random_value()
sensor_characteristic.write(_encode_data(value), send_update=True)
print('New random value written: ', value)
await asyncio.sleep_ms(1000)
# Serially wait for connections. Don't advertise while a central is connected.
async def peripheral_task():
while True:
try:
async with await aioble.advertise(
_ADV_INTERVAL_MS,
name="ESP32",
services=[_BLE_SERVICE_UUID],
) as connection:
print("Connection from", connection.device)
await connection.disconnected()
except asyncio.CancelledError:
# Catch the CancelledError
print("Peripheral task cancelled")
except Exception as e:
print("Error in peripheral_task:", e)
finally:
# Ensure the loop continues to the next iteration
await asyncio.sleep_ms(100)
async def wait_for_write():
while True:
try:
connection, data = await led_characteristic.written()
print(data)
print(type)
data = _decode_data(data)
print('Connection: ', connection)
print('Data: ', data)
if data == 1:
print('Turning LED ON')
led.value(1)
elif data == 0:
print('Turning LED OFF')
led.value(0)
else:
print('Unknown command')
except asyncio.CancelledError:
# Catch the CancelledError
print("Peripheral task cancelled")
except Exception as e:
print("Error in peripheral_task:", e)
finally:
# Ensure the loop continues to the next iteration
await asyncio.sleep_ms(100)
# Run tasks
async def main():
t1 = asyncio.create_task(sensor_task())
t2 = asyncio.create_task(peripheral_task())
t3 = asyncio.create_task(wait_for_write())
await asyncio.gather(t1, t2)
asyncio.run(main())
Konsep Kerja Kode
Mari kita analisis bagian-bagian kunci dari kode untuk memahami logika implementasinya.
Include Library
Untuk mengaktifkan fungsi Bluetooth pada ESP32, kita perlu mengimpor library `aioble` dan `bluetooth` bawaan MicroPython. Selain itu, kita mengimpor modul `asyncio` untuk menangani pemrograman asinkronus, serta fungsi `randint` dari modul `random` yang akan digunakan untuk menghasilkan nilai simulasi data sensor.
Penjelasan Teknis:
- `aioble`: Library tingkat tinggi yang menyederhanakan pemrograman BLE dengan model async/await.
- `bluetooth`: Module inti MicroPython yang menyediakan akses low-level ke stack Bluetooth.
- `asyncio`: Memungkinkan penulisan kode non-blocking, sehingga ESP32 dapat menjalankan tugas lain (misalnya, membaca sensor) sambil tetap responsif terhadap permintaan BLE.
from micropython import const
import asyncio
import aioble
import bluetooth
import struct
from machine import Pin
from random import randint
Mendefinisikan UUID dan Mendaftarkan Layanan serta Karakteristik GATT
Langkah pertama adalah mendefinisikan UUID (Universally Unique Identifier) untuk layanan dan karakteristik. UUID berfungsi sebagai pengenal unik untuk setiap komponen dalam struktur GATT.
Dalam contoh ini, kita akan membuat satu layanan kustom yang berisi dua karakteristik, yaitu:
1. Karakteristik LED: Menyimpan nilai status LED (misalnya, `0` untuk mati, `1` untuk menyala).
2. Karakteristik Sensor: Menyimpan nilai simulasi pembacaan sensor (dalam contoh ini, nilai acak yang digenerate).
Setelah UUID didefinisikan, kita akan mendaftarkan (register) layanan beserta karakteristiknya ke dalam stack BLE ESP32 menggunakan library `aioble`. Proses ini membangun "kerangka" GATT yang akan diiklankan (advertised) dan dapat diakses oleh perangkat BLE client.
_BLE_SERVICE_UUID = bluetooth.UUID('19b10000-e8f2-537e-4f6c-d104768a1214')
_BLE_SENSOR_CHAR_UUID = bluetooth.UUID('19b10001-e8f2-537e-4f6c-d104768a1214')
_BLE_LED_UUID = bluetooth.UUID('19b10002-e8f2-537e-4f6c-d104768a1214')
UUID yang digunakan pada contoh ini dihasilkan melalui generator UUID eksternal untuk memastikan keunikannya. Meskipun Anda dapat membuat UUID kustom untuk aplikasi spesifik, kami merekomendasikan penggunaan UUID yang sama seperti pada contoh untuk memastikan konsistensi selama proses pengujian dan pembelajaran.
Setelah UUID didefinisikan, langkah selanjutnya adalah mendaftarkan (register) layanan GATT dan karakteristiknya ke dalam stack BLE ESP32. Proses ini secara teknis melibatkan pembuatan objek layanan menggunakan `aioble.Service()` dan penambahan karakteristik ke dalam layanan tersebut dengan metode `.add_characteristic()`, yang kemudian diikat (bound) ke perangkat Bluetooth.
# Register GATT server, the service and characteristics
ble_service = aioble.Service(_BLE_SERVICE_UUID)
sensor_characteristic = aioble.Characteristic(ble_service, _BLE_SENSOR_CHAR_UUID, read=True, notify=True)
led_characteristic = aioble.Characteristic(ble_service, _BLE_LED_UUID, read=True, write=True, notify=True, capture=True)
# Register service(s)
aioble.register_services(ble_service)
Saat mendefinisikan sensor_characteristic, properti `read=True` dan `notify=True` diaktifkan. Konfigurasi ini menentukan metode interaksi yang diizinkan untuk perangkat central:
- `read=True`: Memungkinkan perangkat central untuk membaca nilai karakteristik secara eksplisit (read request).
- `notify=True`: Mengaktifkan mekanisme notification. ESP32 dapat secara proaktif mengirim pembaruan nilai ke perangkat central yang telah berlangganan (subscribed) setiap kali nilai karakteristik berubah, tanpa perlu menunggu permintaan baca.
Untuk led_characteristic, properti tambahan `capture=True` ditetapkan. Properti ini memberi wewenang kepada perangkat BLE lain (client) untuk menulis (write) nilai baru ke karakteristik tersebut. Melalui operasi tulis inilah perangkat eksternal (seperti smartphone) dapat mengirim perintah untuk mengontrol LED pada ESP32.
led_characteristic = aioble.Characteristic(ble_service, _BLE_LED_UUID, read=True, write=True, notify=True, capture=True)
Enkode dan Dekode Data
Data yang akan ditulis (write) atau dibaca (read) pada karakteristik BLE harus dikirim dalam format biner (tipe data `bytes`). Fungsi `_encode_data()` bertugas untuk mengonversi data (misalnya, string atau integer) ke dalam format UTF-8 sebelum dikirim, sehingga memastikan kompatibilitas dalam pertukaran data antar perangkat.
Sebaliknya, fungsi `_decode_data()` akan mengonversi kembali deretan byte yang diterima menjadi tipe data yang dapat diproses oleh program (seperti string), sesuai dengan format pengkodean yang digunakan (dalam hal ini UTF-8).
# Helper to encode the data characteristic UTF-8
def _encode_data(data):
return str(data).encode('utf-8')
Ketika perangkat eksternal (misalnya, aplikasi nRF Connect) melakukan operasi tulis (write) ke `led_characteristic`, data yang dikirimkan akan berada dalam format biner (bytes). Data ini harus didekode sebelum dapat diproses.
Fungsi `_write_callback()` yang terikat (bound) pada `led_characteristic` secara otomatis akan terpicu saat operasi tulis terjadi. Di dalam callback ini, data biner yang diterima perlu dikonversi menjadi integer untuk merepresentasikan status LED (misalnya, `0` untuk OFF dan `1` untuk ON). Proses ini biasanya dilakukan dengan menggunakan metode `.decode()` untuk data string, atau `int.from_bytes()` untuk data numerik murni, tergantung pada protokol yang disepakati.
# Helper to decode the LED characteristic encoding (bytes).
def _decode_data(data):
try:
if data is not None:
# Decode the UTF-8 data
number = int.from_bytes(data, 'big')
return number
except Exception as e:
print("Error decoding temperature:", e)
return None
Pembaruan Nilai Karakteristik Sensor Secara Periodik
Fungsi `sensor_task()` merupakan fungsi asinkron (async) yang bertanggung jawab untuk memperbarui nilai pada `sensor_characteristic` secara berkala. Logika kerjanya adalah:
1. Mendapatkan Nilai Baru: Fungsi ini memanggil metode (misalnya, membaca sensor atau, dalam contoh ini, menghasilkan nilai acak) untuk memperoleh data terbaru.
2. Menulis ke Karakteristik: Nilai baru tersebut kemudian ditulis (write) ke `sensor_characteristic` menggunakan metode `.write()` yang disediakan oleh objek karakteristik. Operasi ini akan secara otomatis memicu pengiriman notification ke semua perangkat central yang telah berlangganan (subscribed), jika properti `notify=True` diaktifkan.
3. Pengulangan dengan Interval: Tugas ini dijalankan dalam sebuah loop tak terhingga (infinite loop) dengan jeda 1 detik menggunakan `asyncio.sleep()`. Interval ini dapat disesuaikan sesuai kebutuhan aplikasi, seperti kecepatan pembaruan data sensor atau pertimbangan konsumsi daya.
# Get new value and update characteristic
async def sensor_task():
while True:
value = get_random_value()
sensor_characteristic.write(_encode_data(value), send_update=True)
#print('New random value written: ', value)
await asyncio.sleep_ms(1000)
Fungsi `get_random_value()` merupakan placeholder simulasi. Dalam implementasi nyata, fungsi ini harus digantikan dengan fungsi pembacaan sensor fisik, misalnya, membaca suhu dari sensor DS18B20 atau data analog dari pin ADC ESP32.
Proses Advertising
Selain memperbarui karakteristik sensor, ESP32 perlu mengiklankan (advertise) dirinya sebagai layanan BLE yang dapat ditemukan. Untuk itu, kita menggunakan fungsi `peripheral_task()`.
# Serially wait for connections. Don't advertise while a central is connected.
async def peripheral_task():
while True:
try:
async with await aioble.advertise(
_ADV_INTERVAL_MS,
name="ESP32",
services=[_BLE_SERVICE_UUID],
) as connection:
print("Connection from", connection.device)
await connection.disconnected()
except asyncio.CancelledError:
# Catch the CancelledError
print("Peripheral task cancelled")
except Exception as e:
print("Error in peripheral_task:", e)
finally:
# Ensure the loop continues to the next iteration
await asyncio.sleep_ms(100)
Pada fungsi tersebut, kita mendefinisikan nama perangkat BLE sebagai 'ESP32'. Anda dapat mengubah namanya jika diinginkan. Namun, untuk mengikuti contoh kami, kami sarankan untuk tetap menggunakan nama tersebut.
Menunggu Operasi Tulis
Di dalam fungsi `wait_for_write()`, kita secara kontinu memeriksa apakah `led_characteristic` telah ditulisi. Ketika itu terjadi, kita mendekode data dan menyalakan atau mematikan LED onboard ESP32 sesuai dengan nilai yang diterima.
async def wait_for_write():
while True:
try:
connection, data = await led_characteristic.written()
print(data)
print(type)
data = _decode_data(data)
print('Connection: ', connection)
print('Data: ', data)
if data == 1:
print('Turning LED ON')
led.value(1)
elif data == 0:
print('Turning LED OFF')
led.value(0)
else:
print('Unknown command')
except asyncio.CancelledError:
# Catch the CancelledError
print("Peripheral task cancelled")
except Exception as e:
print("Error in peripheral_task:", e)
finally:
# Ensure the loop continues to the next iteration
await asyncio.sleep_ms(100)
Fungsi Utama
Terakhir, kita membuat fungsi asinkron `main()` yang menjadi dasar program. Di dalamnya, kita membuat tiga tugas asinkron, yaitu satu untuk advertising, satu lagi untuk menulis pada karakteristik sensor, dan tugas terakhir untuk mengontrol LED saat perangkat lain menulis pada `led_characteristic`.
async def main():
t1 = asyncio.create_task(sensor_task())
t2 = asyncio.create_task(peripheral_task())
t3 = asyncio.create_task(wait_for_write())
await asyncio.gather(t1, t2)
Terakhir, kita jalankan kode sebagai berikut.
asyncio.run(main())
Pengujian Kode
Jalankan kode sebelumnya pada ESP32. Kode akan mulai menulis nilai suhu pada karakteristik sensor dan mengiklankan layanannya.
Untuk terhubung ke peripheral ini, membaca karakteristik sensornya, dan menulis ke karakteristik LED, kita akan menggunakan aplikasi nRF Connect.
Aplikasi nRF Connect
Aplikasi nRF Connect dari Nordic bekerja di Android (Google Play Store) dan iOS (App Store). Pergi ke Google Play Store atau App Store, cari "nRF Connect for Mobile" dan instal aplikasinya di smartphone Anda.
Buka smartphone Anda, jalankan aplikasi nRF Connect dari Nordic, dan mulai pindai (scan) perangkat baru. Anda akan menemukan perangkat bernama ESP32, ini adalah nama server BLE yang Anda definisikan sebelumnya.
Hubungkan ke perangkat ESP32. Pada Thonny IDE, Anda akan melihat bahwa kode mendeteksi koneksi baru.
Anda akan melihat bahwa aplikasi menampilkan layanan dengan UUID yang kita definisikan dalam kode, dan bahwa layanan tersebut mengandung dua karakteristik dengan UUID yang telah kita tentukan sebelumnya.
Membaca Karakteristik
Pada karakteristik sensor, klik ikon panah untuk membaca karakteristik dan mengaktifkan notifications. Kemudian, klik ikon untuk mengubah format data (atur ke UTF-8)—pada perangkat Android Anda tidak perlu mengubah format.
Aplikasi akan mulai menampilkan nilai acak di kolom Value. Nilai ini diperbarui setiap detik.
Menulis ke Karakteristik
Untuk menulis ke karakteristik LED dan mengontrol LED, klik ikon panah atas pada karakteristik LED.
Pilih tipe UnsignedInt atau Bool. Kemudian, tulis 1 atau 0 untuk menyalakan atau mematikan LED. 1 menyalakan LED dan 0 mematikan LED.
ESP32 akan mendeteksi bahwa perangkat lain menulis pada karakteristik LED dan akan membaca nilai barunya.
Berdasarkan nilai yang ditulis, ESP32 akan menyalakan atau mematikan LED.
Sebagai alternatif, Anda dapat menggunakan aplikasi Web BLE kami untuk terhubung ke perangkat BLE ESP32. Aplikasi ini berfungsi pada Google Chrome di perangkat Windows dan Android.
Web Bluetooth (kadang juga disebut Web BLE) adalah teknologi yang relatif baru yang memungkinkan Anda untuk terhubung dan mengontrol perangkat dengan BLE, seperti ESP32 atau Raspberry Pi Pico, langsung dari peramban web Anda menggunakan JavaScript.
Siap Untuk Membuat Proyek Impianmu Menjadi Kenyataan?
Klik di sini untuk chat langsung via WhatsApp dan dapatkan dukungan langsung dari tim ahli kami!
0 on: "Panduan Lengkap Bluetooth Low Energy (BLE) ESP32 Menggunakan MicroPython"