Gidsen · 13 min leestijd

Arduino-radarproject: gids voor HC-SR04, SG90-servo en Processing

Arduino-radarproject stap voor stap: bedrading van HC-SR04 en SG90-servo, code voor hoek en afstand, een groen Processing-radarscherm, mini-radar op OLED en veelvoorkomende oplossingen.

Een Arduino-radar is een project waarbij je een HC-SR04-ultrasone afstandssensor op een SG90-servomotor monteert en die heen en weer laat zwenken tussen 0 en 180 graden. Zo meet je zowel de richting als de afstand van objecten in de buurt, en het resultaat verschijnt op je computer als een groen radarscherm zoals in de film. Op elke hoek doet de Arduino een meting en stuurt een regel "hoek,afstand" over de seriële poort; een klein Processing-programma op de computer leest die getallen en tekent de draaiende zweeplijn en de gedetecteerde objecten als rode lijnen.

In deze gids vind je elke stap uitgelegd, van de onderdelenlijst en het bedradingsschema tot de Arduino-code en het Processing-radarscherm. We behandelen ook een mini-radar op een OLED-display die geen computer nodig heeft, versies voor ESP32 en Raspberry Pi Pico, hoe je de zwenksnelheid en meetnauwkeurigheid afstelt en hoe je de meest voorkomende fouten met de seriële poort oplost. Het is goedkoop, in een middag klaar en een van de Arduino-projecten die op schoolpresentaties de meeste aandacht trekt.

Arduino Uno
Arduino Uno
HC-SR04
HC-SR04
SG90 servo
SG90 servo
Breadboard
Breadboard

Hoe werkt een Arduino-radar?

Het hart van het systeem is de HC-SR04. Een van de twee cilinders op de sensor (T) zendt een korte burst geluid van 40 kHz uit die mensen niet kunnen horen; als het geluid een object raakt en terugkaatst, vangt de andere (R) de echo op. De Arduino meet deze heen-en-terugtijd in microseconden. Geluid reist met ongeveer 343 m/s door lucht, dus het heeft ongeveer 29 microseconden nodig voor één centimeter; omdat de weg twee keer wordt afgelegd, heen en terug, wordt de formule afstand (cm) = tijd (µs) / 58. De servo draait de sensor stap voor stap en bij elke stap wordt de meting herhaald. Het resultaat is "iets op deze hoek, zoveel centimeter ver", oftewel een poolcoördinaat. Om dit op het scherm te tekenen worden hoek en afstand omgerekend naar een pixelpositie met x = afstand × cos(hoek) en y = afstand × sin(hoek).

OnderdeelTaakBelangrijkste waarden
HC-SR04Ultrasone afstandsmeting40 kHz, 2–400 cm, ongeveer 15° meethoek, 5 V, 15 mA
SG90 servoDraait de sensor 0–180°0,1 s/60° (4,8 V), 1,8 kg·cm koppel, 4,8–6 V, 9 g
Arduino UnoMeet, stuurt de servo aan, verstuurt de gegevens16 MHz, 5V-logica, USB-seriële poort
ProcessingTekent het radarscherm op de computerGratis, op Java gebaseerd, Serial-bibliotheek inbegrepen
OLED SSD1306 (optioneel)Mini-radarscherm zonder computer128×64 pixels, I2C, adres 0x3C

Onderdelenlijst Arduino-radar

  • Arduino Uno of Nano en een USB-kabel die data doorgeeft (kabels die alleen opladen verschijnen niet als poort op de computer).
  • HC-SR04 ultrasone afstandssensor.
  • SG90-microservo en de plastic hoorns die in het zakje zitten.
  • Een breadboard en 8–10 jumperdraden male-male en male-female.
  • Een elco van 470 µF (minimaal 10 V): die voorkomt dat de voedingsspanning inzakt als de servo beweegt.
  • Dubbelzijdig tape, hete lijm of een klein 3D-geprint beugeltje om de sensor op de servo vast te zetten.
  • Optioneel: een 0,96-inch I2C-OLED-display (voor de versie zonder computer) en een externe 5V-adapter van 2 A.

Bedradingsschema van de Arduino-radar

