Projet Arduino : Radar de vitesse basé sur capteur HC-SR04

Arduino 14-04-26

13 0

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage du radar

4- Programmation de la carte Arduino

Présentation du projet

Le projet de radar de vitesse basé sur la carte Arduino UNO a pour objectif principal de mesurer la vitesse de déplacement d’un objet (comme une voiture miniature ou une personne) sur une courte distance.

Ce système pédagogique permet de comprendre des notions importantes telles que la mesure du temps, la distance, et le calcul de la vitesse. Il est souvent utilisé dans des projets de robotique pour initier à l’acquisition de données et à leur traitement en temps réel.

Le fonctionnement du radar repose sur l’utilisation de deux capteurs ultrasoniques HC-SR04 placés à une distance fixe l’un de l’autre.

Lorsqu’un objet passe devant le premier capteur, celui-ci détecte sa présence et déclenche un chronomètre dans le programme.

Ensuite, lorsque l’objet atteint le deuxième capteur, le temps est arrêté.

En connaissant la distance entre les deux capteurs et le temps mesuré, la carte Arduino calcule la vitesse à l’aide de la formule : vitesse = distance / temps.

Les résultats de la mesure sont ensuite affichés sur un écran LCD I2C 1602, ce qui permet de visualiser facilement la vitesse calculée en temps réel. Ce type d’afficheur est très pratique car il utilise seulement deux fils de communication (SDA et SCL), simplifiant ainsi le câblage du montage.

Enfin, un buzzer est intégré au système pour fournir un signal sonore. Il peut être utilisé pour alerter lorsque la vitesse dépasse une certaine limite définie dans le programme. Cela rend le projet plus interactif et proche d’un véritable radar de contrôle de vitesse utilisé dans la vie réelle.

En résumé, ce projet combine détection, calcul et affichage pour créer un système complet de mesure de vitesse, tout en offrant une excellente introduction aux systèmes embarqués et à la programmation avec Arduino.

Matériel nécessaire

1- Carte Arduino UNO

Arduino Uno

La carte Arduino UNO est le cerveau du système. Elle exécute le programme qui contrôle tous les autres composants. Elle reçoit les données des capteurs ultrasoniques, calcule la vitesse de l’objet détecté, puis affiche les résultats sur l’écran LCD et active le buzzer si nécessaire.

2- Boutons poussoirs (2 pièces)

HC-SR04

Ces capteurs servent à mesurer la distance entre eux et un objet en mouvement.

1- Le premier capteur détecte le passage de l’objet (point de départ)

2- Le second capteur détecte le passage (point d’arrivée)

En mesurant le temps entre les deux détections, on peut calculer la vitesse.

3. Buzzer

Le buzzer est un composant sonore utilisé pour signaler une alerte. Dans ce projet, il se déclenche lorsque la vitesse mesurée dépasse une limite définie, permettant ainsi d’avertir l’utilisateur de manière sonore.

4. Afficheur LCD I2C

L’afficheur LCD I2C est utilisé pour afficher les informations du système, notamment la vitesse mesurée.

5. Câbles de Connexion (Jumper Wires)

Fils de connexion

Les fils de connexion sont utilisés pour relier les différents composants entre eux. Ils assurent la transmission des signaux et de l’alimentation entre la carte Arduino UNO, les capteurs, l’afficheur et le Buzzer.

