Dasar · 10 mnt baca

Array di Arduino: Deklarasi, Perulangan for, dan Contoh Praktis

Cara memakai array di Arduino langkah demi langkah: deklarasi, indeks, perulangan for, array dua dimensi, pin LED, rata-rata sensor (moving average), dan contoh melodi.

Memakai array di Arduino adalah keterampilan pemrograman dasar yang memungkinkanmu mengelompokkan banyak nilai bertipe sama di bawah satu nama dan menjangkau masing-masing lewat nomornya (indeks). Daripada menulis nomor pin enam LED, sepuluh pembacaan sensor terakhir, atau nada sebuah lagu ke variabel terpisah seperti led1, led2, led3, kamu menyimpannya dalam satu array dan memproses semuanya hanya dengan beberapa baris memakai perulangan for. Kodemu jadi lebih pendek, kesalahan berkurang, dan menambah LED baru ke rangkaian cukup dengan menambahkan satu angka ke daftar.

Di panduan ini kamu akan belajar bagaimana array tersimpan di memori, cara mendeklarasikannya, kenapa indeks dimulai dari nol, dan cara menghitung jumlah elemen dengan sizeof. Lalu kita akan membuat tiga contoh nyata: efek LED Knight Rider, moving average (rata-rata bergerak) yang menghaluskan data sensor yang berisik, dan memutar melodi dengan buzzer. Terakhir, kamu akan membuat tabel status lampu lalu lintas dengan array dua dimensi, melihat perbedaannya di ESP32 dan Raspberry Pi Pico, dan mempelajari cara menangkap bug overflow yang diam-diam merusak programmu. Kalau kamu benar-benar baru di topik ini, lihat dulu dasar pemrograman Arduino.

LED yang dipakai di contoh array Arduino
Mengatur enam LED dengan satu array pin, bukan satu per satu, adalah penggunaan array yang paling klasik.

Apa itu array dan bagaimana cara kerjanya?

Array adalah sekumpulan elemen bertipe data sama yang tersusun berdampingan di memori. Bayangkan sebuah lemari dengan laci-laci bernomor: lemarinya punya satu nama, dan setiap laci punya nomor. Di bahasa Arduino yang berbasis C dan C++, penomoran ini dimulai dari 0; array dengan 5 elemen punya indeks 0, 1, 2, 3, dan 4, jadi indeks terakhir selalu satu lebih kecil dari jumlah elemen. Compiler tahu alamat awal array; ketika kamu menulis array[3], compiler menambahkan 3 × ukuran elemen ke alamat awal dan langsung menuju sel itu. Karena itulah akses array sangat cepat, tetapi karena alasan yang sama compiler tidak memeriksa apakah kamu keluar dari batas array. Memori yang dipakai array adalah jumlah elemen dikalikan ukuran satu elemen:

Tipe dataUkuran elemen (Uno)Ukuran elemen (ESP32 / Pico, C++)Array 100 elemen (Uno)
byte / uint8_t1 byte1 byte100 byte
char1 byte1 byte100 byte
int2 byte4 byte200 byte
unsigned int2 byte4 byte200 byte
long4 byte4 byte400 byte
float4 byte4 byte400 byte

Mengingat Arduino Uno hanya punya RAM 2 KB (2048 byte), array int dengan 1000 elemen saja sudah akan menghabiskan hampir seluruh memori. Jadi, biasakan memakai byte untuk nilai antara 0 dan 255 (nomor pin, kecerahan PWM, nilai hari atau jam), int untuk hasil analogRead, dan long untuk jumlah yang besar. Memilih tipe yang tepat berarti memuat data dua kali lebih banyak di memori yang sama.

Bagaimana cara mendeklarasikan array di Arduino?

Ketika mendeklarasikan array, kamu menulis tipe data dulu, lalu nama array, lalu jumlah elemen di dalam kurung siku. Kamu bisa langsung memberi nilainya di dalam kurung kurawal, atau mengosongkan ukurannya dan membiarkan compiler yang menghitung. Program di bawah ini menunjukkan bentuk-bentuk yang paling umum sekaligus dan mencetak hasilnya ke Serial Monitor:

