Projet ESP8266 NodeMCU : Radar de vitesse basé sur HC-SR04

ESP8266 24-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 ESP8266 NodeMCU

Présentation du projet

Le projet consiste à réaliser un radar de vitesse intelligent à l’aide de la carte ESP8266 NodeMCU.

L’objectif principal est de mesurer la vitesse d’un objet en mouvement, comme une voiture ou un robot, en utilisant deux capteurs ultrasoniques HC-SR04.

Le système permet ensuite d’afficher la vitesse mesurée sur un écran LCD avec interface I2C, tout en offrant une alerte sonore via un buzzer si la vitesse dépasse une limite prédéfinie.

Ce projet constitue une application concrète des systèmes embarqués et de la mesure en temps réel.

Le fonctionnement repose sur un principe simple basé sur le temps de passage. Les deux capteurs ultrasoniques sont placés à une distance fixe l’un de l’autre.

Lorsque l’objet passe devant le premier capteur, celui-ci détecte sa présence et le système enregistre un premier instant. Ensuite, lorsque le même objet passe devant le second capteur, un second instant est enregistré.

La différence entre ces deux instants correspond au temps mis par l’objet pour parcourir la distance entre les deux capteurs.

À partir de ce temps mesuré et de la distance connue séparant les capteurs, la carte ESP8266 NodeMCU calcule la vitesse de l’objet.

Cette vitesse est ensuite affichée en temps réel sur l’écran LCD I2C, ce qui permet à l’utilisateur de suivre les mesures de manière claire et instantanée.

Si la vitesse dépasse une valeur limite définie dans le programme, le buzzer s’active automatiquement pour signaler un excès de vitesse, jouant ainsi le rôle d’un système d’alerte.

Ce projet illustre donc l’utilisation combinée de capteurs, de calculs physiques simples et de dispositifs d’affichage et d’alerte pour créer un système embarqué fonctionnel, proche des radars de vitesse utilisés dans la réalité.

Matériel nécessaire

1- Carte ESP8266 NodeMCU

La carte ESP8266 NodeMCU est une carte de développement basée sur le microcontrôleur ESP8266, intégrant une connectivité Wi-Fi. Elle joue le rôle de cerveau du système en traitant les données provenant des capteurs, en effectuant les calculs de vitesse et en contrôlant les autres composants comme l’afficheur et le buzzer.

2- Capteurs HC-SR04

HC-SR04

Les capteurs HC-SR04 sont des capteurs ultrasoniques permettant de mesurer la distance en utilisant des ondes sonores. Ils fonctionnent en émettant une impulsion ultrasonique et en mesurant le temps que met l’écho à revenir après avoir rencontré un obstacle. Dans ce projet, deux capteurs sont utilisés pour détecter le passage d’un objet à deux positions différentes afin de calculer sa vitesse.

3. Buzzer

Le buzzer est un petit composant électronique qui produit un signal sonore lorsqu’il est alimenté. Dans ce projet, il est utilisé comme dispositif d’alerte : il se déclenche automatiquement lorsque la vitesse mesurée dépasse une valeur limite définie, permettant ainsi de signaler un excès de vitesse.

4. Afficheur LCD I2C

L'afficheur LCD I2C permet d’afficher les informations importantes du système, notamment la vitesse mesurée, de manière lisible et en temps réel.

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 ESP826 NodeMCU, 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 ESP8266

Capteur HC-SR04	Carte ESP8266
VCC	3.3 V
Trig	D5
Echo	D6
GND	GND

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

capteur HC-SR04	Carte ESP8266
VCC	3.3 V
Trig	D7
Echo	D8
GND	GND

3- Connexion du Buzzer à la carte ESP8266

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

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

Afficheur LCD I2C	Carte ESP8266
VCC	5V
GND	GND
SDA	D2
SCL	D1

Programmation de la carte ESP8266 NodeMCU

Ce programme en Micropython permet de réaliser un radar de vitesse en utilisant une carte ESP8266, 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 :

