Bloklarla Sensör Okuma ve Blok Kodlamadan MicroPython'a Geçiş

Bloklarla sensör okuma, bir sensörden gelen değeri kod yazmadan, renkli bloklarla okuyup ekrana yazdırmaktır: "analog oku A0" bloğu bir LDR'nin ışık değerini alır, "seri porta yaz" bloğu da bu sayıyı bilgisayardaki Seri Monitör'e gönderir. Bu yazıda önce Arduino'da bloklarla sensör okumayı LDR ve HC-SR04 projeleri üzerinden görecek, her bloğun karşılığı olan analogRead(), Serial.begin(), Serial.println() ve pulseIn() satırlarını yan yana inceleyeceksin. Ardından blok kodlamadan MicroPython'a geçiş adımını Raspberry Pi Pico üzerinde atacak, aynı bloklar Python koduna dönüştüğünde neyin değiştiğini öğreneceksin.

Serideki programların hepsi şimdiye kadar dışarıya bir şey yaptırıyordu: LED yaktık, butona baktık, döngüyle sayaç kurduk. Sensör okumak ise ters yönde çalışır; kart dış dünyayı ölçer, sen de o sayıyı görürsün. Bu yüzden bu bölümde seri port da işin içine giriyor, çünkü sensörün ne ölçtüğünü anlamanın en kolay yolu değeri bilgisayar ekranında görmektir. Yazının ikinci yarısındaki Raspberry Pi Pico blok kodlama projelerinde ise bloklar C++ yerine MicroPython'a karşılık gelir. Kullandığımız bütün projeler BlueGrays'te ücretsizdir ve kodları buradaki alıntılarla birebir aynıdır.

Sensör okumak ne demek: dijital ve analog giriş

Bir buton yalnız iki durum bildirir: basılı ya da değil. Bunu "… numaralı pini oku" bloğuyla (digitalRead) okursun ve sonuç 0 ya da 1 olur. LDR, potansiyometre ya da toprak nem sensörü gibi parçalar ise aradaki bütün değerleri verir; pine gelen gerilim 0 ile 5 V arasında sürekli değişir. Bu gerilimi sayıya çeviren devreye ADC (analogdan dijitale dönüştürücü) denir. Arduino Uno'nun ADC'si 10 bitliktir, yani gerilimi 1024 basamağa böler ve 0–1023 arası bir sayı verir; her basamak yaklaşık 4,9 mV'tur. ESP32 ve Pico'nun ADC'si 12 bitliktir ve 3,3 V ile çalışır. Kartlar arasındaki bu fark, bloktan koda geçerken en sık karıştırılan konulardan biridir; ayrıntısını ADC ve analog dijital dönüşüm yazısında bulabilirsin.

Arduino'da bloklarla LDR okuma

İlk örneğimiz Ldr İle Işık Şiddeti Okuma projesi. LDR, ışık arttıkça direnci düşen bir dirençtir; tek başına gerilim üretmez. Onu ölçebilmek için 10 kΩ'luk sabit bir dirençle seri bağlayıp gerilim bölücü kurarız ve ortadaki noktayı A0'a veririz. Aşağıdaki bağlantıda LDR 5V tarafında olduğu için ışık arttıkça A0'daki gerilim ve okunan sayı büyür; LDR ile direncin yerini değiştirirsen yön tersine döner. Bölücünün çıkışını farklı LDR değerleri için gerilim bölücü hesaplayıcı ile bulabilir, LDR'nin karanlıkta ve aydınlıkta kaç ohm olduğunu LDR ışık sensörü yazısında görebilirsin. Tablonun Pico sütununu yazının sonundaki MicroPython örneğinde kullanacağız.

Blokları yukarıdan aşağı oku. genel değişkenler (en başta) içindeki "tanımla: tam sayı (int) value = 0" bloğu kodun en üstündeki int value; satırıdır. kurulum (bir kez çalışır) bölümünde tek blok var: "seri portu 9600 baud ile başlat", yani Serial.begin(9600);. sürekli tekrarla içinde önce "value değişkenine analog oku A0 ata" gelir; bu, value = analogRead(A0); satırıdır. Sonra iki "seri porta yaz" bloğu var. İlki "Value:" metnini aynı satırda kal seçeneğiyle yazar ve Serial.print() olur; ikincisi value'yu alt satıra geç seçeneğiyle yazar ve Serial.println() olur. Böylece her ölçüm ekranda "Value: 512" gibi tek bir satır olarak görünür. Son blok "500 ms bekle" de delay(500); satırıdır, yani saniyede iki ölçüm alırsın. Okunan sayıyı gerilime çevirmek istersen value × 5,0 / 1023 hesabını kullan: 512 yaklaşık 2,5 V demektir. Karanlık bir odada değerin birkaç yüze düştüğünü, LDR'ye el feneri tuttuğunda 900'ün üzerine çıktığını görebilirsin; kesin sayılar LDR'ye ve ortam ışığına göre değişir.

