Guides · 12 min de lecture

Radar de recul Arduino : HC-SR04, bip, barre de LED et écran OLED

Fabrique un radar de recul Arduino avec un HC-SR04 : tableau distance et bips, code millis() non bloquant, barre de LED, écran OLED, version ESP32 et conseils.

Un radar de recul Arduino est une petite aide à la conduite : un capteur à ultrasons HC-SR04 mesure la distance jusqu'à l'obstacle derrière toi, le bip s'accélère à mesure que tu t'approches, une barre de LED se remplit du vert au rouge et, si tu le souhaites, un écran OLED affiche la distance en centimètres. Les radars de recul des vraies voitures fonctionnent sur le même principe : un capteur dans le pare-chocs envoie une onde sonore, calcule la distance à partir du temps de retour de l'écho et prévient le conducteur par un bip. Avec un Arduino Uno, un HC-SR04, un buzzer et cinq LED, tu peux construire la même chose en une soirée sur une plaque d'essai.

Dans ce guide, nous allons d'abord définir dans un tableau les zones de distance et l'intervalle des bips pour chacune. Ensuite, nous écrirons un code qui fonctionne avec millis() au lieu de delay(), pour que les bips n'interrompent jamais la mesure. Puis nous ajouterons un écran OLED, réduirons les erreurs de mesure avec un filtre médian et une correction de température, écrirons une version ESP32 avec un buzzer passif et une hystérésis, et verrons enfin comment fixer le capteur sur la voiture ou sur le mur du garage.

Capteur de distance à ultrasons HC-SR04
HC-SR04 : un cylindre envoie une onde sonore à 40 kHz, l'autre écoute l'écho. Ces deux cylindres sont les yeux du radar de recul.

Comment fonctionne un radar de recul ?

Quand tu envoies une impulsion de 10 microsecondes sur la broche TRIG du HC-SR04, le capteur émet huit salves sonores à 40 kHz, une fréquence que l'oreille humaine n'entend pas, et passe la broche ECHO à HIGH. Quand le son rencontre un obstacle et revient, ECHO repasse à LOW. Le temps pendant lequel ECHO reste à HIGH correspond à l'aller-retour du son. À 20 °C, le son parcourt environ 343 mètres par seconde dans l'air, soit un centimètre en 29 microsecondes environ. En tenant compte de l'aller et du retour, la formule devient très simple : distance (cm) = durée (µs) / 58. Par exemple, l'écho d'un mur situé à 1 mètre met environ 5800 µs.

Le radar de recul répète cette mesure 15 à 20 fois par seconde et convertit le résultat en zone. Quand la zone change, le nombre de LED allumées et le rythme des bips changent aussi. Voici les caractéristiques du HC-SR04 qui comptent pour ce projet :

CaractéristiqueValeur
Alimentation5 V, environ 15 mA
Fréquence du son40 kHz
Plage de mesure2–400 cm (plage fiable pour se garer : 3–250 cm)
Angle de détectionUn cône d'environ 15°
Impulsion de déclenchementAu moins 10 µs à HIGH sur TRIG
Cadence de mesureAu moins 60 ms entre deux mesures
RésolutionEnviron 3 mm

Liste du matériel

ComposantQuantitéRemarque
Arduino Uno ou Nano1Version ESP32 plus bas
Capteur à ultrasons HC-SR041À l'extérieur de la voiture, préfère le JSN-SR04T étanche
Buzzer actif1Buzzer passif dans la version ESP32
LED (2 vertes, 2 jaunes, 1 rouge)5Alignées pour former une barre de LED
Résistance de 220 Ω5Une par LED
Écran OLED I2C de 0,96 pouce1Affichage facultatif
Plaque d'essai et câbles de connexion1 lotGarde des fils courts
Résistances de 1 kΩ et 2 kΩUne de chaqueESP32 uniquement, pont diviseur sur ECHO

Tableau des distances et des intervalles de bip

Les radars de recul des voitures commencent généralement par un bip lent vers 1,5 mètre, accélèrent à mesure que l'obstacle se rapproche et passent à un son continu dans les 25 à 30 derniers centimètres. Le conducteur sait combien de place il lui reste rien qu'au rythme, sans regarder d'écran. Notre montage compte cinq zones d'alerte et une zone sûre. Chaque bip dure 50 ms ; l'intervalle du tableau est le temps entre le début de deux bips :

ZoneDistanceIntervalle des bipsLED alluméesSignification
SûrePlus de 150 cmSilenceAucuneVoie libre
1101–150 cm800 ms1 verteObstacle détecté
271–100 cm500 ms2 vertesRalentis
346–70 cm300 ms2 vertes + 1 jauneAttention
426–45 cm150 ms2 vertes + 2 jaunesTrès près
525 cm ou moinsSon continuLes cinq (rouge compris)Stop

