Coding Blok Arduino: LED Berkedip dengan Blok dan C++ Berdampingan

Dengan coding blok Arduino, program pertama hampir selalu sama: membuat LED berkedip. Di tulisan ini kita mengerjakannya dari awal sampai akhir. Kita menghubungkan LED ke pin 9 lewat resistor 220 Ω, membaca blok proyek LED Berkedip di BlueGrays satu per satu, dan melihat secara berdampingan setiap blok berubah menjadi baris mana di kode C++ yang di-upload ke board. Kamu juga akan mencoba mengubah satu angka saja, yaitu 100 di blok “tunggu 100 ms”, untuk mengatur seberapa cepat LED berkedip.

Kita tidak berhenti di satu LED. Logika yang sama akan kita kembangkan langkah demi langkah menjadi program yang menyalakan dua LED bergantian, berperilaku seperti lampu lalu lintas, dan berkedip seperti lampu polisi. Setelah itu kamu akan melihat ide yang sama di ESP32 dan di Raspberry Pi Pico dengan MicroPython. Di bagian akhir ada tabel kesalahan yang hampir pasti pernah dilakukan setiap pemula. Semua proyek di tulisan ini gratis di BlueGrays, lengkap dengan blok dan kodenya, dan kamu bisa menjelajahi semua proyek yang punya versi blok per platform di halaman coding blok.

Apa saja yang kamu butuhkan?

Rangkaian: menghubungkan LED ke pin 9

LED punya dua kaki, dan arahnya penting. Kaki panjang adalah anoda (+) dan kaki pendek adalah katoda (-); di sisi katoda, badan plastik LED punya bagian yang rata. Arus hanya mengalir dari anoda ke katoda, jadi kalau LED-nya terpasang terbalik, tidak ada yang terjadi. Hubungkan pin 9 Arduino ke salah satu ujung resistor 220 Ω, lalu ujung resistor yang lain ke kaki panjang LED. Setelah itu sambungkan kaki pendeknya ke GND. Resistor membatasi arus: kurangi 5 V dengan sekitar 2 V yang dibutuhkan LED merah, maka tersisa 3 V di resistor, dan 3 V / 220 Ω kira-kira 14 mA. Arus ini nyaman untuk LED dan aman untuk pin Arduino. Kamu bisa mengecek nilai untuk warna LED-mu sendiri dengan kalkulator resistor LED. Cara kerja LED dibahas di Apa Itu LED?, dan cara baris breadboard terhubung di bagian dalamnya di Apa Itu Breadboard?.

Program pertamamu dalam blok: LED Berkedip

Kalau rangkaiannya sudah siap, ayo lihat programnya. Buka proyek LED Berkedip di BlueGrays dan nyalakan Tampilkan sebagai blok di bagian kode, maka kamu akan melihat blok di bawah ini. Totalnya ada tujuh blok, terbagi dalam dua kelompok besar: setup (jalan sekali) di atas dan ulangi selamanya di bawahnya. Blok tampil dalam bahasa aplikasi: kalau aplikasimu berbahasa Indonesia, blok itu berbunyi “tulis HIGH ke pin”, sedangkan dalam bahasa Inggris blok yang sama bertuliskan “write HIGH to pin”.

Blok di dalam setup (jalan sekali) hanya berjalan satu kali, yaitu ketika board menyala atau ketika kamu menekan reset. Di sini cuma ada satu blok: “atur pin 9 sebagai OUTPUT”. Pin digital Arduino bisa menjadi input atau output. Karena kita akan mengendalikan LED, kita memberi tahu board, “Aku akan mengeluarkan listrik dari pin ini.” Kelompok ulangi selamanya mulai berjalan setelah setup selesai, dari atas ke bawah, berulang-ulang selama board menyala. Empat bloknya menyalakan LED, menunggu 100 milidetik, mematikannya, lalu menunggu 100 milidetik lagi. Setelah blok terakhir, program melompat kembali ke atas dan LED menyala lagi. Yang kita sebut berkedip sebenarnya hanyalah empat langkah ini yang berulang lima kali dalam satu detik.

Blok → baris C++: setiap blok menjadi apa?

1// Led Yakma (proje 1): D9'daki LED 100 ms yanar, 100 ms söner
2// LED Blink (project 1): the LED on D9 is on for 100 ms, off for 100 ms
3void setup() {
4  pinMode(9,OUTPUT);     // LED pini çıkış / LED pin as output
5}
6
7void loop() {
8  digitalWrite(9,HIGH);  // LED'i yak / turn the LED on
9  delay(100);            // 100 ms bekle (1000 ms = 1 s) / wait 100 ms (1000 ms = 1 s)
10  digitalWrite(9,LOW);   // LED'i söndür / turn the LED off
11  delay(100);            // 100 ms bekle / wait 100 ms
12}
13

