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.




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).
| Onderdeel | Taak | Belangrijkste waarden |
|---|---|---|
| HC-SR04 | Ultrasone afstandsmeting | 40 kHz, 2–400 cm, ongeveer 15° meethoek, 5 V, 15 mA |
| SG90 servo | Draait de sensor 0–180° | 0,1 s/60° (4,8 V), 1,8 kg·cm koppel, 4,8–6 V, 9 g |
| Arduino Uno | Meet, stuurt de servo aan, verstuurt de gegevens | 16 MHz, 5V-logica, USB-seriële poort |
| Processing | Tekent het radarscherm op de computer | Gratis, op Java gebaseerd, Serial-bibliotheek inbegrepen |
| OLED SSD1306 (optioneel) | Mini-radarscherm zonder computer | 128×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
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN (5 V) | VBUS (pin 40) |
| HC-SR04 GND | GND | GND | GND |
| HC-SR04 Trig | D10 | GPIO 26 | GP14 |
| HC-SR04 Echo | D11 | GPIO 27 (via spanningsdeler) | GP13 (via spanningsdeler) |
| SG90 bruin (GND) | GND | GND | GND |
| SG90 rood (+5 V) | 5V | VIN (5 V) | VBUS (pin 40) |
| SG90 oranje (signaal) | D9 | GPIO 13 | GP15 |
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.
De sensor op de servo monteren

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
- Sluit de onderdelen aan volgens de tabel hierboven, vergeet de condensator niet en monteer de sensor op de servo.
- Open de Arduino IDE; de Servo-bibliotheek wordt met de IDE meegeleverd, dus je hoeft niets extra te installeren.
- Upload de radarcode hieronder. Heb je moeite met het kiezen van het board of de poort, lees dan Arduino-code wordt niet geüpload.
- 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.
- Installeer Processing 4 op je computer, open een nieuwe sketch en plak de code van het radarscherm erin.
- 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
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
| Codedeel | Wat het doet |
|---|---|
| STEP en STEP_DELAY | Bepalen 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 ... println | Verstuurt elke meting als één regel "hoek,afstand"; het regeleinde vertelt Processing "gegevens compleet". |
| dir = -dir | Keert 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().
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.
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.
| Instelling | Waar? | Wat het doet |
|---|---|---|
| MAX_CM = 100 | Processing | De 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] | Processing | Kiest 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". |
| 9600 | Beide | Baudrate; de waarde in Serial.begin van de Arduino en in Processing moet overeenkomen. |
| fill(0, 12) | Processing | Vervagingssnelheid; 5 geeft een lang spoor, 30 een bijna spoorloos beeld. |
| size(1200, 700) | Processing | Venstergrootte; 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.
| Stap | STEP_DELAY | Eén zwenk (0→180°) | Resultaat |
|---|---|---|---|
| 1° | 20 ms | ongeveer 7 s | Vloeiendste beeld maar traag; hetzelfde object wordt vaak gemeten. |
| 2° | 40 ms | ongeveer 5 s | Aanbevolen instelling: vloeiend en stabiel. |
| 3° | 50 ms | ongeveer 4 s | Sneller; dankzij de bundel van 15° van de sensor wordt geen object gemist. |
| 5° | 70 ms | ongeveer 3,5 s | Het 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.
| Temperatuur | Geluidssnelheid | Heen en terug per 1 cm | Object op 100 cm (met /58) |
|---|---|---|---|
| 0 °C | 331,3 m/s | 60,4 µs | ongeveer 104 cm |
| 10 °C | 337,4 m/s | 59,3 µs | ongeveer 102 cm |
| 20 °C | 343,4 m/s | 58,2 µs | ongeveer 100 cm |
| 30 °C | 349,5 m/s | 57,2 µs | ongeveer 99 cm |
| 40 °C | 355,5 m/s | 56,3 µs | ongeveer 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.
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.

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.
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.
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 += stepVeelvoorkomende fouten en oplossingen
| Symptoom of foutmelding | Oorzaak | Oplossing |
|---|---|---|
| Error opening serial port COM3: Port busy | De 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 0 | Serial.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 niet | Er 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 denied | Op 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 openstaat | De poort wordt door Processing gebruikt. | Stop de Processing-sketch met de Stop-knop voordat je uploadt. |
| Afstand is altijd 0 of onzin | Trig 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 zichzelf | De 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 radarscherm | De 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. |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

Parkeersensor met HC-SR04
Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

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.

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.

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.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

