Temeller · 9 dk okuma

Arduino Kodu Nasıl Okunur? Satır Satır Arduino Kodu Anlama

Arduino kodu anlama rehberi: kütüphaneler, pin tanımları, setup ve loop, fonksiyonlar, if koşulları; örnek kodun satır satır çözümü, ESP32 ve Pico'ya uyarlama.

Arduino kodu anlama becerisi, hazır bir projeyi kopyalayıp çalışmasını ummakla onu gerçekten kendi projen hâline getirmek arasındaki farktır. İnternetteki, kitaplardaki ya da arkadaşının gönderdiği kodların neredeyse hepsi aynı iskeletle yazılır: üstte kütüphaneler ve pin tanımları, ortada bir kez çalışan setup(), altta sonsuza kadar dönen loop() ve gerekirse kendi fonksiyonlar. Bu iskeleti tanıdığında, hiç görmediğin bir kodda bile "bu satır şu pini okuyor, şu koşulda şu motoru çalıştırıyor" diyebilirsin.

Bu yazıda bir Arduino kodunu okumanın adım adım yöntemini göreceksin. Önce bir kodun bölümlerini ve görevlerini tanıyacak, sonra el yaklaşınca kapağı açılan küçük bir çöp kutusu kodunu satır satır çözeceğiz. Ardından değişkenleri, koşulları ve fonksiyonları okumayı, başkasının kodunu kendi devrene uyarlamayı ve aynı kodu ESP32 ile Raspberry Pi Pico'ya taşımayı anlatacağız. Sonunda BlueGrays'teki "Kodu anla" bölümüyle nasıl pratik yapabileceğini de bulacaksın.

Arduino Uno kartı ve pinleri
Koddaki her pin numarası kart üzerindeki bir yazıya karşılık gelir: const int TRIG_PIN = 9 satırı, kablonun D9 yazan deliğe takılı olduğunu söyler.

Bir Arduino kodunun anatomisi

Arduino kodları (sketch) yukarıdan aşağıya hep aynı düzende ilerler. Derleyici dosyayı baştan sona okur, ama kartın çalıştırdığı sıra farklıdır: önce global tanımlar hazırlanır, sonra setup() bir kez çalışır, ardından loop() kart kapanana kadar tekrar tekrar döner. Aşağıdaki tablo bir kodu açtığında göreceğin bölümleri ve onları nasıl tanıyacağını özetliyor:

Kod bölümüGöreviTipik satırNasıl tanırsın?
YorumlarKodu açıklar, derleyici okumaz// açıklama ya da /* ... */// ile başlar, IDE'de gri görünür
KütüphanelerHazır kod ekler (servo, ekran, sensör)#include <Servo.h># ile başlar, en üsttedir
Pin tanımları ve sabitlerPin numaralarına ve eşiklere ad verirconst int LED_PIN = 13;Çoğunlukla BÜYÜK harfli adlar
Global değişkenler ve nesnelerKodun her yerinden erişilen verilerint count = 0; Servo lidServo;Hiçbir fonksiyonun içinde değildir
setup()Açılışta bir kez çalışırpinMode(LED_PIN, OUTPUT);void setup() { ... }
loop()Sürekli tekrar eder, asıl iş buradaif (distance < 20) { ... }void loop() { ... }
Kendi fonksiyonlarınTekrarlanan işi paketlerlong readDistanceCm() { ... }loop'un altında ya da üstünde ayrı bloklar

Okumaya nereden başlamalı? Beş adımlı yöntem

  1. Yorumları ve kütüphaneleri oku. #include satırları hangi donanımın kullanıldığını ele verir: Servo.h bir servo, LiquidCrystal_I2C.h bir I2C LCD, DHT.h bir sıcaklık sensörü demektir.
  2. Pin tanımlarını kâğıda yaz. Her const int ya da #define satırını "TRIG = D9, ECHO = D10" gibi bir bağlantı listesine çevir ve devrenle karşılaştır.
  3. setup()'ı oku. Hangi pinlerin giriş, hangilerinin çıkış olduğunu, seri haberleşme hızını ve kartın açılıştaki durumunu (servo kapalı, LED sönük gibi) burada görürsün.
  4. loop()'u bir kez elle çalıştır. Kendine bir sensör değeri seç (ör. mesafe 45 cm) ve kodu bu değerle satır satır takip et; hangi if bloğuna girildiğini, hangi değişkenin değiştiğini not al.
  5. Fonksiyonlara ihtiyaç oldukça in. loop() içinde readDistanceCm() gibi bir çağrı gördüğünde önce adından ne yaptığını tahmin et, sonra fonksiyonun içine bakıp tahminini doğrula.