1int value;   // Işık değeri / Light reading (0-1023)
2
3void setup() {
4  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
5}
6
7void loop() {
8  value = analogRead(A0);   // LDR gerilimini oku / Read the LDR voltage
9  Serial.print("Value: ");
10  Serial.println(value);
11  delay(500);               // 0,5 sn bekle / Wait 0.5 s
12}

Seri Monitör'ü açıp değerleri görmek

1. Kodu Arduino IDE'ye yapıştır, kartı ve portu seçip Yükle'ye bas.
2. Yükleme bitince sağ üstteki büyüteç simgesine ya da Araçlar > Seri Port Ekranı menüsüne tıkla (kısayol Ctrl+Shift+M).
3. Seri Monitör'ün baud hızı kutusunu koddaki değerle aynı yap: bu projede 9600 baud.
4. Ekranda her yarım saniyede bir "Value: …" satırı akmaya başlar. LDR'nin üstünü elinle kapat ve sayının düştüğünü izle.
5. Değişimi grafik olarak görmek istersen Araçlar > Seri Çizici'yi aç; aynı veriler zaman çizgisi olarak çizilir.
6. Satır sonu ayarlarını ve Seri Monitör'den karta veri göndermeyi Arduino Seri Monitör yazısında ayrıntılı bulabilirsin.

HC-SR04 ile mesafe: µs bekle ve darbe süresi blokları

İkinci sensör projesi HC-SR04 Mesafe Ölçme (Serial Ekran). Burada iki yeni blok var. "trigPin numaralı pine YÜKSEK yaz" ile başlayan üçlü, sensöre ses dalgası göndermesini söyler: aradaki "10 µs bekle" bloğu delayMicroseconds(10); satırıdır ve "ms bekle"den bin kat kısa bir beklemedir. Ardından "duration değişkenine echoPin numaralı pinde YÜKSEK darbe süresi (µs) ata" bloğu gelir; bu, unsigned long duration = pulseIn(echoPin, HIGH); satırıdır ve Echo pininin kaç mikrosaniye YÜKSEK kaldığını ölçer. Ses havada yaklaşık 0,034 cm/µs hızla gider ve bu süre gidiş-dönüş yolunu kapsar. Bu yüzden "totalPath değişkenine duration x 0.034 ata" bloğu toplam yolu, "distance değişkenine totalPath ÷ 2 ata" bloğu da tek yönlü mesafeyi hesaplar. Örneğin 1000 µs'lik bir darbe 34 cm yol, yani 17 cm mesafe demektir; distance bir int olduğu için ondalık kısım atılır. Son olarak "eğer distance > minDistance ve distance < maxDistance" bloğu if (distance > minDistance && distance < maxDistance) olur ve yalnız 3 ile 100 cm arasındaki ölçümleri yazdırır. Sensör yankı alamazsa pulseIn() 0 döndürür; bu kontrol o hatalı sıfırları da ekrandan uzak tutar. Pinler kodda trigPin = 7 ve echoPin = 6. Sensörün çalışma aralığı ve doğruluğu için HC-SR04 mesafe sensörü yazısına bakabilirsin.

ESP32'de aynı fikir: 12 bitlik ADC

Aynı LDR mantığının ESP32 hâli ESP32 LDR Modülü ile Işık Şiddeti Okuma projesinde. Bloklar yine C++ koduna karşılık gelir ve Arduino'daki gibi okunur, ama üç fark var. Birincisi, kod setup() içinde analogReadResolution(12) ile ADC'yi 12 bite sabitler; bu yüzden analogRead() 0–1023 değil 0–4095 arası değer döndürür ve Arduino için yazılmış "500'den küçükse karanlık" gibi bir eşik ESP32'de aynı anlama gelmez. İkincisi, seri port 9600 yerine 115200 baud ile açılır, Seri Monitör'ü de 115200'e almalısın. Üçüncüsü, LDR modülünün AO çıkışında ışık arttıkça gerilim ve ham değer düşer. Kod bu yüzden RAW_DARK = 4000 ve RAW_LIGHT = 100 kalibrasyon değerlerini kullanır, constrain() ile değeri bu aralıkta tutar ve map() ile karanlığı %0, aydınlığı %100 yapar. Klasik ESP32 DevKit'te LDR, ADC1'e bağlı ve yalnız giriş olarak kullanılabilen GPIO 34'e bağlanır. Wi-Fi açıkken ADC2 pinleri okunamadığı için analog sensörleri ADC1 pinlerine bağlamak iyi bir alışkanlıktır. Kartın genel özellikleri için ESP32 nedir yazısına bakabilirsin.

Raspberry Pi Pico'da bloktan MicroPython'a

