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.

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éristique | Valeur |
|---|---|
| Alimentation | 5 V, environ 15 mA |
| Fréquence du son | 40 kHz |
| Plage de mesure | 2–400 cm (plage fiable pour se garer : 3–250 cm) |
| Angle de détection | Un cône d'environ 15° |
| Impulsion de déclenchement | Au moins 10 µs à HIGH sur TRIG |
| Cadence de mesure | Au moins 60 ms entre deux mesures |
| Résolution | Environ 3 mm |
Liste du matériel
| Composant | Quantité | Remarque |
|---|---|---|
| Arduino Uno ou Nano | 1 | Version ESP32 plus bas |
| Capteur à ultrasons HC-SR04 | 1 | À l'extérieur de la voiture, préfère le JSN-SR04T étanche |
| Buzzer actif | 1 | Buzzer passif dans la version ESP32 |
| LED (2 vertes, 2 jaunes, 1 rouge) | 5 | Alignées pour former une barre de LED |
| Résistance de 220 Ω | 5 | Une par LED |
| Écran OLED I2C de 0,96 pouce | 1 | Affichage facultatif |
| Plaque d'essai et câbles de connexion | 1 lot | Garde des fils courts |
| Résistances de 1 kΩ et 2 kΩ | Une de chaque | ESP32 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 :
| Zone | Distance | Intervalle des bips | LED allumées | Signification |
|---|---|---|---|---|
| Sûre | Plus de 150 cm | Silence | Aucune | Voie libre |
| 1 | 101–150 cm | 800 ms | 1 verte | Obstacle détecté |
| 2 | 71–100 cm | 500 ms | 2 vertes | Ralentis |
| 3 | 46–70 cm | 300 ms | 2 vertes + 1 jaune | Attention |
| 4 | 26–45 cm | 150 ms | 2 vertes + 2 jaunes | Très près |
| 5 | 25 cm ou moins | Son continu | Les 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 broche | Arduino Uno | ESP32 | Remarque |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN (5V) | Le capteur a besoin de 5 V |
| HC-SR04 GND | GND | GND | Masse commune |
| HC-SR04 TRIG | D9 | GPIO 4 | Sortie de déclenchement |
| HC-SR04 ECHO | D10 | GPIO 18 | Sur l'ESP32, via un pont 1 kΩ + 2 kΩ |
| Buzzer (+) | D8 | GPIO 19 | Actif sur l'Uno, passif sur l'ESP32 |
| LED 1 et 2 (vertes) | D2, D3 | GPIO 25, 26 | Résistance série de 220 Ω par LED |
| LED 3 et 4 (jaunes) | D4, D5 | GPIO 27, 32 | Résistance série de 220 Ω par LED |
| LED 5 (rouge) | D6 | GPIO 33 | S'allume dans la zone stop |
| OLED SDA / SCL | A4 / A5 | GPIO 21 / 22 | Facultatif |
| OLED VCC | 5V | 3V3 | Vérifie l'ordre des broches du module |
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
- 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.
- Relie TRIG à D9 et ECHO à D10. Garde des fils courts ; un câble mal enfoncé fausse les mesures au hasard.
- 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.
- 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.
- 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.
- 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() :
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 code | Ce qu'elle fait |
|---|---|
| ZONE_CM et BEEP_MS | Regroupent 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 / 58 | Convertit 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 >= period | Vé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 = 60 | Le 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. |
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'air | Vitesse du son | Mesure (durée ÷ 58) |
|---|---|---|
| -10 °C | 325 m/s | Environ 106 cm |
| 0 °C | 331 m/s | Environ 104 cm |
| 10 °C | 337 m/s | Environ 102 cm |
| 20 °C | 343 m/s | Environ 100 cm |
| 30 °C | 350 m/s | Environ 99 cm |
| 40 °C | 356 m/s | Environ 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.
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.
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}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.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| La distance vaut toujours 999 ou ne bouge pas | TRIG 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 hasard | Surface molle ou inclinée, plaque d'essai mal enfoncée, mesures trop rapprochées | Utilise le filtre médian et laisse au moins 60 ms entre deux mesures |
| La distance se fige pendant les bips | Il y a un delay() dans le code | Génère le bip avec millis() et utilise le code de cet article |
| Le buzzer grésille ou reste muet | Code pour buzzer actif utilisé avec un buzzer passif, ou l'inverse | Utilise un buzzer actif avec le code Uno et un passif avec le code ESP32 |
| Les LED clignotent à la limite d'une zone | La distance oscille pile sur la limite | Ajoute aussi au code Uno l'hystérésis de 3 cm du code ESP32 |
| L'ESP32 ne lit aucune distance | Capteur 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 voiture | Le capteur voit le sol, la plaque d'immatriculation ou l'attelage | Monte le capteur plus haut et incline-le de 3 à 5 degrés vers le haut |
| Le buzzer est trop faible | La broche ne fournit pas assez de courant | Pilote le buzzer avec un transistor NPN comme le BC547 |
Projets à essayer après le radar de recul
- Indicateur de garage en couleur : Remplace la barre de LED par un anneau WS2812B NeoPixel qui se remplit du vert au rouge à l'approche de la voiture.
- Système d'occupation de parking : Construis un parking intelligent Arduino qui place un capteur sur chaque place et compte les places libres.
- Radar à ultrasons : Fabrique un radar Arduino qui fait pivoter le capteur sur un servo pour balayer les alentours.
- Robot évitant les obstacles : Associe la même mesure de distance à une commande de moteurs pour faire un robot qui évite les obstacles.
- Mesure précise à courte distance : Pour régler le point d'arrêt au millimètre près, essaie le capteur de distance laser VL53L0X ; les différences sont détaillées dans notre comparatif des capteurs de distance.
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.
Projets à réaliser après cet article
Voir tous les projets
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…

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.

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.

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.

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é.

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.

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

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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

