Proyek Radar Arduino: Panduan HC-SR04, Servo SG90, dan Processing

Radar Arduino adalah proyek yang memasang sensor jarak ultrasonik HC-SR04 di atas motor servo SG90, menyapukannya antara 0 dan 180 derajat untuk mengukur arah sekaligus jarak benda di sekitarnya, lalu menampilkan hasilnya di komputermu sebagai layar radar hijau ala film. Di setiap sudut, Arduino mengambil satu pembacaan dan mengirim baris “sudut,jarak” lewat port serial; program Processing kecil yang berjalan di komputer membaca angka-angka itu lalu menggambar garis sapuan yang berputar dan benda yang terdeteksi sebagai garis merah.

Di panduan ini setiap langkah dijelaskan, mulai dari daftar komponen dan skema rangkaian sampai kode Arduino dan layar radar Processing. Kita juga membahas radar mini di layar OLED yang tidak butuh komputer, versi ESP32 dan Raspberry Pi Pico, cara mengatur kecepatan sapuan dan akurasi pengukuran, serta cara mengatasi error port serial yang paling sering muncul. Proyek ini murah, bisa selesai dalam satu sore, dan termasuk proyek Arduino yang paling menarik perhatian di presentasi sekolah.

Bagaimana radar Arduino bekerja?

Jantung sistem ini adalah HC-SR04. Salah satu dari dua silinder di sensor (T) mengirim semburan suara 40 kHz yang singkat dan tidak bisa didengar manusia; ketika suara itu mengenai benda dan memantul kembali, silinder lainnya (R) menangkap gemanya. Arduino mengukur waktu pulang-pergi ini dalam mikrodetik. Suara merambat di udara dengan kecepatan sekitar 343 m/dtk, jadi butuh sekitar 29 mikrodetik untuk menempuh satu sentimeter; karena jalurnya ditempuh dua kali, berangkat dan kembali, rumusnya menjadi jarak (cm) = waktu (µs) / 58. Servo memutar sensor langkah demi langkah dan pengukuran diulang di setiap langkah. Hasilnya adalah “ada sesuatu di sudut ini, sekian sentimeter jauhnya”, yaitu sebuah koordinat polar. Untuk menggambarnya di layar, sudut dan jarak diubah menjadi posisi piksel dengan x = jarak × cos(sudut) dan y = jarak × sin(sudut).

Daftar komponen radar Arduino

• Arduino Uno atau Nano dan kabel USB yang bisa mengirim data (kabel khusus charge tidak muncul sebagai port di komputer).
• Sensor jarak ultrasonik HC-SR04.
• Servo mikro SG90 beserta lengan (horn) plastik yang ada di kantongnya.
• Breadboard dan 8–10 kabel jumper male-to-male dan male-to-female.
• Kapasitor elektrolit 470 µF (minimal 10 V): mencegah tegangan catu daya anjlok ketika servo bergerak.
• Selotip dua sisi, lem tembak, atau braket kecil cetakan 3D untuk menempelkan sensor ke servo.
• Opsional: layar OLED I2C 0,96 inci (untuk versi tanpa komputer) dan adaptor eksternal 5 V 2 A.

Skema rangkaian radar Arduino

Di Uno, pengkabelan lebih rapi kalau kabel 5 V dan GND dari sensor dan servo kamu sambungkan ke jalur plus dan minus breadboard, lalu jalur itu ke pin 5V dan GND Arduino. Pasang kapasitor 470 µF di jalur yang sama dengan kaki panjang (+) di 5 V dan kaki pendek, yang ditandai garis di badannya, di GND. Pada sebagian servo, kabelnya berwarna hitam, merah, dan putih; dalam hal ini hitam adalah GND dan putih adalah sinyal. Untuk memastikan letak pin di board-mu, pakai alat pinout.

Memasang sensor di atas servo