Örnek kod: satır satır çözümleme

Okuma alıştırması için gerçek bir proje kodu seçtik: bir HC-SR04 mesafe sensörü el yaklaştığını görünce servo kapağı açar, üç saniye sonra kapatır, bu sırada bir LED yanar ve kapağın kaç kez açıldığı seri monitöre yazılır. Kodda kütüphane, sabitler, global değişken, nesne, setup, loop, koşul ve kendi fonksiyonun hepsi var. Önce kodun tamamına bir göz at, ardından tabloyla birlikte satır satır inceleyelim.

C++ (Arduino IDE)
1// Akıllı çöp kutusu: el yaklaşınca kapak açılır / Smart bin: the lid opens when a hand comes close
2#include <Servo.h>                  // servo kütüphanesi / servo library
3
4const int TRIG_PIN = 9;             // HC-SR04 TRIG
5const int ECHO_PIN = 10;            // HC-SR04 ECHO
6const int SERVO_PIN = 6;            // servo sinyal kablosu / servo signal wire
7const int LED_PIN = 13;             // durum LED'i / status LED
8const int OPEN_DISTANCE = 20;       // bundan yakınsa aç (cm) / open if closer than this (cm)
9const int OPEN_ANGLE = 90;          // açık kapak açısı / open lid angle
10const int CLOSED_ANGLE = 0;         // kapalı kapak açısı / closed lid angle
11
12Servo lidServo;                     // servo nesnesi / servo object
13int openCount = 0;                  // kaç kez açıldı / how many times it opened
14
15void setup() {
16  Serial.begin(9600);
17  pinMode(TRIG_PIN, OUTPUT);
18  pinMode(ECHO_PIN, INPUT);
19  pinMode(LED_PIN, OUTPUT);
20  lidServo.attach(SERVO_PIN);
21  lidServo.write(CLOSED_ANGLE);     // açılışta kapalı / closed at power-up
22}
23
24void loop() {
25  long distance = readDistanceCm(); // mesafeyi ölç / measure the distance
26  Serial.print("Mesafe / Distance: ");
27  Serial.println(distance);
28
29  if (distance > 0 && distance < OPEN_DISTANCE) {
30    openCount++;                    // sayacı bir artır / add one to the counter
31    digitalWrite(LED_PIN, HIGH);
32    lidServo.write(OPEN_ANGLE);     // kapağı aç / open the lid
33    delay(3000);                    // 3 sn açık kal / stay open for 3 s
34    lidServo.write(CLOSED_ANGLE);   // kapağı kapat / close the lid
35    digitalWrite(LED_PIN, LOW);
36    Serial.print("Acilma sayisi / Times opened: ");
37    Serial.println(openCount);
38  }
39  delay(100);                       // saniyede yaklaşık 10 ölçüm / about 10 readings per second
40}
41
42// Mesafeyi santimetre olarak döndürür / returns the distance in centimetres
43long readDistanceCm() {
44  digitalWrite(TRIG_PIN, LOW);
45  delayMicroseconds(2);
46  digitalWrite(TRIG_PIN, HIGH);     // 10 µs tetik darbesi / 10 µs trigger pulse
47  delayMicroseconds(10);
48  digitalWrite(TRIG_PIN, LOW);
49  long duration = pulseIn(ECHO_PIN, HIGH, 30000);  // en fazla 30 ms bekle / wait at most 30 ms
50  return duration / 58;             // µs'yi cm'ye çevir / convert µs to cm
51}
SatırNe yapar?Değiştirirsen ne olur?
#include <Servo.h>Servo kütüphanesini koda eklerSilersen derleyici "'Servo' does not name a type" hatası verir
const int TRIG_PIN = 9;9 numaralı pine TRIG_PIN adını verirKabloyu başka pine taşırsan yalnızca bu sayıyı değiştirirsin
const int OPEN_DISTANCE = 20;Kapağın açılacağı eşik mesafesi30 yaparsan kapak daha uzaktan açılır
Servo lidServo;lidServo adında bir servo nesnesi oluştururSonraki bütün satırlarda aynı adı kullanmak zorundasın
int openCount = 0;Global sayaç, açılışta sıfırdırloop() içine taşırsan her turda sıfırlanır ve hep 1 yazar
lidServo.attach(SERVO_PIN);Servoyu 6 numaralı pine bağlarUnutursan servo hiç kıpırdamaz
long distance = readDistanceCm();Fonksiyonu çağırır, dönen değeri saklardistance yalnızca loop() içinde yaşar
if (distance > 0 && distance < OPEN_DISTANCE)İki koşul birlikte doğruysa bloğa girerdistance > 0 kısmı, yankı gelmeyince dönen 0'ı eler
delay(3000);Kartı 3 saniye bekletirBu sürede Arduino başka hiçbir şeyi kontrol etmez
return duration / 58;Yankı süresini santimetreye çevirirSes gidip döndüğü için her 1 cm yaklaşık 58 µs'ye karşılık gelir

