Mengontrol LED Strip dengan arduino + Penjelasan lengkap (Pemrograman dasar)

Pada artikel kali ini, kita akan belajar untuk mengontrol tampilan lampu led strip menggunakan arduino, baik itu membuat animasi kekanan, kekiri, pinggir ketengah, kemasjid dan segala macam. langsung saja, simak tutorial dibawah ini.

Sebelum itu, saya asumsikan anda sudah menguasai dasar pemrograman c++ seperti pengkondisian IF dan perulangan seperti FOR karena kedua identifier itu kita gunakan untuk membuat animasi led.

Daftar isi

---

• Pengertian LED strip dan jenisnya
• Sedikit teori
• Meng-install library
• Bermain dengan warna
• Membuat scrolling LED berjalan
• Kesimpulan

Pengertian LED strip dan jenisnya



LED Strip adalah kumpulan lampu LED yang disusun menjadi semacam pita dan dikontrol oleh mikrokontroller. Kegunaannya bisa bermacam-macam, mulai dari dekorasi dinding, hiasan PC gaming, aksesoris kendaraan dan sebagainya

Bahkan orang juga didekorasi pakai LED strip

Kemudian, LED strip juga memiliki banyak jenis, berikut faktor spesifikasinya

• Warna

LED strip ada yang memiliki 1 warna, dan ada juga berwarna-warni (RGB). biasanya led strip RGB lebih mahal dari pada led strip 1 warna. 

• Addressable atau tidak
LED strip yang sudah addressable berarti LED strip tersebut dapat dinyalakan/dimatikan secara individual, misalnya LED pertama dimatikan, yang kedua dihidupkan dst. 
Pada LED satu warna, kita bisa menghidupkan led 1 selagi mematikan yang lainnya secara bersamaan, jadi kita bisa buat animasi led berjalan. Namun pada LED strip RGB, kita bisa menghidupkan led dengan warna bervariasi disetiap LEDnya sehingga memungkinkan kita untuk bisa buat pelangi berjalan 
Untuk pinnya, biasanya hanya ada 3 yaitu: VCC, DI, dan GND. DI adalah data input signal, nah sinyal inilah yang kita kirimkan dari mikrokontroller.

Berbeda dengan led yang bukan addressable, biasanya led strip non-addressable hanya memiliki pin VCC dan GND, sehingga cukup diberikan arus, led sudah bisa hidup. Untuk LED strip RGB non-addressable, biasanya terdapat 3 pin atau lebih sebagai pengatur warna, dan 1 pin gnd/vcc

• Density / Kerapatan

LED strip juga memiliki kerapatan setiap led yang berbeda-beda, ada yang memiliki 30 LED / meter, 60 LED/ meter, 144 LED / meter dan sebagainya.

• Tegangan Supply

Di pasaran, ada beberapa versi untuk tegangan yang diperlukan. Ada yang butuh 5V, 12V, dan 24V. Namun perberdaan tegangan ini ada efek samping pada LED addressable,

jika tegangan supply-nya 5V, LED tersebut dapat dikontrol secara individual setiap 1 LED.



Namun tidak untuk 12V, led tersebut dikontrol secara individual setiap 3 LED, jadi jika kita atur warna urutan 1 merah dan urutan 2 menjadi biru, hasilnya adalah 3 LED pertama merah dan 3 LED kedua berwarna biru. Biasanya terdapat IC di setiap 3 LED menandakan 3 LED tersebut menggunakan 1 IC yang sama

Sekarang anda tahu jenis-jenisnya, jangan bingung kalau di tokopedia ada barang tertulis sebagai berikut: Led Strip WS2812B Addressable RGB 30 Led/meter 5V

---

Sedikit teori

Pada artikel ini kita menggunakan LED strip yang addressable sehingga kita bisa membuat animasi yang menarik. 

LED Strip menurut saya adalah keajaiban, karena hanya dengan 1 pin data, kita bisa mengatur belasan, puluhan, bahkan ratusan LED. Bagaimana bisa?

Setiap led membutuhkan 24 bit data untuk menampilkan tampilan dengan warna tertentu,

formatnya adalah 8 bit pertama untuk green, 8 bit kedua untuk red, 8 bit ketiga untuk blue. Tata cara menerapkan bit tersebut adalah dengan membuat interval logika 0 dan 1 seperti berikut

Cukup pusing kan? Jangan khawatir, kita tidak perlu bermain bit-bit tersebut tapi cukup dengan menggunakan library NeoPixel yang disediakan oleh Adafruit.



Singkatnya, dengan menggunakan library neopixel kita cukup menentukan led berapa? dihidupkan dengan warna apa? seberapa terang?



berikut script dasarnya:

• Mengimport library dan mengkonfigurasi led strip yang digunakan

/* --------------------------------------------------
 * Import library neopixel
 */
#include <Adafruit_NeoPixel.h>

/* --------------------------------------------------
 * Membuat objek  led strip bernama "strip" untuk digunakan (nama bebas) 
 * dengan format: Adafruit_NeoPixel(jumlah_lednya, pin_arduino, NEO_GRB + NEO_KHZ800)
 */
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, 6, NEO_GRB + NEO_KHZ800);

• Mengaktifkan strip, agar dapat digunakan

strip.begin();

• Mengatur brightness / kecerahan

strip.setBrightness(nilai_kecerahan)

nilai kecerahan dimulai dari 0 - 255,

semakin besar semakin cerah

• Mendefinisikan warna (via RGB)

strip.Color(merah, hijau, biru);

nilai masing-masing warna: 0 - 255



Misalnya: (255, 0, 0) menghasilkan warna merah

(255, 255, 0) menghasilkan warna kuning (campuran merah + hijau)


Tips: Search di google dengan keywoard "Color picker", pilih warna, ambil nilai rgbnya

• Mendefinisikan warna (via HSV)

strip.ColorHSV(hue, saturation, value);
// atau cukup dengan
strip.ColorHSV(hue);

nilai hue = 0 - 65536 (atau lebar integer 16 bit)

nilai saturation = 0-255

nilai value = 0-255



HSV adalah salah satu alternatif RGB jika kita ingin mendapatkan warna berdasarkan slider spektrum warna HSV seperti  gambar dibawah

• Mengatur warna pada seluruh led

strip.fill(warna)

Misal: untuk mengatur warna kuning pada semua led jadi seperti berikut

strip.fill(strip.Color(255, 255, 0));

• Mengatur warna pada led tertentu

strip.setPixelColor(urutan_led, warnanya)

Urutan led dimulai dari 0, jadi untuk led ketiga ditulis 2



Misal: untuk mengatur warna biru pada led nomor 3 seperti berikut

strip.setPixelColor(2, strip.Color(0, 0, 255));

• Mematikan seluruh led

strip.clear();

• Menampilkan pengaturan warna pada led strip

strip.show();

Semua kode pengaturan diatas seperti fill(), setPixelColor(), clear() tidak akan ngefek pada led strip sebelum strip.show() dilakukan, maka biasanya strip.show() dituliskan setelah kode-kode tersebut.

• Mengambil jumlah led yang sudah dideklarasikan

strip.numPixels();

---

Meng-install Library

• Pastikan anda sudah menginstall Arduino
• masuk ke sketch > include library > manage library
• Pada search, ketikkan "Adafruit Neopixel"
• Pilih yang single-wire-based, Klik install

---

Bermain dengan warna



konfigurasi led strip yang saya gunakan pada kode dibawah adalah

menggunakan 60 led dengan pin DI di pin 6 arduino,

Atur wiringnya, jangan lupa menghubungkan VCC dan GND



Skenario 1

Menampilkan warna biru, kemudian jeda setengah detik, lalu menampilkan warna merah, jeda lagi setengah detik, kemudian ulang dari awal lagi.

/* --------------------------------------------------
 * Import library neopixel
 */
#include <Adafruit_NeoPixel.h>

/* --------------------------------------------------
 * Membuat objek led strip untuk digunakan 
 * dengan format: Adafruit_NeoPixel(jumlah_lednya, pin_arduino, NEO_GRB + NEO_KHZ800)
 */
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, 6, NEO_GRB + NEO_KHZ800);


/* --------------------------------------------------
 * memulai tampilan strip 
 * (dilakukan didalam setup karena strip.begin() cukup di lakukan sekali)
 */
void setup() {
    strip.begin(); // mengaktifkan led strip
    strip.show(); // menampilkan tampilan strip (karena belum ada settingan apapun jadi mati semua)
}

void loop() {
    strip.fill(strip.Color(0, 0, 255)); // Mengatur warna menjadi biru
    strip.show(); // Menampilkan settingan diatas pada led (apply)
    delay(500); // Jeda 1 detik
    strip.fill(strip.Color(255, 0, 0)); // Mengatur warna menjadi merah
    strip.show(); // Menampilkan settingan diatas pada led (apply)
    delay(500); // jeda 1 detik
}

Diatas, saya menggunakan strip.fill() untuk mengatur keseluruhan warna dan menampilkannya menggunakan strip.show(). cukup simple..



Hasilnya seperti berikut:

Skenario 2

Pada pengaturan warna, nilai warna tidak hanya bisa ditentukan lewat angka tetap, namun juga bisa ditentukan dari perulangan. Oleh karena itu, kita coba lakukan perulangan 0 sampai 255 dan diterapkan nilai tersebut ke nilai merah..

Hasilnya, kita mendapatkan efek fading warna merah karena kita mengatur warna merah dari 0 sampai 255 satu persatu menggunakan perulangan.



Berikut kodenya:

/* --------------------------------------------------
 * Import library neopixel
 */
#include <Adafruit_NeoPixel.h>

/* --------------------------------------------------
 * Membuat objek led strip untuk digunakan 
 * dengan format: Adafruit_NeoPixel(jumlah_lednya, pin_arduino, NEO_GRB + NEO_KHZ800)
 */
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, 6, NEO_GRB + NEO_KHZ800);


/* --------------------------------------------------
 * memulai tampilan strip 
 * (dilakukan didalam setup karena strip.begin() cukup di lakukan sekali)
 */
void setup() {
    strip.begin(); // mengaktifkan led strip
    strip.show(); // menampilkan tampilan strip (karena belum ada settingan apapun jadi mati semua)
}

void loop() {
  // Melakukan perulangan dari 0 sampai 255 yang tersimpan di variabel i
  for (int i = 0; i <= 255; i++) { 
    strip.fill(strip.Color(i, 0, 0)); // nilai tersebut dimasukkan ke dalam pengaturan warna merah
    strip.show(); // menampilkan hasil pengaturan warna
    delay(50); // kecepatan fade
  }
}

Pada kode diatas, saya melakukan perulangan menggunakan for() { isi_perulangan } mulai dari 0 sampai 255, disetiap perulangannya dilakukan pengaturan warna  kemudian ditampilkan dengan strip.show(), alhasil nilai warna merah bertambah 1 setiap 50 milidetik sampai nilai mencapai 255.



hasilnya seperti berikut:

Skenario 3

Dengan memanfaatkan ColorHSV, kita bisa menggeser warna berdasarkan spektrum hue menggunakan perulangan sehingga menjadi seperti efek pelangi yang tidak bergerak

/* --------------------------------------------------
 * Import library neopixel
 */
#include <Adafruit_NeoPixel.h>

/* --------------------------------------------------
 * Membuat objek led strip untuk digunakan 
 * dengan format: Adafruit_NeoPixel(jumlah_lednya, pin_arduino, NEO_GRB + NEO_KHZ800)
 */
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, 6, NEO_GRB + NEO_KHZ800);


/* --------------------------------------------------
 * memulai tampilan strip 
 * (dilakukan didalam setup karena strip.begin() cukup di lakukan sekali)
 */