C++ (Arduino IDE)
1int notlar[5] = {90, 75, 60, 85, 100};   // boyut ve değerler / size and values
2int pinler[] = {2, 3, 4, 5, 6, 7};       // boyutu derleyici sayar / compiler counts the size
3float olcumler[10] = {1.5, 2.0};         // kalan 8 eleman 0.0 / remaining 8 are 0.0
4int bos[5];                              // global dizi: hepsi 0 / global array: all zeros
5char isim[] = "Arduino";                 // 7 harf + '\0' = 8 bayt / 7 letters + '\0' = 8 bytes
6
7void setup() {
8  Serial.begin(9600);
9  Serial.println(notlar[0]);             // ilk eleman: 90 / first element: 90
10  Serial.println(notlar[4]);             // son eleman: 100 / last element: 100
11  notlar[2] = 65;                        // üçüncü elemanı değiştir / change the third element
12  Serial.println(notlar[2]);             // 65
13  Serial.println(olcumler[5]);           // 0.00
14  Serial.println(bos[3]);                // 0
15  Serial.println(sizeof(isim));          // 8
16  Serial.println(sizeof(pinler) / sizeof(pinler[0]));  // eleman sayısı: 6 / element count: 6
17}
18
19void loop() {
20}
DeklarasiArtinya
int a[5];Array 5 elemen; kalau global semuanya nol, kalau di dalam fungsi nilai awalnya acak
int a[5] = {1, 2, 3, 4, 5};Ukuran dan semua nilai diberikan bersamaan
int a[] = {2, 3, 4};Compiler yang menghitung ukurannya (di sini 3)
float a[10] = {1.5, 2.0};Elemen yang tidak diberi nilai menjadi 0
int a[5] = {0};Cara singkat untuk mengenolkan semua elemen
char s[] = "Arduino";Array teks; ada karakter '\0' tak terlihat di akhirnya (total 8 byte)
const byte a[] = {2, 3, 4}; (array konstan)Array konstan yang tidak bisa diubah di dalam program
Indeks dimulai dari 0. Di array int a[5] dengan 5 elemen tidak ada elemen bernama a[5]; elemen terakhirnya adalah a[4]. Compiler biasanya tidak menangkap kesalahan ini: ketika kamu menulis ke a[5], kamu menimpa variabel lain yang berada tepat di belakang array di memori. Hasilnya bukan pesan error, melainkan nilai-nilai yang tidak masuk akal, Arduino yang reset sendiri, atau kerusakan misterius yang kamu cari berjam-jam.

Menelusuri array dengan perulangan for

Kekuatan sebenarnya dari array terlihat ketika kamu menggabungkannya dengan perulangan for. Variabel perulangan i dimulai dari 0 dan bertambah sampai satu kurang dari jumlah elemen, dan di setiap putaran kamu menjangkau elemen berikutnya dengan array[i]. Daripada mengetik jumlah elemen secara manual, cara paling aman adalah menghitungnya dengan sizeof(array) / sizeof(array[0]): sizeof(array) memberi total byte array, dan sizeof(array[0]) memberi ukuran satu elemen. Misalnya, di Uno array int dengan 7 elemen berukuran 14 byte, dan 14 / 2 = 7. Ketika kamu menambah elemen ke array, rumus ini memperbarui jumlahnya secara otomatis. Kode di bawah mencari rata-rata, nilai minimum, dan maksimum suhu selama seminggu. Jumlah semua pembacaan adalah 161, rata-ratanya 23,0 derajat, minimumnya 19, dan maksimumnya 27. Perhatikan bahwa kondisi perulangannya adalah i < ADET (jumlah): kalau kamu membuatnya lebih kecil atau sama dengan, perulangan berjalan satu kali lebih banyak dan membaca memori di luar array.

