Programlama Temelleri¶

Robot programlama normal programlamadan farklıdır. Burada fiziksel dünyayla uğraşırsınız: motorlar döner, sensörler değer okur, zamanla yarışırsınız. Robot programlamayı öğrenmek hem kod hem fizik dünyasını anlamayı gerektirir.

Bu bölümde genel programlama temellerini robot bağlamında öğreneceksiniz. Kütüphane detaylarına ileriki bölümlerde gireceğiz.

Programlama Nedir?¶

Programlama, bilgisayara veya robot beyinine ne yapacağını söyleme sanatıdır. Bunu belirli kuralları olan özel bir dil ile yaparsınız.

Program: Bilgisayar anlayabileceği şekilde yazılmış talimatlar dizisidir. Robot bu talimatları okur ve uygular.

Algoritma: Bir problemi çözmek için adım adım tarif. Yemek tarifine benzer: malzemeler, sıralı adımlar, sonuç.

Örnek algoritma - "Engel varsa durma": 1. Önündeki mesafeyi ölç 2. Eğer mesafe 10cm'den az ise dur 3. Değilse ileri git 4. 1. adıma geri dön

Yazılım Dilleri¶

Programlama dilleri insanlarla bilgisayarlar arasında köprü görevi görür. Her dilin kendine has özellikleri vardır.

C/C++ - Robot Dünyasının Kralı¶

C++ robot programlamada en yaygın kullanılan dildir. Hem güçlü hem de mikrodenetleyicilerde çalışabilir.

Avantajları: - Hızlı çalışır (donanıma yakın) - Az bellek kullanır - Arduino ve ESP32 destekler - Geniş kütüphane desteği

Dezavantajları: - Öğrenmesi zor - Bellek yönetimi karmaşık - Hata bulması zor

Python - Kolay Başlangıç¶

Python öğrenmesi kolay bir dildir. Raspberry Pi gibi güçlü robot bilgisayarlarında kullanılır.

Avantajları: - Çok kolay öğrenilir - Çok kütüphane var - Hızlı kod yazılır

Dezavantajları: - Yavaş çalışır - Çok bellek kullanır - Mikrodenetleyicilerde çalışmaz

Diğer Diller¶

Java: Büyük robot projelerde kullanılır. FRC robotlarda popüler.

JavaScript: Web tabanlı robot kontrolünde kullanılır.

Scratch: Görsel programlama. Çocuklar için ideal.

Temel Kavramlar¶

Değişkenler¶

Veri saklamak için kullanılır. Robot dünyasında sürekli veriler vardır: sensör okumaları, motor hızları, sayaçlar.

int motorHizi = 150;        // Tam sayı
float sensorDegeri = 25.7;  // Ondalık sayı  
bool butonBasili = true;    // Doğru/yanlış
char yön = 'F';             // Tek karakter (Forward)

Değişken Türleri: - int: Tam sayılar (-32768 ile 32767 arası) - float: Ondalık sayılar (3.14, -2.5 gibi) - bool: Mantıksal değerler (true/false) - char: Tek karakter ('A', '5', '@' gibi)

Fonksiyonlar¶

Belirli bir işi yapan kod blokları. Tekrar eden işleri fonksiyona çevirirsiniz.

// Fonksiyon tanımlama
int topla(int a, int b) {
    int sonuc = a + b;
    return sonuc;  // Sonucu geri döndür
}

// Fonksiyon kullanma
int toplam = topla(5, 3);  // toplam = 8

Fonksiyon avantajları: - Kod tekrarını önler - Hata ayıklama kolay - Anlaşılır kod - Test etmek kolay

Operatörler¶

Veriler üzerinde işlem yapmak için kullanılır.

// Aritmetik operatörler
int a = 10, b = 3;
int toplam = a + b;     // 13
int fark = a - b;       // 7
int carpim = a * b;     // 30
int bolum = a / b;      // 3 (tam bölme)
int kalan = a % b;      // 1 (mod alma)

// Karşılaştırma operatörleri
bool esitMi = (a == b);     // false
bool buyukMu = (a > b);     // true
bool kucukMu = (a < b);     // false

// Mantıksal operatörler
bool sonuc1 = (a > 5) && (b < 5);  // true ve true = true
bool sonuc2 = (a < 5) || (b < 5);  // false veya true = true
bool sonuc3 = !(a == 10);          // not true = false

Kontrol Yapıları¶

Program akışını kontrol eden yapılardır. Robotun karar vermesini sağlar.

If-Else (Koşullu İfadeler)¶

Robot koşullara göre farklı davranır.

int mesafe = 25;  // cm

if (mesafe < 10) {
    // Çok yakın, dur
    robotDur();
} else if (mesafe < 30) {
    // Orta mesafede, yavaş git  
    robotYavaş();
} else {
    // Uzakta, hızlı git
    robotHızlı();
}

Döngüler¶

Belirli işleri tekrar tekrar yapmak için kullanılır.

