``

A* algoritmasının temel fikri

A*, harita üzerindeki her aday düğüm için üç değer kullanır:

Burada $g(n)$, başlangıçtan mevcut düğüme kadar ödenen gerçek maliyettir. $h(n)$ ise düğümden hedefe kalan mesafeye ilişkin sezgisel tahmindir. Algoritma, toplam tahmini maliyeti $f(n)$ en küçük olan düğümü önce inceler.

Bunu bir navigasyon uygulaması gibi düşünebiliriz: $g(n)$ şimdiye kadar kullandığımız yakıtı, $h(n)$ ise hedefe ulaşmak için harcayacağımız tahmini yakıtı temsil eder. Yalnızca geçmişe bakmak aramayı yavaşlatır; yalnızca tahmine güvenmek ise kötü rotalara yol açabilir. A*, ikisini dengeler.

Izgara haritası ve sezgisel fonksiyon

Robotun çevresi çoğunlukla hücrelerden oluşan bir maliyet haritasına dönüştürülür. Boş hücreler geçilebilir, dolu hücreler engeldir. Robot yalnızca yatay ve dikey hareket ediyorsa Manhattan uzaklığı uygundur:

Çapraz hareket serbestse Öklid uzaklığı kullanılabilir:

En kısa yol garantisi için sezgisel fonksiyon gerçek kalan maliyeti abartmamalıdır. Bu özelliğe kabul edilebilirlik denir.

Python ile basit A* uygulaması

Aşağıdaki kod, sıfırların boş alanı ve birlerin engelleri gösterdiği bir ızgarada dört yönlü rota üretir:

import heapq

def astar(grid, start, goal):
    directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
    open_set = [(0, start)]
    came_from = {}
    g_cost = {start: 0}

    def heuristic(node):
        return abs(node[0] - goal[0]) + abs(node[1] - goal[1])

    while open_set:
        _, current = heapq.heappop(open_set)

        if current == goal:
            path = [current]
            while current in came_from:
                current = came_from[current]
                path.append(current)
            return path[::-1]

        for dx, dy in directions:
            neighbor = (current[0] + dx, current[1] + dy)
            x, y = neighbor

            if not (0 <= x < len(grid) and 0 <= y < len(grid[0])):
                continue
            if grid[x][y] == 1:
                continue

            candidate_cost = g_cost[current] + 1
            if candidate_cost < g_cost.get(neighbor, float("inf")):
                came_from[neighbor] = current
                g_cost[neighbor] = candidate_cost
                f_cost = candidate_cost + heuristic(neighbor)
                heapq.heappush(open_set, (f_cost, neighbor))

    return None

open_set, henüz değerlendirilecek hücreleri öncelik sırasıyla tutar. came_from ise hedef bulunduğunda geriye doğru ilerleyerek rotayı yeniden oluşturur. Engel veya harita sınırı kontrolü sayesinde robot geçersiz hücrelere girmez.

Gerçek robotlarda dikkat edilmesi gerekenler

Izgara üzerindeki robot tek bir nokta değildir; fiziksel genişliği vardır. Bu nedenle engeller, robot yarıçapı ve güvenlik payı kadar şişirilmelidir. Aksi hâlde hesaplanan rota matematiksel olarak geçerli olsa bile robot duvara sürtebilir.

A* statik haritalarda güçlü bir başlangıçtır. Sensörlerden gelen güncel veriler, maliyet haritası ve hareket denetleyicisiyle birleştirildiğinde robot yalnızca kısa değil, güvenli ve uygulanabilir bir rota da izleyebilir. Böylece “duvara çarpmadan hedefe ulaşma” problemi, düzenli bir maliyet hesabına dönüşür.

``

Önce drone neyi kontrol eder?

Bir quadcopter’ın hareketi dört temel eksen üzerinden açıklanır:

Kontrolcü, jiroskoptan açısal hızı, ivmeölçerden doğrusal ivmeyi, barometreden yüksekliği ve GPS’ten konumu alır. Ancak hiçbir sensör kusursuz değildir. Jiroskop zamanla sürüklenirken ivmeölçer titreşimlerden etkilenir. Bu nedenle tamamlayıcı filtre veya Kalman filtresi gibi sensör füzyonu yöntemleri kullanılır.

Basit bir açı tahmini şöyle düşünülebilir:

Burada $α$, hızlı fakat sürüklenen jiroskop ile yavaş fakat referans sağlayan ivmeölçer arasındaki güven dengesidir.

PID: Dengeyi sağlayan üçlü

PID kontrolcü, hedef değer ile ölçülen değer arasındaki $e(t)$ hatasını motor komutuna dönüştürür:

Örneğin roll hedefi $0°$, ölçülen açı $8°$ ise PID, drone’u ters yönde yatıracak motor düzeltmesini üretir. Gerçek sistemlerde genellikle iç içe döngüler bulunur: dış döngü açı hedefini açısal hız hedefine, iç döngü ise açısal hız hatasını motor komutuna çevirir. İç döngü daha hızlı çalışır; çünkü önce gövde dengede kalmalıdır.

Aşağıdaki sade Python örneği tek eksenli PID hesabını gösterir:

class PID:
    def __init__(self, kp, ki, kd):
        self.kp, self.ki, self.kd = kp, ki, kd
        self.integral = 0.0
        self.previous_error = 0.0

    def update(self, target, measured, dt):
        error = target - measured
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt
        self.previous_error = error

        return (self.kp * error
                + self.ki * self.integral
                + self.kd * derivative)

Dönen değer doğrudan tek motora verilmez. Bir mixer, roll, pitch, yaw ve throttle çıktılarını drone geometrisine göre dört motora dağıtır. Komutlar ayrıca güvenli motor aralığında sınırlandırılır; integral teriminin kontrolden çıkmaması için anti-windup uygulanır.

Denge kontrolünden otonom rotaya

Otonom uçuş, PID’yi ortadan kaldırmaz; onun üzerine yeni katmanlar ekler. Rota planlayıcı waypoint’leri belirler, konum kontrolcüsü istenen hız ve yatışı hesaplar, tutum kontrolcüsü de bu hedefleri motorlara uygular.

Görev planı → Konum hedefi → Hız hedefi
           → Açı hedefi → Açısal hız → Motorlar

Drone hedef noktanın kuzeyinde kaldıysa konum döngüsü güneye doğru hız ister. Hız döngüsü bunu uygun pitch ve roll açılarına çevirir. En içteki PID döngüleri ise bu açıları fiziksel olarak gerçekleştirir. Engel algılama eklendiğinde kamera, lidar veya ultrasonik sensörlerden gelen veriler rota planlayıcıya aktarılır.

A* algoritması harita üzerinde düşük maliyetli bir yol bulabilirken RRT, karmaşık ve sürekli uzaylarda hızlı aday rotalar üretir. Fakat planlanan rota uçulabilir olmalıdır; keskin dönüşler, maksimum eğim, batarya ve rüzgâr hesaba katılmalıdır.

Sonuç olarak otonom drone, tek bir akıllı algoritmadan değil, farklı hızlarda çalışan güvenilir katmanlardan oluşur. PID refleksleri, sensör füzyonu denge hissini, rota planlama ise yön duygusunu sağlar. Gökyüzündeki zarif hareketin arkasında sürekli hata hesaplayan oldukça çalışkan bir matematik ekibi vardır.

``

Step motorun hareket mantığı

Step motor, elektrik darbelerini belirli açısal hareketlere dönüştürür. Örneğin tur başına 200 adımı bulunan bir motorun doğal adım açısı:

Sürücü 16 mikro adım modunda çalıştırılırsa teorik çözünürlük tur başına $200 \times 16 = 3200$ mikro adıma yükselir. Hedef açı için gönderilmesi gereken darbe sayısı şöyle hesaplanır:

Burada $H$ hedef açıyı, $S$ motorun tam adım sayısını, $M$ ise mikro adım katsayısını ifade eder. Ancak mikro adım kullanmak her zaman aynı oranda gerçek mekanik doğruluk sağlamaz. Motor torku, yük, boşluk ve sürtünme sonucu etkiler.

Encoder neden gereklidir?

Step motor sürücüsü darbe gönderildiğinde motorun hareket ettiğini varsayar. Yük fazla gelirse motor adım kaçırabilir ve kontrol sistemi bundan haberdar olmayabilir. Encoder ise motor milinin gerçek konumunu ölçerek varsayımı ölçülebilir bilgiye dönüştürür.

Artımlı quadrature encoderlarda A ve B adlı iki kanal arasında faz farkı bulunur. Bu sayede hem hareket miktarı hem de yön belirlenebilir. Encoder tur başına $P$ darbe üretiyor ve dört kenar sayımı kullanılıyorsa açısal konum yaklaşık olarak:

formülüyle bulunur. Burada $C$, sayılan encoder kenarıdır.

Kapalı çevrim kontrol

Kontrol sisteminde hedef konum ile encoderın ölçtüğü konum karşılaştırılır:

Ortaya çıkan hata pozitifse motor ileri, negatifse geri hareket ettirilir. Basit uygulamalarda hata büyüklüğüne göre step frekansı ayarlanabilir. Daha akıcı sistemlerde PID kontrolü kullanılır:

Oransal terim mevcut hataya tepki verir, integral terimi kalıcı hatayı azaltır, türev terimi ise ani değişimleri frenler. Yanlış ayarlanmış PID, hassasiyet yerine masada dans eden bir motor üretebilir; bu nedenle düşük kazançlarla başlamak güvenlidir.

