Radar Arduino à ultrasons : HC-SR04, servo SG90 et Processing

Un radar Arduino est un projet qui monte un capteur à ultrasons HC-SR04 sur un servomoteur SG90 et le fait pivoter entre 0 et 180 degrés pour mesurer à la fois la direction et la distance des objets alentour, puis affiche le résultat sur l'ordinateur sous forme d'écran radar vert, comme au cinéma. À chaque angle, l'Arduino effectue une mesure et envoie une ligne au format « angle,distance » sur le port série ; un petit programme Processing qui tourne sur l'ordinateur lit ces nombres et dessine la ligne de balayage qui tourne ainsi que les objets détectés sous forme de lignes rouges.

Dans ce guide, tu trouveras chaque étape expliquée, de la liste du matériel et du schéma de câblage jusqu'au code Arduino et à l'écran radar sous Processing. Nous voyons aussi un mini radar sur écran OLED qui se passe d'ordinateur, des versions pour ESP32 et Raspberry Pi Pico, le réglage de la vitesse de balayage et de la précision des mesures, ainsi que la résolution des erreurs de port série les plus fréquentes. C'est un projet peu coûteux, réalisable en un après-midi, et l'un des projets Arduino qui attirent le plus l'attention lors d'une présentation à l'école.

Comment fonctionne un radar Arduino ?

Le cœur du système est le HC-SR04. L'un des deux cylindres du capteur (T) émet une brève salve sonore à 40 kHz, inaudible pour l'oreille humaine ; quand le son rencontre un objet et revient, l'autre (R) capte l'écho. L'Arduino mesure ce temps d'aller-retour en microsecondes. Le son se propage dans l'air à environ 343 m/s : il lui faut donc environ 29 microsecondes pour parcourir un centimètre et, comme le trajet est fait deux fois (aller et retour), la formule devient distance (cm) = temps (µs) / 58. Le servo fait tourner le capteur pas à pas et la mesure est répétée à chaque pas. On obtient ainsi l'information « il y a quelque chose à tel angle, à tant de centimètres », c'est-à-dire une coordonnée polaire. Pour l'afficher, l'angle et la distance sont convertis en position de pixel avec x = distance × cos(angle) et y = distance × sin(angle).

Matériel nécessaire pour le radar Arduino

• Un Arduino Uno ou Nano et un câble USB qui transmet les données (les câbles de charge seule n'apparaissent pas comme port sur l'ordinateur).
• Un capteur de distance à ultrasons HC-SR04.
• Un micro servo SG90 et les palonniers en plastique fournis dans son sachet.
• Une breadboard et 8 à 10 câbles Dupont mâle-mâle et mâle-femelle.
• Un condensateur électrolytique de 470 µF (au moins 10 V) : il empêche la tension de s'effondrer quand le servo bouge.
• Du ruban adhésif double face, de la colle chaude ou un petit support imprimé en 3D pour fixer le capteur sur le servo.
• En option : un écran OLED I2C de 0,96 pouce (pour la version sans ordinateur) et un adaptateur externe 5 V 2 A.

Schéma de câblage du radar Arduino

Sur l'Uno, le câblage est plus clair si tu relies les fils 5 V et GND du capteur et du servo aux lignes plus et moins de la breadboard, puis ces lignes aux broches 5V et GND de l'Arduino. Branche le condensateur de 470 µF sur ces mêmes lignes, la patte longue (+) côté 5 V et la patte courte, repérée par la bande sur son boîtier, côté GND. Sur certains servos, les fils sont noir, rouge et blanc : dans ce cas, le noir est le GND et le blanc le signal. Pour vérifier l'emplacement des broches sur ta carte, utilise l'outil pinout.

Monter le capteur sur le servo