Şimdi loop()'u iki farklı durumla elle çalıştıralım. Önünde kimse yokken sensör 45 cm ölçer: distance 45 olur, seri monitöre "Mesafe / Distance: 45" yazılır, if koşulundaki 45 < 20 yanlış olduğu için blok atlanır, 100 ms beklenir ve loop() baştan başlar. Bu, saniyede yaklaşık on kez tekrarlanır. Elini 12 cm'ye getirdiğinde iki koşul da doğrudur: openCount 0'dan 1'e çıkar, LED yanar, servo 90 dereceye döner, kart üç saniye bekler, kapak kapanır, LED söner ve seri monitöre "Acilma sayisi / Times opened: 1" yazılır. Bir kodu bu şekilde gerçek sayılarla izlemek, onu okumanın en güvenilir yoludur.

Bir ayrıntıya daha dikkat et: pulseIn() 30 ms içinde yankı alamazsa 0 döndürür. Koşuldaki distance > 0 kontrolü olmasaydı, sensör boşluğa baktığında ölçülen 0 değeri "20'den küçük" sayılır ve kapak durup dururken açılırdı. İyi yazılmış kodlarda böyle küçük kontroller sık görülür; bir satırın neden orada olduğunu anlamıyorsan onu geçici olarak sil ve ne olduğuna bak. Sensörün çalışma mantığını HC-SR04 mesafe sensörü, projenin iki sensörlü tam sürümünü akıllı çöp kutusu yazısında bulabilirsin.

Değişkenler ve veri türleri: kutuların etiketleri

Değişken, içine sayı ya da yazı koyduğun etiketli bir kutudur. Satırın başındaki kelime kutunun türünü, yani içine ne sığacağını söyler. Arduino Uno'da yanlış tür seçmek sessiz hatalara yol açar; örneğin millis() değerini int içinde saklarsan yaklaşık 32 saniye sonra sayı eksiye döner.

TürAralık (Arduino Uno)Tipik kullanım
int-32 768 ile 32 767Pin numaraları, analogRead değerleri, sayaçlar
longYaklaşık ±2,1 milyarpulseIn süresi, büyük sayılar
unsigned long0 ile yaklaşık 4,29 milyarmillis() ve micros() zamanları
floatOndalıklı sayılar, 6–7 basamak hassasiyetSıcaklık, voltaj, mesafe hesapları
booltrue ya da falseBir şey açık mı, kapalı mı?
byte0 ile 255PWM değerleri, küçük sayılar
char / StringTek karakter / metinSeri porttan gelen komutlar, ekran yazıları

Değişkenin nerede tanımlandığı da önemlidir; buna kapsam denir. Örnek koddaki openCount bütün fonksiyonların dışında tanımlandığı için global'dir: değeri loop() her döndüğünde korunur. distance ise loop() içinde tanımlandığı için yereldir; her turda yeniden doğar, tur bitince kaybolur. Başına const gelen değişkenler sabittir, program çalışırken değiştirilemez. Daha derin bir giriş istersen Arduino programlama temelleri ve birden fazla değeri tek bir değişkende tutmak için Arduino dizi (array) yazılarına bakabilirsin.

