Perulangan dan Variabel di Coding Blok: for dan Array di Arduino

Perulangan dan variabel di coding blok adalah dua bahan dasar yang mengubah program dari “lakukan ini sekali” menjadi “terus lakukan ini, dan lakukan dengan cerdas”. Perulangan menjalankan blok yang sama berulang-ulang, dan variabel mengingat sebuah angka selama pengulangan itu berlangsung. Di blok BlueGrays, keduanya muncul sebagai “ulangi selamanya”, “hitung dengan i”, “variabel global (paling atas)”, dan “atur … ke”; di kode Arduino yang di-upload ke board, pasangannya adalah loop(), perulangan for, variabel int, dan baris penugasan.

Di bagian ini kita membaca blok dari empat proyek gratis berdampingan dengan kode C++ aslinya: LED Berjalan, yang menyalakan enam LED satu demi satu; LED Berjalan dengan Kecepatan yang Bisa Diatur, yang mengambil kecepatannya dari potensiometer; Efek LED Knight Rider, yang mengirim cahaya dari satu ujung ke ujung lain lalu kembali; dan versi potensiometernya, Efek LED Knight Rider dengan Kecepatan yang Bisa Diatur. Keempatnya memakai rangkaian yang sama: enam LED di pin D2–D7 dan satu potensiometer di A0. Di akhir, kamu akan menulis contoh penghitungmu sendiri dan membahas tiga kesalahan yang paling sering dilakukan pemula: menghitung kelebihan atau kekurangan satu, melewati ujung array, dan waktu tunggu panjang yang membuat tombol jadi “buta”.

Blok “ulangi selamanya” dan loop(): kenapa board tidak pernah berhenti?

Program di komputermu ditutup begitu tugasnya selesai; program di Arduino tidak. Board tidak punya sistem operasi, dan prosesornya tidak punya pekerjaan lain. Itulah sebabnya setiap proyek blok punya kerangka yang sama: apa pun yang ada di dalam “setup (jalan sekali)” berjalan satu kali ketika board menyala atau tombol reset ditekan, dan apa pun yang ada di dalam “ulangi selamanya” berulang dari atas ke bawah tanpa henti. Di sisi C++, keduanya adalah fungsi setup() dan loop(). Begitu baris terakhir loop() selesai, board langsung melompat kembali ke baris pertama; loop() pendek tanpa waktu tunggu bisa berjalan puluhan ribu kali per detik. Satu-satunya cara menghentikan board adalah memutus dayanya atau meng-upload program baru. Pengulangan tanpa akhir ini bukan cacat, melainkan memang begitu rancangannya: membaca tombol, memantau sensor, dan mengedipkan LED semuanya dikerjakan ulang di setiap putaran, sehingga board terus bereaksi terhadap perubahan di sekitarnya.

Variabel di coding blok: variabel global dan blok deklarasi

Variabel adalah kotak kecil tempat kamu menaruh angka dan memanggilnya dengan namanya. Di blok, variabel dibuat di dalam blok ungu “variabel global (paling atas)”. Blok “deklarasikan bilangan bulat (int) potValue = 0” di dalamnya menjadi baris int potValue di kode: int adalah tipenya, potValue namanya, dan 0 nilai awalnya. “Paling atas” itu penting: baris-baris ini berada di bagian paling atas file, di luar setup() dan loop(). Variabel global yang dideklarasikan seperti ini bisa dilihat dari mana saja di program dan tidak kehilangan nilainya setiap kali loop() mulai lagi. Di Arduino Uno, int berukuran 2 byte dan menyimpan bilangan bulat dari -32768 sampai 32767, lebih dari cukup untuk rentang 0–1023 dari analogRead() dan untuk nomor pin. Mungkin kamu memperhatikan bahwa blok proyek LED Berjalan dengan Kecepatan yang Bisa Diatur bertuliskan potValue = 0, sedangkan kodenya hanya bertuliskan int potValue;. Hasil keduanya sama: di C++, variabel global tanpa nilai awal dimulai dari nol.

Blok yang mengubah variabel di kemudian hari adalah “atur … ke”. Blok “atur potValue ke baca analog A0” berubah menjadi potValue = analogRead(A0); di kode. Tanda = di sini bukan kesamaan seperti di matematika; artinya “hitung nilai di sebelah kanan dan masukkan ke kotak di sebelah kiri”. Perbandingan yang menanyakan apakah dua nilai sama ditulis dengan == di C++, seperti yang kita lihat bersama blok jika di bagian sebelumnya dari seri ini. Ketika blok atur berjalan, nilai lama di kotak dihapus dan nilai baru ditulis. Setiap blok yang membaca variabel itu sekarang memakai nilai baru tersebut: “tunggu potValue ms” menunggu selama berapa pun milidetik yang tersimpan di potValue pada momen itu.

