Arduino Radar Projesi: HC-SR04, Servo ve Processing ile Yapımı

Arduino radar projesi, bir HC-SR04 ultrasonik mesafe sensörünü bir SG90 servo motorun üzerine yerleştirip 0 ile 180 derece arasında döndürerek çevredeki nesnelerin hem yönünü hem de uzaklığını ölçen ve sonucu bilgisayar ekranında filmlerdeki gibi yeşil bir tarama görüntüsüyle gösteren bir projedir. Arduino her açıda bir ölçüm yapar ve "açı,mesafe" biçimindeki satırı seri porttan gönderir; bilgisayarda çalışan küçük bir Processing programı da bu sayıları okuyup dönen tarama çizgisini ve algılanan nesneleri kırmızı çizgilerle çizer.

Bu rehberde malzeme listesinden bağlantı şemasına, Arduino kodundan Processing radar ekranına kadar her adımı açıklamalarıyla bulacaksın. Ayrıca bilgisayar gerektirmeyen OLED ekranlı mini radarı, ESP32 ve Raspberry Pi Pico uyarlamalarını, tarama hızını ve ölçüm doğruluğunu nasıl ayarlayacağını ve en sık karşılaşılan port hatalarının çözümünü de ele alıyoruz. Maliyeti düşük, bir öğleden sonrada bitirilebilen ve okulda sunulduğunda en çok ilgi çeken Arduino projelerinden biridir.

Arduino radar nasıl çalışır?

Sistemin kalbi HC-SR04'tür. Sensörün üzerindeki iki silindirden biri (T) insan kulağının duyamayacağı 40 kHz'lik kısa bir ses patlaması gönderir; ses bir nesneye çarpıp geri döndüğünde diğeri (R) yankıyı yakalar. Arduino bu gidiş-dönüş süresini mikrosaniye cinsinden ölçer. Ses havada yaklaşık 343 m/s hızla ilerler, yani bir santimetreyi yaklaşık 29 mikrosaniyede alır; yol hem gidiş hem dönüş olarak iki kez kat edildiği için formül mesafe (cm) = süre (µs) / 58 olur. Servo motor sensörü adım adım döndürür ve her adımda bu ölçüm tekrarlanır. Sonuçta elimizde "hangi açıda, kaç santimetrede bir şey var" bilgisi, yani kutupsal bir koordinat olur. Ekranda çizmek için açı ve mesafe x = mesafe × cos(açı) ve y = mesafe × sin(açı) formülleriyle piksel konumuna çevrilir.

Arduino radar malzeme listesi

• Arduino Uno ya da Nano ve veri aktarabilen bir USB kablosu (yalnızca şarj eden kablolar bilgisayarda port göstermez).
• HC-SR04 ultrasonik mesafe sensörü.
• SG90 mikro servo motor ve kutusundan çıkan plastik kollar.
• Breadboard ile 8–10 adet erkek-erkek ve erkek-dişi jumper kablo.
• 470 µF (en az 10 V) elektrolitik kondansatör: servo hareket ederken gerilimin çökmesini engeller.
• Sensörü servoya sabitlemek için çift taraflı bant, sıcak silikon ya da küçük bir 3D baskı tutucu.
• İsteğe bağlı: 0,96 inç I2C OLED ekran (bilgisayarsız sürüm için) ve 5 V 2 A harici adaptör.

Arduino radar bağlantı şeması

Uno'da sensörün ve servonun 5 V ve GND uçlarını breadboard'un artı ve eksi hatlarına, bu hatları da Arduino'nun 5V ve GND pinlerine bağlamak kablolamayı sadeleştirir. 470 µF kondansatörü aynı hatlara, uzun bacağı (+) 5 V'a, gövdesinde şerit olan kısa bacağı GND'ye gelecek şekilde tak. Bazı servolarda kablo renkleri siyah, kırmızı ve beyazdır; bu durumda siyah GND, beyaz sinyaldir. Kartının pin yerlerinden emin olmak için pinout aracına bakabilirsin.

Sensörü servoya monte etmek