void setup() {
    strip.begin(); // mengaktifkan led strip
    strip.show(); // menampilkan tampilan strip (karena belum ada settingan apapun jadi mati semua)
}

void loop() {
  // Melakukan perulangan dari 0 sampai 130 yang tersimpan di variabel i
  for (int i = 0; i < 130; i++) { 
    strip.fill(strip.ColorHSV(i*500)); // setiap perulangan dikali 500 (agar bisa mencapai 65000)
    strip.show(); // menampilkan hasil pengaturan warna
    delay(20); // kecepatan pergantian warna
  }
}

Color HSV mempunyai range nilai 0 - 65536, maka saya gunakan perulangan sampai 130 dan pengaturan warna menjadi i * 500 sehingga bisa mencapai nilai maksimal ke 65000, (130*500).



Sehingga hasilnya seperti berikut:

---

Membuat scrolling led berjalan



Anda sudah menguasai bagaimana teknik pemrograman untuk mengkonfigurasi warna LED, sekarang kita akan belajar bagaimana cara mensetting led secara individual. Dengan mensetting led secara individual kita bisa membuat efek-efek dan animasi yang jauh lebih menarik.



Skenario 1

Membuat led hidup satu persatu, kemudian mati satu persatu juga, lalu diulangi lagi.



Skenario tersebut dapat dilakukan menggunakan perulangan seperti contoh sebelumnya,

/* --------------------------------------------------
 * Import library neopixel
 */
#include <Adafruit_NeoPixel.h>

/* --------------------------------------------------
 * Membuat objek led strip untuk digunakan 
 * dengan format: Adafruit_NeoPixel(jumlah_lednya, pin_arduino, NEO_GRB + NEO_KHZ800)
 */
Adafruit_NeoPixel strip = Adafruit_NeoPixel(20, 6, NEO_GRB + NEO_KHZ800);


/* --------------------------------------------------
 * memulai tampilan strip 
 * (dilakukan didalam setup karena strip.begin() cukup di lakukan sekali)
 */
void setup() {
    strip.begin(); // mengaktifkan led strip
    strip.show(); // menampilkan tampilan strip (karena belum ada settingan apapun jadi mati semua)
}

void loop() {
  // Menghidupkan lampu LED
  for (int i = 0; i < strip.numPixels(); i++) { 
    strip.setPixelColor(i, strip.Color(0, 255, 0)); // Mensetting lampu urutan ke - i menjadi hijau
    strip.show(); // menampilkan hasil pengaturan warna
    delay(50); // kecepatan pergantian warna
  }
  // Mematikan lampu LED
  for (int i = 0; i < strip.numPixels(); i++) { 
    strip.setPixelColor(i, strip.Color(0, 0, 0)); // // Mensetting lampu urutan ke - i menjadi mati
    strip.show(); // menampilkan hasil pengaturan warna
    delay(50); // kecepatan pergantian warna
  }
}

Mirip dengan contoh sebelumnya, saya menggunakan perulangan dari 0 ke berapapun jumlah pixel yang anda setting ( strip.numPixel() )  dimana pada kasus ini bernilai 10, saya manfaatkan nilai i untuk men-setting led ke - i menjadi hijau.

Setelah selesai mengulang, saya lakukan perulangan yang sama namun dengan men-setting led ke - i menjadi mati



Hasilnya:

Anda juga bisa memutar balik perulangannya menjadi dari 10 ke 0 untuk mengganti arah scrolling lednya, berarti didalam loop kodenya seperti berikut ini:

// Menghidupkan lampu LED
for (int i = strip.numPixels(); i > 0; i--) { 
  strip.setPixelColor(i, strip.Color(0, 255, 0)); // Mensetting lampu urutan ke - i menjadi hijau
  strip.show(); // menampilkan hasil pengaturan warna
  delay(50); // kecepatan pergantian warna
}
// Mematikan lampu LED
for (int i = strip.numPixels(); i > 0; i--) { 
  strip.setPixelColor(i, strip.Color(0, 0, 0)); // // Mensetting lampu urutan ke - i menjadi mati
  strip.show(); // menampilkan hasil pengaturan warna
  delay(50); // kecepatan pergantian warna
}