AansluitingArduino UnoESP32Raspberry Pi Pico
HC-SR04 VCC5VVIN (5 V)VBUS (pin 40)
HC-SR04 GNDGNDGNDGND
HC-SR04 TrigD10GPIO 26GP14
HC-SR04 EchoD11GPIO 27 (via spanningsdeler)GP13 (via spanningsdeler)
SG90 bruin (GND)GNDGNDGND
SG90 rood (+5 V)5VVIN (5 V)VBUS (pin 40)
SG90 oranje (signaal)D9GPIO 13GP15

Op de Uno is de bedrading overzichtelijker als je de 5V- en GND-draden van de sensor en de servo op de plus- en minrails van het breadboard aansluit en die rails op de 5V- en GND-pinnen van de Arduino. Steek de condensator van 470 µF in dezelfde rails, met het lange pootje (+) op 5 V en het korte pootje, gemarkeerd met de streep op de behuizing, op GND. Bij sommige servo's zijn de draden zwart, rood en wit; in dat geval is zwart GND en wit het signaal. Wil je dubbelchecken waar de pinnen op je board zitten, gebruik dan de pinout-tool.

Als de HC-SR04 op 5 V draait, geeft de Echo-pin ook 5 V af. Dat is prima voor een Arduino Uno, maar de pinnen van de ESP32 en de Raspberry Pi Pico zijn niet 5V-tolerant. Plaats een spanningsdeler van 1 kΩ en 2 kΩ op de Echo-lijn (Echo → 1 kΩ → GPIO, GPIO → 2 kΩ → GND); de spanning op de pin daalt dan naar ongeveer 3,3 V. Je kunt de waarden controleren met de spanningsdelerscalculator.

De sensor op de servo monteren

SG90-microservomotor
SG90-servo: bruin is GND, rood is +5 V, oranje is het signaal. De HC-SR04 is vastgelijmd op de plastic hoorn van de servo.

Zet de servo op 90 graden voordat je de hoorn monteert: upload gewoon een korte testsketch met radarServo.write(90) en laat de servo in die stand staan. Bevestig dan de hoorn zo dat de sensor recht vooruit kijkt. Zo wijst 0° naar rechts, 90° recht vooruit en 180° naar links, en komen de richtingen op het Processing-scherm precies overeen met de werkelijkheid. Als je de HC-SR04 met dubbelzijdig tape of hete lijm op de hoorn plakt, zorg dan dat de twee cilinders evenwijdig aan de grond staan; als de sensor omlaag kantelt, aanziet hij het tafeloppervlak voor een object. Laat de draden genoeg speling zodat ze tijdens de draai van 180 graden niet strak getrokken worden, en zet de servo vast op een zware basis of een doos; een behuizing die bij elke stap trilt, verpest de metingen.

De Arduino-radar stap voor stap bouwen

  1. Sluit de onderdelen aan volgens de tabel hierboven, vergeet de condensator niet en monteer de sensor op de servo.
  2. Open de Arduino IDE; de Servo-bibliotheek wordt met de IDE meegeleverd, dus je hoeft niets extra te installeren.
  3. Upload de radarcode hieronder. Heb je moeite met het kiezen van het board of de poort, lees dan Arduino-code wordt niet geüpload.
  4. Open de Serial Monitor op 9600 baud; als er regels met hoek en afstand zoals "30,45" voorbijscrollen, is de Arduino-kant klaar. Sluit daarna beslist de Serial Monitor.
  5. Installeer Processing 4 op je computer, open een nieuwe sketch en plak de code van het radarscherm erin.
  6. Druk op Run; de poortlijst verschijnt in de console onderaan en het radarvenster opent. Als je je hand voor de sensor beweegt, moeten er rode lijnen verschijnen.

Arduino-radarcode

C++ (Arduino IDE)
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}

Hoe de code werkt