Kolu takmadan önce servoyu 90 dereceye getir: radarServo.write(90) yazan kısa bir deneme kodu yükleyip servoyu bu konumda bırakman yeterli. Ardından kolu, sensör tam karşıya bakacak şekilde tak. Böylece 0° sağı, 90° ileriyi, 180° solu gösterir ve Processing ekranındaki yönler gerçek dünyayla birebir eşleşir. HC-SR04'ü kola çift taraflı bant ya da sıcak silikonla yapıştırırken iki silindirin yere paralel durmasına dikkat et; sensör aşağı eğik kalırsa masanın yüzeyini nesne sanar. Kablolara 180 derecelik dönüşte gerilmeyecek kadar boşluk bırak ve servoyu ağır bir tabana ya da kutuya sabitle; her adımda sarsılan bir gövde ölçümleri bozar.

Adım adım Arduino radar yapımı

1. Bileşenleri yukarıdaki tabloya göre bağla, kondansatörü takmayı unutma ve sensörü servoya monte et.
2. Arduino IDE'yi aç; Servo kütüphanesi IDE ile birlikte gelir, ayrıca kurman gerekmez.
3. Aşağıdaki radar kodunu yükle. Kart ya da port seçiminde sorun yaşarsan Arduino kod yüklenmiyor yazısına göz at.
4. Seri Monitör'ü 9600 baud ile aç; "30,45" gibi açı ve mesafe satırları akıyorsa Arduino tarafı hazırdır. Ardından Seri Monitör'ü mutlaka kapat.
5. Bilgisayarına Processing 4'ü kur, yeni bir çizim (sketch) aç ve radar ekranı kodunu yapıştır.
6. Run düğmesine bas; alttaki konsolda port listesi görünür ve radar penceresi açılır. Elini sensörün önünde gezdirdiğinde kırmızı çizgiler belirmelidir.

Arduino radar kodu

1#include <Servo.h>
2
3const byte SERVO_PIN  = 9;     // SG90 turuncu kablo / SG90 orange wire
4const byte TRIG_PIN   = 10;    // HC-SR04 Trig
5const byte ECHO_PIN   = 11;    // HC-SR04 Echo
6const int  MIN_ANGLE  = 0;     // tarama başlangıcı / sweep start
7const int  MAX_ANGLE  = 180;   // tarama sonu / sweep end
8const int  STEP       = 2;     // adım başına derece / degrees per step
9const int  STEP_DELAY = 40;    // ölçümden önce bekleme (ms) / wait before measuring (ms)
10
11Servo radarServo;
12int angle = MIN_ANGLE;
13int dir = STEP;
14
15int measureCm() {
16  digitalWrite(TRIG_PIN, LOW);
17  delayMicroseconds(2);
18  digitalWrite(TRIG_PIN, HIGH);                         // 10 µs tetik darbesi / 10 µs trigger pulse
19  delayMicroseconds(10);
20  digitalWrite(TRIG_PIN, LOW);
21  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);  // en çok 30 ms bekle / wait at most 30 ms
22  if (us == 0) return 0;                                // yankı yok = menzil dışı / no echo = out of range
23  return us / 58;                                       // gidiş-dönüş süresi → cm / round-trip time → cm
24}
25
26void setup() {
27  Serial.begin(9600);
28  pinMode(TRIG_PIN, OUTPUT);
29  pinMode(ECHO_PIN, INPUT);
30  radarServo.attach(SERVO_PIN);
31  radarServo.write(angle);
32  delay(500);                                           // başlangıç konumuna gitsin / reach the start position
33}
34
35void loop() {
36  radarServo.write(angle);                              // servoyu yeni açıya döndür / move the servo to the new angle
37  delay(STEP_DELAY);                                    // titreşim geçsin / let the vibration settle
38  int distance = measureCm();
39
40  Serial.print(angle);                                  // biçim: açı,mesafe / format: angle,distance
41  Serial.print(',');
42  Serial.println(distance);
43
44  if (angle + dir > MAX_ANGLE || angle + dir < MIN_ANGLE) dir = -dir;  // uçta yön değiştir / reverse at the ends
45  angle += dir;
46}

Kod açıklaması

Gönderilen verinin bu kadar sade olmasının bir nedeni var: virgülle ayrılmış tek satır hem Seri Monitör'de rahatça okunur hem de Processing, Python ya da Excel gibi programlarda tek satır kodla ayrıştırılır. Mesafenin 0 gelmesi "bu açıda menzil içinde bir şey yok" anlamına gelir ve Processing bu değerleri çizmez. Aynı veriyi Arduino IDE'nin Seri Çizici (Serial Plotter) penceresinde açarsan açının testere dişi gibi inip çıktığını, mesafenin de bir nesnenin önünden geçerken sıçradığını görürsün. Bu proje için delay kullanmak yeterlidir; radar çalışırken aynı anda buton okumak ya da LED yakmak istersen döngüyü millis() ile yeniden yazabilirsin.