Skenario 2

Membuat running led. Pada dasarnya sama dengan sebelumnya, tapi hidupnya satu per satu.



Logikanya cukup mudah,

dengan kode diatas, pada setiap perulangan, kita matikan lampu urutan ke i-1

/* --------------------------------------------------
 * Import library neopixel
 */
#include <Adafruit_NeoPixel.h>

/* --------------------------------------------------
 * Membuat objek led strip untuk digunakan 
 * dengan format: Adafruit_NeoPixel(jumlah_lednya, pin_arduino, NEO_GRB + NEO_KHZ800)
 */
Adafruit_NeoPixel strip = Adafruit_NeoPixel(20, 6, NEO_GRB + NEO_KHZ800);


/* --------------------------------------------------
 * memulai tampilan strip 
 * (dilakukan didalam setup karena strip.begin() cukup di lakukan sekali)
 */
void setup() {
    strip.begin(); // mengaktifkan led strip
    strip.show(); // menampilkan tampilan strip (karena belum ada settingan apapun jadi mati semua)
}

void loop() {
  for (int i = 0; i < strip.numPixels(); i++) { 
    strip.setPixelColor(i, strip.Color(0, 255, 0)); // Mensetting lampu urutan ke - i menjadi hijau
    strip.setPixelColor(i-1, strip.Color(0, 0, 0)); // Mematikan lampu pada urutan sebelumnya
    strip.show(); // menampilkan hasil pengaturan warna
  
    // Jika perulangan sudah sampai akhir, kita matikan lampu led terakhir tersebut agar tidak sisa
    if (i == strip.numPixels() - 1) {
      strip.setPixelColor(i, strip.Color(0, 0, 0));
    }
    delay(50); // kecepatan running led (jeda sebelum geser)
  }
}

Hasilnya :

Skenario 3

Membuat  pelangi berjalan

/* --------------------------------------------------
 * Import library neopixel
 */
#include <Adafruit_NeoPixel.h>

/* --------------------------------------------------
 * Membuat objek led strip untuk digunakan 
 * dengan format: Adafruit_NeoPixel(jumlah_lednya, pin_arduino, NEO_GRB + NEO_KHZ800)
 */
Adafruit_NeoPixel strip = Adafruit_NeoPixel(20, 6, NEO_GRB + NEO_KHZ800);


/* --------------------------------------------------
 * memulai tampilan strip 
 * (dilakukan didalam setup karena strip.begin() cukup di lakukan sekali)
 */
void setup() {
    strip.begin(); // mengaktifkan led strip
    strip.show(); // menampilkan tampilan strip (karena belum ada settingan apapun jadi mati semua)
}

void loop() {
  for(int8_t shift = 0; shift <= 450; shift++) {
    for(int8_t led = 0; led < strip.numPixels(); led++) {
      strip.setPixelColor(led, strip.ColorHSV((led*1000 + (shift*500))));
    }
    delay(10); // kecepatan scrolling
    strip.show();
  }
}

Lupa saya gan algoritmanya, wkwkwk.. intinya dengan mengambil range tertentu di pita warna HSV, kemudian range tersebut digeser sehingga membentuk warna yang "berjalan" diatas pita warna HSV.



jadinya seperti berikut:

---

Kesimpulan



Jika anda menguasai semua dasar pemrograman diatas, anda dengan mudah dapat membuat variasi animasi dan efek led sesuai dengan keinginan anda sendiri.



led strip ini bisa digunakan untuk menghias apa saja, misalnya, pada PC anda tidak ada fitur RGB pada motherboard, anda bisa buat dan dikontrol lewat PC. selain itu, bahkan kucing anda bisa saja anda buatkan kalung RGB agar terlihat seperti kucing modern.

Kalau tanya bisa di:
IG : @badar.wildanie (bantu follow lah, cuma sedikit hehe)
WA : 082228 111 059

ya itu aja, hehe.

selamat berkreasi..