Avant de fixer le palonnier, place le servo à 90 degrés : il suffit de téléverser un petit programme de test contenant radarServo.write(90) et de laisser le servo dans cette position. Fixe ensuite le palonnier de façon que le capteur regarde bien droit devant. Ainsi, 0° correspond à la droite, 90° à l'avant et 180° à la gauche, et les directions de l'écran Processing correspondent exactement au monde réel. En collant le HC-SR04 au palonnier avec du double face ou de la colle chaude, veille à ce que les deux cylindres restent parallèles au sol ; si le capteur penche vers le bas, il prendra la surface de la table pour un objet. Laisse assez de mou aux câbles pour qu'ils ne se tendent pas pendant la rotation de 180 degrés et fixe le servo sur un socle lourd ou une boîte ; un montage qui tremble à chaque pas fausse les mesures.

Fabriquer un radar Arduino étape par étape

1. Câble les composants selon le tableau ci-dessus, n'oublie pas le condensateur et monte le capteur sur le servo.
2. Ouvre l'IDE Arduino ; la bibliothèque Servo est fournie avec l'IDE, il n'y a rien d'autre à installer.
3. Téléverse le code du radar ci-dessous. Si tu as un souci avec le choix de la carte ou du port, consulte Arduino : le téléversement échoue.
4. Ouvre le Moniteur série à 9600 bauds ; si des lignes d'angle et de distance comme « 30,45 » défilent, la partie Arduino est prête. Ensuite, ferme absolument le Moniteur série.
5. Installe Processing 4 sur ton ordinateur, ouvre un nouveau sketch et colle le code de l'écran radar.
6. Clique sur Run ; la liste des ports s'affiche dans la console en bas et la fenêtre du radar s'ouvre. Quand tu passes la main devant le capteur, des lignes rouges doivent apparaître.

Code du 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}

Explication du code

Si les données sont aussi simples, c'est voulu : une seule ligne séparée par une virgule se lit facilement dans le Moniteur série et se découpe en une ligne de code dans Processing, Python ou Excel. Une distance de 0 signifie « rien à portée sous cet angle », et Processing ne dessine pas ces valeurs. Si tu ouvres les mêmes données dans le Traceur série de l'IDE Arduino, tu verras l'angle monter et descendre en dents de scie et la distance sauter chaque fois que le capteur passe devant un objet. Pour ce projet, delay suffit ; si tu veux lire un bouton ou allumer une LED pendant que le radar tourne, réécris la boucle avec millis().

L'écran radar vert avec Processing

Processing est un logiciel gratuit basé sur Java, conçu pour la programmation visuelle, dont l'interface ressemble beaucoup à l'IDE Arduino : tu écris le code et tu cliques sur Run. La bibliothèque Serial, nécessaire à la communication série, est fournie avec Processing ; tu peux l'ajouter via le menu Sketch > Import Library ou simplement garder la ligne import en haut du code. Le code suivant se colle dans Processing, pas dans l'IDE Arduino.

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}

La partie la plus importante du code est la fonction serialEvent(). Grâce à bufferUntil('\n'), Processing accumule les données jusqu'à l'arrivée d'un retour à la ligne, puis appelle automatiquement cette fonction avec une ligne complète. La ligne est débarrassée des espaces et du caractère \r avec trim(), coupée en deux à la virgule avec split() et convertie en nombres avec int(). draw(), de son côté, s'exécute environ 60 fois par seconde : il peint d'abord un rectangle noir semi-transparent sur l'écran (fill(0, 12)), puis redessine la grille, la ligne de balayage et l'objet. Comme les anciennes lignes s'assombrissent un peu à chaque image, l'effet de traînée qui s'estompe, typique des vrais radars, apparaît tout seul.

Régler la vitesse du servo et la durée du balayage

D'après sa fiche technique, le SG90 tourne de 60 degrés en 0,1 seconde sous 4,8 V : il boucle donc un pas de 2 degrés en quelques millisecondes. Ce qui fixe vraiment la durée du balayage, ce n'est pas le servo mais l'attente et la mesure à chaque pas. Quand le servo s'arrête, le palonnier et le capteur vibrent un court instant ; une mesure prise à ce moment-là fait sauter les distances. De plus, le fabricant du HC-SR04 recommande de laisser environ 60 ms entre deux mesures, car les échos de l'impulsion précédente qui rebondissent dans la pièce peuvent se mêler à la mesure suivante. En pratique, un total de 50 à 60 ms par pas (attente + mesure) est un bon compromis. Un balayage complet dure environ (180 / pas + 1) × durée d'un pas.