Koşullar, döngüler ve fonksiyonlar nasıl okunur?

  • if / else if / else: "Eğer ... ise şunu yap, değilse bunu yap" diye oku. Süslü parantezler { } hangi satırların koşula bağlı olduğunu gösterir.
  • Karşılaştırmalar: == eşit mi, != eşit değil mi, < küçük mü, >= büyük ya da eşit mi demektir. && "ve", || "veya", ! "değil" anlamına gelir.
  • for döngüsü: for (int i = 0; i < 5; i++) satırını "i 0'dan başlasın, 5'ten küçük olduğu sürece tekrarla, her turda bir artır" diye oku; blok 5 kez çalışır.
  • while döngüsü: while (digitalRead(BUTTON_PIN) == HIGH) "buton basılı olmadığı sürece bekle" gibi okunur; koşul hiç değişmezse kod orada takılı kalır.
  • switch / case: Bir değişkenin değerine göre farklı yollara ayrılır; her case'in sonundaki break unutulursa alttaki case de çalışır.
  • Fonksiyon tanımı: long readDistanceCm() satırında long dönen değerin türü, readDistanceCm adı, boş parantez ise parametre almadığıdır. void ile başlayan fonksiyonlar değer döndürmez, yalnızca iş yapar.
Kod okurken en çok gözden kaçan iki tuzak şunlardır. if (x = 5) bir karşılaştırma değil, x'e 5 atamasıdır ve koşul her zaman doğru çıkar; doğrusu if (x == 5). İkincisi, if (distance < 20); satırının sonundaki noktalı virgül koşulu boşa çıkarır ve alttaki blok her turda çalışır. Derleyici ikisinde de hata vermez, bu yüzden bu satırları okurken özellikle dikkat et.

Kütüphane fonksiyonlarını tanımak

lidServo.write(90) gibi bir satırda nokta işareti, write fonksiyonunun lidServo nesnesine ait olduğunu söyler: "lidServo, 90 dereceye git". Bir kütüphane fonksiyonunun ne yaptığını öğrenmenin üç kolay yolu var: Arduino IDE 2'de fonksiyonun üzerine gelip açıklamasını okumak ya da sağ tıklayıp Go to Definition ile tanımına gitmek, Dosya > Örnekler menüsünden kütüphanenin kendi örneklerini açmak ve kütüphanenin .h dosyasındaki fonksiyon listesine bakmak. Kütüphanelerin nasıl kurulduğunu Arduino kütüphane ekleme yazısında anlattık. Hemen her kodda karşına çıkacak temel komutlar şunlar:

KomutNe yapar?Örnek
pinMode(pin, mod)Pini giriş ya da çıkış yaparpinMode(13, OUTPUT);
digitalWrite(pin, değer)Çıkış pinine 5 V (HIGH) ya da 0 V (LOW) verirdigitalWrite(13, HIGH);
digitalRead(pin)Giriş pininin HIGH mı LOW mu olduğunu okurdigitalRead(2)
analogRead(pin)0–5 V'u 0–1023 arası bir sayıya çeviriranalogRead(A0)
analogWrite(pin, 0–255)PWM ile LED parlaklığı ya da motor hızı ayarlaranalogWrite(9, 128);
delay(ms)Kartı verilen süre kadar durdururdelay(1000);
millis()Açılıştan beri geçen milisaniyeif (millis() - last > 500)
Serial.begin / print / printlnSeri monitöre yazı gönderirSerial.println(distance);
map(x, a, b, c, d)Bir aralığı başka bir aralığa ölçeklermap(value, 0, 1023, 0, 180)
pulseIn(pin, HIGH)Bir darbenin süresini µs olarak ölçerpulseIn(10, HIGH, 30000)

Komutların tam listesi ve her birinin ayrıntılı örnekleri için Arduino komutları yazısına göz atabilirsin. delay() ile millis() arasındaki farkı kavramak, kodları okurken en çok işine yarayacak bilgilerden biridir; millis ve delay yazısı bunu örneklerle açıklıyor.