Arduino ile temel uygulama

Aşağıdaki örnek encoder sayımını izler ve hedefe göre motor yönünü belirler. Kesme kullanılması, hızlı encoder darbelerinin kaçırılma riskini azaltır.

const int stepPin = 5;
const int dirPin = 6;
const int encA = 2;
const int encB = 3;

volatile long encoderCount = 0;
long targetCount = 4000;

void readEncoder() {
  if (digitalRead(encA) == digitalRead(encB))
    encoderCount++;
  else
    encoderCount--;
}

void makeStep() {
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(4);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(500);
}

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(encA, INPUT_PULLUP);
  pinMode(encB, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(encA), readEncoder, CHANGE);
}

void loop() {
  long error = targetCount - encoderCount;

  if (abs(error) > 2) {
    digitalWrite(dirPin, error > 0 ? HIGH : LOW);
    makeStep();
  }
}

İki sayımlık tolerans bölgesi motorun hedef çevresinde sürekli ileri geri titreşmesini önler. Gerçek projede hızlanma ve yavaşlama rampaları eklenmeli; aksi hâlde motor yüksek frekansta aniden başlatıldığında adım kaçırabilir.

Mekanik ayrıntıları unutmayın

Yazılım kusursuz olsa bile kaplin boşluğu, kayış esnemesi ve rulman toleransı sonucu bozabilir. Encoder motor milindeyse motor hareketini ölçer, fakat yük tarafındaki boşluğu göremeyebilir. Çok yüksek doğruluk gereken makinelerde encoderın doğrudan hareketli eksene yerleştirilmesi daha doğrudur.

Sonuç olarak step motor komutu, encoder gerçeği, kontrol algoritması ise ikisi arasındaki uzlaşmayı temsil eder. Sağlam mekanik, doğru elektrik bağlantıları ve dikkatli ayarlanmış kontrol parametreleri birleştiğinde mikrometre seviyesine yaklaşan hareketler ulaşılabilir bir mühendislik hedefi hâline gelir.

``

Temel fikir: Tahmin et, ölç, düzelt

Kalman filtresi, sistemin durumunu doğrudan bilmediğimizi kabul eder. Bunun yerine konum ve hız gibi değişkenleri bir durum vektöründe toplar. Tek boyutlu hareket için şöyle bir vektör kullanabiliriz:

Burada $p_k$ konumu, $v_k$ hızı, $k$ ise zaman adımını gösterir. Sabit hızlı hareket varsayımında yeni durumun modeli şöyledir:

$F$ durum geçiş matrisi, $w_k$ ise modelin açıklayamadığı süreç gürültüsüdür. Zaman aralığı $dt$ olduğunda geçiş matrisi $F = [[1, dt], [0, 1]]$ biçimindedir. Yani yeni konum, eski konuma hız çarpı zaman eklenerek bulunur.

Sensör ölçümü ise şu modelle ifade edilir:

Buradaki $H$, durumun hangi bölümünün ölçüldüğünü; $v_k$ ise sensör gürültüsünü temsil eder. Örneğin GPS yalnızca konum veriyorsa $H = [1, 0]$ olur.

Sensörler neden birleştirilir?

Her sensörün farklı bir süper gücü ve zayıflığı vardır:

Kalman filtresi hızlı sensörlerle sık tahmin yapıp GPS gibi mutlak ölçümler geldiğinde sonucu düzeltir. Böylece GPS’in sıçramaları yumuşatılırken yalnızca IMU kullanmanın oluşturacağı sürüklenme de sınırlandırılır.

Belirsizlik işin merkezinde

Filtre yalnızca konumu değil, tahminine ne kadar güvendiğini de taşır. Bu güven, $P$ hata kovaryans matrisiyle temsil edilir. Süreç gürültüsü kovaryansı $Q$, hareket modelinin; ölçüm gürültüsü kovaryansı $R$ ise sensörün belirsizliğini anlatır.

Tahmin aşaması:

Düzeltme aşamasında önce Kalman kazancı hesaplanır:

$R$ büyükse filtre sensöre daha az, modele daha çok güvenir. $P$ büyüdüğünde ise yeni ölçüm daha etkili olur. Ardından ölçüm ile tahmin arasındaki fark kullanılır:

Python ile basit konum filtresi

Aşağıdaki sınıf, sabit hızlı tek boyutlu hareketi izler ve gürültülü konum ölçümlerini süzer:

import numpy as np