from machine import Pin, I2C, time_pulse_us
import time
from i2c_lcd import I2cLcd

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

DISTANCE = 0.20        # Distance entre les deux capteurs (en mètres)
SEUIL = 10             # Distance seuil pour détecter un objet (en cm)
LIMITE_VITESSE = 1     # Vitesse maximale autorisée (en km/h)

# -------- Capteur 1 --------
trig1 = Pin(14, Pin.OUT)  # Broche Trigger (envoie onde ultrason) - D5
echo1 = Pin(12, Pin.IN)   # Broche Echo (reçoit onde) - D6

# -------- Capteur 2 --------
trig2 = Pin(13, Pin.OUT)  # D7
echo2 = Pin(16, Pin.IN)   # D0

# -------- Buzzer --------
buzzer = Pin(0, Pin.OUT)  # Buzzer connecté sur D3

# -------- LCD I2C --------
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000)  # Initialisation I2C
lcd = I2cLcd(i2c, 0x27, 4, 20)  # Adresse 0x27, écran 20 colonnes x 4 lignes

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

def mesurer_distance(trig, echo):
    """
    Mesure la distance à l'aide d'un capteur HC-SR04
    Retourne la distance en cm
    """
    trig.value(0)          # Assurer que trig est à 0
    time.sleep_us(2)

    trig.value(1)          # Envoyer une impulsion de 10 µs
    time.sleep_us(10)
    trig.value(0)

    # Mesurer la durée de l'écho (temps aller-retour)
    duree = time_pulse_us(echo, 1, 30000)

    if duree < 0:
        return None        # Erreur de mesure

    # Calcul de distance : (vitesse du son * temps) / 2
    return (duree * 0.0343) / 2


def objet_detecte(trig, echo):
    """
    Vérifie si un objet est proche du capteur
    Retourne True si la distance < SEUIL
    """
    d = mesurer_distance(trig, echo)
    return d is not None and d < SEUIL


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(ms=200):
    """
    Génère un bip sonore pendant ms millisecondes
    """
    buzzer.value(1)        # Activer le buzzer
    time.sleep_ms(ms)
    buzzer.value(0)        # Désactiver le buzzer

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

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

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

while True:

    # Mode attente
    afficher("Radar actif", "Attente objet...", "", "")

    # Attendre qu’un objet passe devant le capteur 1
    while not objet_detecte(trig1, echo1):
        time.sleep_ms(5)

    t1 = time.ticks_us()  # Temps de passage au capteur 1

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

    # Attendre passage devant le capteur 2
    while not objet_detecte(trig2, echo2):
        time.sleep_ms(10)

    t2 = time.ticks_us()  # Temps de passage au capteur 2

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

    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:"
        )

        # Vérification dépassement de vitesse
        if vitesse > LIMITE_VITESSE:
            lcd.move_to(6, 3)
            lcd.putstr("DEPASSE")

            # Alarme sonore (plusieurs bips)
            for _ in range(15):
                bip(150)
                time.sleep_ms(100)
        else:
            lcd.move_to(6, 3)
            lcd.putstr("OK")
            bip(80)  # Petit bip de confirmation

    else:
        # Cas d'erreur (temps invalide)
        afficher("Erreur", "Temps invalide", "", "")

    # Pause avant nouvelle 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

from machine import Pin, I2C, time_pulse_us

import time

from i2c_lcd import I2cLcd

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

# CONFIGURATION

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

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

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

LIMITE_VITESSE = 1 # Vitesse maximale autorisée (en km/h)

# -------- Capteur 1 --------

trig1 = Pin(14, Pin.OUT) # Broche Trigger (envoie onde ultrason) - D5

echo1 = Pin(12, Pin.IN) # Broche Echo (reçoit onde) - D6

# -------- Capteur 2 --------

trig2 = Pin(13, Pin.OUT) # D7

echo2 = Pin(16, Pin.IN) # D0