Pico projelerinde bloklar C++ yerine MicroPython koduna karşılık gelir. Blokların görünüşü tanıdık, ama alttaki dil farklı: süslü parantez ve noktalı virgül yoktur, kod blokları girintiyle ayrılır, setup() ve loop() fonksiyonları da bulunmaz. Bu geçişi en sade projeyle, Raspberry Pi Pico Harici LED Yakma (GP14 + Breadboard) ile yapalım. Devre çok basit: GP14 (fiziksel pin 19) 220–330 Ω'luk bir dirençle LED'in uzun bacağına, LED'in kısa bacağı GND'ye (örneğin fiziksel pin 18) gider. Program LED'i yarım saniye yakıp yarım saniye söndürür ve her adımda Thonny'nin Shell penceresine bir satır yazar. Pico'yu yeni tanıyorsan Raspberry Pi Pico nedir yazısıyla başlayabilirsin.

1from machine import Pin
2import time
3
4# ============ PIN / PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)

Tabloda dikkat çeken dört nokta var. Birincisi, from machine import Pin ve import time satırlarının bloğu yoktur; Python'da kullanacağın modülleri en başta içe aktarırsın, bloklar bunu senin yerine varsayar. İkincisi, Arduino'daki "seri portu 9600 baud ile başlat" bloğunun burada karşılığı yok: Pico'da print() çıktısı doğrudan USB üzerinden Thonny'nin Shell penceresine gider, baud ayarı gerekmez. Üçüncüsü, bekleme birimi değişti: Arduino'da "500 ms bekle" bloğu delay(500) iken Pico'da "0.5 saniye bekle" bloğu time.sleep(0.5) olur. Dördüncüsü ve en önemlisi girinti: blokta "sürekli tekrarla" bloğunun ağzına oturan her blok, kodda while True: satırının altında dört boşluk içeride yazılır. Bir satırın girintisini silersen o satır döngünün dışına çıkar; C++'taki süslü parantezlerin işini Python'da boşluklar görür. MicroPython'un diğer temel kurallarını MicroPython temelleri yazısında bulabilirsin.

Aynı işlemler üç dilde: blok, C++ ve MicroPython

Kendi örneğin: Pico'da LDR'yi MicroPython ile okumak

Şimdi Arduino'daki LDR projesini Pico'ya taşıyalım. Bağlantı yukarıdaki tablonun Pico sütunundaki gibi: LDR'nin bir bacağı 3V3(OUT) pinine, diğer bacağı hem GP26'ya hem de 10 kΩ direncin bir ucuna, direncin diğer ucu GND'ye gider. Pico'da analog okuma yapabilen üç pin vardır: GP26 (ADC0), GP27 (ADC1) ve GP28 (ADC2). MicroPython'da ADC(26) nesnesini oluşturup read_u16() çağırırsın; Pico'nun ADC'si donanımda 12 bitlik olsa da bu fonksiyon sonucu 0–65535 aralığına ölçekler. Gerilimi bulmak için değeri 3,3 ile çarpıp 65535'e bölersin. Program Arduino sürümüyle aynı akışı izler: ölç, yazdır, yarım saniye bekle. Üstüne bir de eşik ekledik: oda kararınca dahili LED yanar. Bloklarla düşünürsen while True'dan önceki satırlar "kurulum (bir kez çalışır)" bölümü, while True: "sürekli tekrarla", if/else serinin 3. bölümündeki "eğer … yap … değilse" bloğu, led.on() "led pinini aç (on)", time.sleep(0.5) "0.5 saniye bekle", print() içindeki + str() de "metinleri birleştir" bloğudur. ADC(26).read_u16() satırı ise Arduino'daki "analog oku A0" bloğunun işini görür. THRESHOLD değerini kendi odanda Shell'de gördüğün sayılara göre ayarla.

1from machine import Pin, ADC
2import time
3
4# ============ PIN / PIN ============
5ldr = ADC(26)                   # GP26 = ADC0, bölücünün orta noktası / divider midpoint
6led = Pin(25, Pin.OUT)          # Dahili LED; Pico W'de Pin("LED") / Onboard LED; Pico W: Pin("LED")
7THRESHOLD = 20000               # Karanlık eşiği, odana göre ayarla / Darkness threshold, tune for your room
8
9print("== BlueGrays: Pico LDR ==")
10
11# ============ ANA DÖNGÜ / MAIN LOOP ============
12while True:
13    value = ldr.read_u16()                      # 0-65535
14    voltage = value * 3.3 / 65535               # Volt / Volts
15    print("Value: " + str(value) + "  Voltage: " + str(round(voltage, 2)) + " V")
16
17    if value < THRESHOLD:                       # Az ışık = küçük değer / Little light = small value
18        led.on()
19    else:
20        led.off()
21
22    time.sleep(0.5)                             # 0,5 sn = 500 ms / 0.5 s = 500 ms