C++ (Arduino IDE)
1int sicakliklar[] = {22, 24, 19, 27, 25, 21, 23};   // bir haftalık ölçüm / one week of readings
2const int ADET = sizeof(sicakliklar) / sizeof(sicakliklar[0]);   // 7
3
4void setup() {
5  Serial.begin(9600);
6  long toplam = 0;                       // taşmasın diye long / long to avoid overflow
7  int enKucuk = sicakliklar[0];
8  int enBuyuk = sicakliklar[0];
9
10  for (int i = 0; i < ADET; i++) {       // 0'dan 6'ya / from 0 to 6
11    toplam += sicakliklar[i];
12    if (sicakliklar[i] < enKucuk) enKucuk = sicakliklar[i];
13    if (sicakliklar[i] > enBuyuk) enBuyuk = sicakliklar[i];
14  }
15
16  Serial.print("Ortalama / Average: ");
17  Serial.println((float)toplam / ADET);  // 23.00
18  Serial.print("En dusuk / Min: ");
19  Serial.println(enKucuk);               // 19
20  Serial.print("En yuksek / Max: ");
21  Serial.println(enBuyuk);               // 27
22}
23
24void loop() {
25}

Contoh 1: mengatur pin LED dengan array

Penggunaan array yang paling klasik di Arduino adalah mengatur beberapa LED. Mengendalikan enam LED tanpa array berarti menulis enam baris pinMode terpisah dan baris digitalWrite terpisah untuk setiap langkah; dengan array, satu perulangan sudah cukup. Hubungkan kaki panjang (anoda) setiap LED ke pin digital dan kaki pendeknya ke GND lewat resistor 220 Ω. Kalau ingin menghitung nilai resistornya sendiri, kamu bisa memakai alat kalkulator resistor LED.

LED (indeks array)Arduino UnoESP32Raspberry Pi Pico
LED 1 (ledPins[0])D2GPIO 13GP14
LED 2 (ledPins[1])D3GPIO 14GP13
LED 3 (ledPins[2])D4GPIO 27GP12
LED 4 (ledPins[3])D5GPIO 26GP11
LED 5 (ledPins[4])D6GPIO 25GP10
LED 6 (ledPins[5])D7GPIO 33GP9
Katoda (kaki pendek)GND lewat 220 ΩGND lewat 220 ΩGND lewat 220 Ω
  1. Pasang LED di breadboard secara berurutan; hubungkan kaki pendek (katoda) ke jalur GND lewat resistor 220 Ω.
  2. Hubungkan kaki panjang ke pin 2–7 Arduino sesuai urutan di tabel.
  3. Tulis nomor pin ke array ledPins sesuai urutan fisik LED; urutan di array menentukan arah gerak cahaya.
  4. Di setup(), jadikan semua pin OUTPUT dengan satu perulangan for.
  5. Di loop(), buat efek Knight Rider dengan dua perulangan, satu maju dan satu mundur, lalu upload kodenya.
C++ (Arduino IDE)
1const byte ledPinleri[] = {2, 3, 4, 5, 6, 7};   // LED'lerin fiziksel sırası / physical order of LEDs
2const byte LED_SAYISI = sizeof(ledPinleri) / sizeof(ledPinleri[0]);   // 6
3const int BEKLEME = 100;                         // adım süresi ms / step time in ms
4
5void setup() {
6  for (byte i = 0; i < LED_SAYISI; i++) {
7    pinMode(ledPinleri[i], OUTPUT);              // tüm pinler çıkış / all pins as output
8  }
9}
10
11void loop() {
12  // ileri: 0'dan 5'e / forward: 0 to 5
13  for (byte i = 0; i < LED_SAYISI; i++) {
14    digitalWrite(ledPinleri[i], HIGH);
15    delay(BEKLEME);
16    digitalWrite(ledPinleri[i], LOW);
17  }
18  // geri: 4'ten 1'e, uçlar tekrar yanmaz / backward: 4 to 1, ends are not repeated
19  for (int i = LED_SAYISI - 2; i > 0; i--) {
20    digitalWrite(ledPinleri[i], HIGH);
21    delay(BEKLEME);
22    digitalWrite(ledPinleri[i], LOW);
23  }
24}