Processing ile yeşil radar ekranı

Processing, görsel programlama için geliştirilmiş ücretsiz ve Java tabanlı bir yazılımdır; arayüzü Arduino IDE'ye çok benzer: kodu yazar, Run düğmesine basarsın. Seri haberleşme için gereken Serial kütüphanesi Processing ile birlikte gelir; Sketch > Import Library menüsünden eklenebilir ya da kodun başındaki import satırı yeterlidir. Aşağıdaki kod Arduino IDE'ye değil, Processing'e yapıştırılır.

1// Processing 4 çizimi: Arduino IDE'ye değil, Processing'e yapıştır / Processing 4 sketch: paste into Processing, not the Arduino IDE
2import processing.serial.*;                       // Serial kütüphanesi / Serial library
3
4Serial port;
5int angle = 0;                                    // son açı / last angle
6int distance = 0;                                 // son mesafe (cm) / last distance (cm)
7final int MAX_CM = 100;                           // ekrandaki en uzak mesafe / farthest distance on screen
8float R;                                          // radar yarıçapı (piksel) / radar radius (pixels)
9
10void setup() {
11  size(1200, 700);
12  R = width * 0.45;
13  printArray(Serial.list());                      // portları konsola yaz / print the ports to the console
14  String portName = Serial.list()[0];             // gerekirse [1] ya da "COM4" yaz / use [1] or "COM4" if needed
15  port = new Serial(this, portName, 9600);        // Arduino ile aynı baud / same baud as the Arduino
16  port.bufferUntil('\n');                         // satır sonunu bekle / wait for the end of a line
17  background(0);
18}
19
20void draw() {
21  noStroke();
22  fill(0, 12);                                    // yarı saydam siyah: solan iz / translucent black: fading trail
23  rect(0, 0, width, height);
24  translate(width / 2, height - 60);              // radar merkezi alt ortada / radar centre at the bottom middle
25  drawGrid();
26  drawSweep();
27  drawObject();
28  drawLabels();
29}
30
31void drawGrid() {
32  noFill();
33  strokeWeight(2);
34  stroke(98, 245, 31);
35  for (int i = 1; i <= 4; i++) {
36    float d = 2 * R * i / 4;
37    arc(0, 0, d, d, PI, TWO_PI);                  // 25-50-75-100 cm yayları / 25-50-75-100 cm arcs
38  }
39  for (int a = 0; a <= 180; a += 30) {
40    line(0, 0, R * cos(radians(a)), -R * sin(radians(a)));   // 30 derecelik çizgiler / 30-degree lines
41  }
42}
43
44void drawSweep() {
45  strokeWeight(5);
46  stroke(30, 250, 60);
47  line(0, 0, R * cos(radians(angle)), -R * sin(radians(angle)));   // tarama çizgisi / sweep line
48}
49
50void drawObject() {
51  if (distance <= 0 || distance > MAX_CM) return;  // menzil dışı / out of range
52  float p = R * distance / MAX_CM;                 // cm → piksel / cm → pixels
53  float c = cos(radians(angle));
54  float s = sin(radians(angle));
55  strokeWeight(7);
56  stroke(255, 10, 10);
57  line(p * c, -p * s, R * c, -R * s);              // nesneden dışa kırmızı çizgi / red line from the object outwards
58}
59
60void drawLabels() {
61  resetMatrix();
62  noStroke();
63  fill(0);
64  rect(0, height - 40, width, 40);                 // yazı şeridi / text strip
65  fill(98, 245, 31);
66  textSize(20);
67  for (int i = 1; i <= 4; i++) {
68    text(MAX_CM * i / 4 + " cm", width / 2 + R * i / 4 + 4, height - 66);   // yay etiketleri / arc labels
69  }
70  String d = (distance > 0 && distance <= MAX_CM) ? distance + " cm" : "-";
71  text("Açı / Angle: " + angle + "°", 40, height - 12);
72  text("Mesafe / Distance: " + d, width / 2, height - 12);
73}
74
75void serialEvent(Serial p) {
76  String msg = p.readStringUntil('\n');            // "açı,mesafe" satırı / "angle,distance" line
77  if (msg == null) return;
78  String[] parts = split(trim(msg), ',');
79  if (parts.length == 2) {
80    angle = int(parts[0]);
81    distance = int(parts[1]);
82  }
83}