Sebelum memasang lengan servo, atur servo ke 90 derajat: cukup upload sketch uji singkat yang berisi radarServo.write(90) dan biarkan servo di posisi itu. Lalu pasang lengannya sehingga sensor menghadap lurus ke depan. Dengan begitu 0° menunjuk ke kanan, 90° lurus ke depan, dan 180° ke kiri, dan arah di layar Processing sama persis dengan dunia nyata. Ketika menempelkan HC-SR04 ke lengan servo dengan selotip dua sisi atau lem tembak, pastikan kedua silinder sejajar dengan tanah; kalau sensor miring ke bawah, permukaan meja akan dikira sebagai benda. Sisakan kabel yang cukup kendur supaya tidak tertarik kencang selama putaran 180 derajat, dan tempelkan servo ke alas yang berat atau ke sebuah kotak; badan yang bergetar di setiap langkah akan merusak pembacaan.

Membuat radar Arduino langkah demi langkah

1. Rangkai komponen sesuai tabel di atas, jangan lupa kapasitornya, lalu pasang sensor di atas servo.
2. Buka Arduino IDE; library Servo sudah ikut terpasang bersama IDE, jadi tidak ada yang perlu diinstal lagi.
3. Upload kode radar di bawah. Kalau kamu kesulitan memilih board atau port, lihat kode Arduino gagal di-upload.
4. Buka Serial Monitor di 9600 baud; kalau baris sudut dan jarak seperti “30,45” terus bergulir, sisi Arduino sudah siap. Setelah itu pastikan menutup Serial Monitor.
5. Instal Processing 4 di komputermu, buka sketch baru, lalu tempel kode layar radar.
6. Tekan Run; daftar port muncul di konsol bagian bawah dan jendela radar terbuka. Ketika kamu menggerakkan tangan di depan sensor, garis merah seharusnya muncul.

Kode radar Arduino

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}

Cara kerja kode

Ada alasan datanya dibuat sesederhana ini: satu baris yang dipisah koma mudah dibaca di Serial Monitor dan bisa diurai dengan satu baris kode di Processing, Python, atau Excel. Jarak 0 berarti “tidak ada apa-apa dalam jangkauan di sudut ini”, dan Processing tidak menggambar nilai tersebut. Kalau data yang sama kamu buka di Serial Plotter Arduino IDE, kamu akan melihat sudut naik turun seperti gigi gergaji dan jarak melonjak setiap kali sensor melewati benda. Memakai delay tidak masalah untuk proyek ini; kalau kamu ingin membaca tombol atau menyalakan LED selama radar berjalan, tulis ulang loop-nya dengan millis().

Layar radar hijau di Processing

Processing adalah program gratis berbasis Java yang dibuat untuk pemrograman visual, dan antarmukanya sangat mirip dengan Arduino IDE: kamu menulis kode lalu menekan Run. Library Serial yang dibutuhkan untuk komunikasi serial sudah ikut bersama Processing; kamu bisa menambahkannya dari menu Sketch > Import Library, atau cukup mengandalkan baris import di bagian atas kode. Kode di bawah ini dimasukkan ke Processing, bukan ke Arduino IDE.

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}

Bagian terpenting dari kode ini adalah fungsi serialEvent(). Berkat bufferUntil('\n'), Processing mengumpulkan data yang masuk sampai akhir baris tiba, lalu memanggil fungsi ini secara otomatis dengan satu baris yang lengkap. Baris itu dibersihkan dari spasi dan karakter \r dengan trim(), dipecah dua di tanda koma dengan split(), lalu diubah menjadi angka dengan int(). Sementara itu draw() berjalan sekitar 60 kali per detik: pertama ia mengecat persegi panjang hitam tembus pandang di atas layar (fill(0, 12)), lalu menggambar ulang grid, garis sapuan, dan bendanya. Karena garis lama menjadi sedikit lebih gelap di setiap frame, jejak memudar seperti di layar radar sungguhan muncul dengan sendirinya.

Mengatur kecepatan servo dan waktu sapuan

Menurut datasheet-nya, SG90 berputar 60 derajat dalam 0,1 detik pada 4,8 V, jadi langkah 2 derajat selesai dalam beberapa milidetik. Yang sebenarnya menentukan waktu sapuan bukan servonya, melainkan waktu tunggu dan pengukuran di setiap langkah. Setelah servo berhenti, lengan dan sensornya bergoyang sebentar; mengukur pada momen itu membuat jaraknya melonjak-lonjak. Pembuat HC-SR04 juga menyarankan jeda sekitar 60 ms di antara dua pengukuran, karena gema dari pulsa sebelumnya yang memantul ke sana kemari di ruangan bisa bocor ke pembacaan berikutnya. Dalam praktiknya, total 50–60 ms per langkah (tunggu + ukur) adalah keseimbangan yang baik. Satu sapuan penuh kira-kira butuh (180 / langkah + 1) × waktu langkah.