Perulangan maju menyalakan lalu mematikan setiap LED dari 0 sampai 5 selama 100 ms. Perulangan mundur dimulai dari 4 dan berhenti di 1; karena tidak menyalakan LED di ujung untuk kedua kalinya, cahaya berbalik dengan mulus tanpa jeda di ujung. Kita memakai int sebagai penghitung di perulangan mundur karena byte tidak bertanda (unsigned) dan tidak bisa turun di bawah 0; kalau kamu memakai byte di perulangan yang mengharapkan penghitung turun di bawah 0, nilainya kembali ke 255 setelah 0 dan perulangan tidak pernah selesai. Untuk mengubah urutan efek, kamu cukup menukar angka-angka di array tanpa menyentuh sisa kode. Untuk efek lain yang ditulis dengan logika yang sama, lihat LED berjalan Knight Rider.

Contoh 2: rata-rata sensor dengan array (moving average)

Pembacaan dari sensor analog seperti potensiometer, LDR, atau sensor kelembapan tanah terus bergoyang beberapa unit. Cara termudah mengurangi derau ini adalah mengambil rata-rata N pembacaan terakhir. Kamu menyimpan 10 pembacaan terakhir di sebuah array, dan di setiap pengukuran baru kamu mengurangi nilai paling lama dari total lalu menambahkan nilai yang baru. Karena indeks dikembalikan ke 0 begitu mencapai akhir array, struktur ini disebut ring buffer (buffer melingkar). Memperbarui total dengan cara kurangi-tambah, bukan menghitung ulang setiap kali, membuat prosesnya tetap cepat walaupun jendelanya membesar sampai 100 elemen. Selama 10 pembacaan pertama array belum penuh, jadi rata-ratanya naik dari nol dan stabil di nilai sebenarnya setelah sekitar setengah detik. Hubungkan pin sinyal sensor ke A0 (misalnya kaki tengah potensiometer) dan amati hasilnya sebagai dua garis di Serial Plotter:

C++ (Arduino IDE)
1const byte PENCERE = 10;            // ortalama alınacak okuma sayısı / number of readings to average
2int okumalar[PENCERE];              // global dizi sıfırla başlar / global array starts at zero
3byte indeks = 0;                    // sıradaki hücre / next slot
4long toplam = 0;                    // taşmasın diye long / long to avoid overflow
5
6void setup() {
7  Serial.begin(9600);
8}
9
10void loop() {
11  int yeni = analogRead(A0);
12  toplam -= okumalar[indeks];       // en eski okumayı çıkar / remove the oldest reading
13  okumalar[indeks] = yeni;          // yerine yenisini yaz / store the new one
14  toplam += yeni;                   // toplama ekle / add to the total
15  indeks++;
16  if (indeks >= PENCERE) {          // sona gelince başa dön / wrap around at the end
17    indeks = 0;
18  }
19  int ortalama = toplam / PENCERE;
20  Serial.print(yeni);               // ham değer / raw value
21  Serial.print(" ");
22  Serial.println(ortalama);         // yumuşatılmış değer / smoothed value
23  delay(50);
24}
Di Uno, int paling banyak bisa menampung 32.767. Jumlah 64 pembacaan analog yang bisa mencapai 1023 adalah 65.472, dan variabel int akan overflow lalu berubah menjadi angka negatif. Selalu pakai long untuk perhitungan total dan rata-rata. Makin besar jendelanya, keluarannya makin halus tetapi makin lambat bereaksi terhadap perubahan; 10 pembacaan dengan jeda 50 ms, yaitu jendela setengah detik, adalah titik awal yang bagus untuk kebanyakan sensor. Untuk metode yang lebih canggih, lihat menyaring data sensor.

Contoh 3: menyimpan nada melodi di array

