Blok Kodlama Döngüler ve Değişkenler: Arduino for ve Dizi

Blok kodlamada döngüler ve değişkenler, bir programı "bir kez yap" olmaktan çıkarıp "sürekli ve akıllıca yap" hâline getiren iki yapı taşıdır. Döngü aynı blokları tekrar tekrar çalıştırır, değişken de bu tekrarlar sırasında bir sayıyı aklında tutar. BlueGrays'teki bloklarda bunlar "sürekli tekrarla", "i değişkeniyle say", "genel değişkenler (en başta)" ve "… değişkenine … ata" olarak görünür; karta yüklenen Arduino kodunda ise karşılıkları loop(), for döngüsü, int değişken ve atama satırıdır.

Bu bölümde dört ücretsiz projenin bloklarını gerçek C++ koduyla yan yana okuyacağız: altı LED'i sırayla yakan Yürüyen Led, hızını potansiyometreden alan Hız Ayarlı Yürüyen Led, ışığı bir uçtan öbürüne götürüp geri getiren Karaşimşek Led ve onun potansiyometreli hâli Hız Ayarlı Karaşimşek Led. Dördü de aynı devreyi kullanır: D2–D7 pinlerinde altı LED ve A0'da bir potansiyometre. Sonunda kendi sayaç örneğini yazacak, yeni başlayanların en sık düştüğü üç hatayı da (bir eksik ya da bir fazla saymak, dizinin dışına taşmak ve butonları kör eden uzun beklemeler) tek tek göreceksin.

"Sürekli tekrarla" bloğu ve loop(): kart neden hiç durmaz?

Bilgisayardaki bir program işini bitirince kapanır; Arduino'daki program ise kapanmaz. Kartta bir işletim sistemi yoktur, işlemcinin yapacak başka bir işi de yoktur. Bu yüzden her bloklu projenin iskeleti aynıdır: "kurulum (bir kez çalışır)" bloğunun içindekiler kart enerjilendiğinde ya da reset düğmesine basıldığında yalnız bir kez çalışır, "sürekli tekrarla" bloğunun içindekiler ise baştan sona durmadan tekrar eder. C++ tarafında bunlar setup() ve loop() fonksiyonlarıdır. loop()'un son satırı bittiğinde kart hiç beklemeden ilk satıra döner; içinde hiç bekleme olmayan kısa bir loop() saniyede on binlerce kez çalışabilir. Kartı durdurmanın tek yolu enerjisini kesmek ya da yeni bir program yüklemektir. Bu sonsuz tekrar bir kusur değil, tasarımın kendisidir: buton okuma, sensör izleme, LED yakıp söndürme gibi işlerin hepsi her turda yeniden yapılır ve kart böylece çevresindeki değişikliklere sürekli cevap verir.

Blok kodlamada değişken: genel değişkenler ve tanımla bloğu

Değişken, içine sayı koyduğun ve adıyla çağırdığın küçük bir kutudur. Bloklarda değişkenler mor renkli "genel değişkenler (en başta)" bloğunun içinde tanımlanır. İçindeki "tanımla: tam sayı (int) potValue = 0" bloğu koda int potValue satırı olarak geçer: int türü, potValue adı, 0 da başlangıç değeridir. "En başta" ifadesi önemlidir: bu satırlar setup() ve loop()'un dışında, dosyanın en üstünde durur. Böyle tanımlanan global değişken programın her yerinden görülür ve loop() her yeniden başladığında değerini kaybetmez. Arduino Uno'da int 2 bayttır ve -32768 ile 32767 arasındaki tam sayıları tutar; analogRead()'in verdiği 0–1023 aralığı ve pin numaraları için fazlasıyla yeterlidir. Hız Ayarlı Yürüyen Led projesinin bloklarında potValue = 0 yazarken kodunda yalnız int potValue; yazdığını görebilirsin. İkisi aynı sonucu verir: C++'ta başlangıç değeri verilmeyen global değişkenler sıfırla başlar.