Tu peux adapter ces valeurs à ta voiture : sur un véhicule au porte-à-faux arrière important, ou dans un garage étroit, il est plus sûr de placer la zone stop à 35–40 cm. Si tu préfères que le rythme des bips varie en continu plutôt que par paliers, remplace le tableau des zones par une conversion comme intervalle = map(distance, 25, 150, 100, 800) grâce à la fonction map(). Un tableau par paliers reste toutefois plus facile à distinguer à l'oreille : le conducteur remarque tout de suite le changement de son entre la zone trois et la zone quatre.

Schéma de câblage : HC-SR04, buzzer et barre de LED

Composant et brocheArduino UnoESP32Remarque
HC-SR04 VCC5VVIN (5V)Le capteur a besoin de 5 V
HC-SR04 GNDGNDGNDMasse commune
HC-SR04 TRIGD9GPIO 4Sortie de déclenchement
HC-SR04 ECHOD10GPIO 18Sur l'ESP32, via un pont 1 kΩ + 2 kΩ
Buzzer (+)D8GPIO 19Actif sur l'Uno, passif sur l'ESP32
LED 1 et 2 (vertes)D2, D3GPIO 25, 26Résistance série de 220 Ω par LED
LED 3 et 4 (jaunes)D4, D5GPIO 27, 32Résistance série de 220 Ω par LED
LED 5 (rouge)D6GPIO 33S'allume dans la zone stop
OLED SDA / SCLA4 / A5GPIO 21 / 22Facultatif
OLED VCC5V3V3Vérifie l'ordre des broches du module
La broche ECHO du HC-SR04 sort du 5 V. Ce n'est pas un problème pour l'Arduino Uno, mais les broches de l'ESP32 ne supportent que 3,3 V. Place une résistance de 1 kΩ entre ECHO et GPIO 18, et une de 2 kΩ entre GPIO 18 et GND : 5 V × 2 / 3 ≈ 3,3 V. Tu peux vérifier les valeurs avec l'outil Pont diviseur. N'oublie pas non plus les résistances série des LED : 220 Ω donnent environ 13 mA sous 5 V ; pour tes propres LED, utilise l'outil Résistance de LED.

Pourquoi millis() plutôt que delay() ?

La plupart des codes de radar de recul qu'on trouve en ligne font le bip ainsi : buzzer allumé, delay(50), éteint, delay(intervalle). Dans une zone à 800 ms, cela rend l'Arduino aveugle pendant presque une seconde à chaque tour de boucle. Une voiture qui recule à 2 km/h parcourt environ 45 cm pendant ce temps ; les LED et le son ont toujours un temps de retard sur la distance réelle et, pire encore, la mesure est figée au moment précis où tu entres dans la zone stop. La bonne méthode consiste à séparer les deux tâches : mesurer toutes les 60 ms et décider à chaque tour de boucle, avec millis(), si le buzzer doit être allumé ou éteint. Nous expliquons cette idée en détail dans millis() ou delay().

Montage étape par étape

  1. Place le HC-SR04 à une extrémité de la plaque d'essai, cylindres tournés vers l'extérieur ; relie VCC au 5V et GND au GND.
  2. Relie TRIG à D9 et ECHO à D10. Garde des fils courts ; un câble mal enfoncé fausse les mesures au hasard.
  3. Aligne les cinq LED : de gauche à droite deux vertes, deux jaunes et une rouge. Relie la patte longue (anode) de chaque LED aux broches D2–D6 à travers une résistance de 220 Ω, et la patte courte à la ligne GND.
  4. Relie la patte + du buzzer actif à D8 et l'autre patte au GND. Les buzzers actifs portent généralement un repère + sur le dessus et sonnent tout seuls dès qu'ils reçoivent 5 V.
  5. Téléverse le code, ouvre le moniteur série à 115200 bauds et approche lentement ta main du capteur. La distance et le numéro de zone doivent s'afficher toutes les 60 ms.
  6. Pose un carton au sol, marque 150, 100, 70, 45 et 25 cm avec un mètre ruban et déplace le carton à ces points pour vérifier que les zones changent correctement.

Code du radar de recul Arduino (barre de LED + buzzer)

Le code ci-dessous applique exactement les zones du tableau. Il mesure toutes les 60 ms, prend la médiane des trois dernières mesures et génère le bip avec millis(), indépendamment de la mesure. Il ne contient pas un seul delay() :