Kodun en önemli kısmı serialEvent() fonksiyonudur. bufferUntil('\n') sayesinde Processing satır sonu gelene kadar veriyi biriktirir ve tam bir satır geldiğinde bu fonksiyonu kendiliğinden çağırır. Satır trim() ile boşluklardan ve \r karakterinden temizlenir, split() ile virgülden ikiye bölünür ve int() ile sayıya çevrilir. draw() ise saniyede yaklaşık 60 kez çalışır: önce ekranın üzerine yarı saydam siyah bir dikdörtgen çizer (fill(0, 12)), sonra ızgarayı, tarama çizgisini ve nesneyi yeniden çizer. Eski çizgiler her karede biraz daha karardığı için radarlardaki o iz bırakarak sönme etkisi kendiliğinden oluşur.

Servo hızı ve tarama süresi ayarı

SG90'ın veri sayfasındaki hızı 4,8 V'ta 60 derece için 0,1 saniyedir; yani 2 derecelik bir adımı birkaç milisaniyede tamamlar. Tarama süresini asıl belirleyen servo değil, her adımdaki bekleme ve ölçüm süresidir. Servo durduktan sonra kol ve sensör kısa bir süre titrer; bu sırada ölçüm yapılırsa mesafeler zıplar. Ayrıca HC-SR04 üreticisi iki ölçüm arasında yaklaşık 60 ms bırakılmasını önerir, çünkü önceki darbenin odadaki yankıları sonraki ölçüme karışabilir. Pratikte adım başına toplam 50–60 ms (bekleme + ölçüm) iyi bir dengedir. Bir tam taramanın süresi kabaca (180 / adım + 1) × adım süresi formülüyle bulunur.

Hareketi yumuşatmak için adımı küçük ve beklemeyi kısa tutmalı, hız istiyorsan adımı büyütüp beklemeyi biraz uzatmalısın. Taramayı yalnızca ilgilendiğin bölgeyle sınırlamak da (örneğin 45–135°) süreyi yarıya indirir. Servo kendi kendine sarsılıyor, Arduino ara sıra yeniden başlıyor ve Processing bağlantıyı kaybediyorsa sorun hız değil güçtür: SG90 hareket anında yaklaşık 100–250 mA, zorlandığında 600 mA'e kadar akım çekebilir. Kondansatörü ekle, gerekirse servoyu GND'si Arduino ile ortak olan harici bir 5 V kaynaktan besle.

Ölçüm doğruluğunu artırmak

HC-SR04 kâğıt üzerinde 3 mm çözünürlük vaat etse de radarda doğruluğu üç şey belirler: huzme genişliği, ses hızı ve yüzeyin türü. Sensörün ses demeti yaklaşık 15 derecelik bir koni gibi yayılır. Bu yüzden 50 cm uzaklıktaki ince bir kalem ekranda nokta olarak değil, 15–20 derecelik bir yay olarak görünür; radarın açısal çözünürlüğünü servo adımı değil bu huzme belirler ve nesnenin gerçek yönü bu yayın ortasıdır. Ses hızı ise sıcaklıkla değişir ve v = 331,3 + 0,606 × T (m/s, T °C cinsinden) formülüyle hesaplanır. Koddaki 58 sayısı yaklaşık 22 °C'ye karşılık gelir; soğuk bir garajda ölçümler birkaç yüzde uzun çıkar.

Ortam sıcaklığını bir DHT11 ya da DS18B20 ile ölçüp ses hızını hesaba katabilir, tek seferlik hatalı ölçümleri de üç ölçümün ortancasını alarak atabilirsin. Aşağıdaki iki fonksiyonu ana koda ekleyip loop() içindeki measureCm() çağrısını bunlardan biriyle değiştirmen yeterli. Ortanca filtresi her adımda üç ölçüm yaptığı için taramayı biraz yavaşlatır.

