Pada artikel ini, Arduino Indonesia akan membahas tentang dasar-dasar pemrograman asinkron pada MicroPython menggunakan modul `asyncio` di board ESP32 dan ESP8266 (NodeMCU). Anda akan mempelajari cara menjalankan beberapa tugas secara konkuren, sehingga program seolah-olah melakukan multitasking tanpa membuat eksekusi kode terhenti oleh proses yang berjalan lama.
Sebagai contoh, program Anda dapat menunggu respons dari sebuah server sambil tetap menjalankan tugas lain, seperti memeriksa status tombol atau mengedipkan LED secara bersamaan.
Pemrograman asinkron sangat bermanfaat untuk proyek yang melibatkan interaksi dengan database, komunikasi jaringan (misalnya saat melakukan request ke server atau ketika ESP32/ESP8266 berperan sebagai web server), pembacaan data sensor, menampilkan informasi ke layar, menerima input pengguna, dan berbagai proses lain yang berjalan secara paralel.
Baca juga: Tutorial MicroPython ESP32/ESP8266 - Membaca Sensor Cahaya Ambient BH1750
Pengenalan Pemrograman Asinkron
Pemrograman asinkron adalah pendekatan yang memungkinkan program menjalankan suatu tugas yang berpotensi memakan waktu lama, namun tetap responsif terhadap peristiwa atau tugas lain yang terjadi bersamaan, tanpa harus menunggu tugas tersebut selesai.
Konsep ini bekerja dengan mengeksekusi tugas secara non-blocking dan memanfaatkan mekanisme seperti callback atau await untuk menangani hasil ketika tugas tersebut selesai. Dengan demikian, program dapat melanjutkan proses lain sambil menunggu penyelesaian tugas asinkron. Sebaliknya, pada pemrograman sinkron, setiap proses harus menunggu proses sebelumnya selesai sebelum dapat dijalankan.
Ringkasan:
- Asynchronous menggunakan arsitektur non-blocking, sehingga eksekusi satu tugas tidak bergantung pada tugas lainnya. Banyak tugas dapat berjalan secara bersamaan.
- Synchronous menggunakan arsitektur blocking, sehingga setiap operasi harus menunggu operasi sebelumnya selesai sebelum bisa dieksekusi.
Modul `asyncio` pada MicroPython
MicroPython menyediakan modul `asyncio`, yaitu kerangka kerja asynchronous I/O yang dibuat secara ringan dan terinspirasi dari modul `asyncio` pada Python. Dokumentasi lengkap modul ini dapat ditemukan pada halaman resmi MicroPython.
Sebelum mulai menggunakan `asyncio` untuk pemrograman asinkron, berikut beberapa konsep dasar yang perlu dipahami:
- Event Loop: mekanisme inti yang secara kontinu memantau dan mengeksekusi peristiwa, tugas, atau coroutine yang sudah dijadwalkan.
- Tasks: unit kerja terpisah atau coroutine yang dieksekusi secara konkuren di dalam event loop.
- Asynchronous Functions (Coroutines): fungsi khusus yang dapat dihentikan sementara (paused) dan dilanjutkan kembali tanpa memblokir proses lainnya, sehingga memungkinkan banyak tugas berjalan bersamaan.
- `await`: kata kunci yang digunakan di dalam coroutine untuk menghentikan eksekusi sementara hingga suatu operasi selesai, sambil memberikan kesempatan bagi coroutine lain untuk berjalan.
Selanjutnya, kita akan membahas lebih detail setiap konsep tersebut, termasuk alur kerja dan metode penting pada modul `asyncio` untuk menulis program asinkron.
Event Loop
Event loop merupakan inti dari pemrograman asinkron. Mekanisme ini bekerja dengan terus-menerus memantau dan mengeksekusi peristiwa, tugas, atau coroutine yang telah dijadwalkan. Pada `asyncio`, event loop dapat dibuat menggunakan fungsi `asyncio.get_event_loop()`.
Baris kode tersebut menghasilkan sebuah instance event loop (misalnya bernama `loop`) yang digunakan untuk mengelola, menjadwalkan, dan menjalankan berbagai tugas asinkron dalam program.
loop = asyncio.get_event_loop()
Membuat Tasks
Dalam pemrograman asinkron, task merupakan unit kerja yang dijalankan secara konkuren. Task dibuat untuk mengeksekusi coroutine secara bersamaan. Coroutine sendiri adalah fungsi yang didefinisikan menggunakan kata kunci `async`, dan dapat dijeda serta dilanjutkan kembali, sehingga memungkinkan eksekusi asinkron.
Contohnya:
async def blink_led():
#Code to blink an LED
Selanjutnya, coroutine tersebut dapat dijadwalkan sebagai sebuah task untuk dijalankan oleh event loop menggunakan fungsi `loop.create_task()`.
loop.create_task(blink_led())
Menjalankan Event Loop
Setelah task dibuat, langkah berikutnya adalah menjalankan event loop untuk mengeksekusinya. Event loop akan terus memantau dan menjalankan task yang telah dijadwalkan. Baris kode berikut menginisiasi event loop, seperti yang telah dijelaskan sebelumnya.
loop = asyncio.get_event_loop()
Selanjutnya, `loop.run_forever()` membuat event loop berjalan tanpa henti sambil terus memantau dan mengeksekusi task yang telah dijadwalkan.
loop.run_forever()
Fungsi Asinkron – `async def`
Fungsi asinkron didefinisikan menggunakan sintaks `async def`. Fungsi jenis ini disebut juga coroutine, yang dapat dijeda menggunakan kata kunci `await`, sehingga coroutine lain dapat berjalan secara paralel selama proses tersebut menunggu. Contohnya:
async def blink_led():
while True:
led.toggle() # Toggle LED state
await asyncio.sleep(1)
Pada contoh tersebut, `blink_led()` merupakan sebuah fungsi asinkron. Fungsi ini mengubah status LED, kemudian menjeda eksekusinya selama 1 detik dengan `await asyncio.sleep(1)`. Selama jeda tersebut, task lain tetap dapat berjalan tanpa terblokir.
await asyncio.sleep(1)
Penundaan Asinkron – `asyncio.sleep()`
`asyncio.sleep()` adalah coroutine bawaan modul `asyncio` yang digunakan untuk memberikan jeda pada eksekusi sebuah coroutine dalam durasi tertentu, tanpa menghentikan seluruh event loop. Oleh karena itu, saat menulis fungsi asinkron, semua penggunaan `time.sleep()` harus diganti dengan `asyncio.sleep()`.
Ketika `asyncio.sleep()` dipanggil di dalam coroutine, eksekusi coroutine tersebut akan dijeda sementara sehingga coroutine lain dapat berjalan pada waktu yang sama. Event loop tetap aktif selama jeda berlangsung dan akan memproses task atau event lain yang tersedia. Setelah durasi jeda berakhir, coroutine yang ditunda akan dilanjutkan kembali dari titik di mana `asyncio.sleep()` dipanggil.
`await asyncio.sleep()` merupakan mekanisme non-blocking yang memberikan kontrol kepada coroutine lain di dalam event loop tanpa menyebabkan keterlambatan tambahan. Dengan kata lain, ini memungkinkan eksekusi tugas lain segera berjalan.
await
Kata kunci `await` digunakan di dalam coroutine untuk menandai titik di mana eksekusi dapat dijeda hingga suatu operasi atau event selesai.
Pada contoh berikut, coroutine berhenti selama 1 detik tanpa memblokir keseluruhan event loop.
await asyncio.sleep(1)
Ringkasan…
Saat program asinkron dijalankan, event loop akan bekerja secara terus-menerus untuk mengeksekusi task yang telah dijadwalkan secara konkuren. Setiap coroutine mendapat giliran untuk berjalan, dan pernyataan `await` memungkinkan event loop berpindah antar-task, sehingga tercipta kesan bahwa beberapa proses berjalan secara paralel.
Dengan pendekatan ini, Anda dapat menjalankan banyak tugas sekaligus tanpa harus menunggu satu tugas selesai sebelum melanjutkan tugas berikutnya.
Contoh Dasar Program Asinkron
Setelah memahami konsep dasar pemrograman asinkron dan metode penting dalam modul `asyncio`, kita akan membuat contoh sederhana untuk menerapkan konsep tersebut.
Pada contoh ini, kita akan membuat dua coroutine yang masing-masing mengendalikan LED dengan interval kedip yang berbeda:
- LED Hijau – GPIO 14: berkedip setiap 2 detik
- LED Biru – GPIO 12: berkedip setiap 0,5 detik
Untuk melihat hasilnya secara langsung, hubungkan dua LED ke board ESP32 atau ESP8266, satu pada GPIO 14 dan satu lagi pada GPIO 12.
ESP32
ESP32 NodeMCU
Berikut adalah contoh kode yang digunakan.
import asyncio
from machine import Pin
green_led_pin = 14
green_led = Pin(green_led_pin, Pin.OUT)
blue_led_pin = 12
blue_led = Pin(blue_led_pin, Pin.OUT)
# Define coroutine function
async def blink_green_led():
while True:
green_led.value(not green_led.value() )
await asyncio.sleep(2)
# Define coroutine function
async def blink_blue_led():
while True:
blue_led.value(not blue_led.value())
await asyncio.sleep(0.5)
# Define the main function to run the event loop
async def main():
# Create tasks for blinking two LEDs concurrently
asyncio.create_task(blink_green_led())
asyncio.create_task(blink_blue_led())
# Create and run the event loop
loop = asyncio.get_event_loop()
loop.create_task(main()) # Create a task to run the main function
loop.run_forever() # Run the event loop indefinitely
Cara Kerja Kode
Pertama, kita membuat dua coroutine, masing-masing bertugas mengendalikan satu LED:
# Define coroutine function
async def blink_green_led():
while True:
green_led.value(not green_led.value())
await asyncio.sleep(2)
# Define coroutine function
async def blink_blue_led():
while True:
blue_led.value(not blue_led.value())
await asyncio.sleep(0.5)
Di dalam masing-masing coroutine, status LED diubah secara berulang, lalu dilakukan jeda asinkron menggunakan `await asyncio.sleep(0.5)` sesuai interval yang ditentukan.
Selanjutnya, kita membuat coroutine tambahan bernama `main()` yang berfungsi sebagai pusat pengaturan untuk mengorganisasi dan mengoordinasikan eksekusi seluruh task.
Di dalam coroutine `main()`, kita membuat task untuk `blink_green_led()` dan `blink_blue_led()` sehingga keduanya dapat berjalan secara konkuren.
# Define the main function to run the event loop
async def main():
# Create tasks for blinking two LEDs concurrently
asyncio.create_task(blink_green_led())
asyncio.create_task(blink_blue_led())
Setelah itu, kita membuat instance event loop.
loop = asyncio.get_event_loop()
Perintah `loop.create_task(main())` digunakan untuk menjadwalkan eksekusi coroutine `main()` sebagai sebuah task di dalam event loop.
loop.create_task(main()) # Create a task to run the main function
Terakhir, metode `run_forever()` akan menjalankan event loop secara terus-menerus. Event loop akan terus memantau task yang dijadwalkan, mengeksekusinya secara konkuren, dan mengatur jalannya eksekusi masing-masing task.
loop.run_forever() # Run the event loop indefinitely
Menguji Kode
Jalankan kode tersebut pada ESP32 atau ESP8266 Anda. Hasilnya akan terlihat dua LED berkedip dengan interval yang berbeda.
Baca juga: Panduan Lengkap Menghubungkan Sensor Anemometer ke ESP32/ESP8266 Menggunakan MicroPython
Siap Belajar & Bangun Proyek IoT?
KLIK GAMBAR DI BAWAH INI UNTUK BELI TRAINER KIT ESP32
 |
| Klik gambar untuk pembelian |
Dalam praktik, hasil dan kendala yang ditemui bisa berbeda tergantung perangkat, konfigurasi, versi library, dan sistem yang digunakan.
- Diskusi umum dan tanya jawab praktik: https://t.me/edukasielektronika
- Kendala spesifik dan kasus tertentu: http://bit.ly/Chatarduino
0 on: "ESP32/ESP8266 - Cara Menerapkan Pemrograman Asinkron dengan MicroPython (Multi-Tasking)"