C++ (Arduino IDE)
1// Arduino park sensörü: HC-SR04 + 5 LED bar + aktif buzzer / Arduino parking sensor: HC-SR04 + 5-LED bar + active buzzer
2const int TRIG_PIN = 9;
3const int ECHO_PIN = 10;
4const int BUZZER_PIN = 8;
5const int LED_PINS[5] = {2, 3, 4, 5, 6};          // yeşil, yeşil, sarı, sarı, kırmızı / green, green, yellow, yellow, red
6
7// Bölge sınırları (cm) ve bip aralıkları (ms), tablodaki değerler / zone limits (cm) and beep periods (ms) from the table
8const int ZONE_CM[5] = {150, 100, 70, 45, 25};
9const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};  // 0 = sürekli ses / 0 = continuous tone
10const unsigned int BEEP_ON_MS = 50;                // her bipin süresi / length of each beep
11const unsigned long MEASURE_MS = 60;               // HC-SR04 için en az 60 ms / at least 60 ms for the HC-SR04
12
13unsigned long lastMeasure = 0;
14unsigned long lastBeep = 0;
15int samples[3] = {999, 999, 999};                  // son 3 ölçüm / last 3 readings
16int sampleIndex = 0;
17int distanceCm = 999;
18int zone = 0;                                      // 0 = güvenli, 5 = dur / 0 = safe, 5 = stop
19
20long readDistanceCm() {
21  digitalWrite(TRIG_PIN, LOW);
22  delayMicroseconds(2);
23  digitalWrite(TRIG_PIN, HIGH);                    // 10 µs tetik darbesi / 10 µs trigger pulse
24  delayMicroseconds(10);
25  digitalWrite(TRIG_PIN, LOW);
26  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);  // 25 ms zaman aşımı, yaklaşık 4,3 m / 25 ms timeout, about 4.3 m
27  if (us == 0) return 999;                         // yankı yok: engel uzakta / no echo: obstacle far away
28  return us / 58;                                  // µs / 58 = cm (gidiş-dönüş / round trip)
29}
30
31int median3(int a, int b, int c) {                 // üçün ortancası, ani sıçramaları atar / median of three, drops spikes
32  return max(min(a, b), min(max(a, b), c));
33}
34
35int zoneFor(int d) {
36  int z = 0;
37  for (int i = 0; i < 5; i++) {
38    if (d <= ZONE_CM[i]) z = i + 1;
39  }
40  return z;
41}
42
43void updateLeds() {
44  for (int i = 0; i < 5; i++) {
45    digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);  // bölge kadar LED yak / light as many LEDs as the zone
46  }
47}
48
49void updateBuzzer(unsigned long now) {
50  if (zone == 0) {                                 // güvenli bölge: sessiz / safe zone: silent
51    digitalWrite(BUZZER_PIN, LOW);
52    return;
53  }
54  unsigned int period = BEEP_MS[zone - 1];
55  if (period == 0) {                               // dur bölgesi: sürekli ses / stop zone: continuous tone
56    digitalWrite(BUZZER_PIN, HIGH);
57    return;
58  }
59  if (now - lastBeep >= period) lastBeep = now;    // yeni bip zamanı / time for a new beep
60  digitalWrite(BUZZER_PIN, (now - lastBeep < BEEP_ON_MS) ? HIGH : LOW);
61}
62
63void setup() {
64  pinMode(TRIG_PIN, OUTPUT);
65  pinMode(ECHO_PIN, INPUT);
66  pinMode(BUZZER_PIN, OUTPUT);
67  for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
68  Serial.begin(115200);
69}
70
71void loop() {
72  unsigned long now = millis();
73  if (now - lastMeasure >= MEASURE_MS) {           // 60 ms'de bir ölç / measure every 60 ms
74    lastMeasure = now;
75    samples[sampleIndex] = readDistanceCm();
76    sampleIndex = (sampleIndex + 1) % 3;
77    distanceCm = median3(samples[0], samples[1], samples[2]);
78    zone = zoneFor(distanceCm);
79    updateLeds();
80    Serial.print(F("Mesafe / Distance: "));
81    Serial.print(distanceCm);
82    Serial.print(F(" cm  Bolge / Zone: "));
83    Serial.println(zone);
84  }
85  updateBuzzer(millis());                          // bip, ölçümden bağımsız akar / beeping runs independently of measuring
86}
Partie du codeCe qu'elle fait
ZONE_CM et BEEP_MSRegroupent les limites des zones et les intervalles des bips ; pour modifier le tableau, il suffit d'éditer ces deux lignes.
pulseIn(..., 25000UL)Attend l'écho au maximum 25 ms (environ 4,3 m). Sans écho, la fonction renvoie 0 et le code l'interprète comme 999, c'est-à-dire aucun obstacle.
us / 58Convertit la durée de l'aller-retour en centimètres.
median3()Prend la médiane des trois dernières mesures ; une seule mesure aberrante ne perturbe ni les LED ni le son.
now - lastBeep >= periodVérifie s'il est temps de lancer un nouveau bip ; le buzzer est allumé pendant les 50 premières ms de chaque bip et éteint le reste du temps.
MEASURE_MS = 60Le cycle de mesure le plus court recommandé pour le HC-SR04 ; mesurer plus vite peut te faire prendre un écho tardif de la mesure précédente pour un nouveau.
Pourquoi un filtre médian vaut mieux qu'une moyenne ? Si trois mesures donnent 82, 83 et 3 cm, la moyenne vaut 56 cm et le système passe à tort en zone trois. La médiane vaut 82 cm ; une valeur absurde isolée est tout simplement ignorée. Tu peux comparer différents types de filtres dans filtrer les données d'un capteur.

