Blok Kodlamadan Arduino Koduna Geçiş: C++ ve MicroPython Tablosu

Blok kodlamadan Arduino koduna geçiş için en hızlı yol, her bloğun gerçek kodda hangi satıra denk geldiğini gösteren tek sayfalık bir karşılık tablosunu yanında tutmaktır. Kısa cevap şu: bloklar yeni bir dil değil, Arduino C++ satırlarının görsel hâlidir. "13 numaralı pini ÇIKIŞ olarak ayarla" bloğu pinMode(13, OUTPUT); satırıdır, "1000 ms bekle" bloğu delay(1000); satırıdır, "eğer … yap" bloğu da if yapısıdır. Aşağıdaki tabloda BlueGrays uygulamasındaki blokların gerçek Türkçe etiketleri, Arduino C++ karşılıkları ve Raspberry Pi Pico'da MicroPython karşılıkları yan yana duruyor.

Bu sayfa bir ders değil, bir başvuru kâğıdı. Tabloyu yazdırıp masanın yanına koyabilir, bir projenin bloklarına bakarken hangi satırın neye denk geldiğini oradan kontrol edebilirsin. Tablonun ardından geçişte en sık yapılan hataları, blokları bırakıp koda geçmek için dört aşamalı bir yöntemi ve aynı programın blok, C++ ve MicroPython hâllerini bulacaksın. Örnek program Arduino IDE'de derlenir, Pico'da Thonny ile çalışır.

Tabloyu okumadan önce: üç dil arasındaki dört fark

Blok, C++ ve MicroPython aynı fikri anlatır ama yazım kuralları farklıdır. Tabloyu okurken en çok şu dört farka takılırsın. Birincisi yapı: Arduino C++'ta program setup() ve loop() adlı iki parçadan oluşur, bloklarda bunlar "kurulum (bir kez çalışır)" ve "sürekli tekrarla" diye görünür. MicroPython'da ayrı bir setup yoktur; dosya yukarıdan aşağı bir kez çalışır ve tekrar eden kısım while True: döngüsünün içine yazılır. İkincisi tipler: C++'ta her değişkenin tipi yazılır (int, float, bool), bloklarda bu "tanımla: tam sayı (int)" seçeneğidir, Python'da ise tip hiç yazılmaz.

Üçüncü fark sayı aralıklarıdır. Arduino Uno'da analog okuma 0–1023, PWM 0–255 arasındadır; ESP32'de analog okuma 0–4095'e çıkar; Pico'da MicroPython hem okumayı hem PWM doluluğunu 0–65535 aralığında verir. Bu yüzden bir eşik değerini karttan karta olduğu gibi taşıyamazsın. Dördüncü fark zaman birimidir: delay() milisaniye ister, time.sleep() saniye ister. Yarım saniye C++'ta delay(500), MicroPython'da time.sleep(0.5) olur. Bu dört kuralı aklında tutarsan tablodaki satırların çoğu kendiliğinden yerine oturur.

• Tablodaki sayılar örnektir: blokta 13 yazan yerde senin projende 7 de olabilir, kod satırında da aynı sayı değişir.
• MicroPython sütunundaki pinler Pico'nun GP numaralarıdır (GP14, GP15, GP26). Uno'daki pin numarasıyla aynı olmaları gerekmez; devre şemasına bak.
• "Pico'da blok yok" yazan satırlar, o bloğun Pico projelerinde kullanılmadığını gösterir; MicroPython'da aynı işi gören kod yine de verildi.
• ESP32 de Arduino C++ ile programlanır; C++ sütunu ESP32 için de geçerlidir, yalnız analog aralık ve bazı pin numaraları farklıdır.

Blok, Arduino C++ ve MicroPython karşılık tablosu

Tablo 12 gruba ayrıldı: program yapısı, pinler, zaman, koşul, döngü, değişkenler, matematik, seri port, analog ve PWM, ses, servo ve sensör. Blok sütunundaki metinler uygulamadaki blokların üzerinde yazan etiketlerdir, "…" ve "?" işaretleri başka bir bloğun takıldığı yuvayı gösterir. Bir satırda birden fazla blok varsa nokta ile ayrıldı.