Pour adoucir le mouvement, garde un petit pas et une attente courte ; si tu veux de la vitesse, augmente le pas et allonge un peu l'attente. Limiter le balayage à la zone qui t'intéresse (par exemple 45–135°) divise aussi la durée par deux. Si le servo tressaute tout seul, que l'Arduino redémarre de temps en temps et que Processing perd la connexion, le problème ne vient pas de la vitesse mais de l'alimentation : le SG90 peut consommer environ 100 à 250 mA en mouvement et jusqu'à 600 mA quand il force. Ajoute le condensateur et, si besoin, alimente le servo avec une source externe 5 V dont le GND est commun avec l'Arduino.

Améliorer la précision des mesures

Même si le HC-SR04 promet sur le papier une résolution de 3 mm, la précision d'un radar dépend de trois choses : la largeur du faisceau, la vitesse du son et le type de surface. Le faisceau sonore du capteur s'ouvre comme un cône d'environ 15 degrés. C'est pourquoi un stylo fin à 50 cm n'apparaît pas à l'écran comme un point mais comme un arc de 15 à 20 degrés ; la résolution angulaire du radar est fixée par ce faisceau et non par le pas du servo, et la direction réelle de l'objet se trouve au milieu de l'arc. La vitesse du son varie avec la température et se calcule avec v = 331,3 + 0,606 × T (m/s, T en °C). Le nombre 58 du code correspond à environ 22 °C ; dans un garage froid, les mesures sont trop longues de quelques pour cent.

Tu peux mesurer la température ambiante avec un DHT11 ou un DS18B20 pour tenir compte de la vitesse du son, et écarter les mesures aberrantes isolées en prenant la médiane de trois mesures. Il suffit d'ajouter les deux fonctions ci-dessous au code principal et de remplacer l'appel à measureCm() dans loop() par l'une d'elles. Comme le filtre médian fait trois mesures à chaque pas, il ralentit un peu le balayage.

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

• Les surfaces molles (rideaux, tissu, mousse) absorbent le son ; un objet peut ne pas apparaître là où il se trouve.
• Les surfaces inclinées renvoient le son ailleurs ; une boîte plate tournée de plus de 45° par rapport au capteur peut être lue comme du vide.
• Les objets à moins de 2 cm ne peuvent pas être mesurés ; en pratique, considère toute valeur sous 3–4 cm comme peu fiable.
• Les coins de la pièce provoquent des réflexions multiples et peuvent créer des « fantômes » lointains qui n'existent pas ; fais tes essais dans un espace dégagé et vaste.
• Portée : la fiche technique annonce 400 cm, mais sur de petits objets les mesures stables vont généralement jusqu'à environ 2 mètres ; choisis MAX_CM en conséquence.

Mini radar sur écran OLED (sans ordinateur)

Si tu veux que le radar devienne un appareil portable sur batterie, sans ordinateur, tu peux utiliser un écran OLED de 0,96 pouce à la place de Processing. Le milieu du bord inférieur de l'écran 128×64 à contrôleur SSD1306 devient le centre du radar ; on y dessine un demi-cercle de 60 pixels de rayon, la ligne de balayage et des points indiquant le dernier objet mesuré à chaque angle. Pour le câblage de l'écran (SDA → A4, SCL → A5) et l'installation des bibliothèques, consulte le guide écran OLED SSD1306 ; le HC-SR04 et le servo se branchent comme plus haut.

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}