Précision de la mesure : effet de la température et de la surface

Le nombre 58 du code suppose que la vitesse du son est d'environ 345 m/s, c'est-à-dire que l'air est à environ 22 °C. Or la vitesse du son varie avec la température : v = 331,3 + 0,606 × T (m/s, T en °C). En hiver, à 0 °C, le son est plus lent, l'écho revient plus tard et le capteur croit l'obstacle un peu plus loin qu'il ne l'est. Pour une distance réelle de 100 cm, les mesures sont à peu près les suivantes :

Température de l'airVitesse du sonMesure (durée ÷ 58)
-10 °C325 m/sEnviron 106 cm
0 °C331 m/sEnviron 104 cm
10 °C337 m/sEnviron 102 cm
20 °C343 m/sEnviron 100 cm
30 °C350 m/sEnviron 99 cm
40 °C356 m/sEnviron 97 cm

Pour se garer, quelques centimètres ne changent rien. Mais si tu veux le même point d'arrêt dans un garage à 40 °C en été et par temps de gel en hiver, mesure la température avec un DHT11 ou un DS18B20 et calcule la distance avec durée × (331,3 + 0,606 × T) / 20000. La surface compte bien plus que la température : un mur lisse, une porte de garage ou le pare-chocs d'une autre voiture renvoient bien le son, alors qu'un poteau fin, un grillage, un buisson ou des surfaces molles comme le tissu affaiblissent l'écho ou ne le renvoient pas du tout. Une surface inclinée par rapport au capteur dévie aussi le son ailleurs. C'est pourquoi un radar de recul à ultrasons ne doit jamais être ta seule mesure de sécurité.

Afficher la distance sur un écran OLED

Pour un affichage visible par le conducteur, l'écran OLED de 0,96 pouce est idéal : il affiche la distance en grands chiffres et dessine en dessous une barre qui se remplit à mesure que l'obstacle approche. Le câblage I2C de l'écran et l'installation des bibliothèques Adafruit SSD1306 et Adafruit GFX sont détaillés dans écran OLED SSD1306. L'écran est rafraîchi cinq fois par seconde ; chaque rafraîchissement prend environ 25 à 30 ms, donc dessiner plus souvent perturberait la mesure et le rythme des bips.