class PositionKalman:
    def __init__(self, dt, process_noise=0.1, measurement_noise=4.0):
        self.x = np.array([[0.0], [0.0]])  # konum, hız
        self.F = np.array([[1.0, dt], [0.0, 1.0]])
        self.H = np.array([[1.0, 0.0]])
        self.P = np.eye(2) * 10.0
        self.Q = np.eye(2) * process_noise
        self.R = np.array([[measurement_noise]])
        self.I = np.eye(2)

    def predict(self):
        self.x = self.F @ self.x
        self.P = self.F @ self.P @ self.F.T + self.Q
        return self.x[0, 0]

    def update(self, measured_position):
        z = np.array([[measured_position]])
        innovation = z - self.H @ self.x
        innovation_cov = self.H @ self.P @ self.H.T + self.R
        K = self.P @ self.H.T @ np.linalg.inv(innovation_cov)

        self.x = self.x + K @ innovation
        self.P = (self.I - K @ self.H) @ self.P
        return self.x[0, 0]

predict() hareket modeline göre ara konumu üretir. update() ise GPS benzeri bir ölçüm geldiğinde yenilik değerini hesaplayıp tahmini düzeltir. Gerçek uygulamalarda $Q$ ve $R$ değerleri sensör kayıtları incelenerek ayarlanmalıdır; yanlış ayar, filtrenin ya aşırı titrek ya da tembel olmasına neden olur.

Kalman filtresi sihirli bir gürültü silgisi değildir. Doğru hareket modeli, gerçekçi belirsizlikler ve sensörlerin zaman eşlemesi şarttır. Ancak bu parçalar yerli yerine oturduğunda, birbirinden şüpheli sensörler birlikte oldukça güvenilir bir konum anlatmaya başlar.

``

Görüntüden harekete uzanan zincir

Kamera gerçekte nesneleri değil, piksellerden oluşan kareleri görür. Her karede hedef nesne bulunur, önceki karedeki konumuyla ilişkilendirilir ve robotun nasıl hareket edeceği hesaplanır. Temel işlem hattı şöyledir:

1. Kameradan yeni bir görüntü karesi alınır.
2. Hedef nesne algılanır veya takip edilir.
3. Nesnenin merkez koordinatı hesaplanır.
4. Görüntü merkeziyle hedef merkezi arasındaki hata bulunur.
5. Hata, motor hızına ya da direksiyon açısına dönüştürülür.

Görüntünün genişliği $W$, hedef merkezinin yatay koordinatı $x_t$ olsun. Robotun yönelme hatası:

şeklinde hesaplanabilir. $e_x < 0$ ise hedef solda, $e_x > 0$ ise sağdadır. Hata sıfıra yaklaştıkça robot hedefe bakıyor demektir. Perspektif kamera modelinde bir noktanın görüntü koordinatı yaklaşık olarak

ile ifade edilir. Burada $f$ odak uzaklığı, $Z$ ise nesnenin kameraya olan derinliğidir. Bu nedenle nesne yaklaştıkça görüntüde büyür; yalnızca kutu boyutuna bakarak yaklaşık mesafe tahmini yapılabilir.

Algılama mı, takip mi?

Bu iki kavram sıkça aynı sanılır, ancak görevleri farklıdır.

YOLO gibi sinir ağı tabanlı algılayıcılar hedefi sınıfıyla birlikte bulabilir. KCF, CSRT ve optik akış gibi takip yöntemleri ise ardışık karelerdeki değişimden yararlanır. Pratik bir robot, hedefi belirli aralıklarla algılayıp aradaki karelerde daha hızlı bir takipçi kullanabilir.

OpenCV ile basit renk takibi

Aşağıdaki örnek, turuncu bir nesneyi HSV renk uzayında ayırır ve yatay hataya göre robotun yönünü belirler:

import cv2
import numpy as np

camera = cv2.VideoCapture(0)

while True:
    ok, frame = camera.read()
    if not ok:
        break

    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    lower = np.array([5, 120, 120])
    upper = np.array([20, 255, 255])
    mask = cv2.inRange(hsv, lower, upper)

    contours, _ = cv2.findContours(
        mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
    )

    if contours:
        target = max(contours, key=cv2.contourArea)
        x, y, w, h = cv2.boundingRect(target)
        center_x = x + w // 2
        error = center_x - frame.shape[1] // 2

        command = 'sola dön' if error < -30 else 'sağa dön' if error > 30 else 'ileri'
        print(command, 'hata:', error)
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

    cv2.imshow('Robot Gözü', frame)
    if cv2.waitKey(1) == 27:
        break

camera.release()
cv2.destroyAllWindows()

Kod, en büyük renk bölgesini hedef kabul eder. Gerçek robotta command değişkeni seri port, ROS mesajı veya motor sürücü kartı üzerinden fiziksel harekete çevrilir.

Robot neden titrer?

Ham hata doğrudan motorlara gönderilirse robot sürekli sağa sola oynayabilir. Bunun çözümü PID kontrolüdür:

$K_p$ anlık hataya tepki verir, $K_i$ kalıcı sapmayı azaltır, $K_d$ ise ani değişimleri yumuşatır. Ayrıca küçük hataların yok sayıldığı bir ölü bölge, görüntü filtreleme ve maksimum hız sınırı sistemi sakinleştirir.