Tablonun bazı satırları ilk bakışta birebir görünse de dikkat ister. "i değişkeniyle say: 0 ile 5 arası" bloğunda 5 dahildir, döngü 6 kez döner; C++'ta bu yüzden < değil <= yazılır, Python'da range(0, 6) gerekir çünkü range bitiş sayısını dahil etmez. Bölme bloğu da tuzaklıdır: iki tam sayıyı böldüğünde C++ küsuratı atar ve 7 / 2 sonucu 3 olur, Python ise 3.5 verir. Python'da C++ gibi tam bölme istersen // kullanırsın. "x değerini eşle" bloğunun karşılığı olan map() MicroPython'da hazır gelmez; aşağıdaki örnekte iki satırlık bir arduino_map() işleviyle aynı hesabı yapıyoruz.

İç içe bloklar koda nasıl dönüşür?

Tek tek blokları bilmek yetmez; asıl beceri, iç içe geçmiş blokları tek bir satıra çevirebilmektir. Bunun için bloklarda iki şekli ayırt et. Alt alta dizilen, kenarında çıkıntı olan bloklar komuttur ve her biri kodda bir satır olur. Oval ya da köşeli, başka bir bloğun yuvasına takılan bloklar değerdir; bunlar kodda bir parantezin içine, bir eşittirin sağına ya da bir koşulun içine yerleşir. Aşağıdaki satırlar ücretsiz Buzzer İle Frekans Ayarı projesinden: dört buton frekansı açıp kapatır, artırıp azaltır, değer 50 ile 5000 Hz arasında tutulur.

Bu tabloyu okurken bir alışkanlık edin: önce en içteki bloğu çevir, sonra dışarı doğru ilerle. "frequency değişkenine (frequency değerini 50 ile 5000 arasında sınırla) ata" satırında en içte constrain(frequency, 50, 5000) vardır, dıştaki ata bloğu bunu frequency = … biçimine sokar. Değer bloğu tek başına satır olamaz; ona noktalı virgül koyup bırakırsan derleyici hata vermeyebilir ama sonuç hiçbir yere kaydedilmez.

Bloktan koda geçişte sık yapılan hatalar

Blok editörü bu hataların çoğunu yapmana izin vermez; parçaların şekli yanlış yere takılmayı engeller. Kodda bu koruma kalktığı için geçişin ilk haftalarında aşağıdaki hatalar neredeyse herkesin karşısına çıkar. Hata mesajı İngilizce gelir ama kalıpları azdır; birkaç kez gördükten sonra tanırsın.

Blokları bırakıp koda geçmek: 4 aşamalı yöntem

Geçişi tek seferde yapmaya çalışmak yorucudur. Aşağıdaki dört aşama, okumaktan yazmaya doğru küçük adımlarla ilerler. Her aşamaya bir iki proje ayırmak yeterli; bir sonrakine geçme ölçütü, o aşamadaki işi tabloya bakmadan yapabilmektir.

1. Yan yana oku. Bir projenin bloklarını ve kodunu aynı anda aç, her bloğun kodda hangi satıra denk geldiğini parmağınla eşleştir. Bu aşamada tablo hep yanında dursun. Ölçüt: koddaki her satırı bir bloğa bağlayabilmek.
2. Blokları kapat, tahmin et. Önce bloklara bak, sonra blok görünümünü kapat ve kodu görmeden o blokların C++ hâlini kâğıda yaz. Ardından gerçek kodla karşılaştır. Tersini de dene: kodu oku, blokları tahmin et.
3. Değeri kodda değiştir. Kodu bilgisayarına al ve yalnız bir sayıyı değiştir: bekleme süresini 100'den 500'e, eşiği 400'den 600'e çıkar. Yükle, farkı gözünle gör. Derleme hatası alırsan yukarıdaki hata tablosuna dön.
4. Yeni satır yaz. Bloklarda olmayan bir satırı kendin ekle: değeri Seri Monitör'e yazdıran bir Serial.println(), ikinci bir LED ya da butonla çalışan bir if. Artık bloktan çeviri yapmıyor, kodu doğrudan yazıyorsun.