Sebuah melodi sebenarnya terdiri dari dua daftar: nada mana yang dimainkan (frekuensi) dan berapa lama nada itu berbunyi. Kamu menyimpan dua informasi ini di dua array paralel dengan panjang yang sama: melody[i] dan durations[i] selalu milik nada yang sama. Hubungkan kaki positif buzzer pasif ke pin 8 dan kaki negatifnya ke GND. Kode di bawah memainkan dua baris pertama lagu “Twinkle Twinkle Little Star” dan memisahkan bunyi dengan memberi jeda sepertiga durasi setiap nada di antara nada-nada. Untuk menambah lagu baru, kamu cukup mengisi kedua array; perulangan pemutarnya tidak pernah berubah. Kalau jumlah elemen kedua array berbeda, perulangan akan melewati akhir array yang lebih pendek, jadi menulis jumlah elemen yang sama di setiap baris mencegah bug ini. Kalau melodi yang panjang mulai memenuhi RAM Uno, kamu bisa memindahkan array ke memori flash dengan PROGMEM. Kalau belum tahu bedanya buzzer aktif dan pasif, baca apa itu buzzer.

C++ (Arduino IDE)
1#define NOTA_DO  262   // Hz
2#define NOTA_RE  294
3#define NOTA_MI  330
4#define NOTA_FA  349
5#define NOTA_SOL 392
6#define NOTA_LA  440
7
8const byte BUZZER_PIN = 8;   // pasif buzzer / passive buzzer
9
10// notalar ve süreler aynı sırada / notes and durations in the same order
11const int melodi[] = {NOTA_DO, NOTA_DO, NOTA_SOL, NOTA_SOL, NOTA_LA, NOTA_LA, NOTA_SOL,
12                      NOTA_FA, NOTA_FA, NOTA_MI, NOTA_MI, NOTA_RE, NOTA_RE, NOTA_DO};
13const int sureler[] = {400, 400, 400, 400, 400, 400, 800,
14                       400, 400, 400, 400, 400, 400, 800};
15const int NOTA_SAYISI = sizeof(melodi) / sizeof(melodi[0]);   // 14
16
17void setup() {
18  for (int i = 0; i < NOTA_SAYISI; i++) {
19    tone(BUZZER_PIN, melodi[i], sureler[i]);   // notayı çal / play the note
20    delay(sureler[i] + sureler[i] / 3);         // nota + kısa boşluk / note + short gap
21  }
22  noTone(BUZZER_PIN);
23}
24
25void loop() {
26}

Array multidimensi: menyimpan data berbentuk tabel

Array dua dimensi adalah tabel yang terdiri dari baris dan kolom. int table[4][3] adalah array 12 elemen dengan 4 baris dan 3 kolom; kamu mengakses elemennya dengan table[baris][kolom], dan kedua indeks dimulai dari 0. Di memori, baris-barisnya disusun berurutan, jadi tabel ini memakai 4 × 3 × 2 = 24 byte di Uno. Pola LED matrix 8x8, peta tombol keypad, dan tabel status adalah penggunaan khas array dua dimensi. Di contoh di bawah, kita menulis setiap status lampu lalu lintas di satu baris: tiga kolom pertama menyimpan apakah LED merah, kuning, dan hijau menyala, dan kolom keempat menyimpan berapa milidetik status itu berlangsung. Kamu bisa menghubungkan LED ke tiga pin pertama di tabel pin (D2 merah, D3 kuning, D4 hijau). Kita menghitung jumlah baris dengan sizeof(states) / sizeof(states[0]); di sini sizeof(states[0]) memberi ukuran satu baris penuh. Untuk menambah status baru ke lampu, cukup tulis baris baru di tabel; kode di dalam loop() tetap sama. Pendekatan yang memisahkan logika program dari datanya ini juga akan membantumu nanti ketika membuat state machine Arduino.