CodedeelWat het doet
STEP en STEP_DELAYBepalen hoeveel graden de servo per stap draait en hoelang er voor het meten wordt gewacht; met deze twee constanten stel je de zwenksnelheid af.
measureCm()Stuurt een puls van 10 µs naar de Trig-pin, meet met pulseIn hoelang de Echo-pin HIGH blijft en deelt door 58 om centimeters te krijgen.
pulseIn(..., 30000UL)Wacht hooguit 30 ms en geeft 0 terug als er geen echo komt. Zonder deze timeout kan de functie tot 1 seconde blijven hangen als de sensor op lege ruimte wijst.
radarServo.write(angle)Zet de servo op de gevraagde hoek; de bibliotheek maakt van de waarde 0–180 een puls van 544–2400 µs.
Serial.print ... printlnVerstuurt elke meting als één regel "hoek,afstand"; het regeleinde vertelt Processing "gegevens compleet".
dir = -dirKeert de richting om als de hoek 180 of 0 bereikt, zodat de servo non-stop heen en weer zwenkt.

Er is een reden dat de gegevens zo simpel zijn gehouden: één regel met door komma's gescheiden waarden is makkelijk te lezen in de Serial Monitor en met één regel code te verwerken in Processing, Python of Excel. Een afstand van 0 betekent "niets binnen bereik op deze hoek", en Processing tekent die waarden niet. Open je dezelfde gegevens in de Serial Plotter van de Arduino IDE, dan zie je de hoek als een zaagtand stijgen en dalen en de afstand springen zodra de sensor een object passeert. Delay gebruiken is prima voor dit project; wil je een knop uitlezen of een LED laten branden terwijl de radar draait, schrijf de lus dan om met millis().

Als de servo bij precies 0° of 180° zoemt en trilt, raakt hij zijn mechanische grens. Beperk de zwenk tot 10–170°, of start de servo met radarServo.attach(SERVO_PIN, 500, 2400) en pas het pulsbereik aan op jouw servo.

Het groene radarscherm in Processing

Processing is een gratis, op Java gebaseerd programma voor visueel programmeren, en de interface lijkt sterk op de Arduino IDE: je schrijft de code en drukt op Run. De Serial-bibliotheek voor seriële communicatie wordt met Processing meegeleverd; je kunt hem toevoegen via het menu Sketch > Import Library, of je vertrouwt gewoon op de importregel bovenaan de code. De onderstaande code komt in Processing, niet in de Arduino IDE.

C++ (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}

Het belangrijkste deel van de code is de functie serialEvent(). Dankzij bufferUntil('\n') verzamelt Processing binnenkomende gegevens tot er een regeleinde komt en roept dan automatisch deze functie aan met een complete regel. De regel wordt met trim() ontdaan van spaties en het teken \r, met split() bij de komma in tweeën gesplitst en met int() omgezet naar getallen. draw() draait ondertussen ongeveer 60 keer per seconde: eerst tekent het een doorzichtige zwarte rechthoek over het scherm (fill(0, 12)), daarna tekent het het raster, de zweeplijn en het object opnieuw. Omdat oude lijnen bij elk beeld iets donkerder worden, ontstaat het vervagende spoor dat je op echte radarschermen ziet vanzelf.

InstellingWaar?Wat het doet
MAX_CM = 100ProcessingDe grootste afstand die het scherm bestrijkt; de buitenste boog is 100 cm en de binnenste bogen tonen 25, 50 en 75 cm.
Serial.list()[0]ProcessingKiest de eerste seriële poort van de computer; staat je Arduino verderop in de lijst, pas dan de index aan of typ de naam direct, zoals "COM4".
9600BeideBaudrate; de waarde in Serial.begin van de Arduino en in Processing moet overeenkomen.
fill(0, 12)ProcessingVervagingssnelheid; 5 geeft een lang spoor, 30 een bijna spoorloos beeld.
size(1200, 700)ProcessingVenstergrootte; maak het kleiner als het niet op je scherm past. De straal volgt de breedte, dus houd de hoogte boven de helft van de breedte.

Servosnelheid en zwenktijd afstellen