Dans cette version, les distances sont stockées par angle dans le tableau dist : les points restent ainsi affichés après le passage de la ligne de balayage et sont mis à jour au tour suivant. Le centre du cercle se trouve sur le bord inférieur de l'écran, sa moitié basse sort donc de l'affichage et la bibliothèque ne la dessine pas : il reste un demi-cercle net. Envoyer une image à l'écran prend environ 25 ms en I2C à 400 kHz, c'est pourquoi l'attente a été ramenée à 20 ms et le pas porté à 3 degrés ; un balayage dure environ 4 à 5 secondes. Sur un petit écran, une échelle de 50 cm est plus lisible, d'où MAX_CM à 50. La moitié des 2 Ko de mémoire de l'Uno part dans la mémoire tampon de l'écran, il est donc important de stocker le tableau en octets (uint8_t).

Radar Arduino avec l'ESP32

Sur l'ESP32, la bibliothèque Servo d'Arduino ne fonctionne pas ; installe plutôt la bibliothèque ESP32Servo depuis le Gestionnaire de bibliothèques. Le reste du code est presque identique. Comme l'ESP32 fonctionne en 3,3 V, n'oublie pas le pont diviseur sur la ligne Echo du HC-SR04 ; l'impulsion de 3,3 V sur la ligne Trig suffit en revanche à déclencher la plupart des capteurs. Ce code utilise 115200 bauds : remplace donc aussi le 9600 du code Processing par 115200. Grâce au Wi-Fi de l'ESP32, tu pourras plus tard envoyer les données du radar vers une page web sur ton téléphone plutôt que vers l'ordinateur ; si l'ESP32 est nouveau pour toi, commence par Qu'est-ce que l'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 avec la Raspberry Pi Pico et MicroPython

Sur la Pico, pas besoin de bibliothèque dédiée au servo : il suffit de régler la largeur d'impulsion d'un signal PWM à 50 Hz avec duty_ns(). Le temps de l'écho se mesure avec machine.time_pulse_us(), qui renvoie un nombre négatif en cas de dépassement du délai. Les broches de la Pico sont elles aussi en 3,3 V, le pont diviseur sur la ligne Echo est donc obligatoire. Enregistre le code sur la Pico sous le nom main.py avec Thonny, puis ferme Thonny ; sinon le port reste occupé et Processing ne peut pas se connecter. Comme la Pico ouvre un port série virtuel via l'USB, la vitesse en bauds indiquée dans Processing n'a pas d'importance : le même écran radar fonctionne sans aucune modification.

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

Erreurs fréquentes et solutions

Idées pour aller plus loin avec le radar

• Radar de sécurité avec alarme : quand un objet s'approche à moins de 30 cm, fais sonner un buzzer et allume une LED rouge ; combine-le avec les idées du système d'alarme Arduino.
• Robot éviteur d'obstacles : place le radar à l'avant d'un robot ; quand il s'arrête, il balaie à gauche et à droite puis tourne vers la direction la plus dégagée. Détails dans robot éviteur d'obstacles.
• Carte de la pièce : enregistre les données de balayage sur un module carte SD et trace-les sur l'ordinateur sous forme de nuage de points.
• Radar sans fil : envoie les mesures d'un ESP32 par Wi-Fi vers une page web sur ton téléphone ; avec un serveur web ESP32, tu peux dessiner en temps réel.
• Carte plus précise : remplace le HC-SR04 par un capteur laser (ToF) à faisceau étroit ; tu trouveras les options dans le comparatif des capteurs de distance.
• Canne intelligente : fabrique une canne qui prévient les personnes malvoyantes des obstacles grâce à un capteur de distance et un moteur vibrant : projet de canne intelligente.

Parce qu'il réunit capteur de distance, commande de servo, communication série et dessin de graphiques sur ordinateur dans un seul montage, le radar Arduino est une excellente étape suivante pour les débutants. Pour consolider les bases, jette aussi un œil aux guides sur le capteur de distance HC-SR04 et le servomoteur. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas de câblage et code commenté, des projets de mesure de distance avec le HC-SR04, de capteur de recul, d'utilisation d'un servomoteur et de robot éviteur d'obstacles.