Letakkan tabel ini di samping kode dan kamu bisa melihat apa saja yang diurus blok untukmu. Bentuk kelompok setup dan ulangi selamanya sesuai dengan kurung kurawal fungsi void setup() dan void loop(): kelompok tempat sebuah blok berada menentukan di dalam pasangan kurung kurawal mana barisnya ditulis. Dengan blok, kamu tidak perlu memikirkan titik koma di akhir setiap perintah, huruf besar-kecil (pinMode, digitalWrite), atau tanda kurung. Tapi begitu kamu mulai mengedit kodenya sendiri di Arduino IDE, semua itu jadi penting; satu titik koma yang hilang saja sudah cukup untuk memicu error kompilasi. Itulah manfaat sebenarnya dari blok: kamu memahami logika program lebih dulu, lalu belajar bagaimana logika yang sama ditulis dalam kode.

Apa yang terjadi kalau kamu mengubah “tunggu 100 ms”?

Waktu tunggu dihitung dalam milidetik (ms), dan 1000 ms sama dengan satu detik. Kedua blok tunggu di proyek ini bernilai 100 ms, jadi LED menyala selama 0,1 detik dan mati selama 0,1 detik. Satu siklus penuh berlangsung 200 ms, artinya LED berkedip lima kali per detik. Perbesar angka di kedua blok dan LED melambat; perkecil dan LED makin cepat. Di bawah batas tertentu, matamu tidak bisa lagi membedakan kedipannya dan LED terlihat seperti menyala terus. Tabel ini menunjukkan apa yang akan kamu lihat ketika mengubah kedua waktu tunggu:

Mengembangkan program: dua LED, lampu lalu lintas, lampu polisi

Begitu kamu bisa membuat satu LED berkedip, kamu tidak butuh hal baru untuk mengendalikan beberapa LED; kamu cukup mengulang tiga blok yang sama dengan pin yang berbeda. Di proyek Dua LED Berkedip Bergantian, dua pin dijadikan output di setup: 8 dan 9. Di dalam ulangi selamanya ada “tulis HIGH ke pin 8” dan “tulis LOW ke pin 9”, lalu “tunggu 200 ms”. Kemudian ditulis kebalikannya dan program menunggu 200 ms lagi. Triknya, kedua blok tulis berjalan berurutan tanpa jeda di antaranya, jadi kedua LED tampak bertukar bersamaan. Blok tunggu menentukan berapa lama setiap keadaan bertahan.

Proyek Lampu Lalu Lintas membawa ide yang sama ke tiga LED: merah di D2, kuning di D3, hijau di D4. Kelompok ulangi selamanya punya empat fase, dan setiap fase mengikuti pola yang sama: satu blok tulis HIGH atau tulis LOW untuk masing-masing dari tiga LED, lalu satu blok tunggu. Blok tulis menentukan LED mana yang tetap menyala, dan blok tunggu menentukan berapa lama. Blok yang lebih banyak tidak membuatnya lebih sulit, hanya lebih panjang. Versi yang lebih mirip persimpangan sungguhan, dengan tombol penyeberang jalan, ada di tulisan Lampu Lalu Lintas Arduino.

1// Trafik Lambası (proje 3) / Traffic Light (project 3)
2void setup() {
3  pinMode(2,OUTPUT);    // Kırmızı / Red
4  pinMode(3,OUTPUT);    // Sarı / Yellow
5  pinMode(4,OUTPUT);    // Yeşil / Green
6}
7
8void loop() {
9  // Kırmızı yanar, 2 s bekle / Red on, wait 2 s
10  digitalWrite(2,HIGH);
11  digitalWrite(3,LOW);
12  digitalWrite(4,LOW);
13  delay(2000);
14  // Sarı yanar, 0,3 s bekle / Yellow on, wait 0.3 s
15  digitalWrite(2,LOW);
16  digitalWrite(3,HIGH);
17  digitalWrite(4,LOW);
18  delay(300);
19  // Yeşil yanar, 2 s bekle / Green on, wait 2 s
20  digitalWrite(2,LOW);
21  digitalWrite(3,LOW);
22  digitalWrite(4,HIGH);
23  delay(2000);
24  // Sarı yanar, sonra başa (kırmızıya) dön / Yellow on, then back to red
25  digitalWrite(2,LOW);
26  digitalWrite(3,HIGH);
27  digitalWrite(4,LOW);
28  delay(300);
29}
30

Proyek Lampu Polisi LED memperkenalkan dua jenis blok baru. Yang pertama adalah kelompok variabel global (paling atas) dengan blok “deklarasikan bilangan bulat (int) delayTime = 60” di dalamnya. Itu adalah baris int delayTime = 60; di kode, dan blok ini memberi nama pada waktu kedip. Karena blok tunggu memakai delayTime alih-alih angka, kamu cukup mengubah angka 60 untuk mengatur kecepatannya, bukan empat blok terpisah. Yang kedua adalah blok hijau “ulangi 3 kali”; blok ini menjalankan empat blok di dalamnya tiga kali dan menjadi perulangan for(int i=0;i<3;i++) di C++.