1// Ana radar koduna eklenecek fonksiyonlar / functions to add to the main radar sketch
2
3// Sıcaklığa göre düzeltilmiş ölçüm / temperature-compensated reading
4int measureCmTemp(float tempC) {
5  digitalWrite(TRIG_PIN, LOW);
6  delayMicroseconds(2);
7  digitalWrite(TRIG_PIN, HIGH);
8  delayMicroseconds(10);
9  digitalWrite(TRIG_PIN, LOW);
10  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);
11  if (us == 0) return 0;                                // yankı yok / no echo
12  float v = 331.3 + 0.606 * tempC;                      // ses hızı (m/s) / speed of sound (m/s)
13  return (int)(us * v / 20000.0 + 0.5);                 // µs × (m/s) / 20000 = cm
14}
15
16// Üç ölçümün ortancası: tek seferlik sıçramaları atar / median of three: drops one-off spikes
17int medianCm() {
18  int a = measureCm(); delay(20);
19  int b = measureCm(); delay(20);
20  int c = measureCm();
21  return max(min(a, b), min(max(a, b), c));
22}
23
24// loop() içinde kullanım / use inside loop():
25// int distance = medianCm();
26// int distance = measureCmTemp(18.5);                  // sıcaklık DHT11'den gelebilir / temperature can come from a DHT11

• Yumuşak yüzeyler (perde, kumaş, sünger) sesi emer; nesne olduğu yerde görünmeyebilir.
• Eğik yüzeyler sesi başka yöne yansıtır; sensöre 45°'den fazla açıyla duran düz bir kutu boşluk gibi okunabilir.
• 2 cm'den yakın nesneler ölçülemez; pratikte 3–4 cm'nin altındaki değerleri güvenilmez kabul et.
• Oda köşeleri çoklu yansıma yapar ve gerçekte olmayan uzak "hayaletler" oluşturabilir; deneme alanını boş ve geniş seç.
• Menzil: Veri sayfası 400 cm der, ama küçük nesnelerde kararlı ölçüm genellikle 2 metreye kadar alınır; MAX_CM değerini buna göre seç.

OLED ekranda mini radar (bilgisayarsız)

Radarın bilgisayara bağlı kalmadan, pille çalışan taşınabilir bir cihaz olmasını istiyorsan Processing yerine 0,96 inçlik bir OLED ekran kullanabilirsin. SSD1306 sürücülü 128×64 ekranın alt orta noktası radarın merkezi olur; 60 piksel yarıçaplı bir yarım çember, tarama çizgisi ve her açıda son ölçülen nesneyi gösteren noktalar çizilir. Ekranın bağlantısı (SDA → A4, SCL → A5) ve kütüphane kurulumu için OLED ekran SSD1306 yazısına bakabilirsin; HC-SR04 ve servonun bağlantısı yukarıdakiyle aynıdır.

1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <Servo.h>
5
6const byte SERVO_PIN = 9;                 // SG90 sinyal / SG90 signal
7const byte TRIG_PIN  = 10;                // HC-SR04 Trig
8const byte ECHO_PIN  = 11;                // HC-SR04 Echo
9const int  MAX_CM    = 50;                // ekrandaki en uzak mesafe / farthest distance on screen
10const int  STEP      = 3;                 // adım başına derece / degrees per step
11const int  CX = 64, CY = 63, R = 60;      // radar merkezi ve yarıçapı (piksel) / radar centre and radius (px)
12
13Adafruit_SSD1306 display(128, 64, &Wire, -1);
14Servo radarServo;
15uint8_t dist[180 / STEP + 1];             // her açının son ölçümü (cm) / last reading per angle (cm)
16int angle = 0;
17int dir = STEP;
18
19int measureCm() {
20  digitalWrite(TRIG_PIN, LOW);
21  delayMicroseconds(2);
22  digitalWrite(TRIG_PIN, HIGH);
23  delayMicroseconds(10);
24  digitalWrite(TRIG_PIN, LOW);
25  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);
26  if (us == 0) return 0;                  // yankı yok / no echo
27  return us / 58;
28}
29
30void setup() {
31  pinMode(TRIG_PIN, OUTPUT);
32  pinMode(ECHO_PIN, INPUT);
33  radarServo.attach(SERVO_PIN);
34  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
35    for (;;);                             // ekran bulunamadı / display not found
36  }
37  display.setTextColor(SSD1306_WHITE);
38}
39
40void loop() {
41  radarServo.write(angle);
42  delay(20);                              // çizim de zaman aldığı için kısa / short, drawing takes time too
43  int d = measureCm();
44  dist[angle / STEP] = (d > 255) ? 255 : d;   // byte'a sığdır / fit into a byte
45
46  display.clearDisplay();
47  display.drawCircle(CX, CY, R, SSD1306_WHITE);       // dış yay, alt yarısı ekran dışında / outer arc, lower half off-screen
48  display.drawCircle(CX, CY, R / 2, SSD1306_WHITE);   // orta yay = MAX_CM / 2 / middle arc = MAX_CM / 2
49  for (int i = 0; i <= 180 / STEP; i++) {
50    if (dist[i] > 0 && dist[i] <= MAX_CM) {
51      float rad = radians(i * STEP);
52      int r = map(dist[i], 0, MAX_CM, 0, R);          // cm → piksel / cm → pixels
53      display.fillCircle(CX + r * cos(rad), CY - r * sin(rad), 1, SSD1306_WHITE);
54    }
55  }
56  float rad = radians(angle);
57  display.drawLine(CX, CY, CX + R * cos(rad), CY - R * sin(rad), SSD1306_WHITE);  // tarama çizgisi / sweep line
58  display.setCursor(0, 0);
59  display.print(angle);                   // açı / angle
60  display.setCursor(98, 0);
61  display.print(d);                       // mesafe / distance
62  display.print(F("cm"));
63  display.display();
64
65  if (angle + dir > 180 || angle + dir < 0) dir = -dir;   // uçta yön değiştir / reverse at the ends
66  angle += dir;
67}