Değişkenin değerini sonradan değiştiren blok "… değişkenine … ata" bloğudur. "potValue değişkenine analog oku A0 ata" bloğu koda potValue = analogRead(A0); olarak çevrilir. Buradaki = işareti matematikteki eşitlik değil, "sağdaki değeri hesapla ve soldaki kutuya koy" demektir. İki değerin eşit olup olmadığını soran karşılaştırma ise C++'ta == ile yazılır; bunu serinin önceki bölümünde eğer bloğuyla görmüştük. Atama bloğu çalıştığında kutudaki eski değer silinir, yenisi yazılır. Değişkeni okuyan bloklar da artık o yeni değeri kullanır: "potValue ms bekle" bloğu, potValue'da o anda hangi sayı varsa o kadar milisaniye bekler.

Sayma döngüsü: "i değişkeniyle say" bloğu ve Arduino for döngüsü

Bir işi belli sayıda tekrar etmek için yeşil renkli "i değişkeniyle say: 0 ile 5 arası, adım 1" bloğu kullanılır. Bu blok i adlı bir sayaç oluşturur, ona önce 0 verir, içindeki blokları çalıştırır, sonra i'yi 1 artırıp yeniden çalıştırır ve i 5'i geçene kadar böyle devam eder. Arduino'daki karşılığı for (int i = 0; i < 6; i++) satırıdır. Parantezin içinde noktalı virgülle ayrılmış üç bölüm vardır: başlangıç (int i = 0), devam koşulu (i < 6) ve her turdan sonra yapılacak artış (i++, yani i'yi bir artır). Dikkat etmen gereken en önemli nokta şu: bloktaki bitiş değeri dahildir. "0 ile 5 arası" demek 0, 1, 2, 3, 4 ve 5 demektir; yani döngü 5 değil 6 kez döner ve altı LED'in her birine bir tur düşer. Kodda bu yüzden i <= 5 yerine aynı anlama gelen i < 6 yazar. Arduino kodlarında "sıfırdan başla, eleman sayısından küçükken devam et" kalıbı çok yaygındır, çünkü 6 rakamı doğrudan LED sayısını söyler.

Dizi bloğu: "dizi 2 3 4 5 6 7" ve ledPins[i]

Altı LED için altı ayrı değişken tanımlamak yerine hepsini tek bir listede tutabilirsin. Mor "dizi 2 3 4 5 6 7" bloğu "tanımla: tam sayı (int) ledPins = …" bloğuna takıldığında koda int ledPins[] = {2, 3, 4, 5, 6, 7}; satırı olarak geçer. Köşeli parantez bunun bir dizi olduğunu, süslü parantez de içindeki değerleri gösterir. Dizideki bir elemana sıra numarasıyla, yani indeksle ulaşılır ve C++'ta indeks 0'dan başlar: ilk eleman ledPins[0], son eleman ledPins[5]'tir. Bloklarda bunu "ledPins dizisinden öğe i" bloğu yapar ve koda ledPins[i] olarak çevrilir. Sayma döngüsü de 0'dan başladığı için ikisi birbirine tam oturur: i her turda bir sonraki indeksi, ledPins[i] de o indeksteki pin numarasını verir. Dizinin bir başka güzelliği şu: LED'lerin sırasını değiştirmek istersen döngüye hiç dokunmadan yalnız listedeki sayıların yerini değiştirmen yeterli. Dizileri daha ayrıntılı öğrenmek istersen Arduino'da dizi kullanımı yazısına bakabilirsin.

Yürüyen Led: bloklar ve C++ satır satır

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}

Programın akışını bir zaman çizelgesi gibi düşün. Kart açılınca kurulumdaki döngü altı pini 0'dan 5'e kadar sırayla çıkış yapar ve bu iş bir daha tekrarlanmaz. Ardından sürekli tekrarla başlar: içerideki sayma döngüsü D2'deki LED'i yakar, 150 ms bekler, söndürür, sonra aynı işi D3, D4, D5, D6 ve D7 için yapar. Bir tur 6 × 150 = 900 ms sürer. Son LED sönünce loop() biter, kart hemen başa döner ve ışık yeniden D2'den başlar; turlar arasında boşluk olmadığı için ışık durmadan akıyormuş gibi görünür. Hızı değiştirmek için tek bir sayıyı, 150'yi değiştirmen yeter: 50 yazarsan ışık üç kat hızlanır, 500 yazarsan yavaşça yürür. Bu sabit hızı bir düğmeyle ayarlanabilir yapmak bizi sıradaki projeye götürüyor.

