Temeller · 8 dk okuma

Arduino Dizi Kullanımı: Array Tanımlama, for Döngüsü ve Örnekler

Arduino dizi kullanımı adım adım: array tanımlama, indeks, for döngüsüyle gezme, iki boyutlu diziler, LED pinleri, sensör ortalaması ve melodi örnekleri.

Arduino dizi kullanımı, aynı türden çok sayıda değeri tek bir isim altında toplayıp her birine numarasıyla (indeksiyle) ulaşmanı sağlayan temel bir programlama becerisidir. Altı LED'in pin numarasını, son on sensör okumasını ya da bir şarkının notalarını led1, led2, led3 diye ayrı ayrı değişkenlere yazmak yerine tek bir dizide saklarsın ve bir for döngüsüyle hepsini birkaç satırda işlersin. Böylece kodun kısalır, hata yapma ihtimalin azalır ve devreye yeni bir LED eklemek için yalnızca dizideki listeye bir sayı eklemen yeterli olur.

Bu rehberde dizinin bellekte nasıl durduğunu, nasıl tanımlandığını, indeksin neden sıfırdan başladığını ve eleman sayısını sizeof ile nasıl hesaplayacağını öğreneceksin. Ardından üç gerçek örnek yapacağız: karaşimşek LED efekti, gürültülü sensör verisini yumuşatan hareketli ortalama ve buzzer ile melodi çalma. Son olarak iki boyutlu dizilerle bir trafik lambası durum tablosu kuracak, ESP32 ve Raspberry Pi Pico'daki farklara bakacak ve programı sessizce bozan taşma hatalarını nasıl yakalayacağını göreceksin. Konuya tamamen yeniysen önce Arduino programlama temelleri yazısına göz atabilirsin.

Arduino dizi örneğinde kullanılan LED'ler
Altı LED'i ayrı ayrı değil, tek bir pin dizisiyle yönetmek dizilerin en klasik kullanım örneğidir.

Dizi (array) nedir, nasıl çalışır?

Dizi, bellekte yan yana duran ve hepsi aynı veri tipinde olan elemanlardan oluşan bir bloktur. Bunu numaralı çekmecelerden oluşan bir dolap gibi düşünebilirsin: dolabın tek bir adı vardır, her çekmecenin de bir numarası. C ve C++ tabanlı Arduino dilinde bu numaralandırma 0'dan başlar; 5 elemanlı bir dizinin indeksleri 0, 1, 2, 3 ve 4'tür, yani son indeks her zaman eleman sayısının bir eksiğidir. Derleyici dizinin başlangıç adresini bilir; dizi[3] yazdığında başlangıç adresine 3 × eleman boyutu kadar ekleyip doğrudan o hücreye gider. Bu yüzden diziye erişmek çok hızlıdır, ama aynı sebeple derleyici sınırların dışına çıkıp çıkmadığını kontrol etmez. Bir dizinin kapladığı bellek, eleman sayısı ile tek elemanın boyutunun çarpımıdır:

Veri tipiEleman boyutu (Uno)Eleman boyutu (ESP32 / Pico, C++)100 elemanlı dizi (Uno)
byte / uint8_t1 bayt1 bayt100 bayt
char1 bayt1 bayt100 bayt
int2 bayt4 bayt200 bayt
unsigned int2 bayt4 bayt200 bayt
long4 bayt4 bayt400 bayt
float4 bayt4 bayt400 bayt

Arduino Uno'nun yalnızca 2 KB (2048 bayt) RAM'i olduğunu düşünürsen 1000 elemanlı bir int dizisinin tek başına belleğin neredeyse tamamını yiyeceğini görürsün. Bu yüzden 0–255 arasında kalan değerler (pin numaraları, PWM parlaklığı, gün ya da saat bilgisi) için byte, analogRead sonuçları için int, büyük toplamlar için long kullanmak iyi bir alışkanlıktır. Doğru tipi seçmek, aynı belleğe iki kat daha fazla veri sığdırmak demektir.

Arduino'da dizi nasıl tanımlanır?