C++ (Arduino IDE)
1// Park sensörü + 0,96" OLED: büyük rakamla mesafe ve doluluk çubuğu / parking sensor + 0.96" OLED: big distance digits and a fill bar
2#include <Wire.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1);     // 128x64, reset pini yok / 128x64, no reset pin
7
8const int TRIG_PIN = 9;
9const int ECHO_PIN = 10;
10const int BUZZER_PIN = 8;
11const int LED_PINS[5] = {2, 3, 4, 5, 6};
12const int ZONE_CM[5] = {150, 100, 70, 45, 25};
13const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};
14const unsigned int BEEP_ON_MS = 50;
15const int MAX_SHOW_CM = 200;                       // çubuğun boş olduğu mesafe / distance where the bar is empty
16
17unsigned long lastMeasure = 0, lastBeep = 0, lastDraw = 0;
18int samples[3] = {999, 999, 999};
19int sampleIndex = 0;
20int distanceCm = 999;
21int zone = 0;
22
23long readDistanceCm() {
24  digitalWrite(TRIG_PIN, LOW);
25  delayMicroseconds(2);
26  digitalWrite(TRIG_PIN, HIGH);
27  delayMicroseconds(10);
28  digitalWrite(TRIG_PIN, LOW);
29  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
30  return us == 0 ? 999 : us / 58;
31}
32
33int median3(int a, int b, int c) {
34  return max(min(a, b), min(max(a, b), c));
35}
36
37void drawScreen() {
38  display.clearDisplay();
39  display.setTextSize(1);
40  display.setCursor(0, 0);
41  if (zone == 5) display.print(F("DUR / STOP"));
42  else if (zone == 0) display.print(F("Yol acik / Clear"));
43  else display.print(F("Yaklasiyor / Closer"));
44
45  display.setTextSize(3);                          // büyük rakamlar / big digits
46  display.setCursor(0, 18);
47  if (distanceCm >= 999) display.print(F("---"));
48  else display.print(distanceCm);
49  display.setTextSize(2);
50  display.print(F(" cm"));
51
52  // Yaklaştıkça dolan çubuk / a bar that fills as you get closer
53  int d = constrain(distanceCm, 0, MAX_SHOW_CM);
54  int fill = map(d, MAX_SHOW_CM, 0, 0, 124);
55  display.drawRect(0, 50, 128, 12, SSD1306_WHITE);
56  display.fillRect(2, 52, fill, 8, SSD1306_WHITE);
57  display.display();
58}
59
60void setup() {
61  pinMode(TRIG_PIN, OUTPUT);
62  pinMode(ECHO_PIN, INPUT);
63  pinMode(BUZZER_PIN, OUTPUT);
64  for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
65  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {  // OLED adresi genelde 0x3C / OLED address is usually 0x3C
66    for (;;);                                      // ekran yoksa dur / stop if no display
67  }
68  display.setTextColor(SSD1306_WHITE);
69}
70
71void loop() {
72  unsigned long now = millis();
73  if (now - lastMeasure >= 60) {
74    lastMeasure = now;
75    samples[sampleIndex] = readDistanceCm();
76    sampleIndex = (sampleIndex + 1) % 3;
77    distanceCm = median3(samples[0], samples[1], samples[2]);
78    zone = 0;
79    for (int i = 0; i < 5; i++) if (distanceCm <= ZONE_CM[i]) zone = i + 1;
80    for (int i = 0; i < 5; i++) digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);
81  }
82  if (now - lastDraw >= 200) {                     // ekranı saniyede 5 kez yenile / refresh the screen 5 times a second
83    lastDraw = now;
84    drawScreen();
85  }
86  now = millis();
87  if (zone == 0) {
88    digitalWrite(BUZZER_PIN, LOW);
89  } else if (BEEP_MS[zone - 1] == 0) {
90    digitalWrite(BUZZER_PIN, HIGH);
91  } else {
92    if (now - lastBeep >= BEEP_MS[zone - 1]) lastBeep = now;
93    digitalWrite(BUZZER_PIN, (now - lastBeep < BEEP_ON_MS) ? HIGH : LOW);
94  }
95}

Selon la zone, la ligne du haut affiche Yol acik / Clear, Yaklasiyor / Closer ou DUR / STOP. Les textes sont bilingues (turc / anglais) et écrits sans accents, car la police par défaut de la bibliothèque OLED ne contient que les caractères ASCII de base. Environ 1 Ko des 2 Ko de RAM de l'Uno part dans le tampon de l'écran ; quand tu enrichis le code, garde les textes fixes dans F(), sinon l'écran risque de ne pas démarrer du tout.

Radar de recul avec l'ESP32

La version ESP32 présente trois différences. D'abord, le capteur reste alimenté en 5 V, mais la broche ECHO passe par le pont diviseur. Ensuite, nous utilisons un buzzer passif au lieu d'un buzzer actif et produisons le son sous forme de tonalité à 2,5 kHz avec le matériel LEDC de l'ESP32 ; en changeant la fréquence, tu choisis toi-même le son. Enfin, nous avons ajouté 3 cm d'hystérésis pour que les LED ne clignotent pas à la limite d'une zone : quand la voiture s'éloigne, la distance doit dépasser la limite de 3 cm avant de redescendre d'une zone. Comme les fonctions LEDC ont changé dans la version 3.x du core Arduino pour ESP32, le code teste ESP_ARDUINO_VERSION_MAJOR et compile aussi bien en 2.x qu'en 3.x.