Işık değişimi, hareket bulanıklığı ve nesnenin başka bir cismin arkasına geçmesi gerçek dünyanın sürprizleridir. Kalman filtresiyle konum tahmini, iyi kamera kalibrasyonu ve algılama-takip hibriti kullanıldığında robot yalnızca bakmaz; gördüğünü anlamlandırıp güvenli biçimde peşinden gider.

``

Ters sarkaç neden kararsızdır?

Normal bir sarkaç aşağı doğru durduğunda kararlıdır; küçük bir itmeden sonra tekrar denge noktasına döner. Ters sarkaçta ise ağırlık merkezi dönme ekseninin üzerindedir. Çok küçük bir açı hatası bile yerçekimi torku oluşturarak sapmayı büyütür.

Basitleştirilmiş yerçekimi torku şöyle yazılabilir:

Burada $m$ gövde kütlesi, $g$ yerçekimi ivmesi, $l$ ağırlık merkezinin tekerlek eksenine uzaklığı ve $\theta$ eğim açısıdır. Küçük açılarda $\sin(\theta) \approx \theta$ kabul edilir. Böylece sistem yaklaşık doğrusal modellenebilir; fakat kendi hâline bırakıldığında hâlâ kararsızdır.

Robotun görevi, motorların ürettiği karşı torkla bu sapmayı bastırmaktır. Başka bir ifadeyle robot öne düşüyorsa tekerlekler öne kaçmalı, arkaya düşüyorsa arkaya gitmelidir.

Gerekli bileşenler

Açıyı doğru ölçmek

İvmeölçer uzun vadede güvenilir açı verir, ancak titreşimden etkilenir. Jiroskop kısa vadede pürüzsüzdür, fakat zamanla sürüklenir. Tam bir “biri iyi biri kötü” hikâyesi değil; ikisi birlikte daha güçlüdür.

Tamamlayıcı filtre şu şekilde kurulabilir:

Genellikle $\alpha$ değeri 0,95–0,99 arasında seçilir. Kontrol döngüsünün sabit zaman aralığında çalışması kritik önemdedir.

PID ile denge kontrolü

PID denetleyici, hedef açı ile ölçülen açı arasındaki $e(t)$ hatasını motor komutuna dönüştürür:

$K_p$ robotu dik konuma iter, $K_d$ salınımı frenler, $K_i$ ise kalıcı küçük hataları giderir. Denge robotlarında integral terimi çoğunlukla çok düşük tutulur; aksi hâlde robot geçmiş hataları fazla ciddiye alıp dramatik bir kaçış gerçekleştirebilir.

float error = targetAngle - angle;
integral += error * dt;
float derivative = (error - previousError) / dt;

float output = kp * error
             + ki * integral
             + kd * derivative;

output = constrain(output, -255, 255);
setMotorPower(output);
previousError = error;

Bu kod her kontrol çevriminde açı hatasını hesaplar ve iki motora uygulanacak PWM değerini üretir. Robot çok hızlı titreşiyorsa $K_p$ veya $K_d$ yüksek olabilir. Yavaşça devriliyorsa $K_p$ yetersizdir. Sürekli bir tarafa gidiyorsa hedef açıya küçük bir ofset eklenebilir.

Sağlam bir geliştirme sırası

Önce motor yönlerini ve IMU eksenlerini doğrula. Ardından robotu kaldırarak açı ölçümünü seri portta izle. $K_i=0$ iken düşük $K_p$ ile başla, robot tepki verene kadar artır ve salınımı $K_d$ ile azalt. Enkoderlerden gelen hız bilgisini ikinci bir kontrol döngüsünde kullanmak, robotun dengede dururken odanın öbür ucuna kaçmasını önler.

İlk denemelerde robotu bir askı düzeneğinde çalıştırmak, motor çıkışını sınırlamak ve acil durdurma düğmesi eklemek iyi fikirdir. Başarılı sonuç yalnızca iyi PID ayarına değil; rijit şasiye, düşük mekanik boşluğa, temiz güç hattına ve hızlı örneklemeye bağlıdır. Ters sarkaç tam anlamıyla takım oyunudur.

Temel fikir: Hesaplama grafiği

ROS mimarisi, çalışan bileşenlerin ve aralarındaki bağlantıların oluşturduğu bir hesaplama grafiği olarak düşünülebilir. Grafikte düğümler yazılım bileşenlerini, bağlantılar ise veri akışını temsil eder:

Burada $V$ düğüm kümesi, $E$ ise düğümler arasındaki iletişim kanallarıdır. Örneğin kamera düğümünden görüntü işleme düğümüne doğru bir bağlantı bulunabilir. ROS 2, düğümlerin birbirini keşfetmesi ve haberleşmesi için çoğunlukla DDS tabanlı bir altyapı kullanır.

