Tutorial MicroPython - Implementasi Timer Interrupt pada ESP32/ESP8266

Pada artikel ini, Anda akan mempelajari cara menggunakan timer interrupts (timer dan penanganan peristiwa) pada ESP32 dan ESP8266 yang diprogram dengan MicroPython. Timer interrupts memungkinkan Anda menjadwalkan dan mengeksekusi tugas tertentu secara berkala atau setelah jeda waktu yang telah ditentukan.

Memperkenalkan Interrupt

Interrupts berperan penting dalam menciptakan proses otomatis pada program mikrokontroler dan dapat mengatasi berbagai masalah terkait waktu. Mekanisme interrupt dan penanganan peristiwa (event handling) menyediakan cara bagi sistem untuk merespons suatu kejadian secara langsung, memungkinkan ESP32/ESP8266 bereaksi cepat terhadap perubahan tanpa perlu melakukan polling secara terus-menerus (seperti terus-memeriksa status pin, nilai variabel, atau kondisi waktu).

 

Penggunaan timer interrupts sangat efektif untuk menghasilkan suatu aksi yang berulang secara periodik atau tertunda setelah jangka waktu tertentu, tanpa memerlukan pengecekan berkelanjutan terhadap waktu yang telah berlalu.

Jenis-jenis Interrupt

Terdapat dua kategori utama interrupt, yaitu external interrupt dan timed interrupt:

1. External Interrupts (Interrupt Eksternal): Dipicu oleh sinyal dari luar sistem, seperti penekanan tombol atau perubahan bacaan sensor. Interrupt ini bersifat berbasis perangkat keras (hardware) dan dikaitkan dengan pin GPIO tertentu. Saat status suatu pin berubah (misalnya dari HIGH ke LOW), sebuah tugas atau fungsi akan dieksekusi.

2. Timed Interrupts / Timers (Interrupt Waktu): Dipicu berdasarkan interval waktu, memungkinkan eksekusi aksi secara berkala. Interrupt ini memanfaatkan hardware timer pada board untuk menjalankan fungsi callback pada interval yang telah ditentukan. Pada artikel ini, kita akan membahas jenis interrupt yang kedua ini secara mendalam.

class Timer dalam MicroPython

Modul `machine` pada MicroPython menyediakan kelas bernama `Timer`. Kelas ini menyediakan metode untuk mengeksekusi sebuah fungsi _callback_ secara berkala dalam periode tertentu atau sekali setelah jeda waktu yang telah ditentukan. Fungsi ini sangat berguna untuk menjadwalkan suatu peristiwa atau menjalankan tugas periodik tanpa perlu terus-menerus memantau waktu yang telah berlalu.

Membuat Objek Timer

Untuk membuat sebuah _timer_, Anda cukup memanggil konstruktor `Timer()` dan memberikan argumen berupa ID timer, seperti contoh berikut:

 

my_timer = Timer(id)

 

Kemudian, Anda menginisialisasi timer dengan menggunakan metode `init()` pada objek `Timer()` dan memberikan argumen berupa mode timer, periode, serta fungsi callback. Berikut contohnya:

 

my_timer.init(mode=Timer.PERIODIC, period=1000, callback=timer_callback)

 

Konfigurasi ini membuat timer periodik yang akan menjalankan fungsi `timer_callback` setiap 1000 milidetik (1 detik). Nilai parameter `period` dapat disesuaikan dengan periode yang diinginkan.

Selain menjalankan fungsi callback secara periodik, Anda juga dapat membuatnya dieksekusi hanya sekali setelah jeda waktu tertentu. Untuk mode ini, gunakan `Timer.ONE_SHOT` seperti contoh berikut:

 

my_timer.init(mode=Timer.ONE_SHOT, period=1000, callback=timer_callback)

 

Baris kode ini mengonfigurasi timer (`my_timer`) untuk berjalan dalam mode sekali pakai (one-shot), yang akan memicu fungsi callback yang ditentukan (`timer_callback`) setelah 1000 milidetik.

Pelajari lebih lanjut mengenai kelas `Timer` di dokumentasi resmi MicroPython.

Penerapan Timer Interrupts pada ESP32/ESP8266

Selanjutnya, kita akan melihat beberapa skenario penerapan timer interrupts pada ESP32 dan ESP8266.

- Mengedipkan LED dengan Timer

- Mengedipkan Beberapa LED dengan Frekuensi Berbeda

- Debouncing Tombol Push dengan Timer

1. Mengedipkan LED dengan Timer – MicroPython

Pada contoh ini, Anda akan belajar cara mengedipkan sebuah LED menggunakan Timer. Contoh ini akan membantu memahami cara kerja timer periodik.

Diagram Rangkaian

Kita akan mengedipkan LED yang terhubung ke GPIO 13. Oleh karena itu, hubungkan sebuah LED ke ESP32 atau ESP8266 pada GPIO tersebut. Anda dapat merujuk pada diagram berikut.

ESP32

ESP8266 NodeMCU

Kode Program

Contoh berikut menggunakan kelas `Timer` untuk mengedipkan sebuah LED setiap setengah detik. Kode ini kompatibel dengan papan ESP32 dan ESP8266.

 

from machine import Pin, Timer

from time import sleep

# LED pin

led_pin = 13

led = Pin(led_pin, Pin.OUT)

# Callback function for the timer

def toggle_led(timer):

    led.value(not led.value())  # Toggle the LED state (ON/OFF)

# Create a periodic timer

blink_timer = Timer(1)

blink_timer.init(mode=Timer.PERIODIC, period=500, callback=toggle_led)  # Timer repeats every half second

try:

    # Main loop (optional)

    while True:

        print('Main Loop is running')

        sleep(2)

except KeyboardInterrupt:

    # Keyboard interrupt occurred, deinitialize the timer

    blink_timer.deinit()

    print('Timer deinitialized')

    # Turn off the LED

    led.value(0)

 

Dalam kode ini, kita membuat sebuah timer yang bernama `blink_timer`:

 

blink_timer = Timer(1)

 

Kemudian, kita menginisialisasi timer dengan parameter berikut:

 

blink_timer.init(mode=Timer.PERIODIC, period=500, callback=toggle_led)

 

Konfigurasi ini berarti timer akan memanggil fungsi `toggle_led` setiap 500 milidetik secara terus-menerus (atau hingga program dihentikan).

Fungsi `toggle_led`, sesuai namanya, akan mengubah status LED (menyalakan atau mematikan):

 

# Callback function for the timer

def toggle_led(timer):

    led.value(not led.value())  # Toggle the LED state (ON/OFF)

 

Fungsi callback timer harus menerima satu argumen, yang secara otomatis akan diteruskan oleh objek Timer ketika peristiwa (event) terpicu.

 

Dengan menggunakan timer, Anda juga dapat menjalankan tugas-tugas lain pada main loop tanpa mengganggu satu sama lain. Sebagai contoh, dalam kode ini, kita akan mencetak pesan setiap dua detik di dalam main loop.

 

while True:

    print('Main Loop is running')

    sleep(2)

 

Saat pengguna menghentikan program (misalnya dengan `KeyboardInterrupt`), kita akan menonaktifkan timer menggunakan metode `deinit()` dan mematikan LED.

 

except KeyboardInterrupt:

    # Keyboard interrupt occurred, deinitialize the timer

    blink_timer.deinit()

    print('Timer deinitialized')

    # Turn off the LED

    led_pin.value(0)

 

Pengujian Kode Program

Setelah menghubungkan LED ke GPIO 13, jalankan kode sebelumnya pada papan Anda.

Anda akan melihat pesan "Main Loop is running" muncul setiap dua detik pada Shell, sementara LED berkedip setiap setengah detik secara bersamaan.

 

2. Mengedipkan Beberapa LED dengan Frekuensi Berbeda

Setelah menguji contoh sebelumnya, dapat dipahami bahwa dengan membuat beberapa timer, Anda dapat menjalankan beberapa tugas pada frekuensi yang berbeda. Pada contoh ini, kita akan mengedipkan dua LED yang berbeda. Satu LED akan berkedip setiap setengah detik, dan LED lainnya setiap dua detik.

Diagram Rangkaian

Hubungkan dua LED ke ESP32/ESP8266 (untuk membedakan kedua LED, kita akan menggunakan warna yang berbeda):

- LED Merah: GPIO 13 — akan berkedip setiap setengah detik;

- LED Kuning: GPIO 12 — akan berkedip setiap dua detik.

Anda dapat menggunakan diagram berikut sebagai acuan untuk merangkai sirkuitnya.

ESP32

ESP8266 NodeMCU

Kode Program

Kode berikut menggunakan Timer untuk mengedipkan dua LED berbeda dengan frekuensi yang berbeda. Kode ini kompatibel dengan papan ESP32 dan ESP8266.

 

from machine import Pin, Timer

from time import sleep

# LEDs

red_led_pin = 12

red_led = Pin(red_led_pin, Pin.OUT)