6- Breadboard (Plaque d'essai) :

plaque d'essai

Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.

Schéma de câblage du distributeur du radar

1- Connexion du premier capteur HC-SR04 à la carte Arduino UNO

Capteur HC-SR04	Carte Arduino UNO
VCC	3.3 V
Trig	D2
Echo	D3
GND	GND

2- Connexion du deuxième capteur HC-SR04 à la carte Arduino

capteur HC-SR04	Carte Arduino
VCC	3.3 V
Trig	D4
Echo	D5
GND	GND

3- Connexion du Buzzer à la carte Arduino UNO

Buzzer	Carte Arduino
Borne (+)	D6
Borne (-)	GND

4- Connexion de l’afficheur LCD I2C à la carte Arduino

Afficheur LCD I2C	Carte Arduino
VCC	5V
GND	GND
SDA	A4
SCL	A5

Programmation de la carte Arduino UNO

Ce programme permet de réaliser un radar de vitesse à l’aide d’une carte Arduino UNO, de deux capteurs ultrasoniques HC-SR04, d’un buzzer et d’un écran LCD I2C 16x2 (ici utilisé en version 20x4).

Son objectif est de mesurer la vitesse d’un objet (comme une voiture) en calculant le temps qu’il met pour parcourir une distance connue entre deux capteurs.

On commence par l’importation de cette bibliothèque:

LiquidCrystal_I2C → pour afficher les informations sur l’écran LCD I2C

Voici le code en C++ qui implémente le fonctionnement du système :

#include <Wire.h>                  // Bibliothèque pour communication I2C
#include <LiquidCrystal_I2C.h>    // Bibliothèque pour écran LCD I2C

// =========================
// CONFIGURATION
// =========================

// Distance entre les deux capteurs (en mètres)
#define DISTANCE 0.10        

// Seuil de détection (objet détecté si distance < 5 cm)
#define SEUIL_DETECTION 5   

// Limite de vitesse (km/h)
#define LIMITE_VITESSE 1.0   

// Définition des broches du capteur 1
#define TRIG1 2
#define ECHO1 3

// Définition des broches du capteur 2
#define TRIG2 4
#define ECHO2 5

// Broche du buzzer
#define BUZZER 6

// Initialisation de l'écran LCD I2C (adresse 0x27, 20 colonnes, 4 lignes)
LiquidCrystal_I2C lcd(0x27, 20, 4);

// =========================
// FONCTIONS
// =========================

// Fonction pour mesurer la distance avec un capteur ultrasonique (en cm)
float mesurerDistance(int trig, int echo) {

  // Envoi d'une impulsion ultrasonique
  digitalWrite(trig, LOW);
  delayMicroseconds(2);

  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);

  // Mesure du temps de retour de l'écho (timeout 30 ms)
  long duree = pulseIn(echo, HIGH, 30000);

  // Si aucun signal reçu
  if (duree == 0) return -1;

  // Calcul de la distance (vitesse du son = 0.0343 cm/us)
  return (duree * 0.0343) / 2;
}

// Fonction pour vérifier si un objet est détecté
bool objetDetecte(int trig, int echo) {
  float d = mesurerDistance(trig, echo);

  // Retourne vrai si objet proche
  return (d > 0 && d < SEUIL_DETECTION);
}

// Fonction pour afficher 4 lignes sur le LCD
void afficher(String l1 = "", String l2 = "", String l3 = "", String l4 = "") {

  lcd.clear();  // Efface l'écran

  lcd.setCursor(0, 0);
  lcd.print(l1);

  lcd.setCursor(0, 1);
  lcd.print(l2);

  lcd.setCursor(0, 2);
  lcd.print(l3);

  lcd.setCursor(0, 3);
  lcd.print(l4);
}

// Fonction pour activer le buzzer pendant une durée donnée (ms)
void bip(int duree = 200) {
  digitalWrite(BUZZER, HIGH);
  delay(duree);
  digitalWrite(BUZZER, LOW);
}

// =========================
// INITIALISATION
// =========================

void setup() {

  // Configuration des broches des capteurs
  pinMode(TRIG1, OUTPUT);
  pinMode(ECHO1, INPUT);

  pinMode(TRIG2, OUTPUT);
  pinMode(ECHO2, INPUT);

  // Configuration du buzzer
  pinMode(BUZZER, OUTPUT);

  // Initialisation de l'écran LCD
  lcd.init();
  lcd.backlight();   // Allume le rétroéclairage

  // Message de démarrage
  afficher("Arduino UNO","RADAR DE VITESSE", "Initialisation...",  "");
  delay(10000);  // Pause de 10 secondes
}

// =========================
// BOUCLE PRINCIPALE
// =========================

