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

ESP32 10-04-26

14 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 ESP32

Présentation du projet

Ce projet a pour objectif de concevoir un radar de vitesse capable de mesurer la vitesse de déplacement d’un objet à l’aide d’une carte ESP32. En utilisant deux capteurs ultrasoniques HC-SR04 placés à une distance connue, le système permet de calculer la vitesse en fonction du temps mis par l’objet pour passer d’un capteur à l’autre.

L’afficheur LCD I2C est utilisé pour afficher la vitesse mesurée en temps réel, tandis que le buzzer sert à signaler un dépassement d’une limite de vitesse prédéfinie.

Ce projet permet de mettre en pratique des notions importantes telles que la mesure du temps, le calcul de vitesse, l’utilisation de capteurs et la communication avec des périphériques.

Fonctionnement du projet :

Le fonctionnement du radar repose sur la détection successive d’un objet par deux capteurs HC-SR04. Lorsqu’un objet passe devant le premier capteur, le système enregistre le temps initial. Ensuite, lorsque l’objet est détecté par le second capteur, le temps final est enregistré.

La carte ESP32 calcule alors le temps écoulé entre les deux détections et utilise la distance connue séparant les capteurs pour déterminer la vitesse de l’objet.

Le résultat est ensuite affiché sur l’écran LCD I2C. Si la vitesse dépasse une valeur limite définie dans le programme, le buzzer se déclenche pour alerter l’utilisateur. Ce système fonctionne en boucle continue pour assurer une surveillance en temps réel.

Matériel nécessaire

1- Carte ESP32

La carte ESP32 constitue le cœur du système. Elle assure le traitement des données, la gestion des capteurs et le calcul de la vitesse. Grâce à sa puissance et à ses nombreuses entrées/sorties, elle permet de connecter facilement plusieurs composants comme les capteurs, l’afficheur LCD et le buzzer.

2- Boutons poussoirs (2 pièces)

HC-SR04

Les deux capteurs HC-SR04 sont utilisés pour détecter le passage de l’objet. Chaque capteur mesure la distance en envoyant des ondes ultrasoniques. Lorsqu’un objet passe devant un capteur, celui-ci le détecte et envoie un signal à l’ESP32. L’utilisation de deux capteurs permet de mesurer le temps de déplacement entre deux points afin de 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 l’ESP32, 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 ESP32

Capteur HC-SR04	Carte ESP32
VCC	3.3 V
Trig	GPIO 19
Echo	GPIO 18
GND	GND

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

capteur HC-SR04	Carte ESP32
VCC	3.3 V
Trig	GPIO 17
Echo	GPIO 16
GND	GND

3- Connexion du Buzzer à la carte ESP32

Buzzer	Carte ESP32
Borne (+)	GPIO 23
Borne (-)	GND

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

Afficheur LCD I2C	Carte ESP32
VCC	5V
GND	GND
SDA	GPIO 21
SCL	GPIO 22

Programmation de la carte ESP32

Ce programme en Micropython permet de réaliser un radar de vitesse en utilisant une carte ESP32, deux capteurs ultrasoniques HC-SR04, un afficheur LCD I2C et un buzzer.

Le système fonctionne en mesurant le temps mis par un objet pour parcourir une distance connue entre deux capteurs, afin de calculer sa vitesse.

Les informations sont ensuite affichées sur l’écran LCD, et une alerte sonore est déclenchée en cas de dépassement de la limite de vitesse définie.

On commence par l’importation de ces bibliothèques:

i2c_lcd et lcd_api → pour afficher les informations sur l’écran LCD I2C

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

# Importation des bibliothèques nécessaires
from machine import Pin, I2C, time_pulse_us
import time
from i2c_lcd import I2cLcd

# =========================
# CONFIGURATION
# =========================

DISTANCE = 0.10      # Distance entre les deux capteurs (en mètres)
SEUIL_DETECTION = 10 # Distance seuil pour détecter un objet (en cm)
LIMITE_VITESSE = 1   # Limite de vitesse autorisée (en km/h)

# =========================
# CONFIGURATION DES BROCHES
# =========================

# Capteur 1 (entrée du radar)
trig1 = Pin(19, Pin.OUT)  # Broche TRIG (émission)
echo1 = Pin(18, Pin.IN)   # Broche ECHO (réception)