C++ (Arduino IDE)
1const byte trafikPinleri[3] = {2, 3, 4};   // kırmızı, sarı, yeşil / red, yellow, green
2
3// her satır bir durum: {kırmızı, sarı, yeşil, süre ms} / each row: {red, yellow, green, time ms}
4const unsigned int durumlar[4][4] = {
5  {1, 0, 0, 5000},   // kırmızı / red
6  {1, 1, 0, 1500},   // kırmızı + sarı / red + yellow
7  {0, 0, 1, 5000},   // yeşil / green
8  {0, 1, 0, 1500}    // sarı / yellow
9};
10const byte DURUM_SAYISI = sizeof(durumlar) / sizeof(durumlar[0]);   // 4 satır / 4 rows
11
12void setup() {
13  for (byte i = 0; i < 3; i++) {
14    pinMode(trafikPinleri[i], OUTPUT);
15  }
16}
17
18void loop() {
19  for (byte d = 0; d < DURUM_SAYISI; d++) {          // satırları gez / walk the rows
20    for (byte led = 0; led < 3; led++) {              // sütunları gez / walk the columns
21      digitalWrite(trafikPinleri[led], durumlar[d][led] ? HIGH : LOW);
22    }
23    delay(durumlar[d][3]);                            // durumun süresi / duration of the state
24  }
25}

Array di ESP32 dan Raspberry Pi Pico

Di ESP32, array ditulis dengan sintaks C++ yang sama seperti di Arduino Uno, dan contoh-contoh di atas bisa dikompilasi tanpa diubah; kamu hanya perlu menyesuaikan nomor pin. Di contoh LED, cukup ubah baris array menjadi {13, 14, 27, 26, 25, 33}; pin 6–11 dicadangkan untuk memori flash internal, jadi jangan masukkan pin itu ke array. Di ESP32, int berukuran 4 byte dan tersedia lebih dari 300 KB RAM untuk programmu; array pengukuran 10.000 elemen yang tidak muat di Uno bisa muat dengan lega di sini. Karena pembacaan analog ESP32 berkisar dari 0 sampai 4095, angka di contoh moving average jadi lebih besar, tetapi logikanya sama. Kalau kamu memakai Raspberry Pi Pico dengan MicroPython, kamu memakai list sebagai pengganti array: ukurannya tidak tetap, kamu bisa menambah elemen dengan append() dan mengetahui panjangnya dengan len(). Indeks negatif juga berlaku di list; leds[-1] memberi elemen terakhir. Memasukkan objek Pin langsung ke dalam list membuat kodenya jauh lebih sederhana:

MicroPython
1from machine import Pin
2import time
3
4led_pinleri = [14, 13, 12, 11, 10, 9]            # GP14 -> GP9 sırası / order
5ledler = [Pin(p, Pin.OUT) for p in led_pinleri]  # Pin nesnelerinden liste / list of Pin objects
6print("LED sayisi / LED count:", len(ledler))
7
8while True:
9    for led in ledler:                           # ileri / forward
10        led.on()
11        time.sleep_ms(100)
12        led.off()
13    for i in range(len(ledler) - 2, 0, -1):      # geri, uçlar hariç / backward, ends skipped
14        ledler[i].on()
15        time.sleep_ms(100)
16        ledler[i].off()

Bug overflow dan kesalahan array yang sering terjadi

KesalahanGejalaSolusi
Memakai lebih kecil atau sama dengan di kondisi perulanganPutaran terakhir membaca atau menulis di luar array; nilai tidak masuk akal, resetUbah kondisinya menjadi i < COUNT
Memulai indeks dari 1Elemen pertama terlewati dan putaran terakhir overflowIndeks berjalan dari 0 sampai N-1
Mengira hasil sizeof(array) adalah jumlah elemenPada array int, perulangan berjalan dua kali lebih banyak di Uno dan empat kali lebih banyak di ESP32Pakai sizeof(array) / sizeof(array[0])
Memakai sizeof di dalam fungsiArray dikirim ke fungsi sebagai alamat; sizeof menghasilkan 2 atau 4Kirim jumlah elemen sebagai parameter terpisah
Menyimpan total di variabel intRata-rata negatif begitu 32.767 terlampaui di UnoPakai long untuk total
Tidak memberi nilai awal pada array di dalam fungsiNilai awal acak di array lokalNolkan dengan int a[10] = {0};
Menyalin array ke array lain dengan =Error kompilasi: “invalid array assignment”Salin dengan perulangan for atau memcpy
Mendeklarasikan array yang sangat besar di UnoPeringatan memori rendah, macet, dan resetPakai byte, dan pindahkan tabel konstan ke PROGMEM
Tabel yang tidak pernah berubah (nada melodi, pola karakter, nilai kalibrasi) tetap disalin ke RAM ketika Uno mulai menyala, walaupun kamu menulis const. Pindahkan array konstan yang besar ke memori flash dengan kata kunci PROGMEM dan baca dengan fungsi seperti pgm_read_word(); dengan begitu kamu memakai flash 32 KB dan menghemat RAM 2 KB. Di ESP32 dan Pico, array const memang sudah tetap berada di flash. Kalau curiga memorinya habis, lihat memori Arduino tidak cukup.