Thonny ile Pico'ya yükleme ve main.py

1. Bilgisayarına Thonny'yi kur. Pico'da MicroPython yoksa BOOTSEL düğmesine basılı tutarak USB kablosunu tak; Thonny ilk bağlantıda MicroPython'u kurmayı önerir.
2. Thonny'nin sağ alt köşesinden yorumlayıcı olarak MicroPython (Raspberry Pi Pico) seç. Alttaki Shell penceresinde >>> işaretini görürsen bağlantı tamamdır.
3. Projenin kodunu BlueGrays'ten kopyalayıp Thonny'nin editörüne yapıştır.
4. Yeşil Çalıştır düğmesine ya da F5'e bas. Kod Pico'da çalışır, print() çıktıları Shell'de görünür. Durdurmak için Dur düğmesini (Ctrl+F2) kullan.
5. Kodun bilgisayar olmadan da çalışmasını istiyorsan Dosya > Farklı kaydet'i seç, açılan pencerede Raspberry Pi Pico'yu işaretle ve dosya adını main.py yaz. Pico her enerji aldığında bu dosyayı otomatik çalıştırır; artık bir USB şarj aleti ya da powerbank yeterli.
6. Thonny kartı görmüyorsa kabloyu ve sürücüleri Raspberry Pi Pico tanınmıyor yazısındaki sırayla kontrol et.

Diğer ücretsiz Pico blok projeleri

• Raspberry Pi Pico Dahili LED Yakma (GP25): Hiç kablo gerektirmez; LED_PIN = 25 ile karttaki LED'i yakar. Kodu yukarıdaki projeyle neredeyse aynıdır, iki projeyi yan yana açıp yalnız pin numarasının değiştiğini görebilirsin. Pico W'de dahili LED Wi-Fi yongasına bağlı olduğu için Pin("LED") kullanılır.
• Raspberry Pi Pico 2 LED Alternatif Yakma (GP14 + GP13): led1.value(1) ve led2.value(0) ile zıt durumlardan başlar, döngüde iki LED'e de toggle() uygular. Kod from time import sleep yazdığı için bekleme time.sleep(0.5) değil sleep(0.5) olarak görünür.
• Raspberry Pi Pico Trafik Lambası (GP11/GP12/GP13): all_off() adlı bir fonksiyonla bütün LED'leri söndürür; yeşil 4, sarı 1,5, kırmızı 3 saniye yanar, ardından 1 saniyelik kırmızı+sarı kalkış evresi gelir.
• Raspberry Pi Pico Polis Çakar Efekti (GP11 + GP12): Bu kez bekleme sleep_ms(WAIT_MS) ile milisaniye cinsinden yapılır ve WAIT_MS = 300'dür. Saniye ve milisaniye fonksiyonlarını iki projede yan yana görmek, aşağıdaki en sık hatayı önlemenin en iyi yolu.

Sık yapılan hatalar ve çözümleri

BlueGrays uygulamasında bloklarla devam etmek

Bu yazıdaki bütün projeler BlueGrays uygulamasında ücretsiz. Bir projenin kod bölümünde Bloklarla göster anahtarını açtığında kodun yerine aynı programın blokları gelir; görsele dokununca tam ekran açılır. 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. HC-SR04 projesinde "darbe süresi" bloğunun neyi ölçtüğünü ya da Pico projesinde kurulum kısmının neden while True'dan önce geldiğini burada tek tek görebilirsin. Kod rehberindeki Arduino ve MicroPython komut örneklerinin hepsi de bloklarla gösteriliyor. Öğrendiklerini sınamak istersen Günün soruları her gün A1'den C2'ye seviyelere göre 5 soru, haftalık sıralama ve rozetler sunuyor. Şunu unutma: bloklar karta doğrudan yüklenmez, karta her zaman projenin gerçek kodu gider; Arduino ve ESP32'de Arduino IDE'ye, Pico'da Thonny'ye kopyalayıp yapıştırırsın. Proje listesinde blok rozeti olan projeleri filtreleyebilir, Arduino, ESP32 ve Pico'daki bütün bloklu projeleri blok kodlama sayfasında görebilirsin.

Seri port ve sensör okumayla birlikte artık bir projenin bütün temel parçalarını hem blok hem kod olarak okuyabiliyorsun. Serinin son bölümünde bu adımları sınıfa taşıyoruz: öğretmenler için blok kodlamayla robotik kodlama ders planı. O zamana kadar BlueGrays uygulamasında LDR, HC-SR04 ve Pico LED projelerinin devre şemalarına ve kodlarına adım adım bakabilir, Bloklarla göster ile aynı programın blok hâline geçebilir, Blokları anla ile her adımın ne yaptığını tek tek izleyebilirsin.