Perulangan hitung: blok “hitung dengan i” dan perulangan for Arduino

Untuk mengulang sesuatu sebanyak jumlah tertentu, kamu memakai blok hijau “hitung dengan i dari 0 sampai 5 per 1”. Blok ini membuat penghitung bernama i, mengisinya dengan 0, menjalankan blok di dalamnya, lalu menambahkan 1 ke i dan menjalankannya lagi, dan terus begitu sampai i melewati 5. Padanannya di Arduino adalah baris for (int i = 0; i < 6; i++). Di dalam tanda kurung ada tiga bagian yang dipisahkan titik koma: awal (int i = 0), syarat untuk terus berjalan (i < 6), dan langkah yang dilakukan setelah setiap putaran (i++, artinya tambahkan satu ke i). Hal terpenting yang perlu diperhatikan: nilai akhir di blok ikut dihitung. “Dari 0 sampai 5” berarti 0, 1, 2, 3, 4, dan 5, jadi perulangan berjalan 6 kali, bukan 5, dan masing-masing dari enam LED mendapat satu putaran. Itulah sebabnya kodenya bertuliskan i < 6, yang artinya sama dengan i <= 5. Pola “mulai dari nol, terus selama lebih kecil dari jumlah item” sangat umum di kode Arduino karena angka 6 langsung memberi tahu jumlah LED-nya.

Blok array: “array 2 3 4 5 6 7” dan ledPins[i]

Daripada mendeklarasikan enam variabel terpisah untuk enam LED, kamu bisa menyimpan semuanya dalam satu daftar. Ketika blok ungu “array 2 3 4 5 6 7” dipasang ke “deklarasikan bilangan bulat (int) ledPins = …”, blok itu menjadi baris int ledPins[] = {2, 3, 4, 5, 6, 7}; di kode. Kurung siku menandakan bahwa itu array, dan kurung kurawal berisi nilai-nilainya. Kamu mengakses sebuah elemen lewat nomor posisinya, yaitu indeks, dan di C++ indeks dimulai dari 0: elemen pertama adalah ledPins[0] dan yang terakhir ledPins[5]. Di blok, ini dilakukan oleh “item i dari ledPins”, yang berubah menjadi ledPins[i]. Karena perulangan hitung juga dimulai dari 0, keduanya cocok sekali: di setiap putaran, i memberi indeks berikutnya dan ledPins[i] memberi nomor pin yang tersimpan di sana. Kelebihan lain dari array: untuk mengubah urutan LED, kamu cukup menukar angka-angka di daftar tanpa menyentuh perulangannya. Untuk penjelasan lebih lengkap tentang array, lihat array di Arduino.

LED berjalan: blok dan C++ baris demi baris

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2
3void setup() {
4  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
5  for(int i = 0; i < 6; i++) {
6    pinMode(ledPins[i], OUTPUT);
7  }
8}
9
10void loop() {
11  // Her LED'i sırayla 150 ms yak / Light each LED in turn for 150 ms
12  for(int i = 0; i < 6; i++) {
13    digitalWrite(ledPins[i], HIGH);
14    delay(150);
15    digitalWrite(ledPins[i], LOW);
16  }
17}

Bayangkan program sebagai sebuah garis waktu. Ketika board mulai, perulangan di setup menjadikan keenam pin output satu per satu dari 0 sampai 5, dan itu tidak pernah terjadi lagi. Lalu ulangi selamanya dimulai: perulangan hitung di dalamnya menyalakan LED di D2, menunggu 150 ms, mematikannya, lalu melakukan hal yang sama untuk D3, D4, D5, D6, dan D7. Satu putaran butuh 6 × 150 = 900 ms. Ketika LED terakhir mati, loop() selesai, board langsung melompat kembali ke atas, dan cahaya mulai lagi dari D2; karena tidak ada jeda antarputaran, cahayanya seolah mengalir tanpa henti. Untuk mengubah kecepatan, kamu cukup mengganti satu angka, yaitu 150: tulis 50 dan cahayanya berlari tiga kali lebih cepat, tulis 500 dan cahayanya berjalan santai. Membuat kecepatan tetap itu bisa diatur dengan kenop membawa kita ke proyek berikutnya.