Ide proyek dengan array

  • Paket efek LED: Simpan pola di array dua dimensi dan mainkan setiap baris seperti frame animasi; atur efek LED berjalan Knight Rider dengan satu perulangan.
  • Game memori Simon: Simpan urutan warna yang dibuat secara acak di array dan bandingkan dengan tombol yang ditekan pemain; untuk ide serupa, lihat proyek game Arduino.
  • Kunci password: Simpan password yang benar di array char, tulis tombol yang dimasukkan lewat keypad ke array kedua, lalu bandingkan elemen demi elemen.
  • Animasi LED matrix: Simpan pola 8x8 di array byte dan tampilkan di LED matrix MAX7219.
  • Pencatat data harian: Simpan suhu per jam di array 24 elemen dan hitung nilai minimum, maksimum, dan rata-rata hari itu; kamu bisa memakai DHT11 sebagai sensornya.
  • Kotak musik: Simpan beberapa lagu di array terpisah dan berpindah antarlagu dengan tombol.

Array adalah blok bangunan dasar yang langsung berperan begitu kamu berurusan dengan lebih dari beberapa variabel dalam pemrograman Arduino: daftar pin, riwayat pengukuran, melodi, dan pola semuanya dikelola dengan array. Ketika bekerja dengan teks, kamu bisa lanjut ke memakai String di Arduino untuk mempelajari perbedaan array char dan class String. Di aplikasi BlueGrays, kamu bisa mempelajari proyek LED berjalan, Knight Rider, lampu lalu lintas, dan lagu kebangsaan dengan buzzer langkah demi langkah, lengkap dengan kode berbasis array yang siap pakai dan skema rangkaiannya.

Pertanyaan umum

Bagaimana cara mengetahui jumlah elemen array di Arduino?

Arduino tidak punya fungsi length() bawaan untuk array. Kamu mencari jumlah elemen dengan rumus sizeof(array) / sizeof(array[0]): yang pertama memberi total byte array, yang kedua ukuran satu elemen. Rumus ini hanya bekerja dengan benar di tempat array dideklarasikan; untuk array yang dikirim ke fungsi, hasilnya adalah ukuran pointer.

Apakah indeks array Arduino dimulai dari 0 atau 1?

Di bahasa Arduino yang berbasis C dan C++, indeks array selalu dimulai dari 0. Di array 10 elemen, elemen pertama adalah array[0] dan yang terakhir array[9]. Mengakses array[10] tidak menimbulkan error kompilasi, tetapi merusak memori di luar array.

Apakah ukuran array Arduino bisa diubah belakangan?

Tidak, ukuran array biasa ditetapkan ketika kompilasi dan tidak bisa diperbesar selama program berjalan. Solusi praktisnya adalah mendeklarasikan array dengan ukuran terbesar yang mungkin kamu butuhkan dan mencatat berapa elemen yang sudah terisi di variabel penghitung terpisah. Mengalokasikan memori dinamis dengan malloc atau new memang bisa, tetapi tidak disarankan di Uno yang RAM-nya 2 KB karena membuat memori terfragmentasi.

Bagaimana cara mendeklarasikan array string di Arduino?

Untuk menyimpan beberapa teks, kamu memakai array pointer seperti const char* colors[] = {"Red", "Yellow", "Green"}; dan menjangkau "Yellow" dengan colors[1]. Satu teks tunggal adalah array karakter seperti char name[] = "Arduino"; dan membawa karakter '\0' tak terlihat di akhirnya. Kamu juga bisa menulis array berisi objek String, tetapi di Uno cara ini lebih cepat menghabiskan RAM.