Başkasının kodunu kendi devrene uyarlamak

  1. Koddan bir bağlantı tablosu çıkar. Bütün pin sabitlerini alt alta yaz; bu tablo kodu yazan kişinin devresidir.
  2. Kendi devrenle karşılaştır. Farklı pin kullandıysan kabloları değil, yalnızca const satırlarındaki sayıları değiştir; kodun geri kalanına dokunma.
  3. Kütüphane farklarına bak. Aynı adı taşıyan iki kütüphane farklı fonksiyonlar kullanabilir; I2C LCD'lerde 0x27 ya da 0x3F adres farkı da en sık uyum sorunudur.
  4. Aktif LOW ve aktif HIGH'a dikkat et. Çoğu röle modülü LOW ile çeker; kod HIGH ile açacak şekilde yazılmışsa senin rölen tam tersini yapar.
  5. Seri hızını eşleştir. Kodda Serial.begin(115200) varsa seri monitörde de 115200 seç; yoksa anlamsız karakterler görürsün.
  6. Parça parça test et. Önce yalnızca sensörü okuyan kısmı çalıştır, değerleri gördükten sonra motoru ve ekranı ekle.
Seri monitör, kodun içine tuttuğun bir el fenerdir. Bir koşulun neden çalışmadığını anlamıyorsan if satırının hemen önüne Serial.println(distance) gibi bir satır ekle ve gerçekte hangi değerle karşılaştırma yapıldığını gör. Ayrıntılar Arduino seri monitör yazısında.

Aynı kodu ESP32'ye taşımak

ESP32 de Arduino IDE ile programlandığı için kodun büyük kısmı olduğu gibi çalışır; değişen şeyler pin numaraları, voltaj seviyesi ve bazı kütüphanelerdir. Aşağıdaki tablo Arduino Uno kodunu ESP32'ye taşırken kontrol etmen gerekenleri sıralıyor:

KonuArduino UnoESP32Ne yapmalısın?
Pin adlarıD2–D13, A0–A5GPIO numaralarıSabitleri GPIO numaralarıyla değiştir, 6–11 ve 34–39'a dikkat et
Çalışma voltajı5 V3,3 V5 V çıkış veren sensörlere (HC-SR04 ECHO) gerilim bölücü koy
analogRead10 bit, 0–102312 bit, 0–4095Eşikleri ve map() aralıklarını 4 katına göre yeniden hesapla
Servo kütüphanesiServo.hESP32Servo.hKütüphaneyi değiştir, attach'a darbe aralığını yaz
Seri hızGenelde 9600Genelde 115200Serial.begin ve seri monitörü eşle
Bellek2 KB RAMYaklaşık 320 KB RAMBüyük diziler ve String'ler artık sorun değildir
C++ (Arduino IDE)
1// ESP32 sürümü: değişen satırlar işaretli / ESP32 version: changed lines are marked
2#include <ESP32Servo.h>             // DEĞİŞTİ: Servo.h yerine / CHANGED: instead of Servo.h
3
4const int TRIG_PIN = 26;            // DEĞİŞTİ / CHANGED
5const int ECHO_PIN = 27;            // DEĞİŞTİ: 1k/2k bölücüyle / CHANGED: through a 1k/2k divider
6const int SERVO_PIN = 18;           // DEĞİŞTİ / CHANGED
7const int LED_PIN = 2;              // DEĞİŞTİ: çoğu DevKit'te dahili LED / CHANGED: onboard LED on most DevKits
8const int OPEN_DISTANCE = 20;
9const int OPEN_ANGLE = 90;
10const int CLOSED_ANGLE = 0;
11
12Servo lidServo;
13int openCount = 0;
14
15void setup() {
16  Serial.begin(115200);             // DEĞİŞTİ: ESP32'de yaygın hız / CHANGED: common ESP32 speed
17  pinMode(TRIG_PIN, OUTPUT);
18  pinMode(ECHO_PIN, INPUT);
19  pinMode(LED_PIN, OUTPUT);
20  lidServo.setPeriodHertz(50);      // EKLENDİ: standart servo 50 Hz / ADDED: standard servo 50 Hz
21  lidServo.attach(SERVO_PIN, 500, 2400);  // DEĞİŞTİ: darbe aralığı µs / CHANGED: pulse range in µs
22  lidServo.write(CLOSED_ANGLE);
23}
24
25void loop() {
26  long distance = readDistanceCm();
27  Serial.print("Mesafe / Distance: ");
28  Serial.println(distance);
29
30  if (distance > 0 && distance < OPEN_DISTANCE) {
31    openCount++;
32    digitalWrite(LED_PIN, HIGH);
33    lidServo.write(OPEN_ANGLE);
34    delay(3000);
35    lidServo.write(CLOSED_ANGLE);
36    digitalWrite(LED_PIN, LOW);
37    Serial.print("Acilma sayisi / Times opened: ");
38    Serial.println(openCount);
39  }
40  delay(100);
41}
42
43long readDistanceCm() {
44  digitalWrite(TRIG_PIN, LOW);
45  delayMicroseconds(2);
46  digitalWrite(TRIG_PIN, HIGH);
47  delayMicroseconds(10);
48  digitalWrite(TRIG_PIN, LOW);
49  long duration = pulseIn(ECHO_PIN, HIGH, 30000);
50  return duration / 58;
51}