Ayo berhitung: pada setiap kedipan, LED merah menyala 60 ms dan mati 60 ms, jadi satu kedipan butuh 120 ms. Tiga kedipan menjadi 360 ms, dan hal yang sama berlaku untuk LED biru. Satu siklus penuh berlangsung sekitar 0,7 detik. Atur delayTime ke 30 dan lampunya berkedip dua kali lebih cepat; atur ke 120 dan lampunya melambat. Variabel dan perulangan adalah topik bagian 4 dari seri ini, dan kita membahasnya secara rinci di perulangan dan variabel di coding blok. Proyek LED Berjalan, yang menjalankan cahaya di sepanjang deretan LED, adalah langkah berikutnya di jalur yang sama.

Ide yang sama di ESP32 dan Raspberry Pi Pico

Di ESP32, bloknya hampir sama persis dengan blok Arduino, karena ESP32 juga diprogram dalam C++ dengan Arduino IDE. Di proyek LED Berkedip dengan ESP32, LED terhubung ke GPIO 5 dan blok tunggunya 500 ms. Baris kodenya juga sama: pinMode(5, OUTPUT); digitalWrite(5, HIGH); delay(500);. Perbedaannya hanya nomor pin, pin ESP32 yang mengeluarkan 3,3 V, dan pemilihan board ESP32 di Arduino IDE. Semua yang kamu pelajari di Uno bisa langsung dibawa ke ESP32.

Di proyek Raspberry Pi Pico, blok berubah menjadi kode MicroPython dan nama bloknya sedikit berbeda. Di proyek LED eksternal Pico, LED terhubung ke GP14. Blok “pin led : GP LED_PIN, OUTPUT” sesuai dengan led = Pin(LED_PIN, Pin.OUT), “nyalakan (on) pin led” sesuai dengan led.on(), “tunggu 0.5 detik” sesuai dengan time.sleep(0.5), dan ulangi selamanya sesuai dengan perulangan while True:. Perhatikan bahwa di MicroPython waktu tunggu dihitung dalam detik, bukan milidetik; delay(500) di Arduino menjadi time.sleep(0.5). Kalau kamu ingin mencobanya tanpa kabel sama sekali, proyek LED bawaan Pico menyalakan LED di GP25 yang ada di board itu sendiri; di Pico W, LED bawaan diakses dengan nama “LED”, bukan GP25.

1# Pico harici LED (proje 8163), seri port satırları çıkarıldı
2# Pico external LED (project 8163), serial print lines removed
3from machine import Pin
4import time
5
6LED_PIN = 14                    # GP14, herhangi bir boş GPIO / any free GPIO
7led = Pin(LED_PIN, Pin.OUT)     # pini çıkış yap / set the pin as output
8
9while True:                     # sürekli tekrarla / loop forever
10    led.on()                    # LED'i yak / turn the LED on
11    time.sleep(0.5)             # 0,5 saniye bekle / wait 0.5 s
12    led.off()                   # LED'i söndür / turn the LED off
13    time.sleep(0.5)
14

Kesalahan umum dan cara memperbaikinya

Langkah demi langkah di aplikasi: dari blok ke board

1. Di BlueGrays, buka proyek LED Berkedip, yang punya lencana blok di daftar proyek. Kamu juga bisa memakai filter supaya hanya proyek dengan blok yang ditampilkan.
2. Ikuti skema rangkaian dan pasang LED, resistor 220 Ω, dan dua kabel di breadboard.
3. Di bagian kode, nyalakan Tampilkan sebagai blok. Blok menggantikan kode; ketuk gambarnya untuk membukanya layar penuh.
4. Buka tab Pahami blok. Program dijelaskan langkah demi langkah, dan setiap langkah hanya menampilkan bloknya sendiri beserta fungsinya.
5. Matikan sakelarnya untuk kembali ke kode asli, salin kodenya, lalu tempel ke Arduino IDE. Blok tidak di-upload langsung ke board; yang masuk ke board selalu kode ini.
6. Di Arduino IDE, pilih Arduino Uno sebagai board, pilih port yang benar, lalu tekan Upload. Kalau kamu belum menginstal IDE-nya, tulisan Cara Instal Arduino IDE 2 memandumu langkah demi langkah.
7. Begitu LED berkedip, ubah kedua baris delay(100) menjadi delay(1000), upload lagi, dan lihat sendiri perbedaannya.

Di tulisan ini LED selalu berkedip dengan ritme yang sama; program tidak pernah mendengarkan dunia luar. Langkah berikutnya adalah membiarkan board mengambil keputusan: bagian 3 dari seri ini, blok jika (if) dengan tombol, membahas program yang menyalakan LED ketika kamu menekan tombol dan bagaimana blok “jika” berubah menjadi if/else di C++.

Di aplikasi BlueGrays kamu bisa melihat LED Berkedip, Dua LED Berkedip Bergantian, Lampu Lalu Lintas, Lampu Polisi LED, serta proyek LED untuk ESP32 dan Pico lengkap dengan skema rangkaian dan kodenya, beralih ke versi blok dari program yang sama dengan Tampilkan sebagai blok, dan membaca fungsi setiap langkah dengan Pahami blok.