Düğümler: İş yapan küçük uzmanlar

Düğüm (node), belirli bir görevi yerine getiren çalışan süreç veya mantıksal bileşendir. Bir düğüm kamerayı okuyabilir, diğeri engel algılayabilir, başka biri motor komutu üretebilir. İyi tasarlanmış bir düğüm, tek bir sorumluluğa odaklanır.

Çalışan düğümleri görmek için:

ros2 node list
ros2 node info /kamera_dugumu

İkinci komut, ilgili düğümün yayınladığı ve dinlediği konuları, sunduğu servisleri ve diğer bağlantılarını gösterir. Böylece robotun görünmez iletişim ağı terminalde görünür olur.

Konular: Sürekli veri akışı

Konu (topic), düğümler arasında asenkron veri taşır. Yayıncı düğüm mesaj gönderir; abone düğümler mesajları alır. Yayıncı, abonelerin kim olduğunu bilmek zorunda değildir. Bu gevşek bağlı yapı, bileşenlerin kolayca değiştirilmesini sağlar.

Örneğin bir LIDAR saniyede 10 tarama yayımlıyorsa frekans $f=10\,Hz$, iki mesaj arasındaki yaklaşık süre ise:

Basit bir ROS 2 Python yayıncısı şöyle yazılabilir:

import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class DurumYayincisi(Node):
    def __init__(self):
        super().__init__('durum_yayincisi')
        self.publisher = self.create_publisher(String, '/robot_durumu', 10)
        self.create_timer(1.0, self.durum_gonder)

    def durum_gonder(self):
        mesaj = String()
        mesaj.data = 'Robot göreve hazır!'
        self.publisher.publish(mesaj)

rclpy.init()
rclpy.spin(DurumYayincisi())

Kod, /robot_durumu konusuna saniyede bir metin mesajı yollar. 10 değeri, iletişimin QoS kuyruk derinliğini belirtir; yani geçici yoğunluklarda kaç mesajın saklanabileceğini etkiler.

Servisler: Sor ve cevabı bekle

Servis (service), istek-cevap modelini kullanır. İstemci bir talep gönderir, sunucu işlemi gerçekleştirip tek bir yanıt döndürür. “Haritayı kaydet” veya “sensörü sıfırla” gibi seyrek ve sonucu beklenen işlemler için uygundur. Sürekli kamera görüntüsü taşımak için servis kullanmak ise postacıdan canlı yayın yapmasını istemeye benzer.

ros2 service list
ros2 service call /reset_sensor std_srvs/srv/Trigger

Bu komutlar servisleri listeler ve örnek bir sensör sıfırlama isteği gönderir.

Hangisini ne zaman seçmeli?

Veri düzenli akıyor ve birden fazla bileşen tarafından tüketilebiliyorsa konu seçilir. İşlem belirli bir komutla başlayacak ve kısa sürede cevap verecekse servis daha uygundur. Uzun süren, geri bildirim ve iptal gerektiren navigasyon görevlerinde ise ROS 2’nin action yapısı tercih edilir.

Özetle düğümler robotun uzman çalışanları, konular ortak anons sistemi, servisler ise danışma masasıdır. Bu ayrımı doğru kurmak; ölçeklenebilir, test edilebilir ve parçaları yeniden kullanılabilir robot yazılımlarının temelini oluşturur.

``

SLAM neden zor bir problem?

Harita oluşturmak için robotun konumunu bilmesi gerekir. Konumunu doğru hesaplamak içinse çevresindeki noktaların haritadaki yerlerini bilmelidir. SLAM, bu iki bilinmeyeni sensör ölçümlerini zaman içinde birleştirerek birlikte tahmin eder.

Robotun $t$ anındaki durumu kabaca şöyle gösterilebilir:

Burada $x_t$ ve $y_t$ robotun düzlemdeki konumunu, $\theta_t$ ise baktığı yönü belirtir. Amaç; kontrol girdileri $u_{1:t}$ ve sensör ölçümleri $z_{1:t}$ verildiğinde robotun rotasıyla haritayı birlikte bulmaktır:

Buradaki $m$, bilinmeyen ortam haritasıdır. Denklem ürkütücü görünse de fikir basittir: Robot hareket eder, çevresini ölçer, tahminini düzeltir ve bunu sürekli tekrarlar.

Robot çevresini nasıl algılar?

SLAM sistemlerinde tek bir kusursuz sensör yoktur. Her sensör farklı bir ipucu sağlar ve farklı biçimde hata yapar.

Bu verilerin birleştirilmesine sensör füzyonu denir. Örneğin enkoder robotun bir metre ilerlediğini söylerken LiDAR, duvarın beklenenden yakın olduğunu gösterebilir. Algoritma her ölçümün belirsizliğini hesaba katarak daha güvenilir bir sonuç üretir.