LED berjalan dengan kecepatan yang bisa diatur: nilai potensiometer menjadi waktu tunggu

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2int potValue;                         // Pot değeri = bekleme (ms) / Pot value = delay (ms)
3
4void setup() {
5  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
6  for(int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for(int i = 0; i < 6; i++) {
13    potValue = analogRead(A0);        // Hızı oku (0-1023) / Read the speed (0-1023)
14    digitalWrite(ledPins[i], HIGH);
15    delay(potValue);                  // Pot değeri kadar ms bekle / Wait as many ms as the pot value
16    digitalWrite(ledPins[i], LOW);
17  }
18}

Satu-satunya perbedaan dari LED berjalan adalah dua blok baru. “deklarasikan bilangan bulat (int) potValue = 0” ditambahkan ke variabel global, dan perulangan hitung diawali dengan blok “atur potValue ke baca analog A0”. analogRead(A0) mengubah tegangan di pin tengah potensiometer menjadi angka dari 0 sampai 1023; angka itu langsung masuk ke “tunggu potValue ms”, dengan kata lain baris delay(potValue). Putar kenop ke satu ujung dan setiap LED menyala sekitar satu detik (1023 ms), jadi satu putaran butuh kira-kira 6 detik; putar ke ujung lain dan waktu tunggunya turun ke 0, lalu LED berganti begitu cepat sampai semuanya tampak menyala redup bersamaan. Membaca potensiometer di dalam perulangan, sebelum setiap LED, adalah pilihan yang disengaja: LED berikutnya langsung memakai kecepatan baru begitu kamu memutar kenop, jadi kamu tidak perlu menunggu putaran selesai. Cara kerja potensiometer bisa kamu pelajari di Apa Itu Potensiometer?.

Knight Rider: dua perulangan yang menghitung maju dan mundur

Pada efek Knight Rider, cahaya bergerak dari satu ujung ke ujung lain lalu kembali. Blok proyek Efek LED Knight Rider punya dua perulangan hitung yang tersusun atas-bawah di dalam ulangi selamanya. Yang pertama adalah “hitung dengan i dari 0 sampai 5 per 1” yang sudah kamu kenal, dan menggerakkan cahaya dari D2 ke D7. Yang kedua adalah “hitung dengan i dari 4 sampai 1 per 1”: karena nilai awalnya lebih besar dari nilai akhirnya, blok menghitung mundur dan i menjadi 4, 3, 2, 1. Di kode, ini adalah baris for(int i = 4; i > 0; i--); i-- mengurangi satu dari i. Kenapa dari 4 sampai 1 dan bukan dari 5 sampai 0? Karena ledPins[5] (D7) sudah menyala di akhir putaran maju dan ledPins[0] (D2) di awal putaran berikutnya. Melewatkan kedua ujung di perjalanan balik mencegah LED di ujung menyala dua kali berturut-turut, sehingga pantulannya terlihat mulus. Satu kali pergi-pulang adalah 6 + 4 = 10 langkah, masing-masing 100 ms, total 1 detik. Efek LED Knight Rider dengan Kecepatan yang Bisa Diatur memakai dua perulangan yang sama; bedanya hanya ada blok “atur potValue ke baca analog A0” di awal kedua perulangan, dan yang dipakai adalah “tunggu potValue ms” sebagai ganti 100 ms. Untuk pola lainnya, lihat LED berjalan Knight Rider.

Contoh penghitungmu sendiri: penghitung putaran dan port serial

Sekarang ayo tulis contoh kecil yang menggabungkan semuanya: setiap kali LED berjalan menyelesaikan satu putaran, sebuah penghitung bertambah, dan board mencetak nilai-nilai i serta jumlah putaran ke komputer. Dengan blok dari gambar-gambar tadi, kamu menyusunnya seperti ini: di bawah array ledPins di variabel global, tambahkan “deklarasikan bilangan bulat (int) rounds = 0”. Setup mendapat blok “mulai serial di 9600 baud”. Di dalam perulangan hitung, sebelum LED menyala, blok “cetak serial” mencetak teks “i = ”, lalu i, lalu teks “ pin = ” dengan opsi “tanpa pindah baris”, dan terakhir “item i dari ledPins” dengan opsi “baris baru”. Setelah perulangan hitung, masih di dalam ulangi selamanya, blok “atur rounds ke …” menerima hasil penjumlahan rounds + 1, dan jumlah putaran dicetak dengan “cetak serial … baris baru”.

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri / LED pins
2int rounds = 0;                       // tamamlanan tur sayısı / number of finished rounds
3
4void setup() {
5  Serial.begin(9600);                 // seri port 9600 baud / serial port at 9600 baud
6  for (int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for (int i = 0; i < 6; i++) {
13    Serial.print("i = ");             // aynı satırda kal / stay on the same line
14    Serial.print(i);
15    Serial.print("  pin = ");
16    Serial.println(ledPins[i]);       // alt satıra geç / new line
17    digitalWrite(ledPins[i], HIGH);
18    delay(300);
19    digitalWrite(ledPins[i], LOW);
20  }
21  rounds = rounds + 1;                // sayacı bir artır / add one to the counter
22  Serial.print("Tur / Round: ");
23  Serial.println(rounds);
24}

Setelah meng-upload, buka Serial Monitor di Arduino IDE dan atur ke 9600 baud. Di setiap putaran kamu akan melihat enam baris, dari “i = 0 pin = 2” sampai “i = 5 pin = 7”, diikuti baris “Tur / Round” yang menghitung 1, 2, 3. Keluaran ini adalah bukti paling jelas bahwa nilai akhir blok hitung ikut dihitung: “dari 0 sampai 5” menghasilkan tepat enam nilai. Perhatikan juga bahwa rounds dideklarasikan di variabel global; nilainya tidak kembali ke nol setiap kali loop() mulai, jadi nilainya terbawa dari putaran ke putaran. Satu putaran butuh 6 × 300 = 1,8 detik, jadi batas int 32767 tercapai setelah kira-kira 16 jam; kalau kamu perlu menghitung lebih lama, jadikan variabelnya unsigned long. Penjelasan lebih lanjut tentang Serial Monitor ada di Serial Monitor Arduino.

Rangkaian: 6 LED, resistor 220 Ω, dan potensiometer

Resistor 220 Ω mengalirkan sekitar (5 − 2) / 220 ≈ 14 mA melalui LED merah yang diberi daya 5 V, dan nilai ini aman untuk LED maupun pin Arduino. Kalau kamu memakai LED warna lain, cek resistornya dengan kalkulator resistor LED. Kumpulkan semua katoda di jalur GND breadboard dan hubungkan jalur itu ke pin GND Arduino. Kalau kaki luar potensiometer tertukar, tidak ada yang rusak; hanya arah putaran kenopnya yang terbalik. Proyek LED berjalan dan Knight Rider tidak memakai potensiometer, dan membiarkannya tetap terpasang tidak masalah, jadi kamu bisa mencoba keempat proyek di rangkaian yang sama secara bergantian.

Kesalahan umum pada perulangan dan variabel

Menjelajahi blok perulangan dan variabel di aplikasi BlueGrays

Empat proyek di tulisan ini dan proyek-proyek di bawah sepenuhnya gratis di aplikasi BlueGrays, baik bloknya maupun kodenya. Di bagian kode sebuah proyek, nyalakan sakelar Tampilkan sebagai blok, maka kode diganti dengan blok dari program yang sama; ketuk gambarnya untuk membukanya dalam layar penuh dan memperbesar perulangan hitung yang panjang dengan nyaman. Tab Pahami blok memandumu menelusuri program langkah demi langkah, dan hanya menampilkan blok untuk langkah itu beserta fungsinya. Proyek gratis lain yang layak dilihat dalam bentuk blok: Lampu Polisi LED, yang berjalan dengan variabel delayTime dan dua perulangan hitung; Lampu Lalu Lintas, yang melangkah melalui empat keadaan di dalam ulangi selamanya; Mengukur Intensitas Cahaya dengan LDR, yang menyimpan hasil bacaannya di variabel dan mencetaknya ke port serial; dan Nyala/Mati LED dengan Tombol (On/Off), yang mengingat status LED di sebuah variabel. Setiap contoh Arduino di Panduan kode juga ditampilkan dalam bentuk blok, dan Soal harian membantumu memperkuat apa yang sudah kamu pelajari dengan 5 soal sehari dari A1 sampai C2. Daftar lengkap proyek blok ada di halaman coding blok. Blok tidak di-upload langsung ke board; board selalu menerima kode asli proyeknya, jadi kamu menyalin program yang sudah kamu pahami lewat blok ke Arduino IDE lalu mengirimnya ke board-mu.

Sekarang setelah kamu memahami perulangan dan variabel, langkah berikutnya adalah mengambil angka-angka itu dari dunia nyata: di bagian 5 seri ini kita membahas membaca sensor dengan blok, port serial, dan beralih dari coding blok ke MicroPython di Pico. Sambil menunggu, kamu bisa melihat LED berjalan, Knight Rider, dan versi kecepatan yang bisa diatur dari keduanya di aplikasi BlueGrays lengkap dengan skema rangkaian dan kodenya, beralih ke blok dengan Tampilkan sebagai blok dan ke penjelasan langkah demi langkah dengan Pahami blok, lalu menelusuri sendiri baris kode mana yang cocok dengan setiap perulangan hitung.