Volgens de datasheet draait de SG90 bij 4,8 V in 0,1 seconde 60 graden, dus een stap van 2 graden is in een paar milliseconden klaar. Wat de zwenktijd echt bepaalt is niet de servo, maar de wacht- en meettijd bij elke stap. Nadat de servo stopt, wiebelen de hoorn en de sensor even na; meten op dat moment laat de afstanden springen. De maker van de HC-SR04 raadt bovendien aan ongeveer 60 ms tussen twee metingen te laten, omdat echo's van de vorige puls die door de kamer weerkaatsen in de volgende meting kunnen doorlekken. In de praktijk is een totaal van 50–60 ms per stap (wachten + meten) een goede balans. Een volledige zwenk duurt ongeveer (180 / stap + 1) × staptijd.

StapSTEP_DELAYEén zwenk (0→180°)Resultaat
1°20 msongeveer 7 sVloeiendste beeld maar traag; hetzelfde object wordt vaak gemeten.
2°40 msongeveer 5 sAanbevolen instelling: vloeiend en stabiel.
3°50 msongeveer 4 sSneller; dankzij de bundel van 15° van de sensor wordt geen object gemist.
5°70 msongeveer 3,5 sHet scherm ziet er hakkelig uit; grotere stappen geven meer nawiebelen, dus de wachttijd moet langer.

Houd de stap klein en de wachttijd kort voor een vloeiende beweging; wil je snelheid, vergroot dan de stap en verleng de wachttijd een beetje. Het zwenkbereik beperken tot het gebied waar je in geïnteresseerd bent (bijvoorbeeld 45–135°) halveert de tijd ook. Als de servo uit zichzelf schokt, de Arduino af en toe herstart en Processing de verbinding verliest, ligt het probleem niet aan de snelheid maar aan de voeding: de SG90 kan tijdens het bewegen rond 100–250 mA trekken en onder belasting tot 600 mA. Voeg de condensator toe en voed de servo zo nodig met een externe 5V-voeding die GND deelt met de Arduino.

De meetnauwkeurigheid verbeteren

Hoewel de HC-SR04 op papier een resolutie van 3 mm belooft, bepalen drie dingen de nauwkeurigheid van een radar: bundelbreedte, geluidssnelheid en oppervlaktetype. De geluidsbundel van de sensor spreidt zich uit als een kegel van ongeveer 15 graden. Daarom verschijnt een dunne pen op 50 cm afstand op het scherm niet als een punt maar als een boog van 15–20 graden breed; de hoekresolutie van de radar wordt door deze bundel bepaald, niet door de servostap, en de werkelijke richting van het object is het midden van de boog. De geluidssnelheid verandert met de temperatuur en wordt berekend met v = 331,3 + 0,606 × T (m/s, T in °C). Het getal 58 in de code komt overeen met ongeveer 22 °C; in een koude garage komen de metingen een paar procent te lang uit.

TemperatuurGeluidssnelheidHeen en terug per 1 cmObject op 100 cm (met /58)
0 °C331,3 m/s60,4 µsongeveer 104 cm
10 °C337,4 m/s59,3 µsongeveer 102 cm
20 °C343,4 m/s58,2 µsongeveer 100 cm
30 °C349,5 m/s57,2 µsongeveer 99 cm
40 °C355,5 m/s56,3 µsongeveer 97 cm

Je kunt de kamertemperatuur meten met een DHT11 of DS18B20 en de geluidssnelheid meenemen, en je kunt eenmalige foute metingen wegfilteren door de mediaan van drie metingen te nemen. Voeg gewoon de twee onderstaande functies toe aan de hoofdcode en vervang de aanroep van measureCm() in loop() door een van beide. Omdat het mediaanfilter drie metingen per stap doet, vertraagt het de zwenk een beetje.

C++ (Arduino IDE)
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
  • Zachte oppervlakken (gordijnen, stof, schuim) absorberen geluid; een object kan onzichtbaar blijven waar het staat.
  • Schuine oppervlakken kaatsen geluid elders heen; een platte doos die meer dan 45° van de sensor af is gedraaid, kan als lege ruimte gelezen worden.
  • Objecten dichterbij dan 2 cm kunnen niet worden gemeten; behandel in de praktijk alles onder 3–4 cm als onbetrouwbaar.
  • Hoeken van de kamer veroorzaken meervoudige reflecties en kunnen verre "spoken" creëren die er niet echt zijn; test in een lege, open ruimte.
  • Bereik: de datasheet noemt 400 cm, maar stabiele metingen op kleine objecten reiken meestal tot ongeveer 2 meter; kies MAX_CM dienovereenkomstig.

