Pada artikel ini, Arduino Indonesia akan membahas tentang cara mengontrol LED RGB addressable WS2812B (NeoPixel) dengan ESP32 dan ESP8266 menggunakan MicroPython. MicroPython memiliki library bawaan yang membuat pengontrolan LED ini sangat mudah, yaitu library neopixel. Kami akan menunjukkan cara mengontrol LED secara individual, membuat fungsi untuk menghasilkan efek pencahayaan yang menarik, serta membangun proyek sederhana untuk mengilustrasikan cara kerjanya. Tutorial ini dapat diterapkan pada strip, papan PCB, atau modul apa pun yang menggunakan LED RGB addressable WS2812B (NeoPixel), seperti:
- Strip LED RGB Addressable WS2812B
- Cincin LED RGB Addressable WS2812B
- Stick PCB LED RGB Addressable WS2812B
Dalam tutorial ini, kami akan mengontrol dua cincin LED addressable dan satu stick LED addressable yang dirangkai secara seri.
Pengenalan LED RGB WS2812B
WS2812B adalah LED RGB addressable yang dapat dirangkai secara seri dan dikontrol secara individual hanya dengan menggunakan satu pin digital mikrokontroler. LED ini memiliki IC terintegrasi di dalamnya yang memungkinkan semua fungsi tersebut.
Anda dapat menyolder beberapa cincin atau stick LED dan mereka akan berperilaku sebagai satu kesatuan. Setiap PCB memiliki pin IN dan OUT yang mempermudah perangkaian:
Gambar berikut menunjukkan tampilan setup kami setelah LED disolder.
Menghubungkan strip LED RGB ke ESP32 atau ESP8266 sangat sederhana. Berikan tegangan 5V ke pin VCC, GND ke GND, dan sambungkan sebuah GPIO ke pin Din (data). Kami akan menghubungkan pin data ke GPIO 5.
Mengontrol LED RGB WS2812B
Ada modul bawaan MicroPython bernama neopixel untuk mengontrol LED addressable WS2812B. Misalnya, skrip berikut mengontrol 4 piksel individual:
import machine, neopixel
n = 48
p = 5
np = neopixel.NeoPixel(machine.Pin(p), n)
np[0] = (255, 0, 0)
np[3] = (125, 204, 223)
np[7] = (120, 153, 23)
np[10] = (255, 0, 153)
np.write()
Mengimpor Library
Pertama, impor modul neopixel dan machine:
import machine, neopixel
Membuat Objek Neopixel
Tentukan jumlah piksel di strip Anda ke variabel n:
n = 48
Simpan nomor GPIO yang akan mengontrol strip ke variabel p:
p = 5
Buat objek NeoPixel bernama np pada GPIO yang telah ditentukan dan dengan jumlah LED yang juga telah ditentukan:
np = neopixel.NeoPixel(machine.Pin(p), n)
Mengontrol Piksel Individual
Setelah menginisialisasi objek neopixel, Anda dapat mulai mengontrol LED. Mengontrol satu piksel sangat mudah. Bayangkan strip sebagai sebuah array dengan n elemen (jumlah piksel dalam strip contoh ini). Kemudian, kita hanya perlu mengatur warna untuk elemen tertentu. Contoh, untuk mengatur piksel pertama menjadi merah:
np[0] = (255, 0, 0)
Gambar berikut mungkin membantu Anda memahami cara kerjanya dengan lebih baik:
Kemudian, gunakan metode write() agar perubahan diterapkan.
np.write()
Efek Pencahayaan LED RGB WS2812
Setelah Anda mengetahui cara mengontrol piksel individual, Anda dapat membuat efek pencahayaan sendiri. Kami akan memberikan beberapa fungsi (berdasarkan contoh library) yang dapat Anda gunakan dalam proyek Anda.
Menghapus Semua Piksel
Menghapus semua piksel sama dengan mengatur semua piksel ke warna (0, 0, 0).
def clear():
for i in range(n):
np[i] = (0, 0, 0)
np.write()
Mengatur Semua Piksel ke Warna yang Sama
Dengan cara yang mirip, untuk mengatur semua piksel ke warna yang sama, Anda dapat menggunakan fungsi berikut yang menerima argumen parameter warna r, g, dan b.
def set_color(r, g, b):
for i in range(n):
np[i] = (r, g, b)
np.write()
Efek Bounce (Pantulan)
Fungsi bounce() membuat efek pantulan dan menerima parameter r, g, dan b untuk mengatur warna, serta waktu tunggu. Waktu tunggu menentukan seberapa cepat efek pantulan berjalan.
def bounce(r, g, b, wait):
for i in range(4 * n):
for j in range(n):
np[j] = (r, g, b)
if (i // n) % 2 == 0:
np[i % n] = (0, 0, 0)
else:
np[n – 1 – (i % n)] = (0, 0, 0)
np.write()
time.sleep_ms(wait)
Efek ini menampilkan satu piksel yang padam bergerak melalui semua posisi di sepanjang strip.
Efek Cycle (Siklus)
Efek cycle bekerja mirip dengan efek bounce. Satu piksel menyala bergerak melalui semua posisi strip sementara piksel lainnya padam.
def cycle(r, g, b, wait):
for i in range(4 * n):
for j in range(n):
np[j] = (0, 0, 0)
np[i % n] = (r, g, b)
np.write()
time.sleep_ms(wait)
Efek Pelangi Bergerak
Untuk menghasilkan efek pelangi yang bergerak, Anda memerlukan dua fungsi. Fungsi wheel() menghasilkan spektrum warna pelangi dengan memvariasikan setiap parameter warna antara 0 dan 255.
def wheel(pos):
Input a value 0 to 255 to get a color value.
The colours are a transition r - g - b - back to r.
if pos < 0 or pos > 255:
return (0, 0, 0)
if pos < 85:
return (255 - pos * 3, pos * 3, 0)
if pos < 170:
pos -= 85
return (0, 255 - pos * 3, pos * 3)
pos -= 170
return (pos * 3, 0, 255 - pos * 3)
Setelah itu, gunakan fungsi rainbow_cycle() yang menggunakan hasil dari fungsi wheel() untuk menyebarkan warna pelangi ke seluruh LED di strip Anda.
def rainbow_cycle(wait):
for j in range(255):
for i in range(n):
rc_index = (i * 256 // n) + j
np[i] = wheel(rc_index & 255)
np.write()
time.sleep_ms(wait)
Fungsi ini menerima argumen waktu tunggu. Waktu tunggu menentukan seberapa cepat efek pelangi bergerak.
Dengan memahami cara kerja fungsi-fungsi ini, Anda dapat membangun proyek sendiri untuk menghasilkan efek pencahayaan yang menarik. Untuk melihat bagaimana semuanya bekerja bersama, pada bagian berikutnya kami akan membuat proyek sederhana untuk mengontrol sejumlah LED RGB addressable.
LED RGB WS2812B dengan MicroPython: Contoh Proyek
Di sini, kami akan membangun rangkaian sederhana dengan 4 pushbutton. Rangkaian ini akan menghasilkan efek pencahayaan berbeda tergantung tombol mana yang ditekan.
Komponen yang Diperlukan
Dalam proyek ini, kami menggunakan dua cincin LED RGB addressable dengan ukuran berbeda dan satu stick LED RGB addressable. Namun, Anda dapat menggunakan strip LED RGB atau LED addressable dalam konfigurasi lain.
- ESP32 atau ESP8266
- LED RGB Addressable (cincin, stick, atau strip)
- 4x pushbutton (saklar sesaat)
- 4x resistor 10k Ohm
- Breadboard
- Kabel jumper
(Catatan: tautan referensi produk telah dihilangkan sesuai permintaan.)
Rangkaian
Baik untuk ESP32 maupun ESP8266, kami akan merangkai sirkuit sebagai berikut:
Catatan: Anda dapat memilih pin digital lain jika diperlukan.
ESP32
Anda juga dapat mengikuti diagram skematik berikut untuk merangkai rangkaian ESP32:
ESP8266
Ikuti diagram skematik berikut jika Anda menggunakan EPS8266:
Kode Program
Unggah kode berikut ke ESP32 atau ESP8266 Anda sebagai main.py.
from machine import Pin
import machine, neopixel, time
# define interrupt handling functions
def button_handler(pin):
global button_pressed
button_pressed = pin
# configure pushbuttons as interrupts
button1 = Pin(15, Pin.IN)
button1.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button2 = Pin(14, Pin.IN)
button2.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button3 = Pin(12, Pin.IN)
button3.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button4 = Pin(13, Pin.IN)
button4.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button_pressed = button1
# LED strip configuration
# number of pixels
n = 48
# strip control gpio
p = 5
np = neopixel.NeoPixel(machine.Pin(p), n)
# FUNCTIONS FOR LIGHTING EFFECTS
# bounce
def bounce(r, g, b, wait):
for i in range(2 * n):
for j in range(n):
np[j] = (r, g, b)
if (i // n) % 2 == 0:
np[i % n] = (0, 0, 0)
else:
np[n - 1 - (i % n)] = (0, 0, 0)
np.write()
time.sleep_ms(wait)
# cycle
def cycle(r, g, b, wait):
for i in range(n):
for j in range(n):
np[j] = (0, 0, 0)
np[i % n] = (r, g, b)
np.write()
time.sleep_ms(wait)
# function to go through all colors
def wheel(pos):
# Input a value 0 to 255 to get a color value.
# The colours are a transition r - g - b - back to r.
if pos < 0 or pos > 255:
return (0, 0, 0)
if pos < 85:
return (255 - pos * 3, pos * 3, 0)
if pos < 170:
pos -= 85
return (0, 255 - pos * 3, pos * 3)
pos -= 170
return (pos * 3, 0, 255 - pos * 3)
# rainbow
def rainbow_cycle(wait):
for j in range(255):
for i in range(n):
rc_index = (i * 256 // n) + j
np[i] = wheel(rc_index & 255)
np.write()
time.sleep_ms(wait)
# turn off all pixels
def clear():
for i in range(n):
np[i] = (0, 0, 0)
np.write()
while True:
if button_pressed == button1:
clear()
elif button_pressed == button2:
bounce(23, 210, 15, 70)
elif button_pressed == button3:
cycle(123, 0, 154, 50)
elif button_pressed == button4:
rainbow_cycle(1)
Penjelasan Kode
Lanjutkan membaca bagian ini jika Anda ingin memahami cara kerja kodenya. Jika tidak, Anda dapat langsung melompat ke bagian "Demonstrasi".
Mulai dengan mengimpor library yang diperlukan:
from machine import Pin
import machine, neopixel, time
Pushbutton akan diatur sebagai interrupt. Oleh karena itu, kita perlu membuat fungsi penanganan interrupt (button_handler()) yang akan dijalankan setiap kali interrupt terjadi.
def button_handler(pin):
global button_pressed
button_pressed = pin
Fungsi penanganan interrupt memiliki parameter input (`pin`) yang akan menerima objek dari kelas Pin saat interrupt terjadi. Hal ini memungkinkan kita untuk mengetahui pin mana yang memicu interrupt.
Dalam contoh kami, fungsi penanganan interrupt disebut button_handler dan fungsi ini menyimpan pushbutton yang ditekan ke dalam variabel button_pressed.
def button_handler(pin):
global button_pressed
button_pressed = pin
Catatan: button_pressed didefinisikan sebagai variabel global, agar dapat diakses di seluruh bagian kode, bukan hanya di dalam fungsi button_handler().
Setelah itu, konfigurasikan pushbutton sebagai pin interrupt:
button1 = Pin(15, Pin.IN)
button1.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button2 = Pin(14, Pin.IN)
button2.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button3 = Pin(12, Pin.IN)
button3.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button4 = Pin(13, Pin.IN)
button4.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
Secara default, variabel button_pressed diatur sama dengan button1 karena tombol ini berfungsi untuk mematikan LED, dan kami ingin LED dalam keadaan mati saat awal.
button_pressed = button1
Kemudian, kami membuat objek neopixel pada GPIO 5 dengan 48 LED. Anda harus mengubah variabel n sesuai dengan jumlah LED yang Anda kendalikan.
n = 48 # number of pixels
p = 5 # strip control gpio
np = neopixel.NeoPixel(machine.Pin(p), n)
Setelah itu, kami mendefinisikan fungsi-fungsi yang telah dilihat di bagian sebelumnya, yaitu bounce(), cycle(), wheel(), rainbow_cycle(), dan clear().
Di dalam perulangan while, kami memeriksa tombol mana yang ditekan dan memanggil fungsi berbeda sesuai tombolnya:
- Tombol 1: Membersihkan strip (semua neopixel mati)
- Tombol 2: Efek bounce
- Tombol 3: Efek cycle
- Tombol 4: Efek pelangi (rainbow)
while True:
if button_pressed == button1:
clear()
elif button_pressed == button2:
bounce(23, 210, 15, 10)
elif button_pressed == button3:
cycle(123, 0, 154, 20)
elif button_pressed == button4:
rainbow_cycle(1)
Catatan: Anda dapat mengubah argumen dari fungsi-fungsi sebelumnya untuk mengatur LED dengan warna berbeda atau menyesuaikan parameter wait agar efek berjalan lebih cepat atau lambat.
Demonstrasi
Setelah mengunggah kode di atas ke ESP32 atau ESP8266 Anda sebagai main.py, tekan tombol Enable/Reset pada ESP untuk menjalankan kode baru.
Tekan setiap pushbutton untuk menghasilkan efek yang berbeda. Anda dapat menonton video di bawah ini untuk demonstrasi langsung:
Catatan: Saat Anda menekan pushbutton untuk memilih efek, efek baru hanya akan dimulai setelah efek yang sedang berjalan selesai.
Baca juga: Tutorial MicroPython ESP32/ESP8266 - PWM untuk Mengatur Kecerahan LED
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: "Panduan Lengkap MicroPython ESP32 & ESP8266 - LED RGB Addressable WS2812B (NeoPixel) "