Untuk memperhalus gerakan, buat langkahnya kecil dan waktu tunggunya singkat; kalau kamu ingin cepat, perbesar langkahnya dan perpanjang waktu tunggunya sedikit. Membatasi sapuan ke area yang penting bagimu (misalnya 45–135°) juga memangkas waktunya menjadi setengah. Kalau servo berkedut sendiri, Arduino sesekali restart, dan Processing kehilangan koneksi, masalahnya bukan kecepatan melainkan daya: SG90 bisa menarik sekitar 100–250 mA ketika bergerak dan sampai 600 mA ketika diberi beban. Tambahkan kapasitornya dan, kalau perlu, beri daya servo dari catu daya eksternal 5 V yang GND-nya disatukan dengan Arduino.

Meningkatkan akurasi pengukuran

Meskipun di atas kertas HC-SR04 menjanjikan resolusi 3 mm, ada tiga hal yang menentukan akurasi sebuah radar: lebar berkas, kecepatan suara, dan jenis permukaan. Berkas suara sensor menyebar seperti kerucut sekitar 15 derajat. Karena itulah pulpen tipis yang berjarak 50 cm muncul di layar bukan sebagai titik, melainkan sebagai busur selebar 15–20 derajat; resolusi sudut radar ditentukan oleh berkas ini, bukan oleh langkah servo, dan arah sebenarnya benda itu adalah bagian tengah busur. Kecepatan suara berubah mengikuti suhu dan dihitung dengan v = 331.3 + 0.606 × T (m/dtk, T dalam °C). Angka 58 di kode setara dengan sekitar 22 °C; di garasi yang dingin, pembacaannya keluar beberapa persen terlalu panjang.

Kamu bisa mengukur suhu ruangan dengan DHT11 atau DS18B20 lalu memperhitungkan kecepatan suaranya, dan kamu bisa membuang pembacaan buruk yang sesekali muncul dengan mengambil median dari tiga pembacaan. Cukup tambahkan dua fungsi di bawah ke kode utama dan ganti pemanggilan measureCm() di loop() dengan salah satunya. Karena filter median mengambil tiga pembacaan per langkah, sapuannya jadi sedikit lebih lambat.

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

• Permukaan lembut (gorden, kain, busa) menyerap suara; benda bisa saja tidak muncul di tempatnya.
• Permukaan miring memantulkan suara ke arah lain; kotak datar yang diputar lebih dari 45° dari sensor bisa terbaca sebagai ruang kosong.
• Benda yang lebih dekat dari 2 cm tidak bisa diukur; dalam praktiknya anggap apa pun di bawah 3–4 cm tidak bisa diandalkan.
• Sudut ruangan menimbulkan pantulan berganda dan bisa menciptakan “hantu” jauh yang sebenarnya tidak ada; uji di area kosong dan terbuka.
• Jangkauan: datasheet menyebut 400 cm, tapi pembacaan stabil pada benda kecil biasanya hanya sampai sekitar 2 meter; pilih MAX_CM sesuai dengan itu.

Radar mini di layar OLED (tanpa komputer)

Kalau kamu ingin radarnya menjadi perangkat portabel bertenaga baterai yang tidak butuh komputer, kamu bisa memakai layar OLED 0,96 inci sebagai pengganti Processing. Bagian tengah bawah layar SSD1306 128×64 menjadi pusat radar; di atasnya digambar setengah lingkaran dengan jari-jari 60 piksel, garis sapuan, dan titik-titik yang menunjukkan benda terakhir yang terukur di setiap sudut. Untuk pengkabelan layar (SDA → A4, SCL → A5) dan instalasi library, lihat panduan layar OLED SSD1306; HC-SR04 dan servo dirangkai sama seperti di atas.

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}