Mini-radar op een OLED-display (zonder computer)

Wil je dat de radar een draagbaar apparaat op batterijen wordt dat geen computer nodig heeft, dan kun je in plaats van Processing een 0,96-inch OLED-display gebruiken. Het midden onderaan het 128×64-SSD1306-scherm wordt het middelpunt van de radar; daarop worden een halve cirkel met een straal van 60 pixels, de zweeplijn en stippen met de laatst gemeten afstand op elke hoek getekend. Voor de bedrading van het display (SDA → A4, SCL → A5) en het installeren van de bibliotheek, zie de gids SSD1306-OLED-display; de HC-SR04 en de servo worden aangesloten zoals hierboven.

0,96-inch I2C-OLED-display SSD1306
0,96-inch OLED-display: in de mini-radar zonder computer wordt het een halfrond zwenkscherm van 128×64 pixels.
C++ (Arduino IDE)
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}

In deze versie worden de afstanden per hoek opgeslagen in de array dist, zodat de stippen op het scherm blijven staan nadat de zweeplijn voorbij is en bij de volgende doorgang worden bijgewerkt. Het middelpunt van de cirkel ligt op de onderrand van het scherm, dus de onderste helft valt buiten het display en de bibliotheek tekent die niet, waardoor er een nette halve cirkel overblijft. Het sturen van één beeld naar het scherm duurt bij 400 kHz I2C ongeveer 25 ms, dus de wachttijd is teruggebracht naar 20 ms en de stap verhoogd naar 3 graden; een zwenk duurt ongeveer 4–5 seconden. Een schaal van 50 cm is op een klein scherm makkelijker af te lezen, dus MAX_CM is op 50 gezet. De helft van het geheugen van 2 KB van de Uno gaat naar de displaybuffer, daarom is het belangrijk de array als bytes (uint8_t) te houden.

Arduino-radar met de ESP32

De Arduino Servo-bibliotheek werkt niet op de ESP32; installeer in plaats daarvan de bibliotheek ESP32Servo via de Library Manager. De rest van de code is bijna hetzelfde. Omdat de ESP32 op 3,3 V draait, mag je de spanningsdeler op de Echo-lijn van de HC-SR04 niet vergeten; de puls van 3,3 V op de Trig-lijn is daarentegen genoeg om de meeste sensoren te triggeren. Deze code gebruikt 115200 baud, dus verander ook de 9600 in de Processing-code naar 115200. Dankzij de Wi-Fi van de ESP32 kun je de radargegevens later naar een webpagina op je telefoon sturen in plaats van naar een computer; ben je nieuw met de ESP32, begin dan met Wat is de ESP32.

C++ (Arduino IDE)
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 met de Raspberry Pi Pico en MicroPython

Op de Pico heb je geen aparte servobibliotheek nodig: de pulsbreedte van een PWM-signaal van 50 Hz instellen met duty_ns() is genoeg. De echotijd wordt gemeten met machine.time_pulse_us(), dat bij een timeout een negatief getal teruggeeft. De pinnen van de Pico werken ook op 3,3 V, dus de spanningsdeler op de Echo-lijn is een must. Sla de code met Thonny op de Pico op als main.py en sluit daarna Thonny; anders blijft de poort bezet en kan Processing geen verbinding maken. Omdat de Pico via USB een virtuele seriële poort opent, maakt de baudwaarde in Processing niet uit; hetzelfde radarscherm werkt zonder wijzigingen.

MicroPython
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

Veelvoorkomende fouten en oplossingen