Bu sürümde mesafeler dist dizisinde açıya göre saklanır; böylece tarama çizgisi geçtikten sonra da noktalar ekranda kalır ve bir sonraki turda güncellenir. Merkezi ekranın alt kenarına konan çemberin alt yarısı ekranın dışına taştığı için kütüphane onu çizmez, geriye düzgün bir yarım daire kalır. Ekrana bir kare göndermek 400 kHz I2C hızında yaklaşık 25 ms sürdüğünden bekleme 20 ms'ye indirildi ve adım 3 dereceye çıkarıldı; bir tarama yaklaşık 4–5 saniye sürer. Küçük ekranda 50 cm'lik ölçek daha anlaşılır olduğu için MAX_CM 50 seçildi. Uno'nun 2 KB belleğinin yarısı ekran tamponuna gittiğinden diziyi byte (uint8_t) türünde tutmak da önemlidir.

ESP32 ile Arduino radar

ESP32'de Arduino'nun Servo kütüphanesi çalışmaz; Kütüphane Yöneticisi'nden ESP32Servo kütüphanesini kurman gerekir. Kodun geri kalanı neredeyse aynıdır. ESP32 3,3 V ile çalıştığı için HC-SR04'ün Echo hattına gerilim bölücü takmayı unutma; Trig hattındaki 3,3 V'luk darbe ise sensörlerin çoğunu tetiklemeye yeter. Bu kod 115200 baud kullandığı için Processing kodundaki 9600'ü de 115200 yapmalısın. ESP32'nin Wi-Fi özelliği sayesinde ileride radar verisini bilgisayar yerine telefondaki bir web sayfasına da gönderebilirsin; ESP32'ye yeniysen önce ESP32 nedir yazısına göz at.

1#include <ESP32Servo.h>                // Kütüphane Yöneticisi: ESP32Servo / Library Manager: ESP32Servo
2
3const int SERVO_PIN  = 13;             // SG90 sinyal / SG90 signal
4const int TRIG_PIN   = 26;             // HC-SR04 Trig
5const int ECHO_PIN   = 27;             // 1k/2k bölücüden / through the 1k/2k divider
6const int STEP       = 2;              // adım başına derece / degrees per step
7const int STEP_DELAY = 40;             // ölçümden önce bekleme (ms) / wait before measuring (ms)
8
9Servo radarServo;
10int angle = 0;
11int dir = STEP;
12
13int measureCm() {
14  digitalWrite(TRIG_PIN, LOW);
15  delayMicroseconds(2);
16  digitalWrite(TRIG_PIN, HIGH);
17  delayMicroseconds(10);
18  digitalWrite(TRIG_PIN, LOW);
19  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);
20  if (us == 0) return 0;               // yankı yok / no echo
21  return us / 58;
22}
23
24void setup() {
25  Serial.begin(115200);                       // Processing'de de 115200 / 115200 in Processing too
26  pinMode(TRIG_PIN, OUTPUT);
27  pinMode(ECHO_PIN, INPUT);
28  radarServo.setPeriodHertz(50);              // standart servo 50 Hz / standard servo 50 Hz
29  radarServo.attach(SERVO_PIN, 500, 2400);    // SG90 darbe aralığı (µs) / SG90 pulse range (µs)
30  radarServo.write(angle);
31  delay(500);
32}
33
34void loop() {
35  radarServo.write(angle);
36  delay(STEP_DELAY);
37  int distance = measureCm();
38  Serial.printf("%d,%d\n", angle, distance);  // açı,mesafe / angle,distance
39  if (angle + dir > 180 || angle + dir < 0) dir = -dir;   // uçta yön değiştir / reverse at the ends
40  angle += dir;
41}