For Döngüsü¶

Belirli sayıda tekrar için:

// LED'i 5 kez yakıp söndür
for (int i = 0; i < 5; i++) {
    ledYak();
    bekle(500);    // 500ms bekle
    ledSöndür();
    bekle(500);
}

While Döngüsü¶

Koşul sağlandığı sürece tekrar eder:

// Engel algılanana kadar ileri git
while (engelYok()) {
    robotİleri();
    bekle(100);
}
robotDur();

🚨 ROBOT PROGRAMLAMADA KRİTİK UYARILAR¶

WHILE DÖNGÜSÜ KULLANIMI YASAK!¶

Web arayüzlü robot sistemlerinde while döngüsü kullanmak sistemi tamamen DONDURACAKTIR!

// ❌ ASLA BÖYLE KOD YAZMAYIN - SİSTEM DONAR!
void teleopPeriodic() {
    while (true) {           // Bu satır sistemi öldürür!
        motorIleri(200);
        delay(1000);
    }
}

// ❌ ASLA BÖYLE KOD YAZMAYIN - SİSTEM DONAR!  
void teleopPeriodic() {
    while (engelYok()) {     // Bu da sistemi öldürür!
        robotIleri();
        delay(100);
    }
    robotDur();
}

NEDEN YASAK? Çünkü robot arka planda web sunucusu çalıştırır. While döngüsü web sunucusunu bloke eder ve: - Driver Station bağlantısı kesilir - Robot kontrol edilemez hale gelir - Sistem yeniden başlatılana kadar donmuş kalır

DELAY KULLANIMI YASAK!¶

Robot fonksiyonlarında delay() kullanmak sistemi YAVAŞLATIR ve DONMASINA neden olur!

// ❌ ASLA BÖYLE KOD YAZMAYIN - SİSTEM YAVAŞLAR!
void teleopPeriodic() {
    motorIleri(200);
    delay(1000);        // 1 saniye boyunca hiçbir şey yapamaz!
    motorDur();
    delay(500);         // Robot 0.5 saniye daha ölü!
}

NEDEN YASAK? Çünkü delay() sırasında: - Web arayüzü donar - Gamepad komutları işlenmez - Sensörler okunamaz - Robot tepkisiz kalır

DOĞRU YAKLAŞIM: ZAMANLAMA İLE ÇÖZÜM¶

// ✅ DOĞRU YAKLAŞIM - Zaman tabanlı kontrol
unsigned long sonZaman = 0;
bool motorAktif = false;

void teleopPeriodic() {
    unsigned long simdikiZaman = millis();

    // 2 saniyede bir motor durumunu değiştir
    if (simdikiZaman - sonZaman > 2000) {
        if (motorAktif) {
            motorDur();
            motorAktif = false;
        } else {
            motorIleri(200);
            motorAktif = true;
        }
        sonZaman = simdikiZaman;
    }

    // Bu fonksiyon hızlıca bitecek, web arayüzü çalışmaya devam edecek
}

DURUM MAKİNESİ İLE KONTROL¶

// ✅ DOĞRU YAKLAŞIM - Durum makinesi
enum RobotDurum { BEKLEME, ILERLIYOR, BEKLIYOR };
RobotDurum durum = BEKLEME;
unsigned long durumBaslangici = 0;

void teleopPeriodic() {
    unsigned long simdikiZaman = millis();

    switch (durum) {
        case BEKLEME:
            if (simdikiZaman - durumBaslangici > 1000) {  // 1 saniye bekle
                durum = ILERLIYOR;
                durumBaslangici = simdikiZaman;
                motorIleri(200);
            }
            break;

        case ILERLIYOR:
            if (simdikiZaman - durumBaslangici > 2000) {  // 2 saniye ileri git
                durum = BEKLIYOR;
                durumBaslangici = simdikiZaman;
                motorDur();
            }
            break;

        case BEKLIYOR:
            if (simdikiZaman - durumBaslangici > 500) {   // 0.5 saniye dur
                durum = BEKLEME;
                durumBaslangici = simdikiZaman;
            }
            break;
    }

    // Fonksiyon her durumda hızlıca bitiyor!
}

Algoritmik Düşünme¶

Robot programlamada sadece kod yazmak yetmez. Problemi nasıl çözeceğinizi düşünmelisiniz.

Problem Çözme Adımları¶

Problemi Anla: Ne yapmak istiyorsunuz?
Böl ve Fethet: Büyük problemi küçük parçalara ayır
Algoritma Yaz: Adım adım çözüm yolu belirle
Koda Çevir: Algoritmayı programlama diline çevir
Test Et: Çalışıp çalışmadığını kontrol et

Örnek: Çizgi Takip Robotu¶

Problem: Robot zemin üzerindeki siyah çizgiyi takip etsin.

Algoritma: 1. Çizgi sensörlerini oku 2. Çizgi merkezdeyse düz git 3. Çizgi sağdaysa sola dön 4. Çizgi soldaysa sağa dön 5. Çizgi yoksa dur 6. 1. adıma git