Dizi tanımlarken önce veri tipini, sonra dizinin adını, köşeli parantez içinde de eleman sayısını yazarsın. Değerleri süslü parantezle hemen verebilir ya da boyutu boş bırakıp saymayı derleyiciye bırakabilirsin. Aşağıdaki program en sık kullanılan biçimleri bir arada gösterir ve sonuçları Seri Monitör'e yazar:

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}
TanımlamaAnlamı
int a[5];5 elemanlı dizi; global ise hepsi 0, fonksiyon içinde ise başlangıç değerleri rastgele
int a[5] = {1, 2, 3, 4, 5};Boyut ve tüm değerler birlikte verilir
int a[] = {2, 3, 4};Boyutu derleyici sayar (burada 3)
float a[10] = {1.5, 2.0};Değeri verilmeyen elemanlar 0 olur
int a[5] = {0};Tüm elemanları sıfırlamanın kısa yolu
char s[] = "Arduino";Metin dizisi; sonda görünmez '\0' karakteri vardır (toplam 8 bayt)
const byte a[] = {2, 3, 4};Program içinde değiştirilemeyen sabit dizi
İndeks 0'dan başlar. 5 elemanlı int a[5] dizisinde a[5] diye bir eleman yoktur; son eleman a[4]'tür. Derleyici bu hatayı çoğunlukla yakalamaz: a[5]'e yazdığında bellekte dizinin hemen arkasındaki başka bir değişkenin üzerine yazarsın. Sonuç bir hata mesajı değil; anlamsız değerler, kendiliğinden resetlenen bir Arduino ya da saatlerce aranan gizemli bir arızadır.

for döngüsüyle diziyi gezmek

Dizilerin asıl gücü for döngüsüyle birleşince ortaya çıkar. Döngü değişkeni i, 0'dan başlayıp eleman sayısının bir eksiğine kadar artar ve her turda dizi[i] ile sıradaki elemana ulaşırsın. Eleman sayısını elle yazmak yerine sizeof(dizi) / sizeof(dizi[0]) formülüyle hesaplamak en güvenli yoldur: sizeof(dizi) dizinin toplam bayt sayısını, sizeof(dizi[0]) tek elemanın boyutunu verir. Örneğin Uno'da 7 elemanlı bir int dizisi 14 bayttır ve 14 / 2 = 7 eder. Diziye eleman eklediğinde bu formül sayıyı kendiliğinden günceller. Aşağıdaki kod bir haftalık sıcaklıkların ortalamasını, en düşük ve en yüksek değerini bulur. Ölçümlerin toplamı 161, ortalaması 23,0 derece; en düşük değer 19, en yüksek 27'dir. Döngü koşulunun i < ADET olmasına dikkat et: koşulu küçük eşittir yaparsan döngü bir tur fazla döner ve dizinin dışındaki belleği okur.

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}

Örnek 1: LED pinlerini diziyle yönetmek

Dizilerin Arduino'daki en klasik kullanımı birden fazla LED'i yönetmektir. Altı LED'i dizisiz kontrol etmek için altı ayrı pinMode ve her adım için ayrı digitalWrite satırları yazman gerekir; diziyle ise tek bir döngü yeter. Her LED'in uzun bacağını (anot) bir dijital pine, kısa bacağını 220 Ω dirençle GND'ye bağla. Direnç değerini kendin hesaplamak istersen LED direnci hesaplayıcı aracını kullanabilirsin.

LED (dizi indeksi)Arduino UnoESP32Raspberry Pi Pico
LED 1 (ledPinleri[0])D2GPIO 13GP14
LED 2 (ledPinleri[1])D3GPIO 14GP13
LED 3 (ledPinleri[2])D4GPIO 27GP12
LED 4 (ledPinleri[3])D5GPIO 26GP11
LED 5 (ledPinleri[4])D6GPIO 25GP10
LED 6 (ledPinleri[5])D7GPIO 33GP9
Katot (kısa bacak)220 Ω üzerinden GND220 Ω üzerinden GND220 Ω üzerinden GND
  1. LED'leri breadboard'a sırayla yerleştir; kısa bacakları (katot) 220 Ω dirençler üzerinden GND hattına bağla.
  2. Uzun bacakları tablodaki sırayla Arduino'nun 2–7 numaralı pinlerine bağla.
  3. Pin numaralarını ledPinleri dizisine LED'lerin fiziksel sırasıyla yaz; dizideki sıra ışığın akış yönünü belirler.
  4. setup() içinde tek bir for döngüsüyle bütün pinleri OUTPUT yap.
  5. loop() içinde önce ileri, sonra geri giden iki döngüyle karaşimşek efektini oluştur ve kodu yükle.
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}