Hız Ayarlı Yürüyen Led: potansiyometre değeri bekleme süresi olur

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}

Yürüyen Led'den tek farkı iki yeni bloktur. Genel değişkenlere "tanımla: tam sayı (int) potValue = 0" eklenmiştir ve sayma döngüsünün başında "potValue değişkenine analog oku A0 ata" bloğu vardır. analogRead(A0) potansiyometrenin orta bacağındaki gerilimi 0 ile 1023 arasında bir sayıya çevirir; bu sayı doğrudan "potValue ms bekle" bloğuna, yani delay(potValue) satırına verilir. Böylece potansiyometreyi bir uca çevirdiğinde her LED yaklaşık 1 saniye (1023 ms) yanar ve bir tur 6 saniyeyi bulur; öbür uca çevirdiğinde bekleme 0'a iner ve LED'ler o kadar hızlı yanıp söner ki hepsi aynı anda soluk yanıyor gibi görünür. Okumanın döngünün içinde, her LED'den önce yapılması bilinçli bir seçimdir: düğmeyi çevirdiğin anda bir sonraki LED yeni hızla yanar, turun bitmesini beklemezsin. Potansiyometrenin nasıl çalıştığını potansiyometre nedir yazısında ayrıntılı bulabilirsin.

Karaşimşek: ileri ve geri sayan iki döngü

Karaşimşek efektinde ışık bir uçtan öbür uca gidip geri döner. Karaşimşek Led projesinin bloklarında sürekli tekrarla içinde alt alta iki sayma döngüsü vardır. İlki tanıdık "i değişkeniyle say: 0 ile 5 arası, adım 1" bloğudur ve ışığı D2'den D7'ye götürür. İkincisi "i değişkeniyle say: 4 ile 1 arası, adım 1" bloğudur: başlangıç bitişten büyük olduğu için blok geriye doğru sayar ve i sırayla 4, 3, 2, 1 olur. Kodda bu for(int i = 4; i > 0; i--) satırıdır; i-- i'yi bir azaltır. Neden 5'ten 0'a değil de 4'ten 1'e? Çünkü ledPins[5] (D7) ileri turun sonunda, ledPins[0] (D2) ise bir sonraki ileri turun başında zaten yanıyor. Uçları geri dönüşte atlamak, uçtaki LED'lerin iki kez üst üste yanmasını engeller ve sekme akıcı görünür. Bir gidiş-dönüş 6 + 4 = 10 adım, her adım 100 ms, toplam 1 saniyedir. Hız Ayarlı Karaşimşek Led projesi aynı iki döngüyü kullanır; yalnız iki döngünün de başına "potValue değişkenine analog oku A0 ata" bloğunu ekler ve 100 ms yerine "potValue ms bekle" kullanır. Daha fazla desen fikri için Arduino karaşimşek ve yürüyen LED yazısına göz atabilirsin.

Kendi sayaç örneğin: tur sayacı ve seri port

Şimdi öğrendiklerini birleştiren küçük bir örnek yazalım: Yürüyen Led her turu bitirdiğinde bir sayaç artsın, kart da hem i'nin aldığı değerleri hem tur sayısını bilgisayara yazsın. Bunu görsellerdeki bloklarla şöyle kurarsın: genel değişkenlere, ledPins dizisinin altına "tanımla: tam sayı (int) rounds = 0" eklenir. Kuruluma "seri portu 9600 baud ile başlat" bloğu girer. Sayma döngüsünün içinde, LED'i yakmadan önce "seri porta yaz" bloklarıyla "i = " metni, i ve " pin = " metni "aynı satırda kal" seçeneğiyle, ardından "ledPins dizisinden öğe i" "alt satıra geç" seçeneğiyle yazdırılır. Sayma döngüsü bittikten sonra, hâlâ sürekli tekrarla içindeyken, "rounds değişkenine … ata" bloğuna rounds + 1 toplaması verilir ve tur sayısı "seri porta yaz … alt satıra geç" ile ekrana gelir.

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}