Berapa banyak elemen yang bisa ditampung array di Arduino Uno?

Batasnya ditentukan RAM: Uno punya total RAM 2048 byte, dan sebagian dipakai oleh Serial dan variabel lain. Dalam praktiknya, array sekitar 1500 byte, yaitu 1500 byte atau 750 int, sudah mendekati batas. Kalau kamu memindahkan tabel konstan ke flash dengan PROGMEM, kamu bisa menyimpan jauh lebih banyak data; ESP32 dan Pico punya RAM ratusan KB.

Bagaimana cara menyalin array ke array lain di Arduino?

Di C++ kamu tidak bisa menyalin array dengan menulis target = source; compiler akan memberi error. Kamu bisa menyalin elemen satu per satu dengan perulangan for atau memakai memcpy(target, source, sizeof(source));. Pastikan kedua array punya tipe dan ukuran yang sama; kalau target lebih kecil, memcpy juga akan overflow.

Lihat semua proyek
Lampu Lalu Lintas
AR-3Pemula

Lampu Lalu Lintas

Tiruan mini lampu lalu lintas yang kamu lihat di jalan setiap hari. Merah menyala dua detik, kuning menyala sebentar, hijau menyala dua detik, lalu kembali ke merah lewat kuning lagi, terus berulang.

4.8(136)
439
LED Berjalan
AR-5Menengah

LED Berjalan

Lampu-lampu yang menyala satu demi satu, seolah sedang berlari. Arduino menyalakan enam LED satu per satu; masing-masing menyala sebentar lalu padam, sehingga cahayanya berjalan dari awal ke akhir…

4.6(87)
217
Efek LED Knight Rider
AR-6Menengah

Efek LED Knight Rider

Lampu pemindai klasik: sebuah titik cahaya meluncur dari satu ujung enam LED ke ujung lainnya lalu kembali.

4.8(107)
214
LED Berjalan dengan Kecepatan yang Bisa Diatur
AR-7Menengah

LED Berjalan dengan Kecepatan yang Bisa Diatur

Enam LED menyala satu demi satu, sehingga cahayanya seolah berlari dari satu ujung ke ujung lainnya.

4.6(72)
148
Efek LED Knight Rider dengan Kecepatan yang Bisa Diatur
AR-8Menengah

Efek LED Knight Rider dengan Kecepatan yang Bisa Diatur

Cahaya berlari dari satu ujung enam LED ke ujung lainnya, berbalik, lalu berlari kembali.

4.5(60)
124
Lagu Kebangsaan Turki dengan Buzzer
AR-15Menengah

Lagu Kebangsaan Turki dengan Buzzer

Tekan tombol dan buzzer kecil mulai memainkan Lagu Kebangsaan Turki, nada demi nada.

4.8(114)
234
LED Knight Rider ESP32
ES-6Pemula

LED Knight Rider ESP32

6 LED yang bergerak berurutan dari kiri ke kanan dan dari kanan ke kiri (gaya Knight Rider). Contoh dasar penggunaan loop for dan array. Mengajarkan logika perubahan arah.

4.5(19)
33
LED Berjalan Raspberry Pi Pico (6 LED)
PI-7Pemula

LED Berjalan Raspberry Pi Pico (6 LED)

Animasi "LED berjalan" klasik dengan Pico, versi 6 LED! 6 LED menyala berurutan dari kiri ke kanan, seperti cahaya yang berjalan. Pelajari list Python, list comprehension ([Pin(p, Pin.OUT) for p in LED_PINS]), loop for dengan kendali pin, dan enumerate(). 6 LED di GP9-GP14, masing-masing dengan resistor 220Ω. Alih-alih mendefinisikan LED satu per satu, kita memakai list; kamu bisa menambah LED sebanyak pin GPIO yang bebas. Untuk 100 LED, pakai LED beralamat seperti WS2812B.

5.0(1)
9