İleri döngü 0'dan 5'e kadar her LED'i 100 ms yakıp söndürür. Geri döngü 4'ten başlayıp 1'de durur; uçtaki LED'leri ikinci kez yakmadığı için ışık uçlarda duraksamadan akıcı biçimde geri döner. Geri döngüde sayaç olarak int kullandık, çünkü byte işaretsizdir ve 0'ın altına inemez; sayacın 0'dan küçük olmasını bekleyen bir döngüde byte kullanırsan 0'dan sonra 255'e sarar ve döngü hiç bitmez. Efektin sırasını değiştirmek için kodun geri kalanına dokunmadan yalnızca dizideki sayıların yerini değiştirmen yeterlidir. Aynı mantıkla yazılmış farklı efektler için karaşimşek ve yürüyen LED yazısına bakabilirsin.

Örnek 2: dizi ile sensör ortalaması (hareketli ortalama)

Potansiyometre, LDR ya da toprak nem sensörü gibi analog sensörlerden okunan değerler sürekli birkaç birim titrer. Bu gürültüyü azaltmanın en kolay yolu son N okumanın ortalamasını almaktır. Son 10 okumayı bir dizide tutar, her yeni ölçümde en eski değeri toplamdan çıkarıp yenisini eklersin. Dizinin sonuna gelince indeksi tekrar 0'a döndürdüğümüz için bu yapıya dairesel tampon (ring buffer) denir. Toplamı her seferinde baştan hesaplamak yerine çıkar-ekle yöntemiyle güncellemek, pencere 100 elemana çıksa bile işlemi hızlı tutar. İlk 10 okumada dizi henüz dolmadığı için ortalama sıfırdan yukarı doğru tırmanır ve yaklaşık yarım saniye sonra gerçek değere oturur. Sensörün sinyal ucunu A0'a bağla (örneğin potansiyometrenin orta bacağı) ve sonucu Seri Çizici'de (Serial Plotter) iki çizgi olarak izle:

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}
Uno'da int en fazla 32 767 değerini tutabilir. 1023'e kadar çıkan 64 analog okumanın toplamı 65 472 eder ve int bir değişken taşarak negatif bir sayıya döner. Toplam ve ortalama hesaplarında her zaman long kullan. Pencere büyüdükçe çıktı daha pürüzsüz olur ama değişime daha geç tepki verir; 10 okuma ve 50 ms aralık, yani yarım saniyelik bir pencere çoğu sensör için iyi bir başlangıçtır. Daha gelişmiş yöntemler için sensör verisi filtreleme yazısına göz at.

Örnek 3: melodi notalarını dizide saklamak

Bir melodi aslında iki listeden oluşur: hangi notanın çalınacağı (frekans) ve ne kadar süreceği. Bu iki bilgiyi aynı uzunlukta iki paralel dizide saklarsın: melodi[i] ile sureler[i] her zaman aynı notaya aittir. Pasif buzzer'ın artı bacağını 8 numaralı pine, eksi bacağını GND'ye bağla. Aşağıdaki kod 'Twinkle Twinkle Little Star' şarkısının ilk iki dizesini çalar ve notalar arasına sürenin üçte biri kadar boşluk bırakarak sesleri birbirinden ayırır. Yeni bir şarkı eklemek için yalnızca iki diziyi doldurman yeterlidir; çalma döngüsü hiç değişmez. İki dizinin eleman sayısı farklı olursa döngü kısa olan dizinin dışına taşar, bu yüzden her satıra eşit sayıda eleman yazmak hatayı önler. Uzun melodiler Uno'nun RAM'ini doldurmaya başlarsa dizileri PROGMEM ile flash belleğe taşıyabilirsin. Aktif ve pasif buzzer farkını bilmiyorsan buzzer nedir yazısını oku.

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}

Çok boyutlu diziler: tablo gibi veri saklamak