Bu aşamaların derslerdeki karşılığı serinin yazılarında var. İlk aşama için bloklarla LED yakma yazısındaki blok-satır tablosu iyi bir başlangıçtır. İkinci ve üçüncü aşamada koşul ve döngülerle çalışmak için eğer bloğu ve döngü ve değişkenler yazılarına bak. Pico ile MicroPython'a geçeceksen bloklardan MicroPython'a geçiş yazısı Thonny kurulumunu da anlatır. Sınıfta bu geçişi haftalara yaymak istersen 8 haftalık robotik kodlama planı hazır bir sıra sunar.

BlueGrays uygulamasında blok ve kodu yan yana açmak

Bu tabloyu en çok, gerçek bir projenin blokları ile kodu arasında gidip gelirken kullanırsın. BlueGrays uygulamasında 100'ü aşkın projenin blok görünümü var; ücretsiz projelerin 30'u aşkınında bloklar da açık, Premium projelerde bloklar Premium ile açılır. Bloklar okumak içindir: uygulamada blok düzenlenmez ve bloklar karta yüklenmez. Karta giden her zaman gerçek koddur; onu Kopyala ya da bilgisayarda açmak için Linki Kopyala ile alıp Arduino IDE'ye ya da Pico için Thonny'ye yapıştırırsın.

• Bloklarla göster: Proje sayfasındaki kaynak kodun yanında bu anahtarı açınca aynı program, uygulamanın dilinde blok görseli olarak görünür. Görsele dokununca tam ekran açılır; anahtarı kapatıp açarak birinci ve ikinci aşamayı uygularsın.
• Blokları anla: Blok görünümü açıkken "Kodu anla" sekmesi bu adı alır. Program adım adım parçalara ayrılır; her adımda ilgili parça ve açıklaması yer alır. Sondaki "Kendin dene" görevi dördüncü aşama için hazır bir alıştırmadır.
• Kod rehberi: Öğren bölümündeki 36 kartın (18 Arduino C++, 18 MicroPython) her birinde örnek, Blok, Arduino ve MicroPython sekmeleriyle üç hâlde gösterilir. Tablodaki bir satırı daha ayrıntılı görmek istersen ilgili karta bak.
• Blok kodlu projeler: Keşfet > Projeler bölümünde Filtrele içindeki bu seçenek, yalnız blok görünümü olan projeleri listeler; geçiş için proje seçerken işini kolaylaştırır.

Kod rehberinin nasıl ilerlediğini kod rehberi yazısında, "Kodu anla" ve "Kendin dene" bölümlerini de kodu anla rehberinde ayrıntılı anlattık. Komutların tek tek açıklaması için Arduino komutları listesi de bu tabloyla birlikte iyi çalışır.

Örnek program üç hâliyle: ışığa göre kısılan gece lambası

Tabloyu bir arada görmek için küçük bir program kuralım. Bir LDR ışığı ölçer; oda aydınlıkken LED kapalı kalır, karanlık arttıkça LED yavaş yavaş parlar. Program değişken, analog okuma, koşul, eşleme, PWM, seri port ve bekleme bloklarını kullanır; yani tablonun yarısından fazlası tek örnekte geçer. Fikir ücretsiz Ldr İle Gece Lambası projesine dayanıyor; orada LED yalnız yanar ya da söner, burada PWM ile kısılır. LDR'nin bağlantısı için Ldr İle Işık Şiddeti Okuma projesinin devre şemasına da bakabilirsin.

Önce blok hâli. Uygulamadaki etiketlerle program şu bloklardan oluşur; her madde, aşağıdaki C++ kodunda bir ya da birkaç satıra denk gelir:

1. genel değişkenler (en başta): tanımla: tam sayı (int) lightValue = 0 ve tanımla: tam sayı (int) brightness = 0
2. kurulum (bir kez çalışır): seri portu 9600 baud ile başlat, ardından 9 numaralı pini ÇIKIŞ olarak ayarla
3. sürekli tekrarla: lightValue değişkenine (analog oku A0) ata
4. eğer (lightValue < 400) yap: brightness değişkenine (lightValue değerini eşle: 0 – 400 → 255 – 0) ata; değilse: brightness değişkenine 0 ata
5. 9 numaralı pine PWM brightness yaz
6. seri porta yaz "Light: " aynı satırda kal, seri porta yaz lightValue aynı satırda kal, seri porta yaz " PWM: " aynı satırda kal, seri porta yaz brightness alt satıra geç
7. 200 ms bekle