C++ (Arduino IDE)
1// ESP32 park sensörü: HC-SR04 + 5 LED + pasif buzzer (LEDC), çekirdek 2.x ve 3.x / ESP32 parking sensor: HC-SR04 + 5 LEDs + passive buzzer (LEDC), core 2.x and 3.x
2const int TRIG_PIN = 4;
3const int ECHO_PIN = 18;                           // 1 kΩ + 2 kΩ gerilim bölücüyle / through a 1 kΩ + 2 kΩ divider
4const int BUZZER_PIN = 19;
5const int LED_PINS[5] = {25, 26, 27, 32, 33};
6const int ZONE_CM[5] = {150, 100, 70, 45, 25};
7const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};
8const unsigned int BEEP_ON_MS = 50;
9const unsigned int TONE_HZ = 2500;                 // pasif buzzerın en yüksek sesi genelde 2–4 kHz / passive buzzers are loudest around 2–4 kHz
10const int HYST_CM = 3;                             // bölge sınırında titremeyi önler / stops flicker at zone limits
11const int BUZZER_CH = 0;                           // yalnız 2.x için LEDC kanalı / LEDC channel, 2.x only
12
13unsigned long lastMeasure = 0, lastBeep = 0;
14int samples[3] = {999, 999, 999};
15int sampleIndex = 0;
16int distanceCm = 999;
17int zone = 0;
18bool buzzerOn = false;
19
20void buzzer(bool on) {
21  if (on == buzzerOn) return;                      // yalnız değişince yaz / write only on change
22  buzzerOn = on;
23#if ESP_ARDUINO_VERSION_MAJOR >= 3
24  ledcWriteTone(BUZZER_PIN, on ? TONE_HZ : 0);     // 3.x: pin numarasıyla / 3.x: by pin number
25#else
26  ledcWriteTone(BUZZER_CH, on ? TONE_HZ : 0);      // 2.x: kanal numarasıyla / 2.x: by channel number
27#endif
28}
29
30long readDistanceCm() {
31  digitalWrite(TRIG_PIN, LOW);
32  delayMicroseconds(2);
33  digitalWrite(TRIG_PIN, HIGH);
34  delayMicroseconds(10);
35  digitalWrite(TRIG_PIN, LOW);
36  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
37  return us == 0 ? 999 : us / 58;
38}
39
40int median3(int a, int b, int c) {
41  return max(min(a, b), min(max(a, b), c));
42}
43
44int zoneFor(int d, int current) {
45  int z = 0;
46  for (int i = 0; i < 5; i++) if (d <= ZONE_CM[i]) z = i + 1;
47  if (current > 0 && z < current && d <= ZONE_CM[current - 1] + HYST_CM) z = current;  // uzaklaşırken 3 cm pay / 3 cm margin when moving away
48  return z;
49}
50
51void setup() {
52  Serial.begin(115200);
53  pinMode(TRIG_PIN, OUTPUT);
54  pinMode(ECHO_PIN, INPUT);
55  for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
56#if ESP_ARDUINO_VERSION_MAJOR >= 3
57  ledcAttach(BUZZER_PIN, TONE_HZ, 8);              // 3.x: pin, frekans, çözünürlük / 3.x: pin, frequency, resolution
58#else
59  ledcSetup(BUZZER_CH, TONE_HZ, 8);                // 2.x: kanal kur, sonra pine bağla / 2.x: set up a channel, then attach the pin
60  ledcAttachPin(BUZZER_PIN, BUZZER_CH);
61#endif
62  buzzerOn = true;
63  buzzer(false);                                   // sessiz başla / start silent
64}
65
66void loop() {
67  unsigned long now = millis();
68  if (now - lastMeasure >= 60) {
69    lastMeasure = now;
70    samples[sampleIndex] = readDistanceCm();
71    sampleIndex = (sampleIndex + 1) % 3;
72    distanceCm = median3(samples[0], samples[1], samples[2]);
73    zone = zoneFor(distanceCm, zone);
74    for (int i = 0; i < 5; i++) digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);
75    Serial.printf("Mesafe / Distance: %d cm  Bolge / Zone: %d\n", distanceCm, zone);
76  }
77  now = millis();
78  if (zone == 0) {
79    buzzer(false);
80  } else if (BEEP_MS[zone - 1] == 0) {
81    buzzer(true);
82  } else {
83    if (now - lastBeep >= BEEP_MS[zone - 1]) lastBeep = now;
84    buzzer(now - lastBeep < BEEP_ON_MS);
85  }
86}
Les broches GPIO 34–39 de l'ESP32 fonctionnent uniquement en entrée ; si tu y branches TRIG ou les LED, rien ne se passera, mais elles conviennent pour ECHO. Si le son n'est pas assez fort, essaie des valeurs de TONE_HZ entre 2000 et 4000 ; chaque buzzer passif a une fréquence où il sonne le plus fort. Si tu découvres l'ESP32, Qu'est-ce que l'ESP32 ? est un bon point de départ.