yellow_led_pin = 13

yellow_led = Pin(yellow_led_pin, Pin.OUT)

# Callback function for the red timer

def toggle_red_led(timer):

    red_led.value(not red_led.value())  # Toggle the LED state (ON/OFF)

    print('red LED is: ', red_led.value())

# Callback function for the yellow timer

def toggle_yellow_led(timer):

    yellow_led.value(not yellow_led.value())  # Toggle the LED state (ON/OFF)

    print('yellow LED is: ', yellow_led.value())

# Create periodic timers

red_timer = Timer(1)

yellow_timer = Timer(2)

# Init the timers

red_timer.init(mode=Timer.PERIODIC, period=500, callback=toggle_red_led)  # Timer repeats every 0.5 second

yellow_timer.init(mode=Timer.PERIODIC, period=2000, callback=toggle_yellow_led)  # Timer repeats every 2 seconds

try:

    # Main loop (optional)

    while True:

        print('Main Loop is running')

        sleep(2)

        

except KeyboardInterrupt:

    # Keyboard interrupt occurred, deinitialize the timers

    red_timer.deinit()

    yellow_timer.deinit()

    print('Timers deinitialized')

    # Turn off the LEDs

    yellow_led.value(0)

    red_led.value(0)

 

Dalam kode ini, kita membuat dua timer yang berbeda, masing-masing untuk satu LED:

 

# Create periodic timers

red_timer = Timer(1)

yellow_timer = Timer(2)

 

Kemudian, kita memanggil fungsi callback yang sesuai pada interval yang berbeda:

 

# Init the timers

red_timer.init(mode=Timer.PERIODIC, period=500, callback=toggle_red_led)  # Timer repeats every 0.5 second

yellow_timer.init(mode=Timer.PERIODIC, period=2000, callback=toggle_yellow_led)  # Timer repeats every 2 seconds

 

Fungsi callback tersebut secara sederhana membalikkan nilai status LED saat ini:

 

# Callback function for the red timer

def toggle_red_led(timer):

    red_led.value(not red_led.value())  # Toggle the LED state (ON/OFF)

    print('red LED is: ', red_led.value())

# Callback function for the yellow timer

def toggle_yellow_led(timer):

    yellow_led.value(not yellow_led.value())  # Toggle the LED state (ON/OFF)

    print('yellow LED is: ', yellow_led.value())

 

Pengujian Kode Program

Jalankan kode di atas pada ESP32 atau ESP8266. Anda akan melihat bahwa kedua LED akan berkedip dengan frekuensi yang berbeda.

Secara bersamaan, Anda akan mendapatkan pesan dari perulangan `while` setiap dua detik. Hal ini menunjukkan bahwa tugas-tugas lain tidak mengganggu eksekusi pada main loop.

3. Debouncing Tombol Push dengan Timer

Button bouncing (pantulan tombol) adalah kondisi di mana tombol push dihitung lebih dari satu kali tekan meskipun pada kenyataannya Anda hanya menekannya sekali. Fenomena ini sangat umum terjadi pada tombol mekanis seperti pushbutton.

Hal ini terjadi karena kontak listrik di dalam tombol terhubung dan terputus dengan sangat cepat sebelum mencapai keadaan stabil, sehingga menyebabkan sistem mendaftarkan beberapa peristiwa penekanan dan menghasilkan hitungan yang tidak akurat. Untuk mencegah masalah ini, kita dapat menerapkan teknik debouncing menggunakan penundaan (delay) atau timer.

Pada contoh ini, kita akan melihat cara menggunakan timer dan event untuk melakukan debouncing pada sebuah tombol push.

Diagram Rangkaian

Untuk contoh ini, hubungkan sebuah LED (ke GPIO 13) dan sebuah tombol push (ke GPIO 12) ke ESP32 atau ESP8266.

- LED (GPIO 13)

- Tombol Push (GPIO 12)

Anda dapat menggunakan diagram skematik berikut sebagai acuan.

ESP32

ESP8266B NodeMCU

Kode

from machine import Pin, Timer

import time

led = Pin(13, Pin.OUT)

button = Pin(12, Pin.IN, Pin.PULL_UP)

counter = 0  # Initialize the button press count

debounce_timer = None

def button_pressed(pin):

    global counter, debounce_timer  # Declare variables as global

    if debounce_timer is None:

        counter += 1

        print("Button Pressed! Count: ", counter)

        

        # Toggle the LED on each button press

        led.value(not led.value())

        # Start a timer for debounce period (e.g., 200 milliseconds)

        debounce_timer = Timer(1)

        debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