Symptoom of foutmeldingOorzaakOplossing
Error opening serial port COM3: Port busyDe Serial Monitor of Serial Plotter van de Arduino IDE, Thonny of een tweede Processing-venster houdt de poort bezet.Sluit de Serial Monitor en de andere programma's en voer de Processing-sketch opnieuw uit; trek zo nodig de USB-kabel los en steek hem weer in.
ArrayIndexOutOfBoundsException: Index 0 out of bounds for length 0Serial.list() is leeg: het board is niet aangesloten, de kabel is alleen om op te laden of het CH340-stuurprogramma is niet geïnstalleerd.Gebruik een datakabel en installeer het stuurprogramma; als de Arduino IDE de poort ziet, ziet Processing hem ook.
Het venster opent maar de zweeplijn beweegt nietEr is de verkeerde poort gekozen (op Windows staat COM1 vaak als eerste in de lijst) of de baudrates verschillen.Zoek de positie van de Arduino in de lijst in de console, verander die naar Serial.list()[1] of iets dergelijks, en gebruik aan beide kanten dezelfde baudrate.
The package “processing.serial” does not exist. You might be missing a library.De Serial-bibliotheek wordt niet gevonden; het installatieprogramma van Processing 4.4.8 werd zonder geleverd.Werk Processing bij naar een nieuwere versie of gebruik 4.4.7, en controleer of de importregel correct is getypt.
Error opening serial port /dev/ttyACM0: Permission deniedOp Linux mag je gebruiker de seriële poort niet gebruiken.Voeg je gebruiker toe aan de groep dialout (sudo usermod -a -G dialout $USER) en log daarna uit en weer in.
Code wordt niet naar de Arduino geüpload terwijl Processing openstaatDe poort wordt door Processing gebruikt.Stop de Processing-sketch met de Stop-knop voordat je uploadt.
Afstand is altijd 0 of onzinTrig en Echo zijn verwisseld, de sensor heeft geen spanning of het object is buiten bereik.Controleer de bedrading aan de hand van de tabel en test eerst met een simpele sketch die alleen de afstand meet.
De servo trilt en de Arduino herstart zichzelfDe USB-poort kan de stroom van de servo niet leveren en de spanning zakt in.Voeg een condensator van 470 µF toe of voed de servo met een externe 5V-voeding met gedeelde GND.
Links en rechts zijn verwisseld op het radarschermDe servo of de sensor is andersom gemonteerd.Schrijf in Processing angle = 180 - int(parts[0]); of haal de hoorn eraf en monteer hem omgedraaid opnieuw.
Houd bij het debuggen deze volgorde aan: bekijk eerst de regels "hoek,afstand" in de Serial Monitor, sluit dan de Serial Monitor en start Processing. Als de gegevens aan de Arduino-kant goed stromen, ligt het probleem bijna altijd aan de poortkeuze of de baudrate.

Ideeën om het radarproject uit te breiden

  • Beveiligingsradar met alarm: laat een buzzer klinken en een rode LED branden als een object dichterbij komt dan 30 cm; combineer het met de ideeën in Arduino-alarmsysteem.
  • Robot die obstakels ontwijkt: zet de radar voorop een robot; als de robot stopt, scant hij links en rechts en draait hij naar de vrijste richting. Details in robot die obstakels ontwijkt.
  • Kamerkaart: sla de zwenkgegevens op met een SD-kaartmodule en teken ze op de computer als puntenwolk.
  • Draadloze radar: stuur de metingen van een ESP32 via Wi-Fi naar een webpagina op je telefoon; met een ESP32-webserver kun je in realtime tekenen.
  • Scherpere kaart: gebruik een laser-(ToF-)sensor met een smalle bundel in plaats van de HC-SR04; de opties vind je in de vergelijking van afstandssensoren.
  • Slimme stok: bouw een stok die slechtzienden waarschuwt voor obstakels met een afstandssensor en een trilmotor: project slimme stok.

Omdat het project een afstandssensor, servobesturing, seriële communicatie en het tekenen van grafiek op een computer in één bouwwerk combineert, is het Arduino-radarproject een geweldige vervolgstap voor beginners. Om de basis te versterken, kijk ook naar de gidsen HC-SR04-afstandssensor en servomotor. In de BlueGrays-app vind je stap-voor-stap-projecten voor afstandsmeting met de HC-SR04, een parkeersensor, het gebruik van een servomotor en een robot die obstakels ontwijkt, elk met schakelschema's en code met uitleg.

Veelgestelde vragen

Is een Arduino-radar een echte radar?

