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.

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 tipi | Eleman boyutu (Uno) | Eleman boyutu (ESP32 / Pico, C++) | 100 elemanlı dizi (Uno) |
|---|---|---|---|
| byte / uint8_t | 1 bayt | 1 bayt | 100 bayt |
| char | 1 bayt | 1 bayt | 100 bayt |
| int | 2 bayt | 4 bayt | 200 bayt |
| unsigned int | 2 bayt | 4 bayt | 200 bayt |
| long | 4 bayt | 4 bayt | 400 bayt |
| float | 4 bayt | 4 bayt | 400 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:
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ımlama | Anlamı |
|---|---|
| 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 |
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.
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 Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED 1 (ledPinleri[0]) | D2 | GPIO 13 | GP14 |
| LED 2 (ledPinleri[1]) | D3 | GPIO 14 | GP13 |
| LED 3 (ledPinleri[2]) | D4 | GPIO 27 | GP12 |
| LED 4 (ledPinleri[3]) | D5 | GPIO 26 | GP11 |
| LED 5 (ledPinleri[4]) | D6 | GPIO 25 | GP10 |
| LED 6 (ledPinleri[5]) | D7 | GPIO 33 | GP9 |
| Katot (kısa bacak) | 220 Ω üzerinden GND | 220 Ω üzerinden GND | 220 Ω üzerinden GND |
- LED'leri breadboard'a sırayla yerleştir; kısa bacakları (katot) 220 Ω dirençler üzerinden GND hattına bağla.
- Uzun bacakları tablodaki sırayla Arduino'nun 2–7 numaralı pinlerine bağla.
- Pin numaralarını ledPinleri dizisine LED'lerin fiziksel sırasıyla yaz; dizideki sıra ışığın akış yönünü belirler.
- setup() içinde tek bir for döngüsüyle bütün pinleri OUTPUT yap.
- loop() içinde önce ileri, sonra geri giden iki döngüyle karaşimşek efektini oluştur ve kodu yükle.
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:
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}Ö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.
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.
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:
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ı
| Hata | Belirti | Çözüm |
|---|---|---|
| Döngü koşulunda küçük eşittir kullanmak | Son turda dizinin dışı okunur ya da yazılır; anlamsız değerler, resetler | Koş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ı sanmak | int dizide döngü Uno'da iki, ESP32'de dört kat fazla döner | sizeof(dizi) / sizeof(dizi[0]) kullan |
| Fonksiyon içinde sizeof kullanmak | Dizi fonksiyona adres olarak gider; sizeof 2 ya da 4 döner | Eleman sayısını ayrı bir parametre olarak gönder |
| Toplamı int değişkende tutmak | Uno'da 32 767 aşılınca negatif ortalama | Toplam için long kullan |
| Fonksiyon içindeki diziye ilk değer vermemek | Yerel dizide rastgele başlangıç değerleri | int a[10] = {0}; ile sıfırla |
| Diziyi diziye = ile atamak | Derleme hatası: invalid array assignment | for döngüsüyle ya da memcpy ile kopyala |
| Uno'da çok büyük dizi tanımlamak | Düşük bellek uyarısı, donma ve resetler | byte kullan, sabit tabloları PROGMEM'e taşı |
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.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
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.

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.

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.

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…

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…

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…

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.

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.
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