def debounce_callback(timer):

    global debounce_timer

    debounce_timer = None

# Attach the interrupt to the button's rising edge

button.irq(trigger=Pin.IRQ_RISING, handler=button_pressed)

try:

    # Main loop (optional)

    while True:

        print("Loop is running")

        time.sleep(5)

except KeyboardInterrupt:

    # Keyboard interrupt occurred, deinitialize the timer

    debounce_timer.deinit()

    # Turn off the LED

    led.value(0)

 

Prinsip Kerja Kode Program

Mari kita lihat sekilas bagaimana penggunaan timer untuk melakukan debouncing pada sebuah tombol push.

 

Contoh ini menggunakan timer sekali pakai (one-shot timer) bernama `debounce_timer` yang diinisialisasi setiap kali tombol ditekan dengan periode debouncing tertentu, dalam hal ini 200 milidetik. Periode debouncing dapat diperpanjang jika masih terjadi deteksi yang tidak diinginkan (false positives).

 

debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

 

Untuk mendeteksi penekanan tombol, kita menggunakan interrupt eksternal. Fungsi `button_pressed` akan terpicu pada mode `RISING` (saat tombol ditekan).

 

button.irq(trigger=Pin.IRQ_RISING, handler=button_pressed)

 

Saat tombol ditekan, fungsi `button_pressed` akan dipanggil. Fungsi ini akan menambah nilai counter, mengubah status LED, dan memulai timer sekali pakai untuk proses debouncing.

 

counter += 1

print("Button Pressed! Count: ", counter)

        

# Toggle the LED on each button press

led.value(not led.value())

# Start a timer for debounce period (e.g., 200 milliseconds)

debounce_timer = Timer(1)

debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

 

Fungsi `debounce_callback` dari timer akan dipanggil ketika timer sekali pakai tersebut selesai (expired), yang kemudian mengatur nilai `debounce_timer` kembali menjadi `None`.

 

def debounce_callback(timer):

    global debounce_timer

    debounce_timer = None

 

Jika timer belum selesai dan deteksi penekanan tombol lain terjadi, penekanan tersebut tidak akan diperhitungkan karena `debounce_timer` belum diatur ulang menjadi `None`:

 

if debounce_timer is None:

 

Perhatikan bahwa kita menggunakan variabel global agar dapat mengaksesnya dari seluruh bagian kode, termasuk di dalam fungsi:

 

global counter, debounce_timer  # Declare variables as global

 

Ini hanyalah salah satu dari banyak cara untuk melakukan debouncing pada sebuah tombol push.

Penggunaan `None`

Dalam Python/MicroPython, `None` sering digunakan sebagai placeholder atau nilai default untuk menunjukkan ketiadaan nilai yang bermakna. Pada contoh sebelumnya, `None` membantu kita mengelola status dari variabel `debounce_timer`.

 

Variabel `debounce_timer` awalnya diatur ke `None` untuk menunjukkan bahwa tidak ada timer debouncing yang sedang aktif.

 

debounce_timer = None

 

Di dalam fungsi `button_pressed`, kondisi berikut memeriksa apakah tidak ada timer debouncing yang sedang aktif.

 

if debounce_timer is None:

 

Jika tidak ada timer yang aktif (nilainya `None`), maka aksi penekanan tombol akan dieksekusi, dan sebuah timer sekali pakai baru (`debounce_timer`) diinisialisasi.

 

debounce_timer = Timer(1)

debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

 

Saat timer sekali pakai tersebut selesai, fungsi `debounce_callback` akan dipanggil dan mengatur `debounce_timer` kembali ke `None`, menandakan bahwa periode debouncing telah berakhir.

 

def debounce_callback(timer):

    global debounce_timer

    debounce_timer = None

 

Pengujian Kode Program

Jalankan kode pada ESP32/ESP8266 Anda. Tekan tombol push beberapa kali. Anda akan melihat bahwa tidak terjadi deteksi palsu (false positives) dan penghitungan jumlah penekanan tombol akan akurat.

Jika masih terjadi deteksi palsu (false positives), Anda perlu menambah periode debouncing yang awalnya 200 milidetik pada `debounce_timer`.

 

debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=debounce_callback)

 

 

 

 

 

 

 

 

 

  

Siap Untuk Membuat Proyek Impianmu Menjadi Kenyataan?

Klik di sini untuk chat langsung via WhatsApp dan dapatkan dukungan langsung dari tim ahli kami!