İki boyutlu dizi, satır ve sütunlardan oluşan bir tablodur. int tablo[4][3] 4 satır ve 3 sütundan oluşan 12 elemanlı bir dizidir; elemana tablo[satır][sütun] diye erişirsin ve iki indeks de 0'dan başlar. Bellekte satırlar arka arkaya dizilir, yani bu tablo Uno'da 4 × 3 × 2 = 24 bayt yer kaplar. 8x8 LED matris desenleri, keypad tuş haritaları ve durum tabloları iki boyutlu dizilerin tipik kullanım alanlarıdır. Aşağıdaki örnekte trafik lambasının her durumunu bir satıra yazdık: ilk üç sütun kırmızı, sarı ve yeşil LED'in yanıp yanmayacağını, dördüncü sütun ise o durumun kaç milisaniye süreceğini tutar. LED'leri pin tablosundaki ilk üç pine (D2 kırmızı, D3 sarı, D4 yeşil) bağlayabilirsin. Satır sayısını sizeof(durumlar) / sizeof(durumlar[0]) ile hesapladık; burada sizeof(durumlar[0]) bir satırın tamamının boyutunu verir. Lambaya yeni bir durum eklemek için tabloya satır yazman yeterlidir, loop() içindeki kod aynı kalır. Programın mantığını veriden ayıran bu yaklaşım, ileride bir durum makinesi kurarken de işine yarar.

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}

ESP32 ve Raspberry Pi Pico'da diziler

ESP32'de diziler Arduino Uno'dakiyle aynı C++ sözdizimiyle yazılır ve yukarıdaki örnekler değiştirilmeden derlenir; yalnızca pin numaralarını uyarlaman gerekir. LED örneğinde dizi satırını {13, 14, 27, 26, 25, 33} yapman yeterli; 6–11 numaralı pinler dahili flash belleğe ayrıldığı için bu pinleri diziye yazma. ESP32'de int 4 bayttır ve programlarının kullanabileceği 300 KB'ı aşkın RAM bulunur; Uno'ya sığmayan 10 000 elemanlı bir ölçüm dizisi burada rahatça yer alır. ESP32'nin analog okumaları 0–4095 aralığında olduğundan hareketli ortalama örneğinde sayılar daha büyük çıkar, ama mantık aynıdır. Raspberry Pi Pico'yu MicroPython ile kullanıyorsan diziler yerine liste kullanırsın: boyut sabit değildir, append() ile eleman ekleyebilir, len() ile uzunluğu öğrenebilirsin. Listede negatif indeks de geçerlidir; ledler[-1] son elemanı verir. Listenin içine doğrudan Pin nesneleri koymak kodu çok sadeleştirir:

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()

Taşma hataları ve sık yapılan dizi hataları

HataBelirtiÇözüm
Döngü koşulunda küçük eşittir kullanmakSon turda dizinin dışı okunur ya da yazılır; anlamsız değerler, resetlerKoşulu i < ADET yap
İndeksi 1'den başlatmakİlk eleman atlanır, son turda taşma olurİndeksler 0'dan N-1'e kadardır
sizeof(dizi) sonucunu eleman sayısı sanmakint dizide döngü Uno'da iki, ESP32'de dört kat fazla dönersizeof(dizi) / sizeof(dizi[0]) kullan
Fonksiyon içinde sizeof kullanmakDizi fonksiyona adres olarak gider; sizeof 2 ya da 4 dönerEleman sayısını ayrı bir parametre olarak gönder
Toplamı int değişkende tutmakUno'da 32 767 aşılınca negatif ortalamaToplam için long kullan
Fonksiyon içindeki diziye ilk değer vermemekYerel dizide rastgele başlangıç değerleriint a[10] = {0}; ile sıfırla
Diziyi diziye = ile atamakDerleme hatası: invalid array assignmentfor döngüsüyle ya da memcpy ile kopyala
Uno'da çok büyük dizi tanımlamakDüşük bellek uyarısı, donma ve resetlerbyte kullan, sabit tabloları PROGMEM'e taşı
Değişmeyen tablolar (melodi notaları, karakter desenleri, kalibrasyon değerleri) Uno'da const yazsan bile açılışta RAM'e kopyalanır. Büyük sabit dizileri PROGMEM anahtar kelimesiyle flash belleğe taşı ve pgm_read_word() gibi fonksiyonlarla oku; böylece 32 KB'lık flash'ı kullanıp 2 KB'lık RAM'i korursun. ESP32 ve Pico'da const diziler zaten flash'ta kalır. Belleğin dolduğundan şüpheleniyorsan Arduino bellek yetersiz yazısına bak.