Di versi ini jarak disimpan per sudut di array dist, sehingga titik-titiknya tetap ada di layar setelah garis sapuan lewat dan diperbarui di sapuan berikutnya. Pusat lingkaran berada di tepi bawah layar, jadi setengah bagian bawahnya jatuh di luar layar dan tidak digambar oleh library, sehingga tersisa setengah lingkaran yang rapi. Mengirim satu frame ke layar butuh sekitar 25 ms pada I2C 400 kHz, jadi waktu tunggunya dipangkas menjadi 20 ms dan langkahnya dinaikkan menjadi 3 derajat; satu sapuan butuh sekitar 4–5 detik. Skala 50 cm lebih mudah dibaca di layar kecil, jadi MAX_CM diatur ke 50. Setengah dari memori 2 KB milik Uno terpakai untuk buffer layar, karena itulah penting untuk menyimpan array sebagai byte (uint8_t).

Radar Arduino dengan ESP32

Library Servo Arduino tidak berfungsi di ESP32; sebagai gantinya instal library ESP32Servo dari Library Manager. Sisa kodenya hampir sama. Karena ESP32 bekerja di 3,3 V, jangan lupa pembagi tegangan di jalur Echo HC-SR04; sebaliknya, pulsa 3,3 V di jalur Trig sudah cukup untuk memicu sebagian besar sensor. Kode ini memakai 115200 baud, jadi ubah juga 9600 di kode Processing menjadi 115200. Berkat Wi-Fi ESP32, nantinya kamu bisa mengirim data radar ke halaman web di ponselmu, bukan ke komputer; kalau kamu baru mengenal ESP32, mulailah dengan Apa Itu ESP32.

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}

Radar dengan Raspberry Pi Pico dan MicroPython

Di Pico kamu tidak butuh library servo tersendiri: cukup mengatur lebar pulsa sinyal PWM 50 Hz dengan duty_ns(). Waktu gema diukur dengan machine.time_pulse_us(), yang mengembalikan angka negatif kalau waktunya habis. Pin Pico juga 3,3 V, jadi pembagi di jalur Echo wajib dipasang. Simpan kode ke Pico sebagai main.py dengan Thonny, lalu tutup Thonny; kalau tidak, port tetap terpakai dan Processing tidak bisa terhubung. Karena Pico membuka port serial virtual lewat USB, nilai baud di Processing tidak berpengaruh; layar radar yang sama tetap berjalan tanpa perubahan apa pun.

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

Kesalahan umum dan solusinya

Ide untuk mengembangkan proyek radar

• Radar keamanan dengan alarm: ketika ada benda yang mendekat kurang dari 30 cm, bunyikan buzzer dan nyalakan LED merah; gabungkan dengan ide-ide di sistem alarm Arduino.
• Robot penghindar rintangan: pasang radar di bagian depan robot; ketika robot berhenti, ia memindai ke kiri dan kanan lalu berbelok ke arah yang paling lapang. Detailnya di robot penghindar rintangan.
• Peta ruangan: simpan data sapuan ke modul kartu SD lalu plot sebagai point cloud di komputer.
• Radar nirkabel: kirim pembacaan dari ESP32 lewat Wi-Fi ke halaman web di ponselmu; dengan web server ESP32 kamu bisa menggambarnya secara real time.
• Peta yang lebih tajam: pakai sensor laser (ToF) berkas sempit sebagai pengganti HC-SR04; pilihannya ada di perbandingan sensor jarak.
• Tongkat pintar: buat tongkat yang memperingatkan penyandang tunanetra tentang rintangan dengan sensor jarak dan motor getar: proyek tongkat pintar.

Karena menggabungkan sensor jarak, kendali servo, komunikasi serial, dan menggambar grafik di komputer dalam satu rakitan, proyek radar Arduino adalah langkah lanjutan yang bagus untuk pemula. Untuk memperkuat dasarnya, lihat juga panduan sensor jarak HC-SR04 dan motor servo. Di aplikasi BlueGrays kamu akan menemukan proyek langkah demi langkah untuk pengukuran jarak dengan HC-SR04, sensor parkir, pemakaian motor servo, dan robot penghindar rintangan, masing-masing dengan skema rangkaian dan kode yang diberi penjelasan.