1// ─────────────────────────────────────────
2//   BlueGrays · bluegrays.com
3//   Işığa göre kısılan gece lambası / Dimming night light
4// ─────────────────────────────────────────
5
6int lightValue = 0;   // LDR okuması / LDR reading (0-1023)
7int brightness = 0;   // LED parlaklığı / LED brightness (0-255)
8
9void setup() {
10  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
11  pinMode(9, OUTPUT);   // LED, PWM pini D9 / LED on PWM pin D9
12}
13
14void loop() {
15  lightValue = analogRead(A0);   // Az ışık = küçük değer / Little light = small value
16
17  if (lightValue < 400) {
18    // Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
19    brightness = map(lightValue, 0, 400, 255, 0);
20  } else {
21    brightness = 0;   // Oda aydınlık, LED kapalı / Room is bright, LED off
22  }
23
24  analogWrite(9, brightness);   // PWM 0-255 / PWM 0-255
25
26  Serial.print("Light: ");
27  Serial.print(lightValue);
28  Serial.print("  PWM: ");
29  Serial.println(brightness);
30
31  delay(200);   // 0,2 sn bekle / Wait 0.2 s
32}
33

1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Işığa göre kısılan gece lambası / Dimming night light
4# ─────────────────────────────────────────
5from machine import Pin, ADC, PWM
6import time
7
8ldr = ADC(26)                # GP26 = ADC0 / GP26 = ADC0
9led = PWM(Pin(15))           # LED, GP15 / LED on GP15
10led.freq(1000)               # PWM frekansı 1000 Hz / PWM frequency 1000 Hz
11
12THRESHOLD = 25600            # Uno'daki 400'ün karşılığı / Same as 400 on the Uno
13
14
15def arduino_map(x, in_min, in_max, out_min, out_max):
16    # Arduino map() ile aynı hesap / Same math as Arduino map()
17    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
18
19
20while True:
21    light_value = ldr.read_u16()          # 0-65535 / 0-65535
22
23    if light_value < THRESHOLD:
24        # Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
25        brightness = arduino_map(light_value, 0, THRESHOLD, 65535, 0)
26    else:
27        brightness = 0                    # Oda aydınlık, LED kapalı / Room is bright, LED off
28
29    led.duty_u16(brightness)              # PWM 0-65535 / PWM 0-65535
30
31    print("Light:", light_value, " PWM:", brightness)
32
33    time.sleep(0.2)                       # 0,2 sn bekle / Wait 0.2 s
34

İki kodu satır satır karşılaştırınca tablodaki farkların hepsi görünür. C++'taki setup() Python'da while True'dan önceki satırlardır ve Serial.begin() hiç yoktur. analogRead(A0) yerine ADC(26).read_u16() gelir ve aralık 0–1023'ten 0–65535'e çıkar; bu yüzden eşik 400 yerine 25600'dür. analogWrite(9, …) yerine önce PWM nesnesi kurulur, parlaklık duty_u16() ile 0–65535 arasında verilir. map() hazır olmadığı için arduino_map() işlevi yazılır; içindeki // tam bölme, C++'taki tam sayı bölmesinin aynısıdır. Dört ayrı Serial.print() yerine tek bir print() yeter, delay(200) da time.sleep(0.2) olur.

Blok kodlamadan Arduino C++'a geçiş, yeni bir şey ezberlemekten çok zaten bildiğin blokların yazılı hâlini tanımaktır. Bu tabloyu yanında tut, her projede önce yan yana oku, sonra blokları kapatıp kendin yaz. Tablodaki satırları gerçek projelerde görmek istersen BlueGrays uygulamasında blok görünümü olan projeleri açıp Bloklarla göster anahtarıyla aynı programın iki hâli arasında geçiş yapabilirsin.