Dizilerle yapabileceğin proje fikirleri

  • LED efekt paketi: Desenleri iki boyutlu bir dizide tutup her satırı bir animasyon karesi gibi oynat; karaşimşek ve yürüyen LED efektlerini tek döngüyle yönet.
  • Simon hafıza oyunu: Rastgele üretilen renk sırasını bir dizide sakla ve oyuncunun bastığı butonlarla karşılaştır; benzer fikirler için Arduino oyun projeleri yazısına bak.
  • Şifreli kilit: Doğru şifreyi bir char dizisinde tut, keypad ile girilen tuşları ikinci bir diziye yazıp eleman eleman karşılaştır.
  • LED matris animasyonları: 8x8 desenleri byte dizilerinde saklayıp MAX7219 LED matris üzerinde göster.
  • Günlük veri kaydedici: Saatlik sıcaklıkları 24 elemanlı bir dizide tutup günün en düşük, en yüksek ve ortalama değerini hesapla; sensör olarak DHT11 kullanabilirsin.
  • Melodi kutusu: Birkaç şarkıyı ayrı dizilerde saklayıp bir butonla şarkılar arasında geçiş yap.

Diziler, Arduino programlamada birkaç değişkenden fazlasıyla uğraştığın anda devreye giren temel yapı taşıdır: pin listeleri, ölçüm geçmişi, melodiler ve desenler hep dizilerle yönetilir. Metinlerle çalışırken char dizileri ile String sınıfı arasındaki farkı öğrenmek için Arduino String kullanımı yazısıyla devam edebilirsin. BlueGrays uygulamasında yürüyen LED, karaşimşek, trafik lambası ve buzzer ile İstiklal Marşı projelerini, dizilerle yazılmış hazır kodları ve devre şemalarıyla adım adım inceleyebilirsin.

Sıkça sorulan sorular

Arduino'da dizinin eleman sayısı nasıl bulunur?

Arduino'da diziler için hazır bir length() fonksiyonu yoktur. Eleman sayısını sizeof(dizi) / sizeof(dizi[0]) formülüyle bulursun: ilki dizinin toplam bayt sayısını, ikincisi tek elemanın boyutunu verir. Bu formül yalnızca dizinin tanımlandığı yerde doğru çalışır; fonksiyona gönderilen bir dizide işaretçinin boyutunu verir.

Arduino'da dizi indeksi 0'dan mı 1'den mi başlar?

C ve C++ tabanlı Arduino dilinde dizi indeksi her zaman 0'dan başlar. 10 elemanlı bir dizinin ilk elemanı dizi[0], son elemanı dizi[9]'dur. dizi[10]'a erişmek derleme hatası vermez ama dizinin dışındaki belleği bozar.

Arduino'da dizinin boyutu sonradan değiştirilebilir mi?

Hayır, normal bir dizinin boyutu derleme sırasında belirlenir ve program çalışırken büyütülemez. Pratik çözüm, ihtiyaç duyabileceğin en büyük boyutta bir dizi tanımlayıp kaç elemanın dolu olduğunu ayrı bir sayaç değişkeninde tutmaktır. malloc ya da new ile dinamik bellek ayırmak mümkündür ama 2 KB RAM'li Uno'da bellek parçalanmasına yol açtığı için önerilmez.

Arduino'da metin (string) dizisi nasıl tanımlanır?

Birden fazla metni saklamak için const char* renkler[] = {"Kirmizi", "Sari", "Yesil"}; biçiminde bir işaretçi dizisi kullanılır ve renkler[1] ile "Sari" metnine ulaşılır. Tek bir metin ise char isim[] = "Arduino"; şeklinde bir karakter dizisidir ve sonunda görünmez bir '\0' karakteri taşır. String nesnelerinden oluşan diziler de yazılabilir, ama Uno'da RAM'i daha hızlı tüketir.