Conseils de montage sur la voiture ou au garage

  • Hauteur et angle : Fixe le capteur à 50–70 cm du sol, parallèle à celui-ci et incliné de 3 à 5 degrés vers le haut. Un capteur orienté vers le bas prend les bosses de la chaussée et la bordure du trottoir pour des obstacles.
  • Eau et poussière : Le HC-SR04 n'est pas étanche ; la pluie, la boue et le lavage auto l'abîment vite. Pour un système monté dans le pare-chocs, utilise une sonde à ultrasons étanche comme le JSN-SR04T. Ces sondes ne mesurent qu'à partir de 20–25 cm, il faudra donc placer la zone stop à 30–35 cm.
  • Alimentation : Le circuit électrique de la voiture monte à 13,8–14,4 V moteur tournant, avec des chutes brutales au démarrage et des pics quand une charge est coupée. N'alimente pas l'Arduino directement en 12 V : abaisse la tension à 5 V avec un convertisseur abaisseur comme le LM2596 et protège-le avec un fusible de 1 A. Si tu te branches sur le circuit du feu de recul, le système ne fonctionne qu'en marche arrière.
  • Câblage : Tu peux placer le capteur dans le pare-chocs, l'Arduino dans le coffre, et le buzzer et la barre de LED à la vue du conducteur. Pour des fils TRIG et ECHO de plus de 3–4 mètres, utilise du câble torsadé et ajoute un condensateur de 100 nF entre VCC et GND du capteur.
  • Plusieurs capteurs : Les vraies voitures ont généralement 3 à 4 capteurs dans le pare-chocs arrière. Si tu déclenches deux HC-SR04 en même temps, l'un entend l'écho de l'autre ; mesure-les l'un après l'autre avec au moins 30–60 ms d'écart et indique au conducteur la plus petite distance.
  • Version murale pour le garage : Si tu ne veux pas toucher à la voiture, fixe le capteur sur le mur du fond du garage, à hauteur de pare-chocs. Quand la voiture entre, la barre de LED passe du vert au rouge comme un feu tricolore ; c'est l'aide au stationnement la plus simple et la plus sûre.
Ce projet est destiné à l'apprentissage et au bricolage, il ne remplace pas les systèmes de sécurité de la voiture. Avant de travailler sur l'installation électrique du véhicule, débranche la borne négative de la batterie et éloigne les câbles des pièces mobiles et de l'échappement. Continue d'utiliser tes rétroviseurs et de regarder derrière toi pour repérer les obstacles que le capteur ne voit pas, comme les poteaux fins, les enfants ou les animaux.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
La distance vaut toujours 999 ou ne bouge pasTRIG et ECHO inversés, VCC différent de 5 V ou fil desserréCompare les broches avec le tableau de câblage et alimente le capteur en 5V
Les valeurs sautent au hasardSurface molle ou inclinée, plaque d'essai mal enfoncée, mesures trop rapprochéesUtilise le filtre médian et laisse au moins 60 ms entre deux mesures
La distance se fige pendant les bipsIl y a un delay() dans le codeGénère le bip avec millis() et utilise le code de cet article
Le buzzer grésille ou reste muetCode pour buzzer actif utilisé avec un buzzer passif, ou l'inverseUtilise un buzzer actif avec le code Uno et un passif avec le code ESP32
Les LED clignotent à la limite d'une zoneLa distance oscille pile sur la limiteAjoute aussi au code Uno l'hystérésis de 3 cm du code ESP32
L'ESP32 ne lit aucune distanceCapteur alimenté en 3,3 V ou pont diviseur inverséRelie VCC à VIN et vérifie que la résistance de 2 kΩ est côté GND
Correct sur le bureau, fausses alertes sur la voitureLe capteur voit le sol, la plaque d'immatriculation ou l'attelageMonte le capteur plus haut et incline-le de 3 à 5 degrés vers le haut
Le buzzer est trop faibleLa broche ne fournit pas assez de courantPilote le buzzer avec un transistor NPN comme le BC547
Après chaque modification, refais le même test : place le carton sur les repères de 150, 100, 70, 45 et 25 cm et compare le numéro de zone du moniteur série avec le tableau. S'il correspond partout, ton système est prêt. Tu trouveras les détails du capteur et un premier code de mesure dans capteur de distance HC-SR04, et les types de buzzer dans Qu'est-ce qu'un buzzer ?.

Projets à essayer après le radar de recul

Comme un radar de recul Arduino réunit son, lumière et mesure dans un seul projet, c'est un excellent choix comme premier vrai projet ou pour un projet de technologie au collège ou au lycée. Adapte le tableau des zones à ta voiture, teste d'abord le système au garage, puis va plus loin grâce aux conseils de montage. Dans l'application BlueGrays, tu trouveras le schéma de câblage étape par étape et le code prêt à l'emploi de ce même circuit dans les projets de capteur de stationnement avec HC-SR04 et avec ESP32.

Questions fréquentes

Comment faire un radar de recul avec Arduino ?