# Capteur 2 (sortie du radar)
trig2 = Pin(17, Pin.OUT)
echo2 = Pin(16, Pin.IN)

# Buzzer (alarme sonore)
buzzer = Pin(23, Pin.OUT)

# Écran LCD I2C (adresse 0x27, 4 lignes x 20 colonnes)
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)
lcd = I2cLcd(i2c, 0x27, 4, 20)

# =========================
# FONCTIONS
# =========================

def mesurer_distance(trig, echo):
    # Envoie une impulsion ultrasonique
    trig.value(0)
    time.sleep_us(2)

    trig.value(1)
    time.sleep_us(10)
    trig.value(0)

    # Mesure la durée du signal de retour
    duree = time_pulse_us(echo, 1, 30000)

    # Si aucune réponse (erreur)
    if duree < 0:
        return None

    # Calcul de la distance en cm
    return (duree * 0.0343) / 2


def objet_detecte(trig, echo):
    # Vérifie si un objet est détecté sous le seuil défini
    d = mesurer_distance(trig, echo)
    return d is not None and d < SEUIL_DETECTION


def afficher(l1="", l2="", l3="", l4=""):
    # Affiche 4 lignes sur l'écran LCD
    lcd.clear()
    lcd.move_to(0, 0)
    lcd.putstr(l1)
    lcd.move_to(0, 1)
    lcd.putstr(l2)
    lcd.move_to(0, 2)
    lcd.putstr(l3)
    lcd.move_to(0, 3)
    lcd.putstr(l4)


def bip(duree=200):
    # Active le buzzer pendant une durée donnée (en ms)
    buzzer.value(1)
    time.sleep_ms(duree)
    buzzer.value(0)

# =========================
# INITIALISATION
# =========================

# Message de démarrage
afficher("RADAR DE VITESSE", "Initialisation...", "", "")
time.sleep(5)

# =========================
# BOUCLE PRINCIPALE
# =========================

while True:

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

    # Attente de détection par le capteur 1
    while not objet_detecte(trig1, echo1):
        time.sleep_ms(5)

    # Enregistrement du temps de passage devant le capteur 1
    t1 = time.ticks_us()

    afficher("Voiture detecte", "Mesure en cours...", "", "")

    # Attente de détection par le capteur 2
    while not objet_detecte(trig2, echo2):
        time.sleep_ms(5)

    # Enregistrement du temps de passage devant le capteur 2
    t2 = time.ticks_us()

    # Calcul du temps écoulé (en secondes)
    delta_t = time.ticks_diff(t2, t1) / 1_000_000

    # Vérification que le temps est valide
    if delta_t > 0:

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

        # Affichage des résultats
        afficher(
            "Vitesse:",
            "{:.2f} km/h".format(vitesse),
            "Limite: {} km/h".format(LIMITE_VITESSE),
            "Etat:"
        )

        # =========================
        # GESTION DE L'ALARME
        # =========================

        if vitesse > LIMITE_VITESSE:
            # Dépassement de vitesse
            lcd.move_to(6, 3)
            lcd.putstr("DEPASSE")
            
            # Bips répétés
            for _ in range(15):
                bip(150)
                time.sleep_ms(100)
        else:
            # Vitesse normale
            lcd.move_to(6, 3)
            lcd.putstr("OK")
            bip(80)

    else:
        # Erreur de mesure
        afficher("Erreur", "Temps invalide", "", "")

    # Pause avant la prochaine mesure
    time.sleep(5)

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

# Importation des bibliothèques nécessaires

from machine import Pin, I2C, time_pulse_us

import time

from i2c_lcd import I2cLcd

# =========================

# CONFIGURATION

# =========================

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

SEUIL_DETECTION = 10 # Distance seuil pour détecter un objet (en cm)

LIMITE_VITESSE = 1 # Limite de vitesse autorisée (en km/h)

# =========================

# CONFIGURATION DES BROCHES

# =========================

# Capteur 1 (entrée du radar)

trig1 = Pin(19, Pin.OUT) # Broche TRIG (émission)

echo1 = Pin(18, Pin.IN) # Broche ECHO (réception)