Gördüğün gibi loop() ve readDistanceCm() fonksiyonu tek harf değişmeden taşındı; değişen her şey dosyanın üst kısmında ve setup() içinde. Bu, iyi yazılmış kodun bir özelliğidir: donanıma bağlı ayrıntılar en üstte toplanır, mantık aşağıda temiz kalır. HC-SR04'ün ECHO pini 5 V verdiği için ESP32'ye 1 kΩ ve 2 kΩ'luk bir gerilim bölücü üzerinden bağlanmalıdır; servo da 3,3 V'tan değil, VIN pinindeki 5 V'tan beslenmelidir. Kartlar arasındaki diğer farkları Arduino mu ESP32 mi yazısında karşılaştırdık.

Raspberry Pi Pico'da aynı mantık: MicroPython

Pico'yu MicroPython ile programladığında kod farklı görünür ama mantık aynıdır. #include yerine import, süslü parantez yerine girinti kullanılır. setup() ve loop() kelimeleri yoktur: dosyanın en üstündeki satırlar bir kez çalışır (setup'ın karşılığı), while True: bloğu ise sonsuza kadar döner (loop'un karşılığı). Fonksiyonlar void ya da long yerine def ile başlar. Aşağıdaki kodu yukarıdaki Arduino koduyla yan yana koyarsan her satırın karşılığını bulabilirsin:

MicroPython
1from machine import Pin, PWM, time_pulse_us   # #include karşılığı / the #include part
2import time
3
4TRIG = Pin(14, Pin.OUT)              # HC-SR04 TRIG
5ECHO = Pin(15, Pin.IN)               # HC-SR04 ECHO, bölücüyle / through a divider
6LED = Pin(25, Pin.OUT)               # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
7servo = PWM(Pin(16))
8servo.freq(50)                       # servo 50 Hz ister / servos need 50 Hz
9
10OPEN_DISTANCE = 20                   # cm
11
12
13def set_angle(angle):
14    pulse_us = 500 + angle * 2000 // 180            # 0 derece 0,5 ms, 180 derece 2,5 ms / 0 deg 0.5 ms, 180 deg 2.5 ms
15    servo.duty_u16(pulse_us * 65535 // 20000)       # 20 ms periyodun oranı / share of the 20 ms period
16
17
18def read_distance_cm():
19    TRIG.low()
20    time.sleep_us(2)
21    TRIG.high()                      # 10 µs tetik darbesi / 10 µs trigger pulse
22    time.sleep_us(10)
23    TRIG.low()
24    duration = time_pulse_us(ECHO, 1, 30000)        # zaman aşımında negatif / negative on timeout
25    if duration < 0:
26        return 0
27    return duration // 58
28
29
30set_angle(0)                         # setup() karşılığı / the setup() part
31open_count = 0
32
33while True:                          # loop() karşılığı / the loop() part
34    distance = read_distance_cm()
35    print("Mesafe / Distance:", distance)
36    if 0 < distance < OPEN_DISTANCE:
37        open_count += 1
38        LED.on()
39        set_angle(90)
40        time.sleep(3)
41        set_angle(0)
42        LED.off()
43        print("Acilma sayisi / Times opened:", open_count)
44    time.sleep_ms(100)

Python'da Servo kütüphanesi olmadığı için set_angle() fonksiyonu açıyı darbe süresine kendisi çevirir: servo her 20 ms'de bir gelen 0,5–2,5 ms'lik bir darbeye göre konum alır. 0 < distance < OPEN_DISTANCE yazımı, C++'taki distance > 0 && distance < OPEN_DISTANCE koşulunun Python'daki kısa hâlidir. MicroPython'a yeni başlıyorsan MicroPython temelleri yazısı girinti, değişken ve fonksiyon kurallarını anlatıyor.

BlueGrays'te "Kodu anla" ile çalışmak

BlueGrays uygulamasındaki projelerin kod ekranında bir de "Kodu anla" sekmesi var. "Bu kod ne yapıyor?" başlığı önce kodun işini birkaç cümlelik bir özetle anlatır. "Adım adım" bölümü kodu küçük parçalara böler ve her parçanın altında o satırların ne işe yaradığını, değiştirirsen ne olacağını açıklar. "Takıldıysan" bölümünde en sık karşılaşılan sorunlar belirti ve çözüm olarak sıralanır, "Kendin dene" bölümünde ise ipucu ve çözümüyle birlikte küçük bir görev bulunur; örneğin gece lambasında eşik değerini değiştirip LED'in daha erken yanmasını sağlamak gibi. Bu yazıdaki beş adımlı yöntemi orada da uygulayabilirsin: önce özeti oku, sonra parçaları kendi devrenle eşleştir, en sonda görevi çözüp kodu kendin değiştir.

Kod okuma alıştırmaları

  • Tahmin et, sonra dene: Bir sabiti değiştirmeden önce ne olacağını yaz, sonra kodu yükleyip tahminini kontrol et.
  • Bir satırı yoruma al: Bir satırın başına // koyup kodu yeniden yükle; neyin bozulduğu, o satırın görevini gösterir.
  • Kendi cümlenle anlat: loop()'un her satırını Türkçe bir cümleye çevir; çeviremediğin satır, henüz anlamadığın satırdır.
  • Akış şeması çiz: setup, loop, if ve fonksiyon çağrılarını kutular ve oklarla çiz; özellikle durum makinesi kullanan kodlarda çok işe yarar.
  • Hatayı bilerek yap: Bir noktalı virgülü sil ve derleyicinin mesajını oku; Arduino derleme hataları yazısı en sık mesajları açıklıyor.

Kod okurken sık yapılan hatalar

HataNeden sorun?Doğrusu
Kodu baştan sona bir kez çalışan bir liste sanmakloop() sonsuza kadar tekrar eder, değişkenler turlar arasında değişirloop()'u birkaç tur, farklı değerlerle izle
= ile == işaretlerini karıştırmakif (x = 5) her zaman doğrudurKarşılaştırmada daima == kullan
Tam sayı bölmesini gözden kaçırmak5 / 2 sonucu 2'dir, ondalık kısım atılırOndalık gerekiyorsa 5.0 / 2 ya da float kullan
delay()'in her şeyi durdurduğunu unutmakBekleme sırasında buton ve sensörler okunmazBirden fazla iş için millis() ile zamanlama yap
Kütüphane sürüm farkını yok saymakAynı fonksiyon yeni sürümde farklı ad taşıyabilirKodun hangi kütüphaneyle yazıldığını yorumlarda ara
Pin sabitini değiştirip kabloyu unutmakKod doğru pini okur, kablo başka yerde dururDeğişiklikten sonra bağlantı tablonu güncelle
Zor bir kodu okurken önce onu düz bir dille yeniden yaz: "Mesafeyi ölç. Mesafe 0'dan büyük ve 20'den küçükse sayacı artır, LED'i yak, kapağı aç, 3 saniye bekle, kapağı kapat, LED'i söndür. 100 ms bekle ve baştan başla." Buna sözde kod denir; kodu yazan kişinin düşüncesini yakalamanın en hızlı yoludur.

Kod okumak, tıpkı devre şeması okumak gibi, ne kadar çok örnek görürsen o kadar hızlanan bir beceridir. İlk adım için BlueGrays uygulamasında LED yakma, trafik lambası, butonla LED ve LDR'li gece lambası gibi kısa projeleri açıp "Kodu anla" bölümünü satır satır takip etmeni öneririz; her projede devre şeması, kodun parça parça açıklaması ve küçük bir görev seni bekliyor.

Sıkça sorulan sorular

Arduino kodu hangi dille yazılır?

Arduino kodları C ve C++ dillerine dayanır. Arduino, pinMode ya da digitalWrite gibi işleri kolaylaştıran hazır fonksiyonlar ekler, ama if, for, değişken ve fonksiyon kuralları doğrudan C++'tır. Bu yüzden C++ bilgisi Arduino kodlarını okumayı çok kolaylaştırır.

setup ve loop arasındaki fark nedir?

setup() kart açıldığında ya da resetlendiğinde yalnızca bir kez çalışır ve pin ayarları, seri haberleşme gibi hazırlıklar için kullanılır. loop() ise setup bittikten sonra kart kapanana kadar sürekli tekrar eder; sensör okuma, karar verme ve motor sürme gibi asıl işler burada yapılır.

Arduino'da void ne demek?

void, fonksiyonun geriye bir değer döndürmediğini belirtir. void setup() ve void loop() iş yapar ama sonuç döndürmez. long readDistanceCm() gibi bir fonksiyon ise başındaki türde bir değeri return ile geri verir.

Kod hatasız derleniyor ama devre çalışmıyor, neden?

Derleyici yalnızca yazım kurallarını kontrol eder; yanlış pin numarası, ters bağlanmış bir modül ya da yanlış eşik değeri derleme hatası vermez. Koddaki pin sabitlerini devrenle karşılaştır ve Serial.println ile değerleri seri monitörde izle; sorun çoğunlukla bağlantı ya da eşik değeridir.

Arduino kodunu ESP32'de kullanabilir miyim?

Çoğu zaman evet; ESP32 de Arduino IDE ile programlanır ve temel komutlar aynıdır. Pin numaralarını GPIO numaralarıyla değiştirmen, 5 V sinyalleri 3,3 V'a düşürmen ve Servo gibi bazı kütüphaneleri ESP32 sürümleriyle değiştirmen gerekir. analogRead'in 0–4095 arasında değer verdiğini de unutma.

Hazır Arduino kodlarını nereden bulabilirim?

Arduino IDE'deki Dosya > Örnekler menüsü, kurduğun her kütüphanenin kendi örnekleriyle birlikte iyi bir başlangıçtır. BlueGrays uygulamasındaki projeler de devre şeması ve satır satır açıklamalı kodla gelir. Hangi kaynaktan alırsan al, kodu yüklemeden önce bu yazıdaki yöntemle bir kez okumak hataları baştan yakalamanı sağlar.

Tüm projeleri gör
Led Yakma
AR-1Başlangıç

Led Yakma

Elektroniğin ilk merhabası: tek bir LED'i yakıp söndürmek. Arduino LED'i çok kısa aralıklarla yakıp söndürür, ışık hızlı hızlı göz kırpar.

4.6(200)
1246
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
Buton İle Led Yakma (Push)
AR-9Başlangıç

Buton İle Led Yakma (Push)

Kapı zili gibi: bastığın sürece ışık yanar, bırakınca söner. Arduino butonu sürekli dinler; butona basılıyken LED'i yakar, elini çektiğin an söndürür.

4.8(114)
253
Ldr İle Gece Lambası
AR-12Başlangıç

Ldr İle Gece Lambası

Hava karardığında kendiliğinden yanan, sabah olunca sönen küçük bir gece lambası. Işık sensörü odadaki aydınlığı ölçer; Arduino ortam yeterince karanlıksa LED'i yakar, aydınlanınca söndürür.

4.7(105)
224
HC-SR04 Mesafe Ölçme (Serial Ekran)
AR-27Başlangıç

HC-SR04 Mesafe Ölçme (Serial Ekran)

Yarasalar karanlıkta yollarını nasıl buluyorsa HC-SR04 sensörü de öyle çalışır: duyamadığın bir ses gönderir, yankısını dinler ve önündeki cismin ne kadar uzakta olduğunu ölçer.

4.6(50)
82
DHT11 İle Sıcaklık Ve Nem
AR-55Orta

DHT11 İle Sıcaklık Ve Nem

Odan kaç derece, hava nemli mi, kuru mu? DHT11 sensörü sıcaklığı ve nemi ölçer, Arduino da bu değerleri iki satırlık LCD ekrana yazar ve birkaç saniyede bir yeniler.

4.7(47)
83
HC-SR04 ile Park Sensörü
AR-28Orta
Premium

HC-SR04 ile Park Sensörü

Arabalardaki park sensörünün küçük bir benzeri: bir şey yaklaştıkça bip sesleri hızlanır.

4.8(64)
86
Potansiyometre İle Servo Motor Kullanım
AR-36Başlangıç
Premium

Potansiyometre İle Servo Motor Kullanım

Potansiyometrenin düğmesini çevirdikçe servo motorun kolu da onunla birlikte döner; düğmenin bir ucu sıfır dereceye, öbür ucu yarım tura karşılık gelir.

4.6(37)
53