Kodu yükledikten sonra Arduino IDE'de seri monitörü aç ve hızı 9600 baud yap. Her turda altı satır göreceksin: "i = 0 pin = 2"den "i = 5 pin = 7"ye kadar, ardından 1, 2, 3 diye artan bir "Tur / Round" satırı. Bu çıktı, sayma bloğundaki bitiş değerinin dahil olduğunun en net kanıtıdır: 0 ile 5 arası tam altı değer üretir. rounds değişkeninin genel değişkenlerde tanımlandığına da dikkat et; loop() her başladığında sıfırlanmaz, değerini turdan tura taşır. Bir tur 6 × 300 = 1,8 saniye sürdüğü için int'in sınırı olan 32767'ye yaklaşık 16 saatte ulaşılır; daha uzun sayacaksan değişkeni unsigned long yapabilirsin. Seri monitörün ayrıntıları Arduino seri monitör yazısında.

Devre: 6 LED, 220 Ω direnç ve potansiyometre

220 Ω direnç, 5 V'tan beslenen kırmızı bir LED'den yaklaşık (5 − 2) / 220 ≈ 14 mA akım geçirir; bu hem LED hem Arduino pini için güvenli bir değerdir. Farklı renkte LED kullanıyorsan direnci LED direnci hesaplayıcı ile kontrol edebilirsin. Bütün katotları breadboard'un GND hattında topla ve bu hattı Arduino'nun GND pinine bağla. Potansiyometrenin uç bacaklarını ters bağlarsan bir şey bozulmaz, yalnız çevirme yönü tersine döner. Yürüyen Led ve Karaşimşek Led potansiyometreyi kullanmaz; bağlı kalması da sorun çıkarmaz, böylece dört projeyi aynı devrede sırayla deneyebilirsin.

Döngü ve değişkenlerde sık yapılan hatalar

BlueGrays uygulamasında döngü ve değişken bloklarını incelemek

Bu yazıdaki dört proje ve aşağıdakiler BlueGrays uygulamasında hem bloklarıyla hem koduyla tamamen ücretsiz. Bir projenin kod bölümünde Bloklarla göster anahtarını açınca kodun yerine aynı programın blokları gelir; görsele dokunursan tam ekran açılır ve uzun sayma döngülerini rahatça büyütüp inceleyebilirsin. Blokları anla sekmesi programı adım adım anlatır; her adımda yalnız o adımın bloklarını ve ne yaptığını gösterir. Bloklarıyla bakmaya değer başka ücretsiz projeler: delayTime değişkeni ve iki sayma döngüsüyle çalışan Polis Çakar, sürekli tekrarla içinde dört durumu sırayla geçen Trafik Lambası, okuduğu değeri bir değişkende tutup seri porta yazan Ldr İle Işık Şiddeti Okuma ve LED'in durumunu bir değişkende hatırlayan Buton İle Led Yakma (On Off). Kod rehberindeki her Arduino örneği de bloklarla gösteriliyor, Günün soruları ise her gün A1'den C2'ye seviyelerde 5 soruyla öğrendiklerini pekiştirmene yardım ediyor. Bütün bloklu projelerin listesi blok kodlama sayfasında. Bloklar karta doğrudan yüklenmez; karta her zaman projenin gerçek kodu yüklenir, yani bloklarla anladığın programı Arduino IDE'ye kopyalayıp kartına gönderirsin.

Döngüleri ve değişkenleri öğrendiğine göre sıradaki adım, bu sayıları gerçek dünyadan almak: serinin 5. bölümünde bloklarla sensör okumayı, seri portu ve Pico'da MicroPython'a geçişi anlatıyoruz. O zamana kadar BlueGrays uygulamasında Yürüyen Led, Karaşimşek ve hız ayarlı hâllerine devre şeması ve koduyla bakabilir, Bloklarla göster ile blok hâline, Blokları anla ile adım adım açıklamasına geçerek her sayma döngüsünün kodda hangi satıra karşılık geldiğini kendin takip edebilirsin.