# Capteur 2 (sortie du radar)

trig2 = Pin(17, Pin.OUT)

echo2 = Pin(16, Pin.IN)

# Buzzer (alarme sonore)

buzzer = Pin(23, Pin.OUT)

# Écran LCD I2C (adresse 0x27, 4 lignes x 20 colonnes)

i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)

lcd = I2cLcd(i2c, 0x27, 4, 20)

# =========================

# FONCTIONS

# =========================

def mesurer_distance(trig, echo):

# Envoie une impulsion ultrasonique

trig.value(0)

time.sleep_us(2)

trig.value(1)

time.sleep_us(10)

trig.value(0)

# Mesure la durée du signal de retour

duree = time_pulse_us(echo, 1, 30000)

# Si aucune réponse (erreur)

if duree < 0:

return None

# Calcul de la distance en cm

return (duree * 0.0343) / 2

def objet_detecte(trig, echo):

# Vérifie si un objet est détecté sous le seuil défini

d = mesurer_distance(trig, echo)

return d is not None and d < SEUIL_DETECTION

def afficher(l1="", l2="", l3="", l4=""):

# Affiche 4 lignes sur l'écran LCD

lcd.clear()

lcd.move_to(0, 0)

lcd.putstr(l1)

lcd.move_to(0, 1)

lcd.putstr(l2)

lcd.move_to(0, 2)

lcd.putstr(l3)

lcd.move_to(0, 3)

lcd.putstr(l4)

def bip(duree=200):

# Active le buzzer pendant une durée donnée (en ms)

buzzer.value(1)

time.sleep_ms(duree)

buzzer.value(0)

# =========================

# INITIALISATION

# =========================

# Message de démarrage

afficher("RADAR DE VITESSE", "Initialisation...", "", "")

time.sleep(5)

# =========================

# BOUCLE PRINCIPALE

# =========================

while True:

# Affichage en attente

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

# Attente de détection par le capteur 1

while not objet_detecte(trig1, echo1):

time.sleep_ms(5)

# Enregistrement du temps de passage devant le capteur 1

t1 = time.ticks_us()

afficher("Voiture detecte", "Mesure en cours...", "", "")

# Attente de détection par le capteur 2

while not objet_detecte(trig2, echo2):

time.sleep_ms(5)

# Enregistrement du temps de passage devant le capteur 2

t2 = time.ticks_us()

# Calcul du temps écoulé (en secondes)

delta_t = time.ticks_diff(t2, t1) / 1_000_000

# Vérification que le temps est valide

if delta_t > 0:

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

vitesse = (DISTANCE / delta_t) * 3.6

# Affichage des résultats

afficher(

"Vitesse:",

"{:.2f} km/h".format(vitesse),

"Limite: {} km/h".format(LIMITE_VITESSE),

"Etat:"

)

# =========================

# GESTION DE L'ALARME

# =========================

if vitesse > LIMITE_VITESSE:

# Dépassement de vitesse

lcd.move_to(6, 3)

lcd.putstr("DEPASSE")

# Bips répétés

for _ in range(15):

bip(150)

time.sleep_ms(100)

else:

# Vitesse normale

lcd.move_to(6, 3)

lcd.putstr("OK")

bip(80)

else:

# Erreur de mesure

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

# Pause avant la prochaine mesure

time.sleep(5)

Au démarrage, le programme initialise les différents composants et affiche un message d’accueil sur l’écran LCD. Ensuite, il entre dans une boucle infinie où il attend la détection d’un objet par le premier capteur.

Dès qu’un objet est détecté, le temps est enregistré, puis le programme attend que le même objet soit détecté par le second capteur pour enregistrer un second temps. La différence entre ces deux instants permet de calculer la durée de déplacement.

À partir de cette durée et de la distance séparant les capteurs, la carte ESP32 calcule la vitesse de l’objet en km/h. Cette vitesse est affichée sur l’écran LCD avec un message indiquant si elle est conforme ou dépasse la limite fixée.

Si la vitesse est supérieure à la limite, le buzzer émet plusieurs bips pour alerter l’utilisateur. Dans le cas contraire, un bip court est émis pour signaler un fonctionnement normal.

Le système répète ce processus en continu pour assurer une surveillance en temps réel.