Kod Mantığı:

// Sözde kod (pseudocode)
döngü başla:
    solSensor = oku(sol_pin)
    sagSensor = oku(sag_pin)

    eğer (solSensor == SİYAH ve sagSensor == BEYAZ):
        sola_dön()
    değilse eğer (solSensor == BEYAZ ve sagSensor == SİYAH):
        sağa_dön()
    değilse eğer (solSensor == SİYAH ve sagSensor == SİYAH):
        düz_git()
    değilse:
        dur()
döngü sonu

Hata Ayıklama (Debugging)¶

Program yazarken hatalar yapmak normaldir. Önemli olan hataları nasıl bulacağınızı bilmek.

Yaygın Hata Türleri¶

Sözdizimi Hataları: Dil kurallarına uymama

int x = 5  // Noktalı virgül eksik!
if x > 3   // Parantez eksik!

Mantık Hataları: Kod çalışır ama yanlış sonuç verir

// Yanlış: < yerine > kullanmış
if (mesafe > 10) {
    robotDur();  // Engel varken durmak istiyorduk!
}

Çalışma Zamanı Hataları: Program çalışırken çöker

int dizi[5] = {1,2,3,4,5};
int x = dizi[10];  // Dizi sınırları dışında!

Debug Teknikleri¶

Serial Monitor: En önemli araç

void robotInit() {
    Serial.begin(9600);
    Serial.println("Robot başladı");
}

void teleopPeriodic() {
    int sensor = analogRead(A0);
    Serial.print("Sensör değeri: ");
    Serial.println(sensor);
}

LED Göstergeleri: Görsel debug

// Program hangi kısımda olduğunu LED ile göster
if (engelAlgılandı) {
    digitalWrite(LED_PIN, HIGH);  // LED yak
} else {
    digitalWrite(LED_PIN, LOW);   // LED söndür
}

Robot Programlama Özellikleri¶

Robot programlama masaüstü programlamadan farklıdır. Özel teknikleri vardır.

Gerçek Zamanlı Çalışma¶

Robot gerçek zamanlı çalışır. Sensör değeri okuduğunda hemen karar vermeli.

Sorunlu Yaklaşım:

// Bu robot çok yavaş tepki verir
void teleopPeriodic() {
    sensörOku();
    delay(1000);        // 1 saniye bekle - çok uzun!
    motorKontrol();
}

Doğru Yaklaşım:

// Hızlı tepki veren robot
void teleopPeriodic() {
    sensörOku();        // Hızlı oku
    kararVer();         // Hızlı karar ver
    motorKontrol();     // Hızlı uygula
    // Toplam süre < 50ms olmalı
}

Durum Makinesi¶

Robot farklı durumlarda farklı davranır.

enum RobotDurum {
    BEKLEME,
    ILERLIYOR,
    DONUYOR,
    GERI_GIDIYOR
};

RobotDurum durum = BEKLEME;

void teleopPeriodic() {
    switch (durum) {
        case BEKLEME:
            if (başlaButonu) {
                durum = ILERLIYOR;
            }
            break;

        case ILERLIYOR:
            robotIleri();
            if (engelVar) {
                durum = DONUYOR;
            }
            break;

        case DONUYOR:
            robotSagaDön();
            // Dönüş tamamlandıktan sonra
            durum = ILERLIYOR;
            break;
    }
}

İyi Programlama Alışkanlıkları¶

Anlamlı İsimler Kullanın¶

// Kötü isimler
int x = 150;
int y = digitalRead(2);
void f() { /* motor kontrol */ }

// İyi isimler
int motorHizi = 150;
int butonDurumu = digitalRead(butonPin);
void motorKontrolEt() { /* motor kontrol */ }

Kod Yorumlayın¶

/**
 * Ultrasonik sensör ile mesafe ölçer
 * @return Mesafe (cm cinsinden)
 */
int mesafeOlc() {
    // Trigger pini aktif et
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);

    // Echo süresini ölç
    long sure = pulseIn(echoPin, HIGH);

    // Süreyi mesafeye çevir
    return sure * 0.034 / 2;
}

Sabitler Kullanın¶

// Sabit tanımları
const int MOTOR_HIZ_NORMAL = 150;
const int MOTOR_HIZ_YAVAS = 80;
const int ENGEL_MESAFE = 20;  // cm

// Kullanım
if (mesafe < ENGEL_MESAFE) {
    motorHiz = MOTOR_HIZ_YAVAS;
}

Sonraki Adımlar¶

Programlama temellerini anladığınıza göre:

Pratik Örnekler - Gerçek robot projeleri kodlayın
Yarışma Stratejileri - Rekabetçi robot programlama
Referans - API dokümantasyonu ve örnekler

Robot programlama hem sanat hem bilimdir. Pratik yaparak öğrenirsiniz. Her robot farklıdır, her probleme farklı çözüm gerekir!