Tahmin, ölçüm ve düzeltme döngüsü

SLAM’in kalbinde sürekli çalışan üç aşama bulunur:

1. Hareket tahmini: Robotun motor komutlarına göre yeni konumu hesaplanır.
2. Ölçüm eşleştirme: Yeni sensör verileri, daha önce görülen özelliklerle karşılaştırılır.
3. Düzeltme: Tahmin ile ölçüm arasındaki fark azaltılır.

Basitleştirilmiş bir konum güncellemesi Python ile şöyle modellenebilir:

import numpy as np

def hareket_modeli(durum, mesafe, donus):
    # Önce robotun yönünü güncelle
    x, y, aci = durum
    aci += donus

    # Yeni yöne göre düzlemde ilerle
    x += mesafe * np.cos(aci)
    y += mesafe * np.sin(aci)

    return np.array([x, y, aci])

durum = np.array([0.0, 0.0, 0.0])
durum = hareket_modeli(durum, 1.0, np.pi / 4)

Bu kod yalnızca hareket tahmini yapar. Gerçek bir SLAM sistemi, sensör ölçümlerini kullanarak bu sonucu düzeltir; çünkü tekerlek kayması veya motor hataları robotu matematiksel rotasından uzaklaştırabilir.

Döngü kapatma: “Ben burayı görmüştüm!”

Robot uzun süre ilerledikten sonra başlangıç noktasına dönebilir. Sistem daha önce gördüğü bir koridoru veya köşeyi tanırsa buna döngü kapatma denir. Bu keşif, biriken konum hatalarının tüm rota boyunca dağıtılarak düzeltilmesini sağlar. Aksi hâlde kare biçimindeki bir oda, haritada yamuk bir çokgene dönüşebilir.

SLAM çözümleri genellikle EKF-SLAM, parçacık filtreleri, grafik tabanlı SLAM veya görsel SLAM gibi yaklaşımlara ayrılır. Günümüzde robot süpürgelerden otonom otomobillere, dronlardan artırılmış gerçeklik uygulamalarına kadar pek çok sistem bu fikirlerden yararlanır. Kısacası robot, kusursuz biçimde “bilmez”; hareket eder, ölçer, şüphe duyar ve tahminini tekrar tekrar iyileştirir.

``

Sürü robotiğinin temel fikri

Geleneksel robot sistemlerinde kararları merkezi bir bilgisayar verebilir. Sürü yaklaşımında ise her robot yalnızca yakın çevresini algılar, komşularıyla sınırlı bilgi paylaşır ve birkaç basit kural uygular. Robotların hiçbiri sistemin tamamını görmek zorunda değildir.

Bu yapıya beliren davranış denir. Kuş sürülerinin aynı anda yön değiştirmesi, balıkların avcılardan kaçarken düzenli biçimde dağılması ve karıncaların feromon izleri oluşturması bunun doğal örnekleridir.

Üç basit kural

Birçok sürü hareketi üç davranışla modellenebilir:

1. Ayrılma: Çarpışmayı önlemek için çok yakın komşulardan uzaklaş.
2. Hizalanma: Yakındaki robotların ortalama hareket yönüne yaklaş.
3. Birleşme: Komşuların oluşturduğu merkeze doğru ilerle.

Bir robotun yeni hız vektörü şöyle ifade edilebilir:

Burada $\vec{S}$ ayrılma, $\vec{A}$ hizalanma ve $\vec{C}$ birleşme vektörüdür. $w_s$, $w_a$ ve $w_c$ katsayıları ise davranışların önemini belirler. Ayrılma ağırlığı çok düşükse robotlar birbirine girer; çok yüksekse sürü, kalabalık bir asansörde kişisel alan arayan insanlara dönüşür.

Küçük bir Python modeli

Aşağıdaki fonksiyon, tek bir robot için komşulara göre basitleştirilmiş yön değişimi hesaplar:

import numpy as np

def suru_adimi(konum, hiz, komsu_konumlari, komsu_hizlari):
    if len(komsu_konumlari) == 0:
        return hiz

    merkez = np.mean(komsu_konumlari, axis=0)
    ortalama_hiz = np.mean(komsu_hizlari, axis=0)

    birlesme = merkez - konum
    hizalanma = ortalama_hiz - hiz

    farklar = konum - komsu_konumlari
    mesafeler = np.linalg.norm(farklar, axis=1)
    yakinlar = farklar[mesafeler < 2.0]
    ayrilma = np.sum(yakinlar, axis=0) if len(yakinlar) else np.zeros(2)

    yeni_hiz = hiz + 0.05 * birlesme + 0.1 * hizalanma + 0.3 * ayrilma
    maksimum_hiz = 2.0
    norm = np.linalg.norm(yeni_hiz)

    if norm > maksimum_hiz:
        yeni_hiz = yeni_hiz / norm * maksimum_hiz

    return yeni_hiz