Technisch gezien niet, het is een sonar. Echte radars zenden radiogolven uit, terwijl dit project geluidsgolven van 40 kHz van de HC-SR04 gebruikt. Hij staat bekend als "Arduino-radar" omdat het werkingsprincipe hetzelfde is (een golf uitzenden, de echo timen, met de richting tekenen) en het display op een radarscherm lijkt.

Hoe ver kan een Arduino-radar detecteren?

Het bereik volgens de datasheet van de HC-SR04 is 2–400 cm. Grote vlakke oppervlakken zoals muren zijn tot 3–4 meter te meten, maar voor objecten zoals stoelpoten of mensen is het betrouwbare bereik meestal 1,5–2 meter. MAX_CM in de Processing-code op dit bereik afstemmen geeft het duidelijkste beeld.

Wat heb ik nodig om een Arduino-radar te bouwen?

Een Arduino Uno of Nano, een ultrasone HC-SR04-sensor, een SG90-servo, een breadboard, een paar jumperdraden en een condensator van 470 µF voor de servo zijn genoeg. Het gratis programma Processing tekent het radarscherm op je computer; voor een versie zonder computer voeg je een 0,96-inch OLED-display toe.

Kun je een Arduino-radar maken zonder Processing?

Ja. Met een SSD1306-OLED-display kun je de radar direct op de Arduino tekenen en er een draagbaar apparaat op batterijen van maken. Zelfs zonder display kun je de waarden voor hoek en afstand als grafiek bekijken in de Serial Plotter van de Arduino IDE.

Hoe los ik de fout "Port busy" in Processing op?

Deze fout betekent dat een ander programma de seriële poort gebruikt. Sluit de Serial Monitor en Serial Plotter in de Arduino IDE, Thonny of een andere openstaande Processing-sketch en probeer het opnieuw. Blijft het probleem, trek dan de USB-kabel los en steek hem weer in.

Waarom trilt de servo en herstart de Arduino?

De SG90 trekt bij het bewegen korte pieken hoge stroom en de 5V-lijn van een Arduino die via USB wordt gevoed zakt even in. Een condensator van 470 µF over de servovoeding lost het meestal op; zo niet, voed de servo dan met een externe 5V-voeding die GND deelt met de Arduino.

Alle projecten bekijken
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

Afstand meten met HC-SR04 (Serial-weergave)

De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

4.6(50)
82
Een servomotor gebruiken
AR-35Beginner
Premium

Een servomotor gebruiken

De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

4.7(48)
67
Parkeersensor met HC-SR04
AR-28Gemiddeld
Premium

Parkeersensor met HC-SR04

Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

4.8(64)
86
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
ESP32 HC-SR04 ultrasone afstandssensor
ES-14Gemiddeld

ESP32 HC-SR04 ultrasone afstandssensor

De ultrasone sensor HC-SR04 meet afstand door te timen hoe lang zijn geluidspuls erover doet om van een voorwerp terug te kaatsen (time of flight). In dit project stuurt de ESP32 een puls van 10 microseconden naar de TRIG-pin en leest hij de echotijd met pulseIn() van de ECHO-pin. De afstand wordt in cm getoond op een 16x2 I2C-LCD. De HC-SR04 werkt op 5V, dus de ECHO-pin heeft een spanningsdeler nodig, anders raakt de 3,3V-GPIO van de ESP32 beschadigd.

4.9(29)
48
ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)
ES-38Gevorderd
Premium

ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)

De ESP32-versie van een parkeersensor voor auto's! De HC-SR04-ultrasoonsensor meet de afstand tot het voorwerp ervoor. Naarmate je dichterbij komt, vult een balk van 5 leds zich (groen → geel → rood) en piept de buzzer sneller. Heel dichtbij (onder 10 cm) klinkt een continu alarm en branden alle leds. Het SSD1306 OLED-display toont de live afstand in cm in grote tekst, plus een statusbericht.

14
Afstand meten met een lcd-scherm
AR-31Gevorderd
Premium

Afstand meten met een lcd-scherm

Een gereedschap dat afstand meet zonder liniaal: beweeg je hand heen en weer voor de sensor en kijk hoe het getal verandert.

4.6(45)
59