Raspberry Pi Pico ve MicroPython ile radar

Pico'da servo için ayrı bir kütüphane gerekmez: 50 Hz'lik PWM sinyalinin darbe genişliğini duty_ns() ile ayarlamak yeterlidir. Yankı süresi machine.time_pulse_us() ile ölçülür ve zaman aşımında negatif bir sayı döner. Pico'nun pinleri de 3,3 V olduğundan Echo hattında bölücü şarttır. Kodu Thonny ile main.py adıyla Pico'ya kaydet, sonra Thonny'yi kapat; aksi halde port meşgul kalır ve Processing bağlanamaz. Pico USB üzerinden sanal bir seri port açtığı için Processing'deki baud değeri önemli değildir; aynı radar ekranı hiçbir değişiklik yapmadan çalışır.

1from machine import Pin, PWM, time_pulse_us
2import time
3
4servo = PWM(Pin(15))                     # SG90 sinyal / SG90 signal
5servo.freq(50)                           # standart servo 50 Hz / standard servo 50 Hz
6trig = Pin(14, Pin.OUT)
7echo = Pin(13, Pin.IN)                   # bölücüden gelir / comes through the divider
8
9def set_angle(a):
10    # 0° = 500 µs, 180° = 2400 µs darbe / pulse
11    servo.duty_ns(500000 + a * 1900000 // 180)
12
13def measure_cm():
14    trig.value(0)
15    time.sleep_us(2)
16    trig.value(1)                        # 10 µs tetik / 10 µs trigger
17    time.sleep_us(10)
18    trig.value(0)
19    t = time_pulse_us(echo, 1, 30000)    # en çok 30 ms bekle / wait at most 30 ms
20    if t < 0:
21        return 0                         # yankı yok / no echo
22    return t // 58
23
24angle, step = 0, 2
25set_angle(angle)
26time.sleep_ms(500)
27
28while True:
29    set_angle(angle)
30    time.sleep_ms(40)                    # servo otursun / let the servo settle
31    print("{},{}".format(angle, measure_cm()))   # açı,mesafe / angle,distance
32    if angle + step > 180 or angle + step < 0:
33        step = -step                     # uçta yön değiştir / reverse at the ends
34    angle += step

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

Radar projesini geliştirme fikirleri

• Alarmlı güvenlik radarı: Bir nesne 30 cm'den yakına girdiğinde buzzer öttür ve kırmızı bir LED yak; Arduino alarm sistemi yazısındaki fikirlerle birleştir.
• Engelden kaçan robot: Radarı robotun önüne yerleştir; robot durduğunda sağı ve solu tarayıp en boş yöne dönsün. Ayrıntılar engelden kaçan robot yazısında.
• Oda haritası: Tarama verisini bir SD kart modülüne kaydet ve bilgisayarda nokta bulutu olarak çiz.
• Kablosuz radar: ESP32 ile ölçümleri Wi-Fi üzerinden telefondaki bir web sayfasına gönder; ESP32 web sunucusu ile gerçek zamanlı çizim yapabilirsin.
• Daha keskin harita: HC-SR04 yerine dar huzmeli bir lazer (ToF) sensör kullan; seçenekleri mesafe sensörleri karşılaştırması yazısında bulabilirsin.
• Akıllı baston: Mesafe sensörü ve titreşim motoruyla görme engelliler için engel uyarısı veren bir baston yap: akıllı baston projesi.

Arduino radar projesi; mesafe sensörü, servo kontrolü, seri haberleşme ve bilgisayarda grafik çizimini tek projede birleştirdiği için yeni başlayanlar için harika bir sonraki adımdır. Temelleri pekiştirmek istersen HC-SR04 mesafe sensörü ve servo motor yazılarına da göz atabilirsin. BlueGrays uygulamasında HC-SR04 ile mesafe ölçme, park sensörü, servo motor kullanımı ve engelden kaçan robot projelerini devre şemaları ve açıklamalı kodlarıyla adım adım bulabilirsin.