Fonksiyon önce komşuların merkezini ve ortalama hızını bulur. İki birimden yakın robotlar için ayrılma kuvveti üretir, ardından üç davranışı farklı ağırlıklarla birleştirir. Son bölüm hızın fiziksel sınırı aşmasını engeller. Gerçek robotlarda buna sensör gürültüsü, gecikme, pil seviyesi ve engel algılama gibi değişkenler de eklenir.

Neden dayanıklıdır?

Sürüde görev bilgisi dağıtıldığı için tek bir robotun bozulması çoğunlukla tüm operasyonu durdurmaz. Eğer bir robotun çalışma olasılığı $p$ ve sürüdeki robot sayısı $N$ ise beklenen çalışan robot sayısı basitçe $Np$ olur. Sistem görevini yalnızca belirli sayıda robota ihtiyaç duyarak sürdürebiliyorsa doğal bir hata toleransı kazanır.

Bu özellik; afet bölgelerinde arama, tarım alanlarının izlenmesi, depo taşımacılığı, çevresel ölçüm ve uzay keşfi gibi alanlarda değerlidir. Yine de haberleşme çakışmaları, güvenlik açıkları ve beklenmeyen kolektif davranışlar önemli mühendislik sorunlarıdır.

Sürü robotiğinin en çarpıcı dersi şudur: Karmaşık sonuçlar için her zaman karmaşık bireyler gerekmez. Doğru seçilmiş birkaç yerel kural, yüzlerce robotu koordineli ve dayanıklı bir topluluğa dönüştürebilir.

İleri ve ters kinematik farkı

Robot kolunun eklem açıları biliniyorsa uç noktanın konumunu hesaplamaya ileri kinematik denir. Ters kinematikte ise sonuç bilinir, bilinmeyenler aranır: Robot elinin ulaşması gereken hedef verilir ve uygun eklem açıları çözülür.

İki eklemli düzlemsel kol

Mantığı görmek için uzunlukları $L_1$ ve $L_2$ olan, düzlemde hareket eden iki parçalı bir kol düşünelim. Eklem açıları $\theta_1$ ve $\theta_2$ olsun. İleri kinematik denklemleri şöyledir:

Ters problemde $x$ ve $y$ hedefini bilir, açıları ararız. Önce kosinüs teoreminden ikinci eklemi hesaplarız:

Ardından iki olası dirsek duruşundan biri seçilir:

Birinci eklem açısı ise şu ifadeyle bulunur:

$\pm$ işareti önemlidir: Aynı hedefe “dirsek yukarıda” veya “dirsek aşağıda” olmak üzere iki farklı duruşla ulaşılabilir. Yani robot bazen hedefe giderken küçük bir stil seçimi yapar!

Python ile geometrik çözüm

Aşağıdaki fonksiyon, iki eklemli kol için iki muhtemel açı çiftini derece cinsinden döndürür. Hedef çalışma alanının dışındaysa hata üretir.

import math

def ters_kinematik(x, y, L1, L2):
    c2 = (x*x + y*y - L1*L1 - L2*L2) / (2 * L1 * L2)

    if not -1 <= c2 <= 1:
        raise ValueError('Hedefe ulaşılamıyor')

    cozumler = []
    for isaret in (1, -1):
        s2 = isaret * math.sqrt(max(0, 1 - c2*c2))
        t2 = math.atan2(s2, c2)
        t1 = math.atan2(y, x) - math.atan2(
            L2 * s2, L1 + L2 * c2
        )
        cozumler.append((math.degrees(t1), math.degrees(t2)))

    return cozumler

print(ters_kinematik(1.2, 0.8, 1.0, 1.0))

atan2, sıradan arktanjanttan farklı olarak noktanın hangi bölgede bulunduğunu dikkate alır. max kullanımıysa kayan nokta hataları nedeniyle karekök içine çok küçük negatif bir değer girmesini önler.

Ulaşılabilirlik ve tekillikler

Hedef uzaklığı $r=\sqrt{x^2+y^2}$ ile gösterilirse hedef ancak şu koşulda erişilebilirdir:

Kol tamamen açıldığında veya kendi üzerine katlandığında tekillik oluşabilir. Bu durumlarda küçük bir hedef hareketi, eklemlerde çok büyük hızlar gerektirebilir.

Gerçek robotlarda üç boyut, eklem sınırları ve engeller devreye girdiği için analitik formüller her zaman yeterli olmaz. Jacobian tabanlı yöntemler, gradyan inişi ve CCD gibi sayısal algoritmalar hedefe adım adım yaklaşır. Başarılı bir ters kinematik sistemi yalnızca hedefe ulaşmamalı; güvenli, kararlı ve doğal görünen çözümü de seçmelidir.