Arduino Uno'da bir dizi en fazla kaç eleman alabilir?

Sınırı RAM belirler: Uno'nun toplam 2048 bayt RAM'i vardır ve bunun bir kısmını Serial ile diğer değişkenler kullanır. Pratikte yaklaşık 1500 baytlık bir dizi, yani 1500 byte ya da 750 int sınıra yakındır. Sabit tabloları PROGMEM ile flash belleğe taşırsan çok daha fazla veri saklayabilirsin; ESP32 ve Pico'da ise yüzlerce KB RAM vardır.

Arduino'da bir dizi başka bir diziye nasıl kopyalanır?

C++'ta hedef = kaynak; yazarak dizi kopyalanamaz, derleyici hata verir. Elemanları bir for döngüsüyle tek tek kopyalayabilir ya da memcpy(hedef, kaynak, sizeof(kaynak)); komutunu kullanabilirsin. İki dizinin aynı tipte ve boyutta olduğundan emin ol; hedef küçükse memcpy de taşmaya yol açar.

Tüm projeleri gör
Trafik Lambası
AR-3Başlangıç

Trafik Lambası

Her gün yolda gördüğün trafik ışığının minik bir kopyası. Kırmızı iki saniye yanar, sarı kısa bir an parlar, yeşil iki saniye yanar, ardından yine sarı üzerinden kırmızıya dönülür ve döngü hiç durmaz.

4.8(137)
440
Yürüyen Led
AR-5Orta

Yürüyen Led

Sıra sıra yanıp sönen, koşar gibi ilerleyen ışıklar. Arduino altı LED'i tek tek yakar; her biri kısa bir an parlayıp söner ve ışık baştan sona yürür, sonra yeniden başlar.

4.6(87)
218
Karaşimşek Led
AR-6Orta

Karaşimşek Led

Karaşimşek ışığı adıyla bilinen efekt: ışık altı LED'in üzerinde bir uçtan öbür uca kayar, sonra geri döner.

4.8(107)
214
Hız Ayarlı Yürüyen Led
AR-7Orta

Hız Ayarlı Yürüyen Led

Altı LED sırayla yanıp söner ve ışık sanki bir uçtan öbür uca koşar. Potansiyometrenin düğmesini çevirdikçe bu koşunun hızı anında değişir: bir yöne çevirince ışık uçar, öbür yöne çevirince her LED…

4.6(72)
148
Hız Ayarlı Karaşimşek Led
AR-8Orta

Hız Ayarlı Karaşimşek Led

Altı LED üzerinde bir ışık bir uçtan öbür uca koşar, döner ve yeniden koşar. Potansiyometrenin düğmesini çevirerek bu koşunun hızını anında ayarlarsın: düğme bir yandayken ışık neredeyse uçar, öbür…

4.5(60)
124
Buzzer İle İstiklal Marşı
AR-15Orta

Buzzer İle İstiklal Marşı

Butona bastığında küçük bir buzzer İstiklal Marşı'nı nota nota çalmaya başlar. Arduino her notayı doğru yükseklikte ve doğru sürede çalarak marşın iki kıtasını baştan sona seslendirir, bitince yeni…

4.8(114)
235
ESP32 Yürüyen LED
ES-6Başlangıç

ESP32 Yürüyen LED

6 LED'in sırayla soldan sağa, sağdan sola hareket etmesi (Knight Rider tarzı). For döngüsü ve dizi (array) kullanımının temel örneği. Yön değişimi mantığını öğretir.

4.5(19)
33
Raspberry Pi Pico Yürüyen LED / Chasing LED (6 LED)
PI-7Başlangıç

Raspberry Pi Pico Yürüyen LED / Chasing LED (6 LED)

Pico ile klasik "yürüyen LED" animasyonu, 6 LED versiyonu! 6 LED soldan sağa sırayla yanıp sönüyor, sanki ışık dizi boyunca yürüyor. Bu projede Python listesini (LED_PINS = [14, 13, 12, 11, 10, 9]), list comprehension'ı, for döngüsüyle pin kontrolünü ve enumerate() fonksiyonunu öğreneceksin. GP9-GP14 pinlerine 6 LED bağlanır, her birinde 220Ω akım sınırlama direnci var.

5.0(1)
9