Il te faut un capteur à ultrasons HC-SR04, un buzzer et quelques LED. L'Arduino mesure la durée de l'écho toutes les 60 ms, la convertit en centimètres avec durée / 58 et choisit selon la distance une zone qui fixe le rythme des bips et le nombre de LED allumées. Avec millis() au lieu de delay(), la mesure continue pendant les bips.

Quelle est la portée du capteur HC-SR04 ?

Sa fiche technique annonce 2 à 400 cm, mais sur une surface plane et large, la plage fiable tourne autour de 3 à 250 cm. Pour se garer, une alerte à partir de 150 cm suffit largement. Les poteaux fins et les surfaces molles peuvent passer inaperçus même de plus près.

Le HC-SR04 est-il étanche ?

Non, le HC-SR04 ne résiste ni à l'eau ni à la poussière et ne survit pas longtemps à la pluie et au lavage. Pour un montage à l'extérieur de la voiture, une sonde étanche comme le JSN-SR04T est préférable. Si tu n'en as besoin qu'au garage, le plus simple est de fixer le capteur au mur.

Buzzer actif ou passif pour un radar de recul ?

Un buzzer actif a son propre oscillateur : il sonne dès qu'il reçoit 5 V et se commande avec digitalWrite, c'est pour lui que le code Uno est écrit. Un buzzer passif a besoin d'une fréquence fournie par tone() ou, sur l'ESP32, par LEDC, mais tu choisis la tonalité. Pour les distinguer, applique 5 V : celui qui sonne tout seul est actif.

Comment alimenter l'Arduino en 12 V dans une voiture ?

La tension de bord monte jusqu'à 14,4 V moteur tournant et comporte des pics, la solution la plus sûre est donc un convertisseur abaisseur comme le LM2596 réglé sur 5 V. Ajoute un fusible de 1 A. Si tu te branches sur le feu de recul, le système ne s'allume qu'en marche arrière.

Peut-on utiliser plusieurs capteurs à ultrasons en même temps ?

Oui, mais s'ils émettent au même instant, ils peuvent entendre l'écho des autres. Mesure les capteurs l'un après l'autre avec au moins 30 à 60 ms d'écart et affiche la plus petite distance. Chaque capteur a seulement besoin de ses propres broches TRIG et ECHO.

Voir tous les projets
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

HC-SR04 Mesure de la distance (affichage en série)

Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

4.6(50)
82
Utilisation du buzzer
AR-13Débutant

Utilisation du buzzer

Tu t'es déjà demandé comment une sonnette ou une alarme produit son son ? L'Arduino fait biper un petit buzzer à intervalles courts : bip, silence, bip, silence.

4.7(92)
171
Capteur de stationnement avec HC-SR04
AR-28Intermédiaire
Premium

Capteur de stationnement avec HC-SR04

Une version miniature du radar de recul des voitures : plus un objet s'approche, plus les bips s'accélèrent.

4.8(64)
86
Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)
ES-38Avancé
Premium

Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)

La version ESP32 d'un radar de recul ! Le capteur à ultrasons HC-SR04 mesure la distance jusqu'à l'objet devant lui. Plus il se rapproche, plus une barre de 5 LED se remplit (vert → jaune → rouge) et plus le buzzer bipe vite. Tout près (moins de 10 cm), une alarme continue retentit et toutes les LED s'allument. L'écran OLED SSD1306 affiche la distance en cm en grands caractères, avec un message d'état.

14
ESP32 HC-SR04 Télémètre à ultrasons
ES-14Intermédiaire

ESP32 HC-SR04 Télémètre à ultrasons

Le capteur à ultrasons HC-SR04 mesure une distance d'après le temps que met son impulsion sonore à rebondir sur un objet et revenir (temps de vol). L'ESP32 envoie une impulsion de 10 microsecondes sur TRIG et lit la durée de l'écho sur ECHO avec pulseIn(). La distance s'affiche en cm sur un LCD I2C 16x2. Le HC-SR04 fonctionne en 5 V : ECHO a besoin d'un pont diviseur, sinon le GPIO 3,3 V de l'ESP32 est endommagé.

4.9(29)
48
Mesure de la distance à l'aide d'un écran LCD
AR-31Avancé
Premium

Mesure de la distance à l'aide d'un écran LCD

Un appareil qui mesure les distances sans règle : avance et recule ta main devant le capteur et regarde le nombre changer.

4.6(45)
59
Robot évitant les obstacles
AR-81Avancé
Premium

Robot évitant les obstacles

Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?

5.0(38)
49
Projet de mesure de la taille
AR-33Intermédiaire
Premium

Projet de mesure de la taille

Une toise qui se fixe au cadre de la porte et te dit en centimètres la taille de la personne qui se tient dessous.

4.5(25)
34