# -------- Buzzer --------

buzzer = Pin(0, Pin.OUT) # Buzzer connecté sur D3

# -------- LCD I2C --------

i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000) # Initialisation I2C

lcd = I2cLcd(i2c, 0x27, 4, 20) # Adresse 0x27, écran 20 colonnes x 4 lignes

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

# FONCTIONS

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

def mesurer_distance(trig, echo):

"""

Mesure la distance à l'aide d'un capteur HC-SR04

Retourne la distance en cm

"""

trig.value(0) # Assurer que trig est à 0

time.sleep_us(2)

trig.value(1) # Envoyer une impulsion de 10 µs

time.sleep_us(10)

trig.value(0)

# Mesurer la durée de l'écho (temps aller-retour)

duree = time_pulse_us(echo, 1, 30000)

if duree < 0:

return None # Erreur de mesure

# Calcul de distance : (vitesse du son * temps) / 2

return (duree * 0.0343) / 2

def objet_detecte(trig, echo):

"""

Vérifie si un objet est proche du capteur

Retourne True si la distance < SEUIL

"""

d = mesurer_distance(trig, echo)

return d is not None and d < SEUIL

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(ms=200):

"""

Génère un bip sonore pendant ms millisecondes

"""

buzzer.value(1) # Activer le buzzer

time.sleep_ms(ms)

buzzer.value(0) # Désactiver le buzzer

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

# INITIALISATION

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

# Message de démarrage

afficher("RADAR ESP8266", "Initialisation...", "", "")

time.sleep(5)

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

# BOUCLE PRINCIPALE

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

while True:

# Mode attente

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

# Attendre qu’un objet passe devant le capteur 1

while not objet_detecte(trig1, echo1):

time.sleep_ms(5)

t1 = time.ticks_us() # Temps de passage au capteur 1

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

# Attendre passage devant le capteur 2

while not objet_detecte(trig2, echo2):

time.sleep_ms(10)

t2 = time.ticks_us() # Temps de passage au capteur 2

# Calcul du temps écoulé (en secondes)

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

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:"

)

# Vérification dépassement de vitesse

if vitesse > LIMITE_VITESSE:

lcd.move_to(6, 3)

lcd.putstr("DEPASSE")

# Alarme sonore (plusieurs bips)

for _ in range(15):

bip(150)

time.sleep_ms(100)

else:

lcd.move_to(6, 3)

lcd.putstr("OK")

bip(80) # Petit bip de confirmation

else:

# Cas d'erreur (temps invalide)

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

# Pause avant nouvelle mesure

time.sleep(5)

Le rôle de ce programme est de transformer la carte ESP8266 NodeMCU en un radar de vitesse intelligent capable de détecter le passage d’un objet, de calculer sa vitesse et de signaler un éventuel dépassement.

Concrètement, le programme surveille en permanence deux capteurs ultrasoniques HC-SR04 placés à une distance fixe. Lorsqu’un objet passe devant le premier capteur, le programme enregistre un instant précis, puis attend que ce même objet atteigne le second capteur pour enregistrer un deuxième instant. À partir de la différence entre ces deux temps et de la distance connue, il calcule automatiquement la vitesse de déplacement.

Une fois la vitesse calculée, le programme l’affiche en temps réel sur l’écran LCD I2C, ce qui permet à l’utilisateur de visualiser facilement le résultat. Ensuite, il compare cette vitesse à une limite définie à l’avance. Si la vitesse dépasse cette limite, le programme active le buzzer pour émettre une alerte sonore, indiquant un excès de vitesse. Dans le cas contraire, il signale que la vitesse est normale.

Ainsi, le programme assure plusieurs fonctions essentielles : la détection de présence, la mesure du temps, le calcul de la vitesse, l’affichage des résultats et la gestion d’une alarme. Il constitue le cœur logique du système et permet de reproduire le fonctionnement simplifié d’un radar de vitesse réel.