void loop() {

  // Affichage en attente
  afficher("Radar actif", "Attente ...", "", "");

  // Attente de détection par le capteur 1 (début du chronométrage)
  while (!objetDetecte(TRIG1, ECHO1)) {
    delay(5);
  }

  // Enregistrement du temps initial (en microsecondes)
  unsigned long t1 = micros();

  afficher("Voiture detectee", "Mesure en cours...", "", "");

  // Attente de détection par le capteur 2 (fin du chronométrage)
  while (!objetDetecte(TRIG2, ECHO2)) {
    delay(5);
  }

  // Enregistrement du temps final
  unsigned long t2 = micros();

  // Calcul du temps écoulé en secondes
  float delta_t = (t2 - t1) / 1000000.0;

  // Vérification que le temps est valide
  if (delta_t > 0) {

    // Calcul de la vitesse (m/s → km/h)
    float vitesse = (DISTANCE / delta_t) * 3.6;

    // Affichage des résultats
    afficher(
      "Vitesse:",
      String(vitesse, 2) + " km/h",
      "Limite: " + String(LIMITE_VITESSE) + " km/h",
      "Etat:"
    );

    // Vérification dépassement de vitesse
    if (vitesse > LIMITE_VITESSE) {

      lcd.setCursor(6, 3);
      lcd.print("DEPASSE");  // Alerte

      // Alarme sonore répétée
      for (int i = 0; i < 15; i++) {
        bip(150);
        delay(100);
      }

    } else {

      lcd.setCursor(6, 3);
      lcd.print("OK");  // Vitesse normale

      bip(80);  // Petit bip
    }

  } else {

    // Cas d'erreur (temps invalide)
    afficher("Erreur", "Temps invalide", "", "");
  }

  delay(5000);  // Pause avant la prochaine mesure
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

#include <Wire.h> // Bibliothèque pour communication I2C

#include <LiquidCrystal_I2C.h> // Bibliothèque pour écran LCD I2C

// =========================

// CONFIGURATION

// =========================

// Distance entre les deux capteurs (en mètres)

#define DISTANCE 0.10

// Seuil de détection (objet détecté si distance < 5 cm)

#define SEUIL_DETECTION 5

// Limite de vitesse (km/h)

#define LIMITE_VITESSE 1.0

// Définition des broches du capteur 1

#define TRIG1 2

#define ECHO1 3

// Définition des broches du capteur 2

#define TRIG2 4

#define ECHO2 5

// Broche du buzzer

#define BUZZER 6

// Initialisation de l'écran LCD I2C (adresse 0x27, 20 colonnes, 4 lignes)

LiquidCrystal_I2C lcd(0x27, 20, 4);

// =========================

// FONCTIONS

// =========================

// Fonction pour mesurer la distance avec un capteur ultrasonique (en cm)

float mesurerDistance(int trig, int echo) {

// Envoi d'une impulsion ultrasonique

digitalWrite(trig, LOW);

delayMicroseconds(2);

digitalWrite(trig, HIGH);

delayMicroseconds(10);

digitalWrite(trig, LOW);

// Mesure du temps de retour de l'écho (timeout 30 ms)

long duree = pulseIn(echo, HIGH, 30000);

// Si aucun signal reçu

if (duree == 0) return -1;

// Calcul de la distance (vitesse du son = 0.0343 cm/us)

return (duree * 0.0343) / 2;

}

// Fonction pour vérifier si un objet est détecté

bool objetDetecte(int trig, int echo) {

float d = mesurerDistance(trig, echo);

// Retourne vrai si objet proche

return (d > 0 && d < SEUIL_DETECTION);

}

// Fonction pour afficher 4 lignes sur le LCD

void afficher(String l1 = "", String l2 = "", String l3 = "", String l4 = "") {

lcd.clear(); // Efface l'écran

lcd.setCursor(0, 0);

lcd.print(l1);

lcd.setCursor(0, 1);

lcd.print(l2);

lcd.setCursor(0, 2);

lcd.print(l3);

lcd.setCursor(0, 3);

lcd.print(l4);

}

// Fonction pour activer le buzzer pendant une durée donnée (ms)

void bip(int duree = 200) {

digitalWrite(BUZZER, HIGH);

delay(duree);

digitalWrite(BUZZER, LOW);

}

// =========================

// INITIALISATION

// =========================

void setup() {

// Configuration des broches des capteurs

pinMode(TRIG1, OUTPUT);

pinMode(ECHO1, INPUT);

pinMode(TRIG2, OUTPUT);

pinMode(ECHO2, INPUT);

// Configuration du buzzer

pinMode(BUZZER, OUTPUT);

// Initialisation de l'écran LCD

lcd.init();

lcd.backlight(); // Allume le rétroéclairage

// Message de démarrage

afficher("Arduino UNO","RADAR DE VITESSE", "Initialisation...", "");

delay(10000); // Pause de 10 secondes

}

// =========================

// BOUCLE PRINCIPALE

// =========================

void loop() {

// Affichage en attente

afficher("Radar actif", "Attente ...", "", "");

// Attente de détection par le capteur 1 (début du chronométrage)

while (!objetDetecte(TRIG1, ECHO1)) {

delay(5);

}

// Enregistrement du temps initial (en microsecondes)

unsigned long t1 = micros();

afficher("Voiture detectee", "Mesure en cours...", "", "");

// Attente de détection par le capteur 2 (fin du chronométrage)

while (!objetDetecte(TRIG2, ECHO2)) {

delay(5);

}

// Enregistrement du temps final

unsigned long t2 = micros();

// Calcul du temps écoulé en secondes

float delta_t = (t2 - t1) / 1000000.0;

// Vérification que le temps est valide

if (delta_t > 0) {

// Calcul de la vitesse (m/s → km/h)

float vitesse = (DISTANCE / delta_t) * 3.6;

// Affichage des résultats

afficher(

"Vitesse:",

String(vitesse, 2) + " km/h",

"Limite: " + String(LIMITE_VITESSE) + " km/h",

"Etat:"

);

// Vérification dépassement de vitesse

if (vitesse > LIMITE_VITESSE) {

lcd.setCursor(6, 3);

lcd.print("DEPASSE"); // Alerte

// Alarme sonore répétée

for (int i = 0; i < 15; i++) {

bip(150);

delay(100);

}

} else {

lcd.setCursor(6, 3);

lcd.print("OK"); // Vitesse normale

bip(80); // Petit bip

}

} else {

// Cas d'erreur (temps invalide)

afficher("Erreur", "Temps invalide", "", "");

}

delay(5000); // Pause avant la prochaine mesure

}

Principe de fonctionnement

Le système repose sur une méthode simple :

1- Le premier capteur détecte le passage de l’objet → démarrage du chronomètre

2- Le second capteur détecte le passage → arrêt du chronomètre

3- Le programme calcule la vitesse avec la formule : vitesse = distance / temps

4- Le résultat est affiché sur l’écran LCD

5- Si la vitesse dépasse une limite définie, une alarme sonore est déclenchée

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Projet Arduino : Radar de vitesse basé sur capteur HC-SR04

Arduino 14-04-26

Projet ESP32 : Radar de vitesse basé sur capteur HC-SR04

ESP32 10-04-26

Projet Micro:bit : Radar de vitesse basé sur capteur HC-SR04

Micro:bit 05-04-26

Détection d’obstacles avec Micro:bit et capteur FC-51

Micro:bit 04-04-26

Projet ESP8266 NodeMCU : distributeur de monnaie intelligent

ESP8266 02-04-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 12148vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 11740vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 10122vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino 9777vues

Allumer une LED par la carte ESP32

ESP32 9655vues

Construction des robots

Tutoriels plus commentés

Premiers pas avec Micro:bit et MakeCode

Micro:bit 43 commentaires

Construire un GPS commandé par Arduino

Arduino 31 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 30 commentaires

Présentation du module capteur de lumière à LDR

Composants 22 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Projet Arduino : Radar de vitesse basé sur capteur HC-SR04

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage du radar

4- Programmation de la carte Arduino

Présentation du projet

Matériel nécessaire

Schéma de câblage du distributeur du